[mirror_zfs.git] / include / sys / xvattr.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#ifndef _SYS_XVATTR_H
#define	_SYS_XVATTR_H

#include <sys/vnode.h>
#include <sys/strings.h>

#define	AV_SCANSTAMP_SZ	32		/* length of anti-virus scanstamp */

/*
 * Structure of all optional attributes.
 */
typedef struct xoptattr {
	inode_timespec_t xoa_createtime;	/* Create time of file */
	uint8_t		xoa_archive;
	uint8_t		xoa_system;
	uint8_t		xoa_readonly;
	uint8_t		xoa_hidden;
	uint8_t		xoa_nounlink;
	uint8_t		xoa_immutable;
	uint8_t		xoa_appendonly;
	uint8_t		xoa_nodump;
	uint8_t		xoa_opaque;
	uint8_t		xoa_av_quarantined;
	uint8_t		xoa_av_modified;
	uint8_t		xoa_av_scanstamp[AV_SCANSTAMP_SZ];
	uint8_t		xoa_reparse;
	uint64_t	xoa_generation;
	uint8_t		xoa_offline;
	uint8_t		xoa_sparse;
	uint8_t		xoa_projinherit;
	uint64_t	xoa_projid;
} xoptattr_t;

/*
 * The xvattr structure is really a variable length structure that
 * is made up of:
 * - The classic vattr_t (xva_vattr)
 * - a 32 bit quantity (xva_mapsize) that specifies the size of the
 *   attribute bitmaps in 32 bit words.
 * - A pointer to the returned attribute bitmap (needed because the
 *   previous element, the requested attribute bitmap) is variable length.
 * - The requested attribute bitmap, which is an array of 32 bit words.
 *   Callers use the XVA_SET_REQ() macro to set the bits corresponding to
 *   the attributes that are being requested.
 * - The returned attribute bitmap, which is an array of 32 bit words.
 *   File systems that support optional attributes use the XVA_SET_RTN()
 *   macro to set the bits corresponding to the attributes that are being
 *   returned.
 * - The xoptattr_t structure which contains the attribute values
 *
 * xva_mapsize determines how many words in the attribute bitmaps.
 * Immediately following the attribute bitmaps is the xoptattr_t.
 * xva_getxoptattr() is used to get the pointer to the xoptattr_t
 * section.
 */

#define	XVA_MAPSIZE	3		/* Size of attr bitmaps */
#define	XVA_MAGIC	0x78766174	/* Magic # for verification */

/*
 * The xvattr structure is an extensible structure which permits optional
 * attributes to be requested/returned.  File systems may or may not support
 * optional attributes.  They do so at their own discretion but if they do
 * support optional attributes, they must register the VFSFT_XVATTR feature
 * so that the optional attributes can be set/retrieved.
 *
 * The fields of the xvattr structure are:
 *
 * xva_vattr - The first element of an xvattr is a legacy vattr structure
 * which includes the common attributes.  If AT_XVATTR is set in the va_mask
 * then the entire structure is treated as an xvattr.  If AT_XVATTR is not
 * set, then only the xva_vattr structure can be used.
 *
 * xva_magic - 0x78766174 (hex for "xvat"). Magic number for verification.
 *
 * xva_mapsize - Size of requested and returned attribute bitmaps.
 *
 * xva_rtnattrmapp - Pointer to xva_rtnattrmap[].  We need this since the
 * size of the array before it, xva_reqattrmap[], could change which means
 * the location of xva_rtnattrmap[] could change.  This will allow unbundled
 * file systems to find the location of xva_rtnattrmap[] when the sizes change.
 *
 * xva_reqattrmap[] - Array of requested attributes.  Attributes are
 * represented by a specific bit in a specific element of the attribute
 * map array.  Callers set the bits corresponding to the attributes
 * that the caller wants to get/set.
 *
 * xva_rtnattrmap[] - Array of attributes that the file system was able to
 * process.  Not all file systems support all optional attributes.  This map
 * informs the caller which attributes the underlying file system was able
 * to set/get.  (Same structure as the requested attributes array in terms
 * of each attribute  corresponding to specific bits and array elements.)
 *
 * xva_xoptattrs - Structure containing values of optional attributes.
 * These values are only valid if the corresponding bits in xva_reqattrmap
 * are set and the underlying file system supports those attributes.
 */
