AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 04:50:53 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

xfs: clean up the attr flag confusion

Browse Source 
The ATTR_* flags have a long IRIX history, where they a userspace
interface, the on-disk format and an internal interface.  We've split
out the on-disk interface to the XFS_ATTR_* values, but despite (or
because?) of that the flag have still been a mess.  Switch the
internal interface to pass the on-disk XFS_ATTR_* flags for the
namespace and the Linux XATTR_* flags for the actual flags instead.
The ATTR_* values that are actually used are move to xfs_fs.h with a
new XFS_IOC_* prefix to not conflict with the userspace version that
has the same name and must have the same value.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Chandan Rajendra <chandanrlinux@gmail.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
This commit is contained in:
Christoph Hellwig 2020-02-26 17:30:42 -08:00 committed by Darrick J. Wong
parent f3e93d95fe
commit d5f0f49a9b
13 changed files with 96 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
fs/xfs/libxfs/xfs_attr.c
View File

@ -295,7 +295,7 @@ xfs_attr_set(
struct xfs_inode *dp = args->dp;
struct xfs_mount *mp = dp->i_mount;
struct xfs_trans_res tres;
int rsvd = (args->flags & ATTR_ROOT) != 0;
bool rsvd = (args->attr_filter & XFS_ATTR_ROOT);
int error, local;
unsigned int total;
@ -423,10 +423,10 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
trace_xfs_attr_sf_addname(args);
retval = xfs_attr_shortform_lookup(args);
if (retval == -ENOATTR && (args->flags & ATTR_REPLACE))
if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
return retval;
if (retval == -EEXIST) {
if (args->flags & ATTR_CREATE)
if (args->attr_flags & XATTR_CREATE)
return retval;
retval = xfs_attr_shortform_remove(args);
if (retval)
@ -436,7 +436,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
* that the leaf format add routine won't trip over the attr
* not being around.
*/
args->flags &= ~ATTR_REPLACE;
args->attr_flags &= ~XATTR_REPLACE;
}
if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
@ -489,10 +489,10 @@ xfs_attr_leaf_addname(
* the given flags produce an error or call for an atomic rename.
*/
retval = xfs_attr3_leaf_lookup_int(bp, args);
if (retval == -ENOATTR && (args->flags & ATTR_REPLACE))
if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
goto out_brelse;
if (retval == -EEXIST) {
if (args->flags & ATTR_CREATE) /* pure create op */
if (args->attr_flags & XATTR_CREATE)
goto out_brelse;
trace_xfs_attr_leaf_replace(args);
@ -763,10 +763,10 @@ xfs_attr_node_addname(
goto out;
blk = &state->path.blk[ state->path.active-1 ];
ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
if (retval == -ENOATTR && (args->flags & ATTR_REPLACE))
if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
goto out;
if (retval == -EEXIST) {
if (args->flags & ATTR_CREATE)
if (args->attr_flags & XATTR_CREATE)
goto out;
trace_xfs_attr_node_replace(args);

22
fs/xfs/libxfs/xfs_attr.h
View File

@ -21,26 +21,6 @@ struct xfs_attr_list_context;
* as possible so as to fit into the literal area of the inode.
*/
/*========================================================================
* External interfaces
*========================================================================*/
#define ATTR_DONTFOLLOW 0x0001 /* -- ignored, from IRIX -- */
#define ATTR_ROOT 0x0002 /* use attrs in root (trusted) namespace */
#define ATTR_TRUST 0x0004 /* -- unused, from IRIX -- */
#define ATTR_SECURE 0x0008 /* use attrs in security namespace */
#define ATTR_CREATE 0x0010 /* pure create: fail if attr already exists */
#define ATTR_REPLACE 0x0020 /* pure set: fail if attr does not exist */
#define XFS_ATTR_FLAGS \
{ ATTR_DONTFOLLOW, "DONTFOLLOW" }, \
{ ATTR_ROOT, "ROOT" }, \
{ ATTR_TRUST, "TRUST" }, \
{ ATTR_SECURE, "SECURE" }, \
{ ATTR_CREATE, "CREATE" }, \
{ ATTR_REPLACE, "REPLACE" }
/*
* The maximum size (into the kernel or returned from the kernel) of an
* attribute value or the buffer used for an attr_list() call. Larger
@ -87,7 +67,7 @@ struct xfs_attr_list_context {
int dupcnt; /* count dup hashvals seen */
int bufsize; /* total buffer size */
int firstu; /* first used byte in buffer */
int flags; /* from VOP call */
unsigned int attr_filter; /* XFS_ATTR_{ROOT,SECURE} */
int resynch; /* T/F: resynch with cursor */
put_listent_func_t put_listent; /* list output fmt function */
int index; /* index into output buffer */

14
fs/xfs/libxfs/xfs_attr_leaf.c
View File

@ -456,8 +456,7 @@ xfs_attr_match(
return false;
if (memcmp(args->name, name, namelen) != 0)
return false;
if (XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags) !=
XFS_ATTR_NSP_ONDISK(flags))
if (args->attr_filter != (flags & XFS_ATTR_NSP_ONDISK_MASK))
return false;
return true;
}
@ -697,7 +696,7 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
sfe->namelen = args->namelen;
sfe->valuelen = args->valuelen;
sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
sfe->flags = args->attr_filter;
memcpy(sfe->nameval, args->name, args->namelen);
memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
sf->hdr.count++;
@ -906,7 +905,7 @@ xfs_attr_shortform_to_leaf(
nargs.valuelen = sfe->valuelen;
nargs.hashval = xfs_da_hashname(sfe->nameval,
sfe->namelen);
nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
nargs.attr_filter = sfe->flags & XFS_ATTR_NSP_ONDISK_MASK;
error = xfs_attr3_leaf_lookup_int(bp, &nargs); /* set a->index */
ASSERT(error == -ENOATTR);
error = xfs_attr3_leaf_add(bp, &nargs);
@ -1112,7 +1111,7 @@ xfs_attr3_leaf_to_shortform(
nargs.value = &name_loc->nameval[nargs.namelen];
nargs.valuelen = be16_to_cpu(name_loc->valuelen);
nargs.hashval = be32_to_cpu(entry->hashval);
nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
nargs.attr_filter = entry->flags & XFS_ATTR_NSP_ONDISK_MASK;
xfs_attr_shortform_add(&nargs, forkoff);
}
error = 0;
@ -1437,8 +1436,9 @@ xfs_attr3_leaf_add_work(
entry->nameidx = cpu_to_be16(ichdr->freemap[mapindex].base +
ichdr->freemap[mapindex].size);
entry->hashval = cpu_to_be32(args->hashval);
entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
entry->flags = args->attr_filter;
if (tmp)
entry->flags |= XFS_ATTR_LOCAL;
if (args->op_flags & XFS_DA_OP_RENAME) {
entry->flags |= XFS_ATTR_INCOMPLETE;
if ((args->blkno2 == args->blkno) &&

3
fs/xfs/libxfs/xfs_da_btree.h
View File

@ -59,7 +59,8 @@ typedef struct xfs_da_args {
uint8_t filetype; /* filetype of inode for directories */
void *value; /* set of bytes (maybe contain NULLs) */
int valuelen; /* length of value */
int flags; /* argument flags (eg: ATTR_NOCREATE) */
unsigned int attr_filter; /* XFS_ATTR_{ROOT,SECURE} */
unsigned int attr_flags; /* XATTR_{CREATE,REPLACE} */
xfs_dahash_t hashval; /* hash value of name */
xfs_ino_t inumber; /* input/output inode number */
struct xfs_inode *dp; /* directory inode to manipulate */

12
fs/xfs/libxfs/xfs_da_format.h
View File

@ -692,19 +692,7 @@ struct xfs_attr3_leafblock {
#define XFS_ATTR_ROOT (1 << XFS_ATTR_ROOT_BIT)
#define XFS_ATTR_SECURE (1 << XFS_ATTR_SECURE_BIT)
#define XFS_ATTR_INCOMPLETE (1 << XFS_ATTR_INCOMPLETE_BIT)
/*
* Conversion macros for converting namespace bits from argument flags
* to ondisk flags.
*/
#define XFS_ATTR_NSP_ARGS_MASK (ATTR_ROOT | ATTR_SECURE)
#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | XFS_ATTR_SECURE)
#define XFS_ATTR_NSP_ONDISK(flags) ((flags) & XFS_ATTR_NSP_ONDISK_MASK)
#define XFS_ATTR_NSP_ARGS(flags) ((flags) & XFS_ATTR_NSP_ARGS_MASK)
#define XFS_ATTR_NSP_ARGS_TO_ONDISK(x) (((x) & ATTR_ROOT ? XFS_ATTR_ROOT : 0) |\
((x) & ATTR_SECURE ? XFS_ATTR_SECURE : 0))
#define XFS_ATTR_NSP_ONDISK_TO_ARGS(x) (((x) & XFS_ATTR_ROOT ? ATTR_ROOT : 0) |\
((x) & XFS_ATTR_SECURE ? ATTR_SECURE : 0))
/*
* Alignment for namelist and valuelist entries (since they are mixed

12
fs/xfs/libxfs/xfs_fs.h
View File

@ -568,6 +568,16 @@ typedef struct xfs_fsop_setdm_handlereq {
struct fsdmidata __user *data; /* DMAPI data */
} xfs_fsop_setdm_handlereq_t;
/*
* Flags passed in xfs_attr_multiop.am_flags for the attr ioctl interface.
*
* NOTE: Must match the values declared in libattr without the XFS_IOC_ prefix.
*/
#define XFS_IOC_ATTR_ROOT 0x0002 /* use attrs in root namespace */
#define XFS_IOC_ATTR_SECURE 0x0008 /* use attrs in security namespace */
#define XFS_IOC_ATTR_CREATE 0x0010 /* fail if attr already exists */
#define XFS_IOC_ATTR_REPLACE 0x0020 /* fail if attr does not exist */
typedef struct xfs_attrlist_cursor {
__u32 opaque[4];
} xfs_attrlist_cursor_t;
@ -609,7 +619,7 @@ typedef struct xfs_attr_multiop {
void __user *am_attrname;
void __user *am_attrvalue;
__u32 am_length;
__u32 am_flags;
__u32 am_flags; /* XFS_IOC_ATTR_* */
} xfs_attr_multiop_t;
typedef struct xfs_fsop_attrmulti_handlereq {

5
fs/xfs/scrub/attr.c
View File

@ -148,10 +148,7 @@ xchk_xattr_listent(
}
args.op_flags = XFS_DA_OP_NOTIME;
if (flags & XFS_ATTR_ROOT)
args.flags |= ATTR_ROOT;
else if (flags & XFS_ATTR_SECURE)
args.flags |= ATTR_SECURE;
args.attr_filter = flags & XFS_ATTR_NSP_ONDISK_MASK;
args.geo = context->dp->i_mount->m_attr_geo;
args.whichfork = XFS_ATTR_FORK;
args.dp = context->dp;

4
fs/xfs/xfs_acl.c
View File

@ -131,7 +131,7 @@ xfs_get_acl(struct inode *inode, int type)
struct posix_acl *acl = NULL;
struct xfs_da_args args = {
.dp = ip,
.flags = ATTR_ROOT,
.attr_filter = XFS_ATTR_ROOT,
.valuelen = XFS_ACL_MAX_SIZE(mp),
};
int error;
@ -172,7 +172,7 @@ __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
struct xfs_inode *ip = XFS_I(inode);
struct xfs_da_args args = {
.dp = ip,
.flags = ATTR_ROOT,
.attr_filter = XFS_ATTR_ROOT,
};
int error;

44
fs/xfs/xfs_ioctl.c
View File

@ -320,11 +320,7 @@ xfs_ioc_attr_put_listent(
/*
* Only list entries in the right namespace.
*/
if (((context->flags & ATTR_SECURE) == 0) !=
((flags & XFS_ATTR_SECURE) == 0))
return;
if (((context->flags & ATTR_ROOT) == 0) !=
((flags & XFS_ATTR_ROOT) == 0))
if (context->attr_filter != (flags & XFS_ATTR_NSP_ONDISK_MASK))
return;
arraytop = sizeof(*alist) +
@ -349,6 +345,28 @@ xfs_ioc_attr_put_listent(
trace_xfs_attr_list_add(context);
}
static unsigned int
xfs_attr_filter(
u32 ioc_flags)
{
if (ioc_flags & XFS_IOC_ATTR_ROOT)
return XFS_ATTR_ROOT;
if (ioc_flags & XFS_IOC_ATTR_SECURE)
return XFS_ATTR_SECURE;
return 0;
}
static unsigned int
xfs_attr_flags(
u32 ioc_flags)
{
if (ioc_flags & XFS_IOC_ATTR_CREATE)
return XATTR_CREATE;
if (ioc_flags & XFS_IOC_ATTR_REPLACE)
return XATTR_REPLACE;
return 0;
}
int
xfs_ioc_attr_list(
struct xfs_inode *dp,
@ -370,9 +388,9 @@ xfs_ioc_attr_list(
/*
* Reject flags, only allow namespaces.
*/
if (flags & ~(ATTR_ROOT | ATTR_SECURE))
if (flags & ~(XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE))
return -EINVAL;
if (flags == (ATTR_ROOT | ATTR_SECURE))
if (flags == (XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE))
return -EINVAL;
/*
@ -397,7 +415,7 @@ xfs_ioc_attr_list(
context.dp = dp;
context.cursor = &cursor;
context.resynch = 1;
context.flags = flags;
context.attr_filter = xfs_attr_filter(flags);
context.buffer = buffer;
context.bufsize = (bufsize & ~(sizeof(int)-1)); /* align */
context.firstu = context.bufsize;
@ -454,7 +472,8 @@ xfs_attrmulti_attr_get(
{
struct xfs_da_args args = {
.dp = XFS_I(inode),
.flags = flags,
.attr_filter = xfs_attr_filter(flags),
.attr_flags = xfs_attr_flags(flags),
.name = name,
.namelen = strlen(name),
.valuelen = *len,
@ -491,7 +510,8 @@ xfs_attrmulti_attr_set(
{
struct xfs_da_args args = {
.dp = XFS_I(inode),
.flags = flags,
.attr_filter = xfs_attr_filter(flags),
.attr_flags = xfs_attr_flags(flags),
.name = name,
.namelen = strlen(name),
};
@ -510,7 +530,7 @@ xfs_attrmulti_attr_set(
}
error = xfs_attr_set(&args);
if (!error && (flags & ATTR_ROOT))
if (!error && (flags & XFS_IOC_ATTR_ROOT))
xfs_forget_acl(inode, name);
kfree(args.value);
return error;
@ -529,7 +549,7 @@ xfs_ioc_attrmulti_one(
unsigned char *name;
int error;
if ((flags & ATTR_ROOT) && (flags & ATTR_SECURE))
if ((flags & XFS_IOC_ATTR_ROOT) && (flags & XFS_IOC_ATTR_SECURE))
return -EINVAL;
name = strndup_user(uname, MAXNAMELEN);

3
fs/xfs/xfs_iops.c
View File

@ -22,7 +22,6 @@
#include "xfs_iomap.h"
#include "xfs_error.h"
#include <linux/xattr.h>
#include <linux/posix_acl.h>
#include <linux/security.h>
#include <linux/iversion.h>
@ -52,7 +51,7 @@ xfs_initxattrs(
for (xattr = xattr_array; xattr->name != NULL; xattr++) {
struct xfs_da_args args = {
.dp = ip,
.flags = ATTR_SECURE,
.attr_filter = XFS_ATTR_SECURE,
.name = xattr->name,
.namelen = strlen(xattr->name),
.value = xattr->value,

1
fs/xfs/xfs_linux.h
View File

@ -60,6 +60,7 @@ typedef __u32 xfs_nlink_t;
#include <linux/list_sort.h>
#include <linux/ratelimit.h>
#include <linux/rhashtable.h>
#include <linux/xattr.h>
#include <asm/page.h>
#include <asm/div64.h>

38
fs/xfs/xfs_trace.h
View File

@ -36,6 +36,10 @@ struct xfs_owner_info;
struct xfs_trans_res;
struct xfs_inobt_rec_incore;
#define XFS_ATTR_FILTER_FLAGS \
{ XFS_ATTR_ROOT, "ROOT" }, \
{ XFS_ATTR_SECURE, "SECURE" }
DECLARE_EVENT_CLASS(xfs_attr_list_class,
TP_PROTO(struct xfs_attr_list_context *ctx),
TP_ARGS(ctx),
@ -50,7 +54,7 @@ DECLARE_EVENT_CLASS(xfs_attr_list_class,
__field(int, count)
__field(int, firstu)
__field(int, dupcnt)
__field(int, flags)
__field(unsigned int, attr_filter)
),
TP_fast_assign(
__entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
@ -62,10 +66,10 @@ DECLARE_EVENT_CLASS(xfs_attr_list_class,
__entry->bufsize = ctx->bufsize;
__entry->count = ctx->count;
__entry->firstu = ctx->firstu;
__entry->flags = ctx->flags;
__entry->attr_filter = ctx->attr_filter;
),
TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
"buffer %p size %u count %u firstu %u flags %d %s",
"buffer %p size %u count %u firstu %u filter %s",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->hashval,
@ -76,8 +80,8 @@ DECLARE_EVENT_CLASS(xfs_attr_list_class,
__entry->bufsize,
__entry->count,
__entry->firstu,
__entry->flags,
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS)
__print_flags(__entry->attr_filter, "|",
XFS_ATTR_FILTER_FLAGS)
)
)
@ -174,7 +178,7 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__field(int, count)
__field(int, firstu)
__field(int, dupcnt)
__field(int, flags)
__field(unsigned int, attr_filter)
__field(u32, bt_hashval)
__field(u32, bt_before)
),
@ -188,12 +192,12 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__entry->bufsize = ctx->bufsize;
__entry->count = ctx->count;
__entry->firstu = ctx->firstu;
__entry->flags = ctx->flags;
__entry->attr_filter = ctx->attr_filter;
__entry->bt_hashval = be32_to_cpu(btree->hashval);
__entry->bt_before = be32_to_cpu(btree->before);
),
TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
"buffer %p size %u count %u firstu %u flags %d %s "
"buffer %p size %u count %u firstu %u filter %s "
"node hashval %u, node before %u",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
@ -205,8 +209,8 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__entry->bufsize,
__entry->count,
__entry->firstu,
__entry->flags,
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS),
__print_flags(__entry->attr_filter, "|",
XFS_ATTR_FILTER_FLAGS),
__entry->bt_hashval,
__entry->bt_before)
);
@ -1701,7 +1705,8 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__field(int, namelen)
__field(int, valuelen)
__field(xfs_dahash_t, hashval)
__field(int, flags)
__field(unsigned int, attr_filter)
__field(unsigned int, attr_flags)
__field(int, op_flags)
),
TP_fast_assign(
@ -1712,11 +1717,12 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__entry->namelen = args->namelen;
__entry->valuelen = args->valuelen;
__entry->hashval = args->hashval;
__entry->flags = args->flags;
__entry->attr_filter = args->attr_filter;
__entry->attr_flags = args->attr_flags;
__entry->op_flags = args->op_flags;
),
TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d "
"hashval 0x%x flags %s op_flags %s",
"hashval 0x%x filter %s flags %s op_flags %s",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->namelen,
@ -1724,7 +1730,11 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__entry->namelen,
__entry->valuelen,
__entry->hashval,
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS),
__print_flags(__entry->attr_filter, "|",
XFS_ATTR_FILTER_FLAGS),
__print_flags(__entry->attr_flags, "|",
{ XATTR_CREATE, "CREATE" },
{ XATTR_REPLACE, "REPLACE" }),
__print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
)

18
fs/xfs/xfs_xattr.c
View File

@ -16,7 +16,6 @@
#include "xfs_da_btree.h"
#include <linux/posix_acl_xattr.h>
#include <linux/xattr.h>
static int
@ -25,7 +24,7 @@ xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused,
{
struct xfs_da_args args = {
.dp = XFS_I(inode),
.flags = handler->flags,
.attr_filter = handler->flags,
.name = name,
.namelen = strlen(name),
.value = value,
@ -46,7 +45,8 @@ xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
{
struct xfs_da_args args = {
.dp = XFS_I(inode),
.flags = handler->flags,
.attr_filter = handler->flags,
.attr_flags = flags,
.name = name,
.namelen = strlen(name),
.value = (void *)value,
@ -54,14 +54,8 @@ xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
};
int error;
/* Convert Linux syscall to XFS internal ATTR flags */
if (flags & XATTR_CREATE)
args.flags |= ATTR_CREATE;
if (flags & XATTR_REPLACE)
args.flags |= ATTR_REPLACE;
error = xfs_attr_set(&args);
if (!error && (handler->flags & ATTR_ROOT))
if (!error && (handler->flags & XFS_ATTR_ROOT))
xfs_forget_acl(inode, name);
return error;
}
@ -75,14 +69,14 @@ static const struct xattr_handler xfs_xattr_user_handler = {
static const struct xattr_handler xfs_xattr_trusted_handler = {
.prefix = XATTR_TRUSTED_PREFIX,
.flags = ATTR_ROOT,
.flags = XFS_ATTR_ROOT,
.get = xfs_xattr_get,
.set = xfs_xattr_set,
};
static const struct xattr_handler xfs_xattr_security_handler = {
.prefix = XATTR_SECURITY_PREFIX,
.flags = ATTR_SECURE,
.flags = XFS_ATTR_SECURE,
.get = xfs_xattr_get,
.set = xfs_xattr_set,
};