microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

xfs: clean up the attr flag confusion 

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 коммит произвёл Darrick J. Wong
Родитель f3e93d95fe
Коммит d5f0f49a9b
13 изменённых файлов: 96 добавлений и 96 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

16
fs/xfs/libxfs/xfs_attr.c
Просмотреть файл

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

22
fs/xfs/libxfs/xfs_attr.h
Просмотреть файл

@ -21,26 +21,6 @@ struct xfs_attr_list_context;
* as possible so as to fit into the literal area of the inode. * 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 * 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 * 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 dupcnt; /* count dup hashvals seen */
int bufsize; /* total buffer size */ int bufsize; /* total buffer size */
int firstu; /* first used byte in buffer */ 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 */ int resynch; /* T/F: resynch with cursor */
put_listent_func_t put_listent; /* list output fmt function */ put_listent_func_t put_listent; /* list output fmt function */
int index; /* index into output buffer */ int index; /* index into output buffer */

14
fs/xfs/libxfs/xfs_attr_leaf.c
Просмотреть файл

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

3
fs/xfs/libxfs/xfs_da_btree.h
Просмотреть файл

@ -59,7 +59,8 @@ typedef struct xfs_da_args {
uint8_t filetype; /* filetype of inode for directories */ uint8_t filetype; /* filetype of inode for directories */
void *value; /* set of bytes (maybe contain NULLs) */ void *value; /* set of bytes (maybe contain NULLs) */
int valuelen; /* length of value */ 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_dahash_t hashval; /* hash value of name */
xfs_ino_t inumber; /* input/output inode number */ xfs_ino_t inumber; /* input/output inode number */
struct xfs_inode *dp; /* directory inode to manipulate */ struct xfs_inode *dp; /* directory inode to manipulate */

12
fs/xfs/libxfs/xfs_da_format.h
Просмотреть файл

@ -692,19 +692,7 @@ struct xfs_attr3_leafblock {
#define XFS_ATTR_ROOT (1 << XFS_ATTR_ROOT_BIT) #define XFS_ATTR_ROOT (1 << XFS_ATTR_ROOT_BIT)
#define XFS_ATTR_SECURE (1 << XFS_ATTR_SECURE_BIT) #define XFS_ATTR_SECURE (1 << XFS_ATTR_SECURE_BIT)
#define XFS_ATTR_INCOMPLETE (1 << XFS_ATTR_INCOMPLETE_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_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 * Alignment for namelist and valuelist entries (since they are mixed

12
fs/xfs/libxfs/xfs_fs.h
Просмотреть файл

@ -568,6 +568,16 @@ typedef struct xfs_fsop_setdm_handlereq {
struct fsdmidata __user *data; /* DMAPI data */ struct fsdmidata __user *data; /* DMAPI data */
} xfs_fsop_setdm_handlereq_t; } 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 { typedef struct xfs_attrlist_cursor {
__u32 opaque[4]; __u32 opaque[4];
} xfs_attrlist_cursor_t; } xfs_attrlist_cursor_t;
@ -609,7 +619,7 @@ typedef struct xfs_attr_multiop {
void __user *am_attrname; void __user *am_attrname;
void __user *am_attrvalue; void __user *am_attrvalue;
__u32 am_length; __u32 am_length;
__u32 am_flags; __u32 am_flags; /* XFS_IOC_ATTR_* */
} xfs_attr_multiop_t; } xfs_attr_multiop_t;
typedef struct xfs_fsop_attrmulti_handlereq { typedef struct xfs_fsop_attrmulti_handlereq {

5
fs/xfs/scrub/attr.c
Просмотреть файл

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

4
fs/xfs/xfs_acl.c
Просмотреть файл

@ -131,7 +131,7 @@ xfs_get_acl(struct inode *inode, int type)
struct posix_acl *acl = NULL; struct posix_acl *acl = NULL;
struct xfs_da_args args = { struct xfs_da_args args = {
.dp = ip, .dp = ip,
.flags = ATTR_ROOT, .attr_filter = XFS_ATTR_ROOT,
.valuelen = XFS_ACL_MAX_SIZE(mp), .valuelen = XFS_ACL_MAX_SIZE(mp),
}; };
int error; 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_inode *ip = XFS_I(inode);
struct xfs_da_args args = { struct xfs_da_args args = {
.dp = ip, .dp = ip,
.flags = ATTR_ROOT, .attr_filter = XFS_ATTR_ROOT,
}; };
int error; int error;

44
fs/xfs/xfs_ioctl.c
Просмотреть файл

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

3
fs/xfs/xfs_iops.c
Просмотреть файл

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

1
fs/xfs/xfs_linux.h
Просмотреть файл

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

38
fs/xfs/xfs_trace.h
Просмотреть файл

@ -36,6 +36,10 @@ struct xfs_owner_info;
struct xfs_trans_res; struct xfs_trans_res;
struct xfs_inobt_rec_incore; 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, DECLARE_EVENT_CLASS(xfs_attr_list_class,
TP_PROTO(struct xfs_attr_list_context *ctx), TP_PROTO(struct xfs_attr_list_context *ctx),
TP_ARGS(ctx), TP_ARGS(ctx),
@ -50,7 +54,7 @@ DECLARE_EVENT_CLASS(xfs_attr_list_class,
__field(int, count) __field(int, count)
__field(int, firstu) __field(int, firstu)
__field(int, dupcnt) __field(int, dupcnt)
__field(int, flags) __field(unsigned int, attr_filter)
), ),
TP_fast_assign( TP_fast_assign(
__entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; __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->bufsize = ctx->bufsize;
__entry->count = ctx->count; __entry->count = ctx->count;
__entry->firstu = ctx->firstu; __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 " 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), MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino, __entry->ino,
__entry->hashval, __entry->hashval,
@ -76,8 +80,8 @@ DECLARE_EVENT_CLASS(xfs_attr_list_class,
__entry->bufsize, __entry->bufsize,
__entry->count, __entry->count,
__entry->firstu, __entry->firstu,
__entry->flags, __print_flags(__entry->attr_filter, "|",
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS) XFS_ATTR_FILTER_FLAGS)
) )
) )
@ -174,7 +178,7 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__field(int, count) __field(int, count)
__field(int, firstu) __field(int, firstu)
__field(int, dupcnt) __field(int, dupcnt)
__field(int, flags) __field(unsigned int, attr_filter)
__field(u32, bt_hashval) __field(u32, bt_hashval)
__field(u32, bt_before) __field(u32, bt_before)
), ),
@ -188,12 +192,12 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__entry->bufsize = ctx->bufsize; __entry->bufsize = ctx->bufsize;
__entry->count = ctx->count; __entry->count = ctx->count;
__entry->firstu = ctx->firstu; __entry->firstu = ctx->firstu;
__entry->flags = ctx->flags; __entry->attr_filter = ctx->attr_filter;
__entry->bt_hashval = be32_to_cpu(btree->hashval); __entry->bt_hashval = be32_to_cpu(btree->hashval);
__entry->bt_before = be32_to_cpu(btree->before); __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 " 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", "node hashval %u, node before %u",
MAJOR(__entry->dev), MINOR(__entry->dev), MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino, __entry->ino,
@ -205,8 +209,8 @@ TRACE_EVENT(xfs_attr_list_node_descend,
__entry->bufsize, __entry->bufsize,
__entry->count, __entry->count,
__entry->firstu, __entry->firstu,
__entry->flags, __print_flags(__entry->attr_filter, "|",
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS), XFS_ATTR_FILTER_FLAGS),
__entry->bt_hashval, __entry->bt_hashval,
__entry->bt_before) __entry->bt_before)
); );
@ -1701,7 +1705,8 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__field(int, namelen) __field(int, namelen)
__field(int, valuelen) __field(int, valuelen)
__field(xfs_dahash_t, hashval) __field(xfs_dahash_t, hashval)
__field(int, flags) __field(unsigned int, attr_filter)
__field(unsigned int, attr_flags)
__field(int, op_flags) __field(int, op_flags)
), ),
TP_fast_assign( TP_fast_assign(
@ -1712,11 +1717,12 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__entry->namelen = args->namelen; __entry->namelen = args->namelen;
__entry->valuelen = args->valuelen; __entry->valuelen = args->valuelen;
__entry->hashval = args->hashval; __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; __entry->op_flags = args->op_flags;
), ),
TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d " 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), MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino, __entry->ino,
__entry->namelen, __entry->namelen,
@ -1724,7 +1730,11 @@ DECLARE_EVENT_CLASS(xfs_attr_class,
__entry->namelen, __entry->namelen,
__entry->valuelen, __entry->valuelen,
__entry->hashval, __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)) __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
) )

18
fs/xfs/xfs_xattr.c
Просмотреть файл

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