sys/cddl/contrib/opensolaris/uts/common/sys/vnode.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2017 RackTop Systems.
  25  */
  26
  27 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 #ifndef _SYS_VNODE_H
  41 #define _SYS_VNODE_H
  42
  43 #include_next <sys/vnode.h>
  44
  45 #define IS_DEVVP(vp)    \
  46         ((vp)->v_type == VCHR || (vp)->v_type == VBLK || (vp)->v_type == VFIFO)
  47
  48 #define V_XATTRDIR      0x0000  /* attribute unnamed directory */
  49
  50 #define AV_SCANSTAMP_SZ 32              /* length of anti-virus scanstamp */
  51
  52 /*
  53  * Structure of all optional attributes.
  54  */
  55 typedef struct xoptattr {
  56         timestruc_t     xoa_createtime; /* Create time of file */
  57         uint8_t         xoa_archive;
  58         uint8_t         xoa_system;
  59         uint8_t         xoa_readonly;
  60         uint8_t         xoa_hidden;
  61         uint8_t         xoa_nounlink;
  62         uint8_t         xoa_immutable;
  63         uint8_t         xoa_appendonly;
  64         uint8_t         xoa_nodump;
  65         uint8_t         xoa_opaque;
  66         uint8_t         xoa_av_quarantined;
  67         uint8_t         xoa_av_modified;
  68         uint8_t         xoa_av_scanstamp[AV_SCANSTAMP_SZ];
  69         uint8_t         xoa_reparse;
  70         uint64_t        xoa_generation;
  71         uint8_t         xoa_offline;
  72         uint8_t         xoa_sparse;
  73 } xoptattr_t;
  74
  75 /*
  76  * The xvattr structure is really a variable length structure that
  77  * is made up of:
  78  * - The classic vattr_t (xva_vattr)
  79  * - a 32 bit quantity (xva_mapsize) that specifies the size of the
  80  *   attribute bitmaps in 32 bit words.
  81  * - A pointer to the returned attribute bitmap (needed because the
  82  *   previous element, the requested attribute bitmap) is variable lenth.
  83  * - The requested attribute bitmap, which is an array of 32 bit words.
  84  *   Callers use the XVA_SET_REQ() macro to set the bits corresponding to
  85  *   the attributes that are being requested.
  86  * - The returned attribute bitmap, which is an array of 32 bit words.
  87  *   File systems that support optional attributes use the XVA_SET_RTN()
  88  *   macro to set the bits corresponding to the attributes that are being
  89  *   returned.
  90  * - The xoptattr_t structure which contains the attribute values
  91  *
  92  * xva_mapsize determines how many words in the attribute bitmaps.
  93  * Immediately following the attribute bitmaps is the xoptattr_t.
  94  * xva_getxoptattr() is used to get the pointer to the xoptattr_t
  95  * section.
  96  */
  97
  98 #define XVA_MAPSIZE     3               /* Size of attr bitmaps */
  99 #define XVA_MAGIC       0x78766174      /* Magic # for verification */
 100
 101 /*
 102  * The xvattr structure is an extensible structure which permits optional
 103  * attributes to be requested/returned.  File systems may or may not support
 104  * optional attributes.  They do so at their own discretion but if they do
 105  * support optional attributes, they must register the VFSFT_XVATTR feature
 106  * so that the optional attributes can be set/retrived.
 107  *
 108  * The fields of the xvattr structure are:
 109  *
 110  * xva_vattr - The first element of an xvattr is a legacy vattr structure
 111  * which includes the common attributes.  If AT_XVATTR is set in the va_mask
 112  * then the entire structure is treated as an xvattr.  If AT_XVATTR is not
 113  * set, then only the xva_vattr structure can be used.
 114  *
 115  * xva_magic - 0x78766174 (hex for "xvat"). Magic number for verification.
 116  *
 117  * xva_mapsize - Size of requested and returned attribute bitmaps.
 118  *
 119  * xva_rtnattrmapp - Pointer to xva_rtnattrmap[].  We need this since the
 120  * size of the array before it, xva_reqattrmap[], could change which means
 121  * the location of xva_rtnattrmap[] could change.  This will allow unbundled
 122  * file systems to find the location of xva_rtnattrmap[] when the sizes change.
 123  *
 124  * xva_reqattrmap[] - Array of requested attributes.  Attributes are
 125  * represented by a specific bit in a specific element of the attribute
 126  * map array.  Callers set the bits corresponding to the attributes
 127  * that the caller wants to get/set.
 128  *
 129  * xva_rtnattrmap[] - Array of attributes that the file system was able to
 130  * process.  Not all file systems support all optional attributes.  This map
 131  * informs the caller which attributes the underlying file system was able
 132  * to set/get.  (Same structure as the requested attributes array in terms
 133  * of each attribute  corresponding to specific bits and array elements.)
 134  *
 135  * xva_xoptattrs - Structure containing values of optional attributes.
 136  * These values are only valid if the corresponding bits in xva_reqattrmap
 137  * are set and the underlying file system supports those attributes.
 138  */
 139 typedef struct xvattr {
 140         vattr_t         xva_vattr;      /* Embedded vattr structure */
 141         uint32_t        xva_magic;      /* Magic Number */
 142         uint32_t        xva_mapsize;    /* Size of attr bitmap (32-bit words) */
 143         uint32_t        *xva_rtnattrmapp;       /* Ptr to xva_rtnattrmap[] */
 144         uint32_t        xva_reqattrmap[XVA_MAPSIZE];    /* Requested attrs */
 145         uint32_t        xva_rtnattrmap[XVA_MAPSIZE];    /* Returned attrs */
 146         xoptattr_t      xva_xoptattrs;  /* Optional attributes */
 147 } xvattr_t;
 148
 149 /*
 150  * Attributes of interest to the caller of setattr or getattr.
 151  */
 152 #define AT_TYPE         0x00001
 153 #define AT_MODE         0x00002
 154 #define AT_UID          0x00004
 155 #define AT_GID          0x00008
 156 #define AT_FSID         0x00010
 157 #define AT_NODEID       0x00020
 158 #define AT_NLINK        0x00040
 159 #define AT_SIZE         0x00080
 160 #define AT_ATIME        0x00100
 161 #define AT_MTIME        0x00200
 162 #define AT_CTIME        0x00400
 163 #define AT_RDEV         0x00800
 164 #define AT_BLKSIZE      0x01000
 165 #define AT_NBLOCKS      0x02000
 166 /*                      0x04000 */      /* unused */
 167 #define AT_SEQ          0x08000
 168 /*
 169  * If AT_XVATTR is set then there are additional bits to process in
 170  * the xvattr_t's attribute bitmap.  If this is not set then the bitmap
 171  * MUST be ignored.  Note that this bit must be set/cleared explicitly.
 172  * That is, setting AT_ALL will NOT set AT_XVATTR.
 173  */
 174 #define AT_XVATTR       0x10000
 175
 176 #define AT_ALL          (AT_TYPE|AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|\
 177                         AT_NLINK|AT_SIZE|AT_ATIME|AT_MTIME|AT_CTIME|\
 178                         AT_RDEV|AT_BLKSIZE|AT_NBLOCKS|AT_SEQ)
 179
 180 #define AT_STAT         (AT_MODE|AT_UID|AT_GID|AT_FSID|AT_NODEID|AT_NLINK|\
 181                         AT_SIZE|AT_ATIME|AT_MTIME|AT_CTIME|AT_RDEV|AT_TYPE)
 182
 183 #define AT_TIMES        (AT_ATIME|AT_MTIME|AT_CTIME)
 184
 185 #define AT_NOSET        (AT_NLINK|AT_RDEV|AT_FSID|AT_NODEID|AT_TYPE|\
 186                         AT_BLKSIZE|AT_NBLOCKS|AT_SEQ)
 187
 188 /*
 189  * Attribute bits used in the extensible attribute's (xva's) attribute
 190  * bitmaps.  Note that the bitmaps are made up of a variable length number
 191  * of 32-bit words.  The convention is to use XAT{n}_{attrname} where "n"
 192  * is the element in the bitmap (starting at 1).  This convention is for
 193  * the convenience of the maintainer to keep track of which element each
 194  * attribute belongs to.
 195  *
 196  * NOTE THAT CONSUMERS MUST *NOT* USE THE XATn_* DEFINES DIRECTLY.  CONSUMERS
 197  * MUST USE THE XAT_* DEFINES.
 198  */
 199 #define XAT0_INDEX      0LL             /* Index into bitmap for XAT0 attrs */
 200 #define XAT0_CREATETIME 0x00000001      /* Create time of file */
 201 #define XAT0_ARCHIVE    0x00000002      /* Archive */
 202 #define XAT0_SYSTEM     0x00000004      /* System */
 203 #define XAT0_READONLY   0x00000008      /* Readonly */
 204 #define XAT0_HIDDEN     0x00000010      /* Hidden */
 205 #define XAT0_NOUNLINK   0x00000020      /* Nounlink */
 206 #define XAT0_IMMUTABLE  0x00000040      /* immutable */
 207 #define XAT0_APPENDONLY 0x00000080      /* appendonly */
 208 #define XAT0_NODUMP     0x00000100      /* nodump */
 209 #define XAT0_OPAQUE     0x00000200      /* opaque */
 210 #define XAT0_AV_QUARANTINED     0x00000400      /* anti-virus quarantine */
 211 #define XAT0_AV_MODIFIED        0x00000800      /* anti-virus modified */
 212 #define XAT0_AV_SCANSTAMP       0x00001000      /* anti-virus scanstamp */
 213 #define XAT0_REPARSE    0x00002000      /* FS reparse point */
 214 #define XAT0_GEN        0x00004000      /* object generation number */
 215 #define XAT0_OFFLINE    0x00008000      /* offline */
 216 #define XAT0_SPARSE     0x00010000      /* sparse */
 217
 218 #define XAT0_ALL_ATTRS  (XAT0_CREATETIME|XAT0_ARCHIVE|XAT0_SYSTEM| \
 219     XAT0_READONLY|XAT0_HIDDEN|XAT0_NOUNLINK|XAT0_IMMUTABLE|XAT0_APPENDONLY| \
 220     XAT0_NODUMP|XAT0_OPAQUE|XAT0_AV_QUARANTINED|  XAT0_AV_MODIFIED| \
 221     XAT0_AV_SCANSTAMP|XAT0_REPARSE|XATO_GEN|XAT0_OFFLINE|XAT0_SPARSE)
 222
 223 /* Support for XAT_* optional attributes */
 224 #define XVA_MASK                0xffffffff      /* Used to mask off 32 bits */
 225 #define XVA_SHFT                32              /* Used to shift index */
 226
 227 /*
 228  * Used to pry out the index and attribute bits from the XAT_* attributes
 229  * defined below.  Note that we're masking things down to 32 bits then
 230  * casting to uint32_t.
 231  */
 232 #define XVA_INDEX(attr)         ((uint32_t)(((attr) >> XVA_SHFT) & XVA_MASK))
 233 #define XVA_ATTRBIT(attr)       ((uint32_t)((attr) & XVA_MASK))
 234
 235 /*
 236  * The following defines present a "flat namespace" so that consumers don't
 237  * need to keep track of which element belongs to which bitmap entry.
 238  *
 239  * NOTE THAT THESE MUST NEVER BE OR-ed TOGETHER
 240  */
 241 #define XAT_CREATETIME          ((XAT0_INDEX << XVA_SHFT) | XAT0_CREATETIME)
 242 #define XAT_ARCHIVE             ((XAT0_INDEX << XVA_SHFT) | XAT0_ARCHIVE)
 243 #define XAT_SYSTEM              ((XAT0_INDEX << XVA_SHFT) | XAT0_SYSTEM)
 244 #define XAT_READONLY            ((XAT0_INDEX << XVA_SHFT) | XAT0_READONLY)
 245 #define XAT_HIDDEN              ((XAT0_INDEX << XVA_SHFT) | XAT0_HIDDEN)
 246 #define XAT_NOUNLINK            ((XAT0_INDEX << XVA_SHFT) | XAT0_NOUNLINK)
 247 #define XAT_IMMUTABLE           ((XAT0_INDEX << XVA_SHFT) | XAT0_IMMUTABLE)
 248 #define XAT_APPENDONLY          ((XAT0_INDEX << XVA_SHFT) | XAT0_APPENDONLY)
 249 #define XAT_NODUMP              ((XAT0_INDEX << XVA_SHFT) | XAT0_NODUMP)
 250 #define XAT_OPAQUE              ((XAT0_INDEX << XVA_SHFT) | XAT0_OPAQUE)
 251 #define XAT_AV_QUARANTINED      ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_QUARANTINED)
 252 #define XAT_AV_MODIFIED         ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_MODIFIED)
 253 #define XAT_AV_SCANSTAMP        ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_SCANSTAMP)
 254 #define XAT_REPARSE             ((XAT0_INDEX << XVA_SHFT) | XAT0_REPARSE)
 255 #define XAT_GEN                 ((XAT0_INDEX << XVA_SHFT) | XAT0_GEN)
 256 #define XAT_OFFLINE             ((XAT0_INDEX << XVA_SHFT) | XAT0_OFFLINE)
 257 #define XAT_SPARSE              ((XAT0_INDEX << XVA_SHFT) | XAT0_SPARSE)
 258
 259 /*
 260  * The returned attribute map array (xva_rtnattrmap[]) is located past the
 261  * requested attribute map array (xva_reqattrmap[]).  Its location changes
 262  * when the array sizes change.  We use a separate pointer in a known location
 263  * (xva_rtnattrmapp) to hold the location of xva_rtnattrmap[].  This is
 264  * set in xva_init()
 265  */
 266 #define XVA_RTNATTRMAP(xvap)    ((xvap)->xva_rtnattrmapp)
 267
 268 /*
 269  * XVA_SET_REQ() sets an attribute bit in the proper element in the bitmap
 270  * of requested attributes (xva_reqattrmap[]).
 271  */
 272 #define XVA_SET_REQ(xvap, attr) {                               \
 273         ASSERT((xvap)->xva_vattr.va_mask | AT_XVATTR);          \
 274         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 275         (xvap)->xva_reqattrmap[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr); \
 276 }
 277 /*
 278  * XVA_CLR_REQ() clears an attribute bit in the proper element in the bitmap
 279  * of requested attributes (xva_reqattrmap[]).
 280  */
 281 #define XVA_CLR_REQ(xvap, attr) {                               \
 282         ASSERT((xvap)->xva_vattr.va_mask | AT_XVATTR);          \
 283         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 284         (xvap)->xva_reqattrmap[XVA_INDEX(attr)] &= ~XVA_ATTRBIT(attr); \
 285 }
 286
 287 /*
 288  * XVA_SET_RTN() sets an attribute bit in the proper element in the bitmap
 289  * of returned attributes (xva_rtnattrmap[]).
 290  */
 291 #define XVA_SET_RTN(xvap, attr) {                               \
 292         ASSERT((xvap)->xva_vattr.va_mask | AT_XVATTR);          \
 293         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 294         (XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr); \
 295 }
 296
 297 /*
 298  * XVA_ISSET_REQ() checks the requested attribute bitmap (xva_reqattrmap[])
 299  * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 300  */
 301 #define XVA_ISSET_REQ(xvap, attr)                                       \
 302         ((((xvap)->xva_vattr.va_mask | AT_XVATTR) &&                    \
 303                 ((xvap)->xva_magic == XVA_MAGIC) &&                     \
 304                 ((xvap)->xva_mapsize > XVA_INDEX(attr))) ?              \
 305         ((xvap)->xva_reqattrmap[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)
 306
 307 /*
 308  * XVA_ISSET_RTN() checks the returned attribute bitmap (xva_rtnattrmap[])
 309  * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 310  */
 311 #define XVA_ISSET_RTN(xvap, attr)                                       \
 312         ((((xvap)->xva_vattr.va_mask | AT_XVATTR) &&                    \
 313                 ((xvap)->xva_magic == XVA_MAGIC) &&                     \
 314                 ((xvap)->xva_mapsize > XVA_INDEX(attr))) ?              \
 315         ((XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)
 316
 317 #define MODEMASK        07777           /* mode bits plus permission bits */
 318 #define PERMMASK        00777           /* permission bits */
 319
 320 /*
 321  * VOP_ACCESS flags
 322  */
 323 #define V_ACE_MASK      0x1     /* mask represents  NFSv4 ACE permissions */
 324
 325 /*
 326  * Flags for vnode operations.
 327  */
 328 enum rm         { RMFILE, RMDIRECTORY };        /* rm or rmdir (remove) */
 329 enum create     { CRCREAT, CRMKNOD, CRMKDIR };  /* reason for create */
 330
 331 /*
 332  * Structure used on VOP_GETSECATTR and VOP_SETSECATTR operations
 333  */
 334
 335 typedef struct vsecattr {
 336         uint_t          vsa_mask;       /* See below */
 337         int             vsa_aclcnt;     /* ACL entry count */
 338         void            *vsa_aclentp;   /* pointer to ACL entries */
 339         int             vsa_dfaclcnt;   /* default ACL entry count */
 340         void            *vsa_dfaclentp; /* pointer to default ACL entries */
 341         size_t          vsa_aclentsz;   /* ACE size in bytes of vsa_aclentp */
 342         uint_t          vsa_aclflags;   /* ACE ACL flags */
 343 } vsecattr_t;
 344
 345 /* vsa_mask values */
 346 #define VSA_ACL                 0x0001
 347 #define VSA_ACLCNT              0x0002
 348 #define VSA_DFACL               0x0004
 349 #define VSA_DFACLCNT            0x0008
 350 #define VSA_ACE                 0x0010
 351 #define VSA_ACECNT              0x0020
 352 #define VSA_ACE_ALLTYPES        0x0040
 353 #define VSA_ACE_ACLFLAGS        0x0080  /* get/set ACE ACL flags */
 354
 355 /*
 356  * Structure used by various vnode operations to determine
 357  * the context (pid, host, identity) of a caller.
 358  *
 359  * The cc_caller_id is used to identify one or more callers who invoke
 360  * operations, possibly on behalf of others.  For example, the NFS
 361  * server could have it's own cc_caller_id which can be detected by
 362  * vnode/vfs operations or (FEM) monitors on those operations.  New
 363  * caller IDs are generated by fs_new_caller_id().
 364  */
 365 typedef struct caller_context {
 366         pid_t           cc_pid;         /* Process ID of the caller */
 367         int             cc_sysid;       /* System ID, used for remote calls */
 368         u_longlong_t    cc_caller_id;   /* Identifier for (set of) caller(s) */
 369         ulong_t         cc_flags;
 370 } caller_context_t;
 371
 372 struct taskq;
 373
 374 /*
 375  * Flags for VOP_LOOKUP
 376  *
 377  * Defined in file.h, but also possible, FIGNORECASE and FSEARCH
 378  *
 379  */
 380 #define LOOKUP_DIR              0x01    /* want parent dir vp */
 381 #define LOOKUP_XATTR            0x02    /* lookup up extended attr dir */
 382 #define CREATE_XATTR_DIR        0x04    /* Create extended attr dir */
 383 #define LOOKUP_HAVE_SYSATTR_DIR 0x08    /* Already created virtual GFS dir */
 384
 385 /*
 386  * Flags for VOP_READDIR
 387  */
 388 #define V_RDDIR_ENTFLAGS        0x01    /* request dirent flags */
 389 #define V_RDDIR_ACCFILTER       0x02    /* filter out inaccessible dirents */
 390
 391 /*
 392  * Public vnode manipulation functions.
 393  */
 394 #ifdef  _KERNEL
 395
 396 void    vn_rele_async(struct vnode *vp, struct taskq *taskq);
 397
 398 /*
 399  * Extensible vnode attribute (xva) routines:
 400  * xva_init() initializes an xvattr_t (zero struct, init mapsize, set AT_XATTR)
 401  * xva_getxoptattr() returns a ponter to the xoptattr_t section of xvattr_t
 402  */
 403 void            xva_init(xvattr_t *);
 404 xoptattr_t      *xva_getxoptattr(xvattr_t *);   /* Get ptr to xoptattr_t */
 405
 406 #define VN_RELE_ASYNC(vp, taskq)        { \
 407         vn_rele_async(vp, taskq); \
 408 }
 409
 410 #endif  /* _KERNEL */
 411
 412 /*
 413  * Flags to VOP_SETATTR/VOP_GETATTR.
 414  */
 415 #define ATTR_UTIME      0x01    /* non-default utime(2) request */
 416 #define ATTR_EXEC       0x02    /* invocation from exec(2) */
 417 #define ATTR_COMM       0x04    /* yield common vp attributes */
 418 #define ATTR_HINT       0x08    /* information returned will be `hint' */
 419 #define ATTR_REAL       0x10    /* yield attributes of the real vp */
 420 #define ATTR_NOACLCHECK 0x20    /* Don't check ACL when checking permissions */
 421 #define ATTR_TRIGGER    0x40    /* Mount first if vnode is a trigger mount */
 422
 423 #ifdef  __cplusplus
 424 }
 425 #endif
 426
 427 #endif  /* _SYS_VNODE_H */