typedef struct xvattr {
	vattr_t		xva_vattr;	/* Embedded vattr structure */
	uint32_t	xva_magic;	/* Magic Number */
	uint32_t	xva_mapsize;	/* Size of attr bitmap (32-bit words) */
	uint32_t	*xva_rtnattrmapp;	/* Ptr to xva_rtnattrmap[] */
	uint32_t	xva_reqattrmap[XVA_MAPSIZE];	/* Requested attrs */
	uint32_t	xva_rtnattrmap[XVA_MAPSIZE];	/* Returned attrs */
	xoptattr_t	xva_xoptattrs;	/* Optional attributes */
} xvattr_t;

/*
 * Attribute bits used in the extensible attribute's (xva's) attribute
 * bitmaps.  Note that the bitmaps are made up of a variable length number
 * of 32-bit words.  The convention is to use XAT{n}_{attrname} where "n"
 * is the element in the bitmap (starting at 1).  This convention is for
 * the convenience of the maintainer to keep track of which element each
 * attribute belongs to.
 *
 * NOTE THAT CONSUMERS MUST *NOT* USE THE XATn_* DEFINES DIRECTLY.  CONSUMERS
 * MUST USE THE XAT_* DEFINES.
 */
#define	XAT0_INDEX	0LL		/* Index into bitmap for XAT0 attrs */
#define	XAT0_CREATETIME	0x00000001	/* Create time of file */
#define	XAT0_ARCHIVE	0x00000002	/* Archive */
#define	XAT0_SYSTEM	0x00000004	/* System */
#define	XAT0_READONLY	0x00000008	/* Readonly */
#define	XAT0_HIDDEN	0x00000010	/* Hidden */
#define	XAT0_NOUNLINK	0x00000020	/* Nounlink */
#define	XAT0_IMMUTABLE	0x00000040	/* immutable */
#define	XAT0_APPENDONLY	0x00000080	/* appendonly */
#define	XAT0_NODUMP	0x00000100	/* nodump */
#define	XAT0_OPAQUE	0x00000200	/* opaque */
#define	XAT0_AV_QUARANTINED	0x00000400	/* anti-virus quarantine */
#define	XAT0_AV_MODIFIED	0x00000800	/* anti-virus modified */
#define	XAT0_AV_SCANSTAMP	0x00001000	/* anti-virus scanstamp */
#define	XAT0_REPARSE	0x00002000	/* FS reparse point */
#define	XAT0_GEN	0x00004000	/* object generation number */
#define	XAT0_OFFLINE	0x00008000	/* offline */
#define	XAT0_SPARSE	0x00010000	/* sparse */
#define	XAT0_PROJINHERIT	0x00020000	/* Create with parent projid */
#define	XAT0_PROJID	0x00040000	/* Project ID */

#define	XAT0_ALL_ATTRS	(XAT0_CREATETIME|XAT0_ARCHIVE|XAT0_SYSTEM| \
    XAT0_READONLY|XAT0_HIDDEN|XAT0_NOUNLINK|XAT0_IMMUTABLE|XAT0_APPENDONLY| \
    XAT0_NODUMP|XAT0_OPAQUE|XAT0_AV_QUARANTINED|  XAT0_AV_MODIFIED| \
    XAT0_AV_SCANSTAMP|XAT0_REPARSE|XATO_GEN|XAT0_OFFLINE|XAT0_SPARSE| \
    XAT0_PROJINHERIT | XAT0_PROJID)

/* Support for XAT_* optional attributes */
#define	XVA_MASK		0xffffffff	/* Used to mask off 32 bits */
#define	XVA_SHFT		32		/* Used to shift index */

/*
 * Used to pry out the index and attribute bits from the XAT_* attributes
 * defined below.  Note that we're masking things down to 32 bits then
 * casting to uint32_t.
 */
#define	XVA_INDEX(attr)		((uint32_t)(((attr) >> XVA_SHFT) & XVA_MASK))
#define	XVA_ATTRBIT(attr)	((uint32_t)((attr) & XVA_MASK))

/*
 * The following defines present a "flat namespace" so that consumers don't
 * need to keep track of which element belongs to which bitmap entry.
 *
 * NOTE THAT THESE MUST NEVER BE OR-ed TOGETHER
 */
