include/sys/xvattr.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 https://opensource.org/licenses/CDDL-1.0.
  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  */
  25
  26 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  27 /*        All Rights Reserved   */
  28
  29 /*
  30  * University Copyright- Copyright (c) 1982, 1986, 1988
  31  * The Regents of the University of California
  32  * All Rights Reserved
  33  *
  34  * University Acknowledgment- Portions of this document are derived from
  35  * software developed by the University of California, Berkeley, and its
  36  * contributors.
  37  */
  38
  39 #ifndef _SYS_XVATTR_H
  40 #define _SYS_XVATTR_H
  41
  42 #include <sys/vnode.h>
  43 #include <sys/string.h>
  44
  45 #define AV_SCANSTAMP_SZ 32              /* length of anti-virus scanstamp */
  46
  47 /*
  48  * Structure of all optional attributes.
  49  */
  50 typedef struct xoptattr {
  51         inode_timespec_t xoa_createtime;        /* Create time of file */
  52         uint8_t         xoa_archive;
  53         uint8_t         xoa_system;
  54         uint8_t         xoa_readonly;
  55         uint8_t         xoa_hidden;
  56         uint8_t         xoa_nounlink;
  57         uint8_t         xoa_immutable;
  58         uint8_t         xoa_appendonly;
  59         uint8_t         xoa_nodump;
  60         uint8_t         xoa_opaque;
  61         uint8_t         xoa_av_quarantined;
  62         uint8_t         xoa_av_modified;
  63         uint8_t         xoa_av_scanstamp[AV_SCANSTAMP_SZ];
  64         uint8_t         xoa_reparse;
  65         uint64_t        xoa_generation;
  66         uint8_t         xoa_offline;
  67         uint8_t         xoa_sparse;
  68         uint8_t         xoa_projinherit;
  69         uint64_t        xoa_projid;
  70 } xoptattr_t;
  71
  72 /*
  73  * The xvattr structure is really a variable length structure that
  74  * is made up of:
  75  * - The classic vattr_t (xva_vattr)
  76  * - a 32 bit quantity (xva_mapsize) that specifies the size of the
  77  *   attribute bitmaps in 32 bit words.
  78  * - A pointer to the returned attribute bitmap (needed because the
  79  *   previous element, the requested attribute bitmap) is variable length.
  80  * - The requested attribute bitmap, which is an array of 32 bit words.
  81  *   Callers use the XVA_SET_REQ() macro to set the bits corresponding to
  82  *   the attributes that are being requested.
  83  * - The returned attribute bitmap, which is an array of 32 bit words.
  84  *   File systems that support optional attributes use the XVA_SET_RTN()
  85  *   macro to set the bits corresponding to the attributes that are being
  86  *   returned.
  87  * - The xoptattr_t structure which contains the attribute values
  88  *
  89  * xva_mapsize determines how many words in the attribute bitmaps.
  90  * Immediately following the attribute bitmaps is the xoptattr_t.
  91  * xva_getxoptattr() is used to get the pointer to the xoptattr_t
  92  * section.
  93  */
  94
  95 #define XVA_MAPSIZE     3               /* Size of attr bitmaps */
  96 #define XVA_MAGIC       0x78766174      /* Magic # for verification */
  97
  98 /*
  99  * The xvattr structure is an extensible structure which permits optional
 100  * attributes to be requested/returned.  File systems may or may not support
 101  * optional attributes.  They do so at their own discretion but if they do
 102  * support optional attributes, they must register the VFSFT_XVATTR feature
 103  * so that the optional attributes can be set/retrieved.
 104  *
 105  * The fields of the xvattr structure are:
 106  *
 107  * xva_vattr - The first element of an xvattr is a legacy vattr structure
 108  * which includes the common attributes.  If AT_XVATTR is set in the va_mask
 109  * then the entire structure is treated as an xvattr.  If AT_XVATTR is not
 110  * set, then only the xva_vattr structure can be used.
 111  *
 112  * xva_magic - 0x78766174 (hex for "xvat"). Magic number for verification.
 113  *
 114  * xva_mapsize - Size of requested and returned attribute bitmaps.
 115  *
 116  * xva_rtnattrmapp - Pointer to xva_rtnattrmap[].  We need this since the
 117  * size of the array before it, xva_reqattrmap[], could change which means
 118  * the location of xva_rtnattrmap[] could change.  This will allow unbundled
 119  * file systems to find the location of xva_rtnattrmap[] when the sizes change.
 120  *
 121  * xva_reqattrmap[] - Array of requested attributes.  Attributes are
 122  * represented by a specific bit in a specific element of the attribute
 123  * map array.  Callers set the bits corresponding to the attributes
 124  * that the caller wants to get/set.
 125  *
 126  * xva_rtnattrmap[] - Array of attributes that the file system was able to
 127  * process.  Not all file systems support all optional attributes.  This map
 128  * informs the caller which attributes the underlying file system was able
 129  * to set/get.  (Same structure as the requested attributes array in terms
 130  * of each attribute  corresponding to specific bits and array elements.)
 131  *
 132  * xva_xoptattrs - Structure containing values of optional attributes.
 133  * These values are only valid if the corresponding bits in xva_reqattrmap
 134  * are set and the underlying file system supports those attributes.
 135  */
 136 typedef struct xvattr {
 137         vattr_t         xva_vattr;      /* Embedded vattr structure */
 138         uint32_t        xva_magic;      /* Magic Number */
 139         uint32_t        xva_mapsize;    /* Size of attr bitmap (32-bit words) */
 140         uint32_t        *xva_rtnattrmapp;       /* Ptr to xva_rtnattrmap[] */
 141         uint32_t        xva_reqattrmap[XVA_MAPSIZE];    /* Requested attrs */
 142         uint32_t        xva_rtnattrmap[XVA_MAPSIZE];    /* Returned attrs */
 143         xoptattr_t      xva_xoptattrs;  /* Optional attributes */
 144 } xvattr_t;
 145
 146 /*
 147  * Attribute bits used in the extensible attribute's (xva's) attribute
 148  * bitmaps.  Note that the bitmaps are made up of a variable length number
 149  * of 32-bit words.  The convention is to use XAT{n}_{attrname} where "n"
 150  * is the element in the bitmap (starting at 1).  This convention is for
 151  * the convenience of the maintainer to keep track of which element each
 152  * attribute belongs to.
 153  *
 154  * NOTE THAT CONSUMERS MUST *NOT* USE THE XATn_* DEFINES DIRECTLY.  CONSUMERS
 155  * MUST USE THE XAT_* DEFINES.
 156  */
 157 #define XAT0_INDEX      0LL             /* Index into bitmap for XAT0 attrs */
 158 #define XAT0_CREATETIME 0x00000001      /* Create time of file */
 159 #define XAT0_ARCHIVE    0x00000002      /* Archive */
 160 #define XAT0_SYSTEM     0x00000004      /* System */
 161 #define XAT0_READONLY   0x00000008      /* Readonly */
 162 #define XAT0_HIDDEN     0x00000010      /* Hidden */
 163 #define XAT0_NOUNLINK   0x00000020      /* Nounlink */
 164 #define XAT0_IMMUTABLE  0x00000040      /* immutable */
 165 #define XAT0_APPENDONLY 0x00000080      /* appendonly */
 166 #define XAT0_NODUMP     0x00000100      /* nodump */
 167 #define XAT0_OPAQUE     0x00000200      /* opaque */
 168 #define XAT0_AV_QUARANTINED     0x00000400      /* anti-virus quarantine */
 169 #define XAT0_AV_MODIFIED        0x00000800      /* anti-virus modified */
 170 #define XAT0_AV_SCANSTAMP       0x00001000      /* anti-virus scanstamp */
 171 #define XAT0_REPARSE    0x00002000      /* FS reparse point */
 172 #define XAT0_GEN        0x00004000      /* object generation number */
 173 #define XAT0_OFFLINE    0x00008000      /* offline */
 174 #define XAT0_SPARSE     0x00010000      /* sparse */
 175 #define XAT0_PROJINHERIT        0x00020000      /* Create with parent projid */
 176 #define XAT0_PROJID     0x00040000      /* Project ID */
 177
 178 #define XAT0_ALL_ATTRS  (XAT0_CREATETIME|XAT0_ARCHIVE|XAT0_SYSTEM| \
 179     XAT0_READONLY|XAT0_HIDDEN|XAT0_NOUNLINK|XAT0_IMMUTABLE|XAT0_APPENDONLY| \
 180     XAT0_NODUMP|XAT0_OPAQUE|XAT0_AV_QUARANTINED|  XAT0_AV_MODIFIED| \
 181     XAT0_AV_SCANSTAMP|XAT0_REPARSE|XATO_GEN|XAT0_OFFLINE|XAT0_SPARSE| \
 182     XAT0_PROJINHERIT | XAT0_PROJID)
 183
 184 /* Support for XAT_* optional attributes */
 185 #define XVA_MASK                0xffffffff      /* Used to mask off 32 bits */
 186 #define XVA_SHFT                32              /* Used to shift index */
 187
 188 /*
 189  * Used to pry out the index and attribute bits from the XAT_* attributes
 190  * defined below.  Note that we're masking things down to 32 bits then
 191  * casting to uint32_t.
 192  */
 193 #define XVA_INDEX(attr)         ((uint32_t)(((attr) >> XVA_SHFT) & XVA_MASK))
 194 #define XVA_ATTRBIT(attr)       ((uint32_t)((attr) & XVA_MASK))
 195
 196 /*
 197  * The following defines present a "flat namespace" so that consumers don't
 198  * need to keep track of which element belongs to which bitmap entry.
 199  *
 200  * NOTE THAT THESE MUST NEVER BE OR-ed TOGETHER
 201  */
 202 #define XAT_CREATETIME          ((XAT0_INDEX << XVA_SHFT) | XAT0_CREATETIME)
 203 #define XAT_ARCHIVE             ((XAT0_INDEX << XVA_SHFT) | XAT0_ARCHIVE)
 204 #define XAT_SYSTEM              ((XAT0_INDEX << XVA_SHFT) | XAT0_SYSTEM)
 205 #define XAT_READONLY            ((XAT0_INDEX << XVA_SHFT) | XAT0_READONLY)
 206 #define XAT_HIDDEN              ((XAT0_INDEX << XVA_SHFT) | XAT0_HIDDEN)
 207 #define XAT_NOUNLINK            ((XAT0_INDEX << XVA_SHFT) | XAT0_NOUNLINK)
 208 #define XAT_IMMUTABLE           ((XAT0_INDEX << XVA_SHFT) | XAT0_IMMUTABLE)
 209 #define XAT_APPENDONLY          ((XAT0_INDEX << XVA_SHFT) | XAT0_APPENDONLY)
 210 #define XAT_NODUMP              ((XAT0_INDEX << XVA_SHFT) | XAT0_NODUMP)
 211 #define XAT_OPAQUE              ((XAT0_INDEX << XVA_SHFT) | XAT0_OPAQUE)
 212 #define XAT_AV_QUARANTINED      ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_QUARANTINED)
 213 #define XAT_AV_MODIFIED         ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_MODIFIED)
 214 #define XAT_AV_SCANSTAMP        ((XAT0_INDEX << XVA_SHFT) | XAT0_AV_SCANSTAMP)
 215 #define XAT_REPARSE             ((XAT0_INDEX << XVA_SHFT) | XAT0_REPARSE)
 216 #define XAT_GEN                 ((XAT0_INDEX << XVA_SHFT) | XAT0_GEN)
 217 #define XAT_OFFLINE             ((XAT0_INDEX << XVA_SHFT) | XAT0_OFFLINE)
 218 #define XAT_SPARSE              ((XAT0_INDEX << XVA_SHFT) | XAT0_SPARSE)
 219 #define XAT_PROJINHERIT         ((XAT0_INDEX << XVA_SHFT) | XAT0_PROJINHERIT)
 220 #define XAT_PROJID              ((XAT0_INDEX << XVA_SHFT) | XAT0_PROJID)
 221
 222 /*
 223  * The returned attribute map array (xva_rtnattrmap[]) is located past the
 224  * requested attribute map array (xva_reqattrmap[]).  Its location changes
 225  * when the array sizes change.  We use a separate pointer in a known location
 226  * (xva_rtnattrmapp) to hold the location of xva_rtnattrmap[].  This is
 227  * set in xva_init()
 228  */
 229 #define XVA_RTNATTRMAP(xvap)    ((xvap)->xva_rtnattrmapp)
 230
 231 /*
 232  * XVA_SET_REQ() sets an attribute bit in the proper element in the bitmap
 233  * of requested attributes (xva_reqattrmap[]).
 234  */
 235 #define XVA_SET_REQ(xvap, attr)                                 \
 236         ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);          \
 237         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 238         (xvap)->xva_reqattrmap[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)
 239 /*
 240  * XVA_CLR_REQ() clears an attribute bit in the proper element in the bitmap
 241  * of requested attributes (xva_reqattrmap[]).
 242  */
 243 #define XVA_CLR_REQ(xvap, attr)                                 \
 244         ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);          \
 245         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 246         (xvap)->xva_reqattrmap[XVA_INDEX(attr)] &= ~XVA_ATTRBIT(attr)
 247
 248 /*
 249  * XVA_SET_RTN() sets an attribute bit in the proper element in the bitmap
 250  * of returned attributes (xva_rtnattrmap[]).
 251  */
 252 #define XVA_SET_RTN(xvap, attr)                                 \
 253         ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);          \
 254         ASSERT((xvap)->xva_magic == XVA_MAGIC);                 \
 255         (XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)
 256
 257 /*
 258  * XVA_ISSET_REQ() checks the requested attribute bitmap (xva_reqattrmap[])
 259  * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 260  */
 261 #define XVA_ISSET_REQ(xvap, attr)                                       \
 262         ((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&                    \
 263                 ((xvap)->xva_magic == XVA_MAGIC) &&                     \
 264                 ((xvap)->xva_mapsize > XVA_INDEX(attr))) ?              \
 265         ((xvap)->xva_reqattrmap[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)
 266
 267 /*
 268  * XVA_ISSET_RTN() checks the returned attribute bitmap (xva_rtnattrmap[])
 269  * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 270  */
 271 #define XVA_ISSET_RTN(xvap, attr)                                       \
 272         ((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&                    \
 273                 ((xvap)->xva_magic == XVA_MAGIC) &&                     \
 274                 ((xvap)->xva_mapsize > XVA_INDEX(attr))) ?              \
 275         ((XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)
 276
 277 /*
 278  * Zero out the structure, set the size of the requested/returned bitmaps,
 279  * set AT_XVATTR in the embedded vattr_t's va_mask, and set up the pointer
 280  * to the returned attributes array.
 281  */
 282 static inline void
 283 xva_init(xvattr_t *xvap)
 284 {
 285         memset(xvap, 0, sizeof (xvattr_t));
 286         xvap->xva_mapsize = XVA_MAPSIZE;
 287         xvap->xva_magic = XVA_MAGIC;
 288         xvap->xva_vattr.va_mask = ATTR_XVATTR;
 289         xvap->xva_rtnattrmapp = &(xvap->xva_rtnattrmap)[0];
 290 }
 291
 292 /*
 293  * If AT_XVATTR is set, returns a pointer to the embedded xoptattr_t
 294  * structure.  Otherwise, returns NULL.
 295  */
 296 static inline xoptattr_t *
 297 xva_getxoptattr(xvattr_t *xvap)
 298 {
 299         xoptattr_t *xoap = NULL;
 300         if (xvap->xva_vattr.va_mask & AT_XVATTR)
 301                         xoap = &xvap->xva_xoptattrs;
 302         return (xoap);
 303 }
 304
 305 #define MODEMASK        07777           /* mode bits plus permission bits */
 306 #define PERMMASK        00777           /* permission bits */
 307
 308 /*
 309  * VOP_ACCESS flags
 310  */
 311 #define V_ACE_MASK      0x1     /* mask represents  NFSv4 ACE permissions */
 312 #define V_APPEND        0x2     /* want to do append only check */
 313
 314 /*
 315  * Structure used on VOP_GETSECATTR and VOP_SETSECATTR operations
 316  */
 317
 318 typedef struct vsecattr {
 319         uint_t          vsa_mask;       /* See below */
 320         int             vsa_aclcnt;     /* ACL entry count */
 321         void            *vsa_aclentp;   /* pointer to ACL entries */
 322         int             vsa_dfaclcnt;   /* default ACL entry count */
 323         void            *vsa_dfaclentp; /* pointer to default ACL entries */
 324         size_t          vsa_aclentsz;   /* ACE size in bytes of vsa_aclentp */
 325         uint_t          vsa_aclflags;   /* ACE ACL flags */
 326 } vsecattr_t;
 327
 328 /* vsa_mask values */
 329 #define VSA_ACL                 0x0001
 330 #define VSA_ACLCNT              0x0002
 331 #define VSA_DFACL               0x0004
 332 #define VSA_DFACLCNT            0x0008
 333 #define VSA_ACE                 0x0010
 334 #define VSA_ACECNT              0x0020
 335 #define VSA_ACE_ALLTYPES        0x0040
 336 #define VSA_ACE_ACLFLAGS        0x0080  /* get/set ACE ACL flags */
 337
 338 #endif /* _SYS_XVATTR_H */