#define	XAT_CREATETIME		((XAT0_INDEX << XVA_SHFT) | XAT0_CREATETIME)
#define	XAT_ARCHIVE		((XAT0_INDEX << XVA_SHFT) | XAT0_ARCHIVE)
#define	XAT_SYSTEM		((XAT0_INDEX << XVA_SHFT) | XAT0_SYSTEM)
#define	XAT_READONLY		((XAT0_INDEX << XVA_SHFT) | XAT0_READONLY)
#define	XAT_HIDDEN		((XAT0_INDEX << XVA_SHFT) | XAT0_HIDDEN)
#define	XAT_NOUNLINK		((XAT0_INDEX << XVA_SHFT) | XAT0_NOUNLINK)
#define	XAT_IMMUTABLE		((XAT0_INDEX << XVA_SHFT) | XAT0_IMMUTABLE)
#define	XAT_APPENDONLY		((XAT0_INDEX << XVA_SHFT) | XAT0_APPENDONLY)
#define	XAT_NODUMP		((XAT0_INDEX << XVA_SHFT) | XAT0_NODUMP)
#define	XAT_OPAQUE		((XAT0_INDEX << XVA_SHFT) | XAT0_OPAQUE)
#define	XAT_AV_QUARANTINED	((XAT0_INDEX << XVA_SHFT) | XAT0_AV_QUARANTINED)
#define	XAT_AV_MODIFIED		((XAT0_INDEX << XVA_SHFT) | XAT0_AV_MODIFIED)
#define	XAT_AV_SCANSTAMP	((XAT0_INDEX << XVA_SHFT) | XAT0_AV_SCANSTAMP)
#define	XAT_REPARSE		((XAT0_INDEX << XVA_SHFT) | XAT0_REPARSE)
#define	XAT_GEN			((XAT0_INDEX << XVA_SHFT) | XAT0_GEN)
#define	XAT_OFFLINE		((XAT0_INDEX << XVA_SHFT) | XAT0_OFFLINE)
#define	XAT_SPARSE		((XAT0_INDEX << XVA_SHFT) | XAT0_SPARSE)
#define	XAT_PROJINHERIT		((XAT0_INDEX << XVA_SHFT) | XAT0_PROJINHERIT)
#define	XAT_PROJID		((XAT0_INDEX << XVA_SHFT) | XAT0_PROJID)

/*
 * The returned attribute map array (xva_rtnattrmap[]) is located past the
 * requested attribute map array (xva_reqattrmap[]).  Its location changes
 * when the array sizes change.  We use a separate pointer in a known location
 * (xva_rtnattrmapp) to hold the location of xva_rtnattrmap[].  This is
 * set in xva_init()
 */
#define	XVA_RTNATTRMAP(xvap)	((xvap)->xva_rtnattrmapp)

/*
 * XVA_SET_REQ() sets an attribute bit in the proper element in the bitmap
 * of requested attributes (xva_reqattrmap[]).
 */
#define	XVA_SET_REQ(xvap, attr)					\
	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
	(xvap)->xva_reqattrmap[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)
/*
 * XVA_CLR_REQ() clears an attribute bit in the proper element in the bitmap
 * of requested attributes (xva_reqattrmap[]).
 */
#define	XVA_CLR_REQ(xvap, attr)					\
	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
	(xvap)->xva_reqattrmap[XVA_INDEX(attr)] &= ~XVA_ATTRBIT(attr)

/*
 * XVA_SET_RTN() sets an attribute bit in the proper element in the bitmap
 * of returned attributes (xva_rtnattrmap[]).
 */
#define	XVA_SET_RTN(xvap, attr)					\
	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR);		\
	ASSERT((xvap)->xva_magic == XVA_MAGIC);			\
	(XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] |= XVA_ATTRBIT(attr)

/*
 * XVA_ISSET_REQ() checks the requested attribute bitmap (xva_reqattrmap[])
 * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 */
#define	XVA_ISSET_REQ(xvap, attr)					\
	((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&			\
		((xvap)->xva_magic == XVA_MAGIC) &&			\
		((xvap)->xva_mapsize > XVA_INDEX(attr))) ?		\
	((xvap)->xva_reqattrmap[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) :	0)

/*
 * XVA_ISSET_RTN() checks the returned attribute bitmap (xva_rtnattrmap[])
 * to see of the corresponding attribute bit is set.  If so, returns non-zero.
 */
#define	XVA_ISSET_RTN(xvap, attr)					\
	((((xvap)->xva_vattr.va_mask & AT_XVATTR) &&			\
		((xvap)->xva_magic == XVA_MAGIC) &&			\
		((xvap)->xva_mapsize > XVA_INDEX(attr))) ?		\
	((XVA_RTNATTRMAP(xvap))[XVA_INDEX(attr)] & XVA_ATTRBIT(attr)) : 0)

/*
 * Zero out the structure, set the size of the requested/returned bitmaps,
 * set AT_XVATTR in the embedded vattr_t's va_mask, and set up the pointer
 * to the returned attributes array.
 */
static inline void
xva_init(xvattr_t *xvap)
{
	bzero(xvap, sizeof (xvattr_t));
	xvap->xva_mapsize = XVA_MAPSIZE;
	xvap->xva_magic = XVA_MAGIC;
	xvap->xva_vattr.va_mask = ATTR_XVATTR;
	xvap->xva_rtnattrmapp = &(xvap->xva_rtnattrmap)[0];
}

/*
 * If AT_XVATTR is set, returns a pointer to the embedded xoptattr_t
 * structure.  Otherwise, returns NULL.
 */
static inline xoptattr_t *
xva_getxoptattr(xvattr_t *xvap)
{
	xoptattr_t *xoap = NULL;
	if (xvap->xva_vattr.va_mask & AT_XVATTR)
			xoap = &xvap->xva_xoptattrs;
	return (xoap);
}

#define	MODEMASK	07777		/* mode bits plus permission bits */
#define	PERMMASK	00777		/* permission bits */

/*
 * VOP_ACCESS flags
 */
#define	V_ACE_MASK	0x1	/* mask represents  NFSv4 ACE permissions */
#define	V_APPEND	0x2	/* want to do append only check */

/*
 * Structure used on VOP_GETSECATTR and VOP_SETSECATTR operations
 */

typedef struct vsecattr {
	uint_t		vsa_mask;	/* See below */
	int		vsa_aclcnt;	/* ACL entry count */
	void		*vsa_aclentp;	/* pointer to ACL entries */
	int		vsa_dfaclcnt;	/* default ACL entry count */
	void		*vsa_dfaclentp;	/* pointer to default ACL entries */
	size_t		vsa_aclentsz;	/* ACE size in bytes of vsa_aclentp */
	uint_t		vsa_aclflags;	/* ACE ACL flags */
} vsecattr_t;

/* vsa_mask values */
#define	VSA_ACL			0x0001
#define	VSA_ACLCNT		0x0002
#define	VSA_DFACL		0x0004
#define	VSA_DFACLCNT		0x0008
#define	VSA_ACE			0x0010
#define	VSA_ACECNT		0x0020
#define	VSA_ACE_ALLTYPES	0x0040
#define	VSA_ACE_ACLFLAGS	0x0080	/* get/set ACE ACL flags */

#endif /* _SYS_XVATTR_H */
Commit	Line	Data
321a498b BB	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	*/
	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>
93ce2b4c	43	#include <sys/strings.h>
321a498b BB	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 {
6413c95f	51	inode_timespec_t xoa_createtime; /* Create time of file */
321a498b BB	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;
9c5167d1 NF	68	uint8_t xoa_projinherit;
9c5167d1 NF	69	uint64_t xoa_projid;
321a498b BB	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
4e33ba4c	79	* previous element, the requested attribute bitmap) is variable length.
321a498b BB	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
4e33ba4c	103	* so that the optional attributes can be set/retrieved.
321a498b BB	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 */
9c5167d1 NF	175	#define XAT0_PROJINHERIT 0x00020000 /* Create with parent projid */
9c5167d1 NF	176	#define XAT0_PROJID 0x00040000 /* Project ID */
321a498b BB	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\| \
9c5167d1 NF	181	XAT0_AV_SCANSTAMP\|XAT0_REPARSE\|XATO_GEN\|XAT0_OFFLINE\|XAT0_SPARSE\| \
9c5167d1 NF	182	XAT0_PROJINHERIT \| XAT0_PROJID)
321a498b BB	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)
9c5167d1 NF	219	#define XAT_PROJINHERIT ((XAT0_INDEX << XVA_SHFT) \| XAT0_PROJINHERIT)
9c5167d1 NF	220	#define XAT_PROJID ((XAT0_INDEX << XVA_SHFT) \| XAT0_PROJID)
321a498b BB	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) \
05100ec8	236	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR); \
321a498b BB	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) \
05100ec8	244	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR); \
321a498b BB	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) \
05100ec8	253	ASSERT((xvap)->xva_vattr.va_mask & AT_XVATTR); \
321a498b BB	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) \
05100ec8	262	((((xvap)->xva_vattr.va_mask & AT_XVATTR) && \
321a498b BB	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) \
05100ec8	272	((((xvap)->xva_vattr.va_mask & AT_XVATTR) && \
321a498b BB	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	bzero(xvap, 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 */