* [PATCH v7 00/23] Parent Pointers v7
@ 2018-06-10 5:04 Allison Henderson
2018-06-10 5:04 ` [PATCH v7 01/23] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
` (22 more replies)
0 siblings, 23 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
Hi all,
This is the 7th version of parent pointer attributes for xfs. The goal of
this patch set is to add a parent pointer attribute to each inode. The
attribute name containing the parent inode, generation, and directory offset,
while the attribute value contains the file name. This feature will enable
future optimizations for online scrub, or any other feature that could make
use of quickly deriving an inodes path from the mount point. This set also
introduces deferred attribute operations, though it is currently only used by
the new parent pointer code.
Some points of interest since v6:
I've integrated most of the feedback provided on v6, and addressed some bugs
I found during the log replay in patch 6. Patches 2, 7, and 21 are new, so
I would appreciate some focus on those. I'm still working on an alternate
solution to patch 3, but wanted to give folks an update for where things
are at the moment.
As always, comments and feedback are appreciated. Thank you!
Allison Henderson (14):
xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h
xfs: Add helper function xfs_attr_try_sf_addname
xfs: Add trans toggle to attr routines
xfs: Add attibute set and helper functions
xfs: Add attibute remove and helper functions
xfs: Set up infastructure for deferred attribute operations
xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred
xfs: Remove all strlen calls in all xfs_attr_* functions for attr
names.
xfs: Hold inode locks in xfs_ialloc
xfs: Add parent pointers to rename
xfs: Add the parent pointer support to the superblock version 5.
xfs: Add helper function xfs_attr_list_context_init
xfs: Add parent pointer ioctl
xfs: Add delayed attributes error tag
Dave Chinner (5):
xfs: define parent pointer xattr format
xfs: extent transaction reservations for parent attributes
xfs: parent pointer attribute creation
xfs: add parent attributes to link
xfs: remove parent pointers in unlink
Mark Tinguely (4):
xfs: get directory offset when adding directory name
xfs: get directory offset when removing directory name
xfs: get directory offset when replacing a directory name
xfs: add parent pointer support to attribute code
fs/xfs/Makefile | 4 +
fs/xfs/libxfs/xfs_attr.c | 504 +++++++++++++++++++++++++------------
fs/xfs/libxfs/xfs_attr.h | 199 +++++++++++++++
fs/xfs/libxfs/xfs_attr_leaf.c | 12 +-
fs/xfs/libxfs/xfs_attr_leaf.h | 10 +-
fs/xfs/libxfs/xfs_bmap.c | 49 ++--
fs/xfs/libxfs/xfs_bmap.h | 1 +
fs/xfs/libxfs/xfs_da_btree.h | 1 +
fs/xfs/libxfs/xfs_da_format.h | 37 ++-
fs/xfs/libxfs/xfs_defer.h | 1 +
fs/xfs/libxfs/xfs_dir2.c | 41 +--
fs/xfs/libxfs/xfs_dir2.h | 10 +-
fs/xfs/libxfs/xfs_dir2_block.c | 9 +-
fs/xfs/libxfs/xfs_dir2_leaf.c | 8 +-
fs/xfs/libxfs/xfs_dir2_node.c | 8 +-
fs/xfs/libxfs/xfs_dir2_sf.c | 6 +
fs/xfs/libxfs/xfs_errortag.h | 4 +-
fs/xfs/libxfs/xfs_format.h | 10 +-
fs/xfs/libxfs/xfs_fs.h | 43 ++++
fs/xfs/libxfs/xfs_log_format.h | 44 +++-
fs/xfs/libxfs/xfs_parent.c | 171 +++++++++++++
fs/xfs/libxfs/xfs_parent.h | 38 +++
fs/xfs/libxfs/xfs_sb.c | 2 +
fs/xfs/libxfs/xfs_trans_resv.c | 111 ++++++--
fs/xfs/libxfs/xfs_trans_resv.h | 1 +
fs/xfs/libxfs/xfs_types.h | 1 +
fs/xfs/xfs_acl.c | 12 +-
fs/xfs/xfs_attr.h | 160 ------------
fs/xfs/xfs_attr_item.c | 560 +++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr_item.h | 120 +++++++++
fs/xfs/xfs_attr_list.c | 75 ++++--
fs/xfs/xfs_error.c | 3 +
fs/xfs/xfs_inode.c | 188 ++++++++++----
fs/xfs/xfs_ioctl.c | 99 +++++++-
fs/xfs/xfs_iops.c | 6 +-
fs/xfs/xfs_log_recover.c | 173 +++++++++++++
fs/xfs/xfs_ondisk.h | 6 +
fs/xfs/xfs_parent_utils.c | 150 +++++++++++
fs/xfs/xfs_parent_utils.h | 32 +++
fs/xfs/xfs_qm.c | 1 +
fs/xfs/xfs_super.c | 5 +
fs/xfs/xfs_symlink.c | 2 +-
fs/xfs/xfs_trans.h | 14 ++
fs/xfs/xfs_trans_attr.c | 293 +++++++++++++++++++++
fs/xfs/xfs_xattr.c | 10 +-
45 files changed, 2733 insertions(+), 501 deletions(-)
create mode 100644 fs/xfs/libxfs/xfs_attr.h
create mode 100644 fs/xfs/libxfs/xfs_parent.c
create mode 100644 fs/xfs/libxfs/xfs_parent.h
delete mode 100644 fs/xfs/xfs_attr.h
create mode 100644 fs/xfs/xfs_attr_item.c
create mode 100644 fs/xfs/xfs_attr_item.h
create mode 100644 fs/xfs/xfs_parent_utils.c
create mode 100644 fs/xfs/xfs_parent_utils.h
create mode 100644 fs/xfs/xfs_trans_attr.c
--
2.7.4
^ permalink raw reply [flat|nested] 33+ messages in thread
* [PATCH v7 01/23] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
` (21 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch moves fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h
since xfs_attr.c is in libxfs. We will need these later in
xfsprogs.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.h | 160 +++++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr.h | 160 -----------------------------------------------
2 files changed, 160 insertions(+), 160 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
new file mode 100644
index 0000000..d07bf27
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#ifndef __XFS_ATTR_H__
+#define __XFS_ATTR_H__
+
+struct xfs_inode;
+struct xfs_da_args;
+struct xfs_attr_list_context;
+
+/*
+ * Large attribute lists are structured around Btrees where all the data
+ * elements are in the leaf nodes. Attribute names are hashed into an int,
+ * then that int is used as the index into the Btree. Since the hashval
+ * of an attribute name may not be unique, we may have duplicate keys.
+ * The internal links in the Btree are logical block offsets into the file.
+ *
+ * Small attribute lists use a different format and are packed as tightly
+ * as possible so as to fit into the literal area of the inode.
+ */
+
+/*========================================================================
+ * External interfaces
+ *========================================================================*/
+
+
+#define ATTR_DONTFOLLOW 0x0001 /* -- unused, 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 ATTR_KERNOTIME 0x1000 /* [kernel] don't update inode timestamps */
+#define ATTR_KERNOVAL 0x2000 /* [kernel] get attr size only, not value */
+
+#define ATTR_INCOMPLETE 0x4000 /* [kernel] return INCOMPLETE attr keys */
+
+#define XFS_ATTR_FLAGS \
+ { ATTR_DONTFOLLOW, "DONTFOLLOW" }, \
+ { ATTR_ROOT, "ROOT" }, \
+ { ATTR_TRUST, "TRUST" }, \
+ { ATTR_SECURE, "SECURE" }, \
+ { ATTR_CREATE, "CREATE" }, \
+ { ATTR_REPLACE, "REPLACE" }, \
+ { ATTR_KERNOTIME, "KERNOTIME" }, \
+ { ATTR_KERNOVAL, "KERNOVAL" }, \
+ { ATTR_INCOMPLETE, "INCOMPLETE" }
+
+/*
+ * 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
+ * sizes will result in an ERANGE return code.
+ */
+#define ATTR_MAX_VALUELEN (64*1024) /* max length of a value */
+
+/*
+ * Define how lists of attribute names are returned to the user from
+ * the attr_list() call. A large, 32bit aligned, buffer is passed in
+ * along with its size. We put an array of offsets at the top that each
+ * reference an attrlist_ent_t and pack the attrlist_ent_t's at the bottom.
+ */
+typedef struct attrlist {
+ __s32 al_count; /* number of entries in attrlist */
+ __s32 al_more; /* T/F: more attrs (do call again) */
+ __s32 al_offset[1]; /* byte offsets of attrs [var-sized] */
+} attrlist_t;
+
+/*
+ * Show the interesting info about one attribute. This is what the
+ * al_offset[i] entry points to.
+ */
+typedef struct attrlist_ent { /* data from attr_list() */
+ __u32 a_valuelen; /* number bytes in value of attr */
+ char a_name[1]; /* attr name (NULL terminated) */
+} attrlist_ent_t;
+
+/*
+ * Given a pointer to the (char*) buffer containing the attr_list() result,
+ * and an index, return a pointer to the indicated attribute in the buffer.
+ */
+#define ATTR_ENTRY(buffer, index) \
+ ((attrlist_ent_t *) \
+ &((char *)buffer)[ ((attrlist_t *)(buffer))->al_offset[index] ])
+
+/*
+ * Kernel-internal version of the attrlist cursor.
+ */
+typedef struct attrlist_cursor_kern {
+ __u32 hashval; /* hash value of next entry to add */
+ __u32 blkno; /* block containing entry (suggestion) */
+ __u32 offset; /* offset in list of equal-hashvals */
+ __u16 pad1; /* padding to match user-level */
+ __u8 pad2; /* padding to match user-level */
+ __u8 initted; /* T/F: cursor has been initialized */
+} attrlist_cursor_kern_t;
+
+
+/*========================================================================
+ * Structure used to pass context around among the routines.
+ *========================================================================*/
+
+
+/* void; state communicated via *context */
+typedef void (*put_listent_func_t)(struct xfs_attr_list_context *, int,
+ unsigned char *, int, int);
+
+typedef struct xfs_attr_list_context {
+ struct xfs_trans *tp;
+ struct xfs_inode *dp; /* inode */
+ struct attrlist_cursor_kern *cursor; /* position in list */
+ char *alist; /* output buffer */
+ int seen_enough; /* T/F: seen enough of list? */
+ ssize_t count; /* num used entries */
+ int dupcnt; /* count dup hashvals seen */
+ int bufsize; /* total buffer size */
+ int firstu; /* first used byte in buffer */
+ int flags; /* from VOP call */
+ int resynch; /* T/F: resynch with cursor */
+ put_listent_func_t put_listent; /* list output fmt function */
+ int index; /* index into output buffer */
+} xfs_attr_list_context_t;
+
+
+/*========================================================================
+ * Function prototypes for the kernel.
+ *========================================================================*/
+
+/*
+ * Overall external interface routines.
+ */
+int xfs_attr_inactive(struct xfs_inode *dp);
+int xfs_attr_list_int_ilocked(struct xfs_attr_list_context *);
+int xfs_attr_list_int(struct xfs_attr_list_context *);
+int xfs_inode_hasattr(struct xfs_inode *ip);
+int xfs_attr_get_ilocked(struct xfs_inode *ip, struct xfs_da_args *args);
+int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
+ unsigned char *value, int *valuelenp, int flags);
+int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
+ unsigned char *value, int valuelen, int flags);
+int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
+int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
+ int flags, struct attrlist_cursor_kern *cursor);
+
+
+#endif /* __XFS_ATTR_H__ */
diff --git a/fs/xfs/xfs_attr.h b/fs/xfs/xfs_attr.h
deleted file mode 100644
index d07bf27..0000000
--- a/fs/xfs/xfs_attr.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc.
- * All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-#ifndef __XFS_ATTR_H__
-#define __XFS_ATTR_H__
-
-struct xfs_inode;
-struct xfs_da_args;
-struct xfs_attr_list_context;
-
-/*
- * Large attribute lists are structured around Btrees where all the data
- * elements are in the leaf nodes. Attribute names are hashed into an int,
- * then that int is used as the index into the Btree. Since the hashval
- * of an attribute name may not be unique, we may have duplicate keys.
- * The internal links in the Btree are logical block offsets into the file.
- *
- * Small attribute lists use a different format and are packed as tightly
- * as possible so as to fit into the literal area of the inode.
- */
-
-/*========================================================================
- * External interfaces
- *========================================================================*/
-
-
-#define ATTR_DONTFOLLOW 0x0001 /* -- unused, 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 ATTR_KERNOTIME 0x1000 /* [kernel] don't update inode timestamps */
-#define ATTR_KERNOVAL 0x2000 /* [kernel] get attr size only, not value */
-
-#define ATTR_INCOMPLETE 0x4000 /* [kernel] return INCOMPLETE attr keys */
-
-#define XFS_ATTR_FLAGS \
- { ATTR_DONTFOLLOW, "DONTFOLLOW" }, \
- { ATTR_ROOT, "ROOT" }, \
- { ATTR_TRUST, "TRUST" }, \
- { ATTR_SECURE, "SECURE" }, \
- { ATTR_CREATE, "CREATE" }, \
- { ATTR_REPLACE, "REPLACE" }, \
- { ATTR_KERNOTIME, "KERNOTIME" }, \
- { ATTR_KERNOVAL, "KERNOVAL" }, \
- { ATTR_INCOMPLETE, "INCOMPLETE" }
-
-/*
- * 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
- * sizes will result in an ERANGE return code.
- */
-#define ATTR_MAX_VALUELEN (64*1024) /* max length of a value */
-
-/*
- * Define how lists of attribute names are returned to the user from
- * the attr_list() call. A large, 32bit aligned, buffer is passed in
- * along with its size. We put an array of offsets at the top that each
- * reference an attrlist_ent_t and pack the attrlist_ent_t's at the bottom.
- */
-typedef struct attrlist {
- __s32 al_count; /* number of entries in attrlist */
- __s32 al_more; /* T/F: more attrs (do call again) */
- __s32 al_offset[1]; /* byte offsets of attrs [var-sized] */
-} attrlist_t;
-
-/*
- * Show the interesting info about one attribute. This is what the
- * al_offset[i] entry points to.
- */
-typedef struct attrlist_ent { /* data from attr_list() */
- __u32 a_valuelen; /* number bytes in value of attr */
- char a_name[1]; /* attr name (NULL terminated) */
-} attrlist_ent_t;
-
-/*
- * Given a pointer to the (char*) buffer containing the attr_list() result,
- * and an index, return a pointer to the indicated attribute in the buffer.
- */
-#define ATTR_ENTRY(buffer, index) \
- ((attrlist_ent_t *) \
- &((char *)buffer)[ ((attrlist_t *)(buffer))->al_offset[index] ])
-
-/*
- * Kernel-internal version of the attrlist cursor.
- */
-typedef struct attrlist_cursor_kern {
- __u32 hashval; /* hash value of next entry to add */
- __u32 blkno; /* block containing entry (suggestion) */
- __u32 offset; /* offset in list of equal-hashvals */
- __u16 pad1; /* padding to match user-level */
- __u8 pad2; /* padding to match user-level */
- __u8 initted; /* T/F: cursor has been initialized */
-} attrlist_cursor_kern_t;
-
-
-/*========================================================================
- * Structure used to pass context around among the routines.
- *========================================================================*/
-
-
-/* void; state communicated via *context */
-typedef void (*put_listent_func_t)(struct xfs_attr_list_context *, int,
- unsigned char *, int, int);
-
-typedef struct xfs_attr_list_context {
- struct xfs_trans *tp;
- struct xfs_inode *dp; /* inode */
- struct attrlist_cursor_kern *cursor; /* position in list */
- char *alist; /* output buffer */
- int seen_enough; /* T/F: seen enough of list? */
- ssize_t count; /* num used entries */
- int dupcnt; /* count dup hashvals seen */
- int bufsize; /* total buffer size */
- int firstu; /* first used byte in buffer */
- int flags; /* from VOP call */
- int resynch; /* T/F: resynch with cursor */
- put_listent_func_t put_listent; /* list output fmt function */
- int index; /* index into output buffer */
-} xfs_attr_list_context_t;
-
-
-/*========================================================================
- * Function prototypes for the kernel.
- *========================================================================*/
-
-/*
- * Overall external interface routines.
- */
-int xfs_attr_inactive(struct xfs_inode *dp);
-int xfs_attr_list_int_ilocked(struct xfs_attr_list_context *);
-int xfs_attr_list_int(struct xfs_attr_list_context *);
-int xfs_inode_hasattr(struct xfs_inode *ip);
-int xfs_attr_get_ilocked(struct xfs_inode *ip, struct xfs_da_args *args);
-int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
- unsigned char *value, int *valuelenp, int flags);
-int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
- unsigned char *value, int valuelen, int flags);
-int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
-int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
- int flags, struct attrlist_cursor_kern *cursor);
-
-
-#endif /* __XFS_ATTR_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
2018-06-10 5:04 ` [PATCH v7 01/23] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 6:58 ` Amir Goldstein
2018-06-10 5:04 ` [PATCH v7 03/23] xfs: Add trans toggle to attr routines Allison Henderson
` (20 subsequent siblings)
22 siblings, 1 reply; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch adds a subroutine xfs_attr_try_sf_addname
used by xfs_attr_set. This subrotine will attempt to
add the attribute name specified in args in shortform,
as well and perform error handling previously done in
xfs_attr_set.
This patch helps to pre-simplify xfs_attr_set for reviewing
purposes and reduce indentation. New function will be added
in the next patch.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 64 +++++++++++++++++++++++++++++++-----------------
1 file changed, 41 insertions(+), 23 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index ce4a34a..1524197 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -203,6 +203,44 @@ xfs_attr_calc_size(
return nblks;
}
+STATIC int
+xfs_attr_try_sf_addname(
+ struct xfs_inode *dp,
+ struct xfs_da_args *args,
+ int flags)
+{
+
+ struct xfs_mount *mp = dp->i_mount;
+ int error;
+ int err2;
+
+ error = xfs_attr_shortform_addname(args);
+ if (error != -ENOSPC) {
+ /*
+ * Commit the shortform mods, and we're done.
+ * NOTE: this is also the error path
+ * (EEXIST, etc).
+ */
+ ASSERT(args->trans != NULL);
+
+ /*
+ * If this is a synchronous mount, make sure
+ * that the transaction goes to disk before
+ * returning to the user.
+ */
+ if (mp->m_flags & XFS_MOUNT_WSYNC)
+ xfs_trans_set_sync(args->trans);
+
+ if (!error && (flags & ATTR_KERNOTIME) == 0) {
+ xfs_trans_ichgtime(args->trans, dp,
+ XFS_ICHGTIME_CHG);
+ }
+ err2 = xfs_trans_commit(args->trans);
+ error = error ? error : err2;
+ }
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -218,7 +256,7 @@ xfs_attr_set(
struct xfs_trans_res tres;
xfs_fsblock_t firstblock;
int rsvd = (flags & ATTR_ROOT) != 0;
- int error, err2, local;
+ int error, local;
XFS_STATS_INC(mp, xs_attr_set);
@@ -297,30 +335,10 @@ xfs_attr_set(
* Try to add the attr to the attribute list in
* the inode.
*/
- error = xfs_attr_shortform_addname(&args);
+ error = xfs_attr_try_sf_addname(dp, &args, flags);
if (error != -ENOSPC) {
- /*
- * Commit the shortform mods, and we're done.
- * NOTE: this is also the error path (EEXIST, etc).
- */
- ASSERT(args.trans != NULL);
-
- /*
- * If this is a synchronous mount, make sure that
- * the transaction goes to disk before returning
- * to the user.
- */
- if (mp->m_flags & XFS_MOUNT_WSYNC)
- xfs_trans_set_sync(args.trans);
-
- if (!error && (flags & ATTR_KERNOTIME) == 0) {
- xfs_trans_ichgtime(args.trans, dp,
- XFS_ICHGTIME_CHG);
- }
- err2 = xfs_trans_commit(args.trans);
xfs_iunlock(dp, XFS_ILOCK_EXCL);
-
- return error ? error : err2;
+ return error;
}
/*
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 03/23] xfs: Add trans toggle to attr routines
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
2018-06-10 5:04 ` [PATCH v7 01/23] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
2018-06-10 5:04 ` [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-13 12:11 ` Brian Foster
2018-06-10 5:04 ` [PATCH v7 04/23] xfs: Add attibute set and helper functions Allison Henderson
` (19 subsequent siblings)
22 siblings, 1 reply; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch adds a roll_trans parameter to all attribute routines.
Calling functions may pass true to roll transactions as normal,
or false to hold them. We will need this later for delayed
attribute operations.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 165 ++++++++++++++++++++++++------------------
fs/xfs/libxfs/xfs_attr_leaf.c | 12 +--
fs/xfs/libxfs/xfs_attr_leaf.h | 10 ++-
3 files changed, 108 insertions(+), 79 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 1524197..e8cb369 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -55,21 +55,21 @@
/*
* Internal routines when attribute list fits inside the inode.
*/
-STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
+STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans);
/*
* Internal routines when attribute list is one block.
*/
STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
-STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
-STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
+STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans);
+STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans);
/*
* Internal routines when attribute list is more than one block.
*/
STATIC int xfs_attr_node_get(xfs_da_args_t *args);
-STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
-STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
+STATIC int xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans);
+STATIC int xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans);
STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
@@ -207,15 +207,16 @@ STATIC int
xfs_attr_try_sf_addname(
struct xfs_inode *dp,
struct xfs_da_args *args,
- int flags)
+ int flags,
+ bool roll_trans)
{
struct xfs_mount *mp = dp->i_mount;
int error;
int err2;
- error = xfs_attr_shortform_addname(args);
- if (error != -ENOSPC) {
+ error = xfs_attr_shortform_addname(args, roll_trans);
+ if (error != -ENOSPC && roll_trans) {
/*
* Commit the shortform mods, and we're done.
* NOTE: this is also the error path
@@ -335,7 +336,7 @@ xfs_attr_set(
* Try to add the attr to the attribute list in
* the inode.
*/
- error = xfs_attr_try_sf_addname(dp, &args, flags);
+ error = xfs_attr_try_sf_addname(dp, &args, flags, true);
if (error != -ENOSPC) {
xfs_iunlock(dp, XFS_ILOCK_EXCL);
return error;
@@ -374,9 +375,9 @@ xfs_attr_set(
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
- error = xfs_attr_leaf_addname(&args);
+ error = xfs_attr_leaf_addname(&args, true);
else
- error = xfs_attr_node_addname(&args);
+ error = xfs_attr_node_addname(&args, true);
if (error)
goto out;
@@ -471,11 +472,11 @@ xfs_attr_remove(
error = -ENOATTR;
} else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
- error = xfs_attr_shortform_remove(&args);
+ error = xfs_attr_shortform_remove(&args, true);
} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
- error = xfs_attr_leaf_removename(&args);
+ error = xfs_attr_leaf_removename(&args, true);
} else {
- error = xfs_attr_node_removename(&args);
+ error = xfs_attr_node_removename(&args, true);
}
if (error)
@@ -516,7 +517,7 @@ xfs_attr_remove(
* This is the external routine.
*/
STATIC int
-xfs_attr_shortform_addname(xfs_da_args_t *args)
+xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans)
{
int newsize, forkoff, retval;
@@ -528,7 +529,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
} else if (retval == -EEXIST) {
if (args->flags & ATTR_CREATE)
return retval;
- retval = xfs_attr_shortform_remove(args);
+ retval = xfs_attr_shortform_remove(args, roll_trans);
ASSERT(retval == 0);
}
@@ -543,7 +544,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
if (!forkoff)
return -ENOSPC;
- xfs_attr_shortform_add(args, forkoff);
+ xfs_attr_shortform_add(args, forkoff, roll_trans);
return 0;
}
@@ -559,7 +560,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
* if bmap_one_block() says there is only one block (ie: no remote blks).
*/
STATIC int
-xfs_attr_leaf_addname(xfs_da_args_t *args)
+xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans)
{
xfs_inode_t *dp;
struct xfs_buf *bp;
@@ -622,36 +623,42 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
* can manage its own transactions.
*/
xfs_defer_init(args->dfops, args->firstblock);
- error = xfs_attr3_leaf_to_node(args);
+ error = xfs_attr3_leaf_to_node(args, roll_trans);
if (error)
goto out_defer_cancel;
xfs_defer_ijoin(args->dfops, dp);
- error = xfs_defer_finish(&args->trans, args->dfops);
- if (error)
- goto out_defer_cancel;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans, args->dfops);
+ if (error)
+ goto out_defer_cancel;
- /*
- * Commit the current trans (including the inode) and start
- * a new one.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- return error;
+ /*
+ * Commit the current trans (including the inode) and
+ * start a new one.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ return error;
+ }
/*
* Fob the whole rest of the problem off on the Btree code.
*/
- error = xfs_attr_node_addname(args);
+ error = xfs_attr_node_addname(args, roll_trans);
+
return error;
}
- /*
- * Commit the transaction that added the attr name so that
- * later routines can manage their own transactions.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- return error;
+
+ if (roll_trans) {
+ /*
+ * Commit the transaction that added the attr name so that
+ * later routines can manage their own transactions.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ return error;
+ }
/*
* If there was an out-of-line value, allocate the blocks we
@@ -709,9 +716,11 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
/*
* If the result is small enough, shrink it all into the inode.
*/
- if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
+ if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
+ roll_trans) {
xfs_defer_init(args->dfops, args->firstblock);
- error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
+ error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
+ roll_trans);
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
@@ -745,7 +754,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
* if bmap_one_block() says there is only one block (ie: no remote blks).
*/
STATIC int
-xfs_attr_leaf_removename(xfs_da_args_t *args)
+xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans)
{
xfs_inode_t *dp;
struct xfs_buf *bp;
@@ -774,15 +783,19 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
* If the result is small enough, shrink it all into the inode.
*/
if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
- xfs_defer_init(args->dfops, args->firstblock);
- error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
+ if (roll_trans)
+ xfs_defer_init(args->dfops, args->firstblock);
+ error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
+ roll_trans);
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
xfs_defer_ijoin(args->dfops, dp);
- error = xfs_defer_finish(&args->trans, args->dfops);
- if (error)
- goto out_defer_cancel;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans, args->dfops);
+ if (error)
+ goto out_defer_cancel;
+ }
}
return 0;
out_defer_cancel:
@@ -837,7 +850,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
* add a whole extra layer of confusion on top of that.
*/
STATIC int
-xfs_attr_node_addname(xfs_da_args_t *args)
+xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans)
{
xfs_da_state_t *state;
xfs_da_state_blk_t *blk;
@@ -903,21 +916,24 @@ xfs_attr_node_addname(xfs_da_args_t *args)
xfs_da_state_free(state);
state = NULL;
xfs_defer_init(args->dfops, args->firstblock);
- error = xfs_attr3_leaf_to_node(args);
+ error = xfs_attr3_leaf_to_node(args, roll_trans);
if (error)
goto out_defer_cancel;
xfs_defer_ijoin(args->dfops, dp);
- error = xfs_defer_finish(&args->trans, args->dfops);
- if (error)
- goto out_defer_cancel;
-
- /*
- * Commit the node conversion and start the next
- * trans in the chain.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- goto out;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans,
+ args->dfops);
+ if (error)
+ goto out_defer_cancel;
+
+ /*
+ * Commit the node conversion and start the next
+ * trans in the chain.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ goto out;
+ }
goto restart;
}
@@ -933,9 +949,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
if (error)
goto out_defer_cancel;
xfs_defer_ijoin(args->dfops, dp);
- error = xfs_defer_finish(&args->trans, args->dfops);
- if (error)
- goto out_defer_cancel;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans, args->dfops);
+ if (error)
+ goto out_defer_cancel;
+ }
} else {
/*
* Addition succeeded, update Btree hashvals.
@@ -954,9 +972,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
* Commit the leaf addition or btree split and start the next
* trans in the chain.
*/
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- goto out;
+ if (roll_trans) {
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ goto out;
+ }
/*
* If there was an out-of-line value, allocate the blocks we
@@ -1031,9 +1051,12 @@ xfs_attr_node_addname(xfs_da_args_t *args)
if (error)
goto out_defer_cancel;
xfs_defer_ijoin(args->dfops, dp);
- error = xfs_defer_finish(&args->trans, args->dfops);
- if (error)
- goto out_defer_cancel;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans,
+ args->dfops);
+ if (error)
+ goto out_defer_cancel;
+ }
}
/*
@@ -1072,7 +1095,7 @@ xfs_attr_node_addname(xfs_da_args_t *args)
* the root node (a special case of an intermediate node).
*/
STATIC int
-xfs_attr_node_removename(xfs_da_args_t *args)
+xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans)
{
xfs_da_state_t *state;
xfs_da_state_blk_t *blk;
@@ -1181,9 +1204,11 @@ xfs_attr_node_removename(xfs_da_args_t *args)
if (error)
goto out;
- if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
+ if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
+ roll_trans) {
xfs_defer_init(args->dfops, args->firstblock);
- error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
+ error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
+ roll_trans);
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 2135b8e..01935fe 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -546,7 +546,7 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
* Overflow from the inode has already been checked for.
*/
void
-xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
+xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff, bool roll_trans)
{
xfs_attr_shortform_t *sf;
xfs_attr_sf_entry_t *sfe;
@@ -618,7 +618,7 @@ xfs_attr_fork_remove(
* Remove an attribute from the shortform attribute list structure.
*/
int
-xfs_attr_shortform_remove(xfs_da_args_t *args)
+xfs_attr_shortform_remove(xfs_da_args_t *args, bool roll_trans)
{
xfs_attr_shortform_t *sf;
xfs_attr_sf_entry_t *sfe;
@@ -970,7 +970,8 @@ int
xfs_attr3_leaf_to_shortform(
struct xfs_buf *bp,
struct xfs_da_args *args,
- int forkoff)
+ int forkoff,
+ bool roll_trans)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr3_icleaf_hdr ichdr;
@@ -1039,7 +1040,7 @@ xfs_attr3_leaf_to_shortform(
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);
- xfs_attr_shortform_add(&nargs, forkoff);
+ xfs_attr_shortform_add(&nargs, forkoff, roll_trans);
}
error = 0;
@@ -1053,7 +1054,8 @@ xfs_attr3_leaf_to_shortform(
*/
int
xfs_attr3_leaf_to_node(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr3_icleaf_hdr icleafhdr;
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index 4da08af..79c236c 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
@@ -45,12 +45,13 @@ typedef struct xfs_attr_inactive_list {
* Internal routines when attribute fork size < XFS_LITINO(mp).
*/
void xfs_attr_shortform_create(struct xfs_da_args *args);
-void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff);
+void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff,
+ bool roll_trans);
int xfs_attr_shortform_lookup(struct xfs_da_args *args);
int xfs_attr_shortform_getvalue(struct xfs_da_args *args);
int xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
struct xfs_buf **leaf_bp);
-int xfs_attr_shortform_remove(struct xfs_da_args *args);
+int xfs_attr_shortform_remove(struct xfs_da_args *args, bool roll_trans);
int xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
int xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
@@ -59,9 +60,10 @@ void xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
/*
* Internal routines when attribute fork size == XFS_LBSIZE(mp).
*/
-int xfs_attr3_leaf_to_node(struct xfs_da_args *args);
+int xfs_attr3_leaf_to_node(struct xfs_da_args *args, bool roll_trans);
int xfs_attr3_leaf_to_shortform(struct xfs_buf *bp,
- struct xfs_da_args *args, int forkoff);
+ struct xfs_da_args *args, int forkoff,
+ bool roll_trans);
int xfs_attr3_leaf_clearflag(struct xfs_da_args *args);
int xfs_attr3_leaf_setflag(struct xfs_da_args *args);
int xfs_attr3_leaf_flipflags(struct xfs_da_args *args);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 04/23] xfs: Add attibute set and helper functions
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (2 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 03/23] xfs: Add trans toggle to attr routines Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 05/23] xfs: Add attibute remove " Allison Henderson
` (18 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch adds xfs_attr_set_args and xfs_bmap_set_attrforkoff.
These sub-routines set the attributes specified in @args.
We will use this later for setting parent pointers as a deferred
attribute operation.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 169 +++++++++++++++++++++++++++++------------------
fs/xfs/libxfs/xfs_attr.h | 2 +
fs/xfs/libxfs/xfs_bmap.c | 49 ++++++++------
fs/xfs/libxfs/xfs_bmap.h | 1 +
4 files changed, 137 insertions(+), 84 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index e8cb369..856c816 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -242,6 +242,108 @@ xfs_attr_try_sf_addname(
return error;
}
+/*
+ * Set the attribute specified in @args. In the case of the parent attribute
+ * being set, we do not want to roll the transaction on shortform-to-leaf
+ * conversion, as the attribute must be added in the same transaction as the
+ * parent directory modifications. Hence @roll_trans needs to be set
+ * appropriately to control whether the transaction is committed during this
+ * function.
+ */
+int
+xfs_attr_set_args(
+ struct xfs_da_args *args,
+ int flags,
+ struct xfs_buf *leaf_bp,
+ bool roll_trans)
+{
+ struct xfs_inode *dp = args->dp;
+ int error = 0;
+ int sf_size;
+
+ /*
+ * New inodes setting the parent pointer attr will
+ * not have an attribute fork yet. So set the attribute
+ * fork appropriately
+ */
+ if (XFS_IFORK_Q((args->dp)) == 0) {
+ sf_size = sizeof(struct xfs_attr_sf_hdr) +
+ XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
+ xfs_bmap_set_attrforkoff(args->dp, sf_size, NULL);
+ args->dp->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
+ args->dp->i_afp->if_flags = XFS_IFEXTENTS;
+ }
+
+ /*
+ * If the attribute list is non-existent or a shortform list,
+ * upgrade it to a single-leaf-block attribute list.
+ */
+ if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL ||
+ (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
+ dp->i_d.di_anextents == 0)) {
+
+ /*
+ * Build initial attribute list (if required).
+ */
+ if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS)
+ xfs_attr_shortform_create(args);
+
+ /*
+ * Try to add the attr to the attribute list in the inode.
+ */
+ error = xfs_attr_try_sf_addname(dp, args, flags, roll_trans);
+ if (error != -ENOSPC)
+ goto out;
+
+ /*
+ * It won't fit in the shortform, transform to a leaf block.
+ * GROT: another possible req'mt for a double-split btree op.
+ */
+ error = xfs_attr_shortform_to_leaf(args, &leaf_bp);
+ if (error)
+ goto out;
+
+ xfs_defer_bjoin(args->dfops, leaf_bp);
+ xfs_defer_ijoin(args->dfops, dp);
+ if (roll_trans) {
+ /*
+ * Prevent the leaf buffer from being unlocked so that a
+ * concurrent AIL push cannot grab the half-baked leaf
+ * buffer and run into problems with the write verifier.
+ */
+ xfs_trans_bhold(args->trans, leaf_bp);
+
+ error = xfs_defer_finish(&args->trans, args->dfops);
+ if (error) {
+ args->trans = NULL;
+ goto out;
+ }
+
+ /*
+ * Commit the leaf transformation. We'll need another
+ * (linked) transaction to add the new attribute to the
+ * leaf.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ goto out;
+ xfs_defer_ijoin(args->dfops, dp);
+ xfs_trans_bjoin(args->trans, leaf_bp);
+ leaf_bp = NULL;
+ }
+ }
+
+ if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
+ error = xfs_attr_leaf_addname(args, roll_trans);
+ else
+ error = xfs_attr_node_addname(args, roll_trans);
+ if (error)
+ goto out;
+
+out:
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -318,68 +420,9 @@ xfs_attr_set(
xfs_trans_ijoin(args.trans, dp, 0);
- /*
- * If the attribute list is non-existent or a shortform list,
- * upgrade it to a single-leaf-block attribute list.
- */
- if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL ||
- (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
- dp->i_d.di_anextents == 0)) {
-
- /*
- * Build initial attribute list (if required).
- */
- if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS)
- xfs_attr_shortform_create(&args);
-
- /*
- * Try to add the attr to the attribute list in
- * the inode.
- */
- error = xfs_attr_try_sf_addname(dp, &args, flags, true);
- if (error != -ENOSPC) {
- xfs_iunlock(dp, XFS_ILOCK_EXCL);
- return error;
- }
-
- /*
- * It won't fit in the shortform, transform to a leaf block.
- * GROT: another possible req'mt for a double-split btree op.
- */
- xfs_defer_init(args.dfops, args.firstblock);
- error = xfs_attr_shortform_to_leaf(&args, &leaf_bp);
- if (error)
- goto out_defer_cancel;
- /*
- * Prevent the leaf buffer from being unlocked so that a
- * concurrent AIL push cannot grab the half-baked leaf
- * buffer and run into problems with the write verifier.
- */
- xfs_trans_bhold(args.trans, leaf_bp);
- xfs_defer_bjoin(args.dfops, leaf_bp);
- xfs_defer_ijoin(args.dfops, dp);
- error = xfs_defer_finish(&args.trans, args.dfops);
- if (error)
- goto out_defer_cancel;
-
- /*
- * Commit the leaf transformation. We'll need another (linked)
- * transaction to add the new attribute to the leaf, which
- * means that we have to hold & join the leaf buffer here too.
- */
- error = xfs_trans_roll_inode(&args.trans, dp);
- if (error)
- goto out;
- xfs_trans_bjoin(args.trans, leaf_bp);
- leaf_bp = NULL;
- }
-
- if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
- error = xfs_attr_leaf_addname(&args, true);
- else
- error = xfs_attr_node_addname(&args, true);
+ error = xfs_attr_set_args(&args, flags, leaf_bp, true);
if (error)
- goto out;
+ goto out_defer_cancel;
/*
* If this is a synchronous mount, make sure that the
@@ -388,9 +431,6 @@ xfs_attr_set(
if (mp->m_flags & XFS_MOUNT_WSYNC)
xfs_trans_set_sync(args.trans);
- if ((flags & ATTR_KERNOTIME) == 0)
- xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);
-
/*
* Commit the last in the sequence of transactions.
*/
@@ -402,7 +442,6 @@ xfs_attr_set(
out_defer_cancel:
xfs_defer_cancel(&dfops);
-out:
if (leaf_bp)
xfs_trans_brelse(args.trans, leaf_bp);
if (args.trans)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index d07bf27..b5dc02c 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -152,6 +152,8 @@ int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
unsigned char *value, int *valuelenp, int flags);
int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
unsigned char *value, int valuelen, int flags);
+int xfs_attr_set_args(struct xfs_da_args *args, int flags,
+ struct xfs_buf *leaf_bp, bool roll_trans);
int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int flags, struct attrlist_cursor_kern *cursor);
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 6a7c2f0..4e16a5d 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -1031,6 +1031,34 @@ xfs_bmap_add_attrfork_local(
return -EFSCORRUPTED;
}
+/* Set an inode attr fork off based on the format */
+int
+xfs_bmap_set_attrforkoff(
+ struct xfs_inode *ip,
+ int size,
+ int *version)
+{
+ switch (ip->i_d.di_format) {
+ case XFS_DINODE_FMT_DEV:
+ ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
+ break;
+ case XFS_DINODE_FMT_LOCAL:
+ case XFS_DINODE_FMT_EXTENTS:
+ case XFS_DINODE_FMT_BTREE:
+ ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size);
+ if (!ip->i_d.di_forkoff)
+ ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3;
+ else if ((ip->i_mount->m_flags & XFS_MOUNT_ATTR2) && version)
+ *version = 2;
+ break;
+ default:
+ ASSERT(0);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
/*
* Convert inode from non-attributed to attributed.
* Must not be in a transaction, ip must not be locked.
@@ -1084,26 +1112,9 @@ xfs_bmap_add_attrfork(
xfs_trans_ijoin(tp, ip, 0);
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-
- switch (ip->i_d.di_format) {
- case XFS_DINODE_FMT_DEV:
- ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
- break;
- case XFS_DINODE_FMT_LOCAL:
- case XFS_DINODE_FMT_EXTENTS:
- case XFS_DINODE_FMT_BTREE:
- ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size);
- if (!ip->i_d.di_forkoff)
- ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3;
- else if (mp->m_flags & XFS_MOUNT_ATTR2)
- version = 2;
- break;
- default:
- ASSERT(0);
- error = -EINVAL;
+ error = xfs_bmap_set_attrforkoff(ip, size, &version);
+ if (error)
goto trans_cancel;
- }
-
ASSERT(ip->i_afp == NULL);
ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
ip->i_afp->if_flags = XFS_IFEXTENTS;
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index 2b766b3..50e9115 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -191,6 +191,7 @@ void xfs_trim_extent(struct xfs_bmbt_irec *irec, xfs_fileoff_t bno,
xfs_filblks_t len);
void xfs_trim_extent_eof(struct xfs_bmbt_irec *, struct xfs_inode *);
int xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
+int xfs_bmap_set_attrforkoff(struct xfs_inode *ip, int size, int *version);
void xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);
void xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
xfs_fsblock_t bno, xfs_filblks_t len,
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 05/23] xfs: Add attibute remove and helper functions
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (3 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 04/23] xfs: Add attibute set and helper functions Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations Allison Henderson
` (17 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch adds xfs_attr_remove_args. These sub-routines remove
the attributes specified in @args. We will use this later for setting
parent pointers as a deferred attribute operation.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 37 +++++++++++++++++++++++++++----------
fs/xfs/libxfs/xfs_attr.h | 1 +
2 files changed, 28 insertions(+), 10 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 856c816..ab769e5 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -344,6 +344,32 @@ xfs_attr_set_args(
return error;
}
+/*
+ * Remove the attribute specified in @args.
+ */
+int
+xfs_attr_remove_args(
+ struct xfs_da_args *args,
+ int flags,
+ bool roll_trans)
+{
+ struct xfs_inode *dp = args->dp;
+ int error;
+
+ if (!xfs_inode_hasattr(dp)) {
+ error = -ENOATTR;
+ } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
+ ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
+ error = xfs_attr_shortform_remove(args, roll_trans);
+ } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
+ error = xfs_attr_leaf_removename(args, roll_trans);
+ } else {
+ error = xfs_attr_node_removename(args, roll_trans);
+ }
+
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -507,16 +533,7 @@ xfs_attr_remove(
*/
xfs_trans_ijoin(args.trans, dp, 0);
- if (!xfs_inode_hasattr(dp)) {
- error = -ENOATTR;
- } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
- ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
- error = xfs_attr_shortform_remove(&args, true);
- } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
- error = xfs_attr_leaf_removename(&args, true);
- } else {
- error = xfs_attr_node_removename(&args, true);
- }
+ error = xfs_attr_remove_args(&args, flags, true);
if (error)
goto out;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index b5dc02c..ef6b47e 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -155,6 +155,7 @@ int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
int xfs_attr_set_args(struct xfs_da_args *args, int flags,
struct xfs_buf *leaf_bp, bool roll_trans);
int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
+int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int flags, struct attrlist_cursor_kern *cursor);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (4 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 05/23] xfs: Add attibute remove " Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-13 15:18 ` Brian Foster
2018-06-10 5:04 ` [PATCH v7 07/23] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
` (16 subsequent siblings)
22 siblings, 1 reply; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
This patch adds two new log item types for setting or
removing attributes as deferred operations. The
xfs_attri_log_item logs an intent to set or remove an
attribute. The corresponding xfs_attrd_log_item holds
a reference to the xfs_attri_log_item and is freed once
the transaction is done. Both log items use a generic
xfs_attr_log_format structure that contains the attribute
name, value, flags, inode, and an op_flag that indicates
if the operations is a set or remove.
At the moment, this feature will only be used by the parent
pointer patch set which uses attributes to store information
about an inodes parent.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/Makefile | 2 +
fs/xfs/libxfs/xfs_attr.c | 5 +-
fs/xfs/libxfs/xfs_attr.h | 26 +-
fs/xfs/libxfs/xfs_defer.h | 1 +
fs/xfs/libxfs/xfs_log_format.h | 44 +++-
fs/xfs/libxfs/xfs_types.h | 1 +
fs/xfs/xfs_attr_item.c | 560 +++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr_item.h | 120 +++++++++
fs/xfs/xfs_log_recover.c | 173 +++++++++++++
fs/xfs/xfs_ondisk.h | 2 +
fs/xfs/xfs_super.c | 1 +
fs/xfs/xfs_trans.h | 14 ++
fs/xfs/xfs_trans_attr.c | 285 +++++++++++++++++++++
13 files changed, 1229 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 7ceb41a..d3c0004 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -107,6 +107,7 @@ xfs-y += xfs_log.o \
xfs_bmap_item.o \
xfs_buf_item.o \
xfs_extfree_item.o \
+ xfs_attr_item.o \
xfs_icreate_item.o \
xfs_inode_item.o \
xfs_refcount_item.o \
@@ -116,6 +117,7 @@ xfs-y += xfs_log.o \
xfs_trans_bmap.o \
xfs_trans_buf.o \
xfs_trans_extfree.o \
+ xfs_trans_attr.o \
xfs_trans_inode.o \
xfs_trans_refcount.o \
xfs_trans_rmap.o \
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index ab769e5..408a49d 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -41,6 +41,7 @@
#include "xfs_quota.h"
#include "xfs_trans_space.h"
#include "xfs_trace.h"
+#include "xfs_attr_item.h"
/*
* xfs_attr.c
@@ -74,7 +75,7 @@ STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
-STATIC int
+int
xfs_attr_args_init(
struct xfs_da_args *args,
struct xfs_inode *dp,
@@ -170,7 +171,7 @@ xfs_attr_get(
/*
* Calculate how many blocks we need for the new attribute,
*/
-STATIC int
+int
xfs_attr_calc_size(
struct xfs_da_args *args,
int *local)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index ef6b47e..33b33d3 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -18,6 +18,8 @@
#ifndef __XFS_ATTR_H__
#define __XFS_ATTR_H__
+#include "libxfs/xfs_defer.h"
+
struct xfs_inode;
struct xfs_da_args;
struct xfs_attr_list_context;
@@ -90,6 +92,26 @@ typedef struct attrlist_ent { /* data from attr_list() */
} attrlist_ent_t;
/*
+ * List of attrs to commit later.
+ */
+struct xfs_attr_item {
+ struct xfs_inode *xattri_ip;
+ uint32_t xattri_op_flags;
+ uint32_t xattri_value_len; /* length of value */
+ uint32_t xattri_name_len; /* length of name */
+ uint32_t xattri_flags; /* attr flags */
+ struct list_head xattri_list;
+
+ /*
+ * A byte array follows the header containing the file name and
+ * attribute value.
+ */
+};
+
+#define XFS_ATTR_ITEM_SIZEOF(namelen, valuelen) \
+ (sizeof(struct xfs_attr_item) + (namelen) + (valuelen))
+
+/*
* Given a pointer to the (char*) buffer containing the attr_list() result,
* and an index, return a pointer to the indicated attribute in the buffer.
*/
@@ -158,6 +180,8 @@ int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int flags, struct attrlist_cursor_kern *cursor);
-
+int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
+ const unsigned char *name, int flags);
+int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
#endif /* __XFS_ATTR_H__ */
diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
index 045beac..11e1690 100644
--- a/fs/xfs/libxfs/xfs_defer.h
+++ b/fs/xfs/libxfs/xfs_defer.h
@@ -55,6 +55,7 @@ enum xfs_defer_ops_type {
XFS_DEFER_OPS_TYPE_REFCOUNT,
XFS_DEFER_OPS_TYPE_RMAP,
XFS_DEFER_OPS_TYPE_FREE,
+ XFS_DEFER_OPS_TYPE_ATTR,
XFS_DEFER_OPS_TYPE_MAX,
};
diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
index 349d9f8..291e5ff 100644
--- a/fs/xfs/libxfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -116,7 +116,12 @@ static inline uint xlog_get_cycle(char *ptr)
#define XLOG_REG_TYPE_CUD_FORMAT 24
#define XLOG_REG_TYPE_BUI_FORMAT 25
#define XLOG_REG_TYPE_BUD_FORMAT 26
-#define XLOG_REG_TYPE_MAX 26
+#define XLOG_REG_TYPE_ATTRI_FORMAT 27
+#define XLOG_REG_TYPE_ATTRD_FORMAT 28
+#define XLOG_REG_TYPE_ATTR_NAME 29
+#define XLOG_REG_TYPE_ATTR_VALUE 30
+#define XLOG_REG_TYPE_MAX 31
+
/*
* Flags to log operation header
@@ -239,6 +244,8 @@ typedef struct xfs_trans_header {
#define XFS_LI_CUD 0x1243
#define XFS_LI_BUI 0x1244 /* bmbt update intent */
#define XFS_LI_BUD 0x1245
+#define XFS_LI_ATTRI 0x1246 /* attr set/remove intent*/
+#define XFS_LI_ATTRD 0x1247 /* attr set/remove done */
#define XFS_LI_TYPE_DESC \
{ XFS_LI_EFI, "XFS_LI_EFI" }, \
@@ -254,7 +261,9 @@ typedef struct xfs_trans_header {
{ XFS_LI_CUI, "XFS_LI_CUI" }, \
{ XFS_LI_CUD, "XFS_LI_CUD" }, \
{ XFS_LI_BUI, "XFS_LI_BUI" }, \
- { XFS_LI_BUD, "XFS_LI_BUD" }
+ { XFS_LI_BUD, "XFS_LI_BUD" }, \
+ { XFS_LI_ATTRI, "XFS_LI_ATTRI" }, \
+ { XFS_LI_ATTRD, "XFS_LI_ATTRD" }
/*
* Inode Log Item Format definitions.
@@ -852,4 +861,35 @@ struct xfs_icreate_log {
__be32 icl_gen; /* inode generation number to use */
};
+/*
+ * Flags for deferred attribute operations.
+ * Upper bits are flags, lower byte is type code
+ */
+#define XFS_ATTR_OP_FLAGS_SET 1 /* Set the attribute */
+#define XFS_ATTR_OP_FLAGS_REMOVE 2 /* Remove the attribute */
+#define XFS_ATTR_OP_FLAGS_TYPE_MASK 0x0FF /* Flags type mask */
+
+/*
+ * This is the structure used to lay out an attr log item in the
+ * log.
+ */
+struct xfs_attri_log_format {
+ uint16_t alfi_type; /* attri log item type */
+ uint16_t alfi_size; /* size of this item */
+ uint32_t __pad; /* pad to 64 bit aligned */
+ uint64_t alfi_id; /* attri identifier */
+ xfs_ino_t alfi_ino; /* the inode for this attr operation */
+ uint32_t alfi_op_flags; /* marks the op as a set or remove */
+ uint32_t alfi_name_len; /* attr name length */
+ uint32_t alfi_value_len; /* attr value length */
+ uint32_t alfi_attr_flags;/* attr flags */
+};
+
+struct xfs_attrd_log_format {
+ uint16_t alfd_type; /* attrd log item type */
+ uint16_t alfd_size; /* size of this item */
+ uint32_t __pad; /* pad to 64 bit aligned */
+ uint64_t alfd_alf_id; /* id of corresponding attrd */
+};
+
#endif /* __XFS_LOG_FORMAT_H__ */
diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
index 3c56069..2905ce3 100644
--- a/fs/xfs/libxfs/xfs_types.h
+++ b/fs/xfs/libxfs/xfs_types.h
@@ -23,6 +23,7 @@ typedef uint32_t prid_t; /* project ID */
typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
typedef uint32_t xfs_extlen_t; /* extent length in blocks */
+typedef uint32_t xfs_attrlen_t; /* attr length */
typedef uint32_t xfs_agnumber_t; /* allocation group number */
typedef int32_t xfs_extnum_t; /* # of extents in a file */
typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
new file mode 100644
index 0000000..e90d516
--- /dev/null
+++ b/fs/xfs/xfs_attr_item.c
@@ -0,0 +1,560 @@
+/*
+ * Copyright (c) 2017 Oracle, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation Inc.
+ */
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_bit.h"
+#include "xfs_mount.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_buf_item.h"
+#include "xfs_attr_item.h"
+#include "xfs_log.h"
+#include "xfs_btree.h"
+#include "xfs_rmap.h"
+#include "xfs_inode.h"
+#include "xfs_icache.h"
+
+static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip)
+{
+ return container_of(lip, struct xfs_attri_log_item, item);
+}
+
+void
+xfs_attri_item_free(
+ struct xfs_attri_log_item *attrip)
+{
+ kmem_free(attrip->item.li_lv_shadow);
+ kmem_free(attrip);
+}
+
+/*
+ * This returns the number of iovecs needed to log the given attri item.
+ * We only need 1 iovec for an attri item. It just logs the attr_log_format
+ * structure.
+ */
+static inline int
+xfs_attri_item_sizeof(
+ struct xfs_attri_log_item *attrip)
+{
+ return sizeof(struct xfs_attri_log_format);
+}
+
+STATIC void
+xfs_attri_item_size(
+ struct xfs_log_item *lip,
+ int *nvecs,
+ int *nbytes)
+{
+ struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
+
+ *nvecs += 1;
+ *nbytes += xfs_attri_item_sizeof(attrip);
+
+ if (attrip->name_len > 0) {
+ *nvecs += 1;
+ nbytes += ATTR_NVEC_SIZE(attrip->name_len);
+ }
+
+ if (attrip->value_len > 0) {
+ *nvecs += 1;
+ nbytes += ATTR_NVEC_SIZE(attrip->value_len);
+ }
+}
+
+/*
+ * This is called to fill in the vector of log iovecs for the
+ * given attri log item. We use only 1 iovec, and we point that
+ * at the attri_log_format structure embedded in the attri item.
+ * It is at this point that we assert that all of the attr
+ * slots in the attri item have been filled.
+ */
+STATIC void
+xfs_attri_item_format(
+ struct xfs_log_item *lip,
+ struct xfs_log_vec *lv)
+{
+ struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
+ struct xfs_log_iovec *vecp = NULL;
+
+ attrip->format.alfi_type = XFS_LI_ATTRI;
+ attrip->format.alfi_size = 1;
+ if (attrip->name_len > 0)
+ attrip->format.alfi_size++;
+ if (attrip->value_len > 0)
+ attrip->format.alfi_size++;
+
+ xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT,
+ &attrip->format,
+ xfs_attri_item_sizeof(attrip));
+ if (attrip->name_len > 0)
+ xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_NAME,
+ attrip->name, ATTR_NVEC_SIZE(attrip->name_len));
+
+ if (attrip->value_len > 0)
+ xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_VALUE,
+ attrip->value,
+ ATTR_NVEC_SIZE(attrip->value_len));
+}
+
+
+/*
+ * Pinning has no meaning for an attri item, so just return.
+ */
+STATIC void
+xfs_attri_item_pin(
+ struct xfs_log_item *lip)
+{
+}
+
+/*
+ * The unpin operation is the last place an ATTRI is manipulated in the log. It
+ * is either inserted in the AIL or aborted in the event of a log I/O error. In
+ * either case, the ATTRI transaction has been successfully committed to make it
+ * this far. Therefore, we expect whoever committed the ATTRI to either
+ * construct and commit the ATTRD or drop the ATTRD's reference in the event of
+ * error. Simply drop the log's ATTRI reference now that the log is done with
+ * it.
+ */
+STATIC void
+xfs_attri_item_unpin(
+ struct xfs_log_item *lip,
+ int remove)
+{
+ struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
+
+ xfs_attri_release(attrip);
+}
+
+/*
+ * attri items have no locking or pushing. However, since ATTRIs are pulled
+ * from the AIL when their corresponding ATTRDs are committed to disk, their
+ * situation is very similar to being pinned. Return XFS_ITEM_PINNED so that
+ * the caller will eventually flush the log. This should help in getting the
+ * ATTRI out of the AIL.
+ */
+STATIC uint
+xfs_attri_item_push(
+ struct xfs_log_item *lip,
+ struct list_head *buffer_list)
+{
+ return XFS_ITEM_PINNED;
+}
+
+/*
+ * The ATTRI has been either committed or aborted if the transaction has been
+ * cancelled. If the transaction was cancelled, an ATTRD isn't going to be
+ * constructed and thus we free the ATTRI here directly.
+ */
+STATIC void
+xfs_attri_item_unlock(
+ struct xfs_log_item *lip)
+{
+ if (lip->li_flags & XFS_LI_ABORTED)
+ xfs_attri_release(ATTRI_ITEM(lip));
+}
+
+/*
+ * The ATTRI is logged only once and cannot be moved in the log, so simply
+ * return the lsn at which it's been logged.
+ */
+STATIC xfs_lsn_t
+xfs_attri_item_committed(
+ struct xfs_log_item *lip,
+ xfs_lsn_t lsn)
+{
+ return lsn;
+}
+
+STATIC void
+xfs_attri_item_committing(
+ struct xfs_log_item *lip,
+ xfs_lsn_t lsn)
+{
+}
+
+/*
+ * This is the ops vector shared by all attri log items.
+ */
+static const struct xfs_item_ops xfs_attri_item_ops = {
+ .iop_size = xfs_attri_item_size,
+ .iop_format = xfs_attri_item_format,
+ .iop_pin = xfs_attri_item_pin,
+ .iop_unpin = xfs_attri_item_unpin,
+ .iop_unlock = xfs_attri_item_unlock,
+ .iop_committed = xfs_attri_item_committed,
+ .iop_push = xfs_attri_item_push,
+ .iop_committing = xfs_attri_item_committing
+};
+
+
+/*
+ * Allocate and initialize an attri item
+ */
+struct xfs_attri_log_item *
+xfs_attri_init(
+ struct xfs_mount *mp)
+
+{
+ struct xfs_attri_log_item *attrip;
+ uint size;
+
+ size = (uint)(sizeof(struct xfs_attri_log_item));
+ attrip = kmem_zalloc(size, KM_SLEEP);
+
+ xfs_log_item_init(mp, &(attrip->item), XFS_LI_ATTRI,
+ &xfs_attri_item_ops);
+ attrip->format.alfi_id = (uintptr_t)(void *)attrip;
+ atomic_set(&attrip->refcount, 2);
+
+ return attrip;
+}
+
+/*
+ * Copy an attr format buffer from the given buf, and into the destination
+ * attr format structure.
+ */
+int
+xfs_attri_copy_format(struct xfs_log_iovec *buf,
+ struct xfs_attri_log_format *dst_attr_fmt)
+{
+ struct xfs_attri_log_format *src_attr_fmt = buf->i_addr;
+ uint len = sizeof(struct xfs_attri_log_format);
+
+ if (buf->i_len == len) {
+ memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
+ return 0;
+ }
+ return -EFSCORRUPTED;
+}
+
+/*
+ * Copy an attr format buffer from the given buf, and into the destination
+ * attr format structure.
+ */
+int
+xfs_attrd_copy_format(struct xfs_log_iovec *buf,
+ struct xfs_attrd_log_format *dst_attr_fmt)
+{
+ struct xfs_attrd_log_format *src_attr_fmt = buf->i_addr;
+ uint len = sizeof(struct xfs_attrd_log_format);
+
+ if (buf->i_len == len) {
+ memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
+ return 0;
+ }
+ return -EFSCORRUPTED;
+}
+
+/*
+ * Freeing the attrip requires that we remove it from the AIL if it has already
+ * been placed there. However, the ATTRI may not yet have been placed in the AIL
+ * when called by xfs_attri_release() from ATTRD processing due to the ordering of
+ * committed vs unpin operations in bulk insert operations. Hence the reference
+ * count to ensure only the last caller frees the ATTRI.
+ */
+void
+xfs_attri_release(
+ struct xfs_attri_log_item *attrip)
+{
+ ASSERT(atomic_read(&attrip->refcount) > 0);
+ if (atomic_dec_and_test(&attrip->refcount)) {
+ xfs_trans_ail_remove(&attrip->item, SHUTDOWN_LOG_IO_ERROR);
+ xfs_attri_item_free(attrip);
+ }
+}
+
+static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip)
+{
+ return container_of(lip, struct xfs_attrd_log_item, item);
+}
+
+STATIC void
+xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp)
+{
+ kmem_free(attrdp->item.li_lv_shadow);
+ kmem_free(attrdp);
+}
+
+/*
+ * This returns the number of iovecs needed to log the given attrd item.
+ * We only need 1 iovec for an attrd item. It just logs the attr_log_format
+ * structure.
+ */
+static inline int
+xfs_attrd_item_sizeof(
+ struct xfs_attrd_log_item *attrdp)
+{
+ return sizeof(struct xfs_attrd_log_format);
+}
+
+STATIC void
+xfs_attrd_item_size(
+ struct xfs_log_item *lip,
+ int *nvecs,
+ int *nbytes)
+{
+ struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
+ *nvecs += 1;
+ *nbytes += xfs_attrd_item_sizeof(attrdp);
+
+ if (attrdp->name_len > 0) {
+ *nvecs += 1;
+ nbytes += attrdp->name_len;
+ }
+
+ if (attrdp->value_len > 0) {
+ *nvecs += 1;
+ nbytes += attrdp->value_len;
+ }
+}
+
+/*
+ * This is called to fill in the vector of log iovecs for the
+ * given attrd log item. We use only 1 iovec, and we point that
+ * at the attr_log_format structure embedded in the attrd item.
+ * It is at this point that we assert that all of the attr
+ * slots in the attrd item have been filled.
+ */
+STATIC void
+xfs_attrd_item_format(
+ struct xfs_log_item *lip,
+ struct xfs_log_vec *lv)
+{
+ struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
+ struct xfs_log_iovec *vecp = NULL;
+
+ attrdp->format.alfd_type = XFS_LI_ATTRD;
+ attrdp->format.alfd_size = 1;
+
+ xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT,
+ &attrdp->format,
+ xfs_attrd_item_sizeof(attrdp));
+}
+
+/*
+ * Pinning has no meaning for an attrd item, so just return.
+ */
+STATIC void
+xfs_attrd_item_pin(
+ struct xfs_log_item *lip)
+{
+}
+
+/*
+ * Since pinning has no meaning for an attrd item, unpinning does
+ * not either.
+ */
+STATIC void
+xfs_attrd_item_unpin(
+ struct xfs_log_item *lip,
+ int remove)
+{
+}
+
+/*
+ * There isn't much you can do to push on an attrd item. It is simply stuck
+ * waiting for the log to be flushed to disk.
+ */
+STATIC uint
+xfs_attrd_item_push(
+ struct xfs_log_item *lip,
+ struct list_head *buffer_list)
+{
+ return XFS_ITEM_PINNED;
+}
+
+/*
+ * The ATTRD is either committed or aborted if the transaction is cancelled. If
+ * the transaction is cancelled, drop our reference to the ATTRI and free the
+ * ATTRD.
+ */
+STATIC void
+xfs_attrd_item_unlock(
+ struct xfs_log_item *lip)
+{
+ struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
+
+ if (lip->li_flags & XFS_LI_ABORTED) {
+ xfs_attri_release(attrdp->attrip);
+ xfs_attrd_item_free(attrdp);
+ }
+}
+
+/*
+ * When the attrd item is committed to disk, all we need to do is delete our
+ * reference to our partner attri item and then free ourselves. Since we're
+ * freeing ourselves we must return -1 to keep the transaction code from
+ * further referencing this item.
+ */
+STATIC xfs_lsn_t
+xfs_attrd_item_committed(
+ struct xfs_log_item *lip,
+ xfs_lsn_t lsn)
+{
+ struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
+
+ /*
+ * Drop the ATTRI reference regardless of whether the ATTRD has been
+ * aborted. Once the ATTRD transaction is constructed, it is the sole
+ * responsibility of the ATTRD to release the ATTRI (even if the ATTRI
+ * is aborted due to log I/O error).
+ */
+ xfs_attri_release(attrdp->attrip);
+ xfs_attrd_item_free(attrdp);
+
+ return (xfs_lsn_t)-1;
+}
+
+STATIC void
+xfs_attrd_item_committing(
+ struct xfs_log_item *lip,
+ xfs_lsn_t lsn)
+{
+}
+
+/*
+ * This is the ops vector shared by all attrd log items.
+ */
+static const struct xfs_item_ops xfs_attrd_item_ops = {
+ .iop_size = xfs_attrd_item_size,
+ .iop_format = xfs_attrd_item_format,
+ .iop_pin = xfs_attrd_item_pin,
+ .iop_unpin = xfs_attrd_item_unpin,
+ .iop_unlock = xfs_attrd_item_unlock,
+ .iop_committed = xfs_attrd_item_committed,
+ .iop_push = xfs_attrd_item_push,
+ .iop_committing = xfs_attrd_item_committing
+};
+
+/*
+ * Allocate and initialize an attrd item
+ */
+struct xfs_attrd_log_item *
+xfs_attrd_init(
+ struct xfs_mount *mp,
+ struct xfs_attri_log_item *attrip)
+
+{
+ struct xfs_attrd_log_item *attrdp;
+ uint size;
+
+ size = (uint)(sizeof(struct xfs_attrd_log_item));
+ attrdp = kmem_zalloc(size, KM_SLEEP);
+
+ xfs_log_item_init(mp, &attrdp->item, XFS_LI_ATTRD,
+ &xfs_attrd_item_ops);
+ attrdp->attrip = attrip;
+ attrdp->format.alfd_alf_id = attrip->format.alfi_id;
+
+ return attrdp;
+}
+
+/*
+ * Process an attr intent item that was recovered from
+ * the log. We need to delete the attr that it describes.
+ */
+int
+xfs_attri_recover(
+ struct xfs_mount *mp,
+ struct xfs_attri_log_item *attrip,
+ struct xfs_defer_ops *dfops)
+{
+ struct xfs_inode *ip;
+ struct xfs_attrd_log_item *attrdp;
+ struct xfs_trans *tp;
+ int error = 0;
+ struct xfs_attri_log_format *attrp;
+
+ ASSERT(!test_bit(XFS_ATTRI_RECOVERED, &attrip->flags));
+
+ /*
+ * First check the validity of the attr described by the
+ * ATTRI. If any are bad, then assume that all are bad and
+ * just toss the ATTRI.
+ */
+ attrp = &attrip->format;
+ if (
+ /*
+ * Must have either XFS_ATTR_OP_FLAGS_SET or
+ * XFS_ATTR_OP_FLAGS_REMOVE set
+ */
+ !(attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET ||
+ attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE) ||
+
+ /* Check size of value and name lengths */
+ (attrp->alfi_value_len > XATTR_SIZE_MAX ||
+ attrp->alfi_name_len > XATTR_NAME_MAX) ||
+
+ /*
+ * If the XFS_ATTR_OP_FLAGS_SET flag is set,
+ * there must also be a name and value
+ */
+ (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET &&
+ (attrp->alfi_value_len == 0 || attrp->alfi_name_len == 0)) ||
+
+ /*
+ * If the XFS_ATTR_OP_FLAGS_REMOVE flag is set,
+ * there must also be a name
+ */
+ (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE &&
+ (attrp->alfi_name_len == 0))
+ ) {
+ /*
+ * This will pull the ATTRI from the AIL and
+ * free the memory associated with it.
+ */
+ set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
+ xfs_attri_release(attrip);
+ return -EIO;
+ }
+
+ error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
+ if (error)
+ return error;
+ attrdp = xfs_trans_get_attrd(tp, attrip);
+ attrp = &attrip->format;
+
+ error = xfs_iget(mp, tp, attrp->alfi_ino, 0, 0, &ip);
+ if (error)
+ return error;
+
+ xfs_ilock(ip, XFS_ILOCK_EXCL);
+
+ error = xfs_trans_attr(tp, dfops, attrdp, ip,
+ attrp->alfi_op_flags,
+ attrp->alfi_attr_flags,
+ attrp->alfi_name_len,
+ attrp->alfi_value_len,
+ attrip->name,
+ attrip->value);
+ if (error)
+ goto abort_error;
+
+
+ set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
+ error = xfs_trans_commit(tp);
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ return error;
+
+abort_error:
+ xfs_trans_cancel(tp);
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ return error;
+}
diff --git a/fs/xfs/xfs_attr_item.h b/fs/xfs/xfs_attr_item.h
new file mode 100644
index 0000000..184e6b1
--- /dev/null
+++ b/fs/xfs/xfs_attr_item.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2017 Oracle, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation Inc.
+ */
+#ifndef __XFS_ATTR_ITEM_H__
+#define __XFS_ATTR_ITEM_H__
+
+/* kernel only ATTRI/ATTRD definitions */
+
+struct xfs_mount;
+struct kmem_zone;
+
+/*
+ * Max number of attrs in fast allocation path.
+ */
+#define XFS_ATTRI_MAX_FAST_ATTRS 1
+
+
+/*
+ * Define ATTR flag bits. Manipulated by set/clear/test_bit operators.
+ */
+#define XFS_ATTRI_RECOVERED 1
+
+
+/* nvecs must be in multiples of 4 */
+#define ATTR_NVEC_SIZE(size) (size == sizeof(int32_t) ? sizeof(int32_t) : \
+ size + sizeof(int32_t) - \
+ (size % sizeof(int32_t)))
+
+/*
+ * This is the "attr intention" log item. It is used to log the fact
+ * that some attrs need to be processed. It is used in conjunction with the
+ * "attr done" log item described below.
+ *
+ * The ATTRI is reference counted so that it is not freed prior to both the
+ * ATTRI and ATTRD being committed and unpinned. This ensures the ATTRI is
+ * inserted into the AIL even in the event of out of order ATTRI/ATTRD
+ * processing. In other words, an ATTRI is born with two references:
+ *
+ * 1.) an ATTRI held reference to track ATTRI AIL insertion
+ * 2.) an ATTRD held reference to track ATTRD commit
+ *
+ * On allocation, both references are the responsibility of the caller. Once
+ * the ATTRI is added to and dirtied in a transaction, ownership of reference
+ * one transfers to the transaction. The reference is dropped once the ATTRI is
+ * inserted to the AIL or in the event of failure along the way (e.g., commit
+ * failure, log I/O error, etc.). Note that the caller remains responsible for
+ * the ATTRD reference under all circumstances to this point. The caller has no
+ * means to detect failure once the transaction is committed, however.
+ * Therefore, an ATTRD is required after this point, even in the event of
+ * unrelated failure.
+ *
+ * Once an ATTRD is allocated and dirtied in a transaction, reference two
+ * transfers to the transaction. The ATTRD reference is dropped once it reaches
+ * the unpin handler. Similar to the ATTRI, the reference also drops in the
+ * event of commit failure or log I/O errors. Note that the ATTRD is not
+ * inserted in the AIL, so at this point both the ATTI and ATTRD are freed.
+ */
+struct xfs_attri_log_item {
+ xfs_log_item_t item;
+ atomic_t refcount;
+ unsigned long flags; /* misc flags */
+ int name_len;
+ void *name;
+ int value_len;
+ void *value;
+ struct xfs_attri_log_format format;
+};
+
+/*
+ * This is the "attr done" log item. It is used to log
+ * the fact that some attrs earlier mentioned in an attri item
+ * have been freed.
+ */
+struct xfs_attrd_log_item {
+ struct xfs_log_item item;
+ struct xfs_attri_log_item *attrip;
+ uint next_attr;
+ int name_len;
+ void *name;
+ int value_len;
+ void *value;
+ struct xfs_attrd_log_format format;
+};
+
+/*
+ * Max number of attrs in fast allocation path.
+ */
+#define XFS_ATTRD_MAX_FAST_ATTRS 1
+
+extern struct kmem_zone *xfs_attri_zone;
+extern struct kmem_zone *xfs_attrd_zone;
+
+struct xfs_attri_log_item *xfs_attri_init(struct xfs_mount *mp);
+struct xfs_attrd_log_item *xfs_attrd_init(struct xfs_mount *mp,
+ struct xfs_attri_log_item *attrip);
+int xfs_attri_copy_format(struct xfs_log_iovec *buf,
+ struct xfs_attri_log_format *dst_attri_fmt);
+int xfs_attrd_copy_format(struct xfs_log_iovec *buf,
+ struct xfs_attrd_log_format *dst_attrd_fmt);
+void xfs_attri_item_free(struct xfs_attri_log_item *attrip);
+void xfs_attri_release(struct xfs_attri_log_item *attrip);
+
+int xfs_attri_recover(struct xfs_mount *mp,
+ struct xfs_attri_log_item *attrip,
+ struct xfs_defer_ops *dfops);
+
+#endif /* __XFS_ATTR_ITEM_H__ */
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 2b2383f..b34e7f8 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -34,6 +34,7 @@
#include "xfs_log_recover.h"
#include "xfs_inode_item.h"
#include "xfs_extfree_item.h"
+#include "xfs_attr_item.h"
#include "xfs_trans_priv.h"
#include "xfs_alloc.h"
#include "xfs_ialloc.h"
@@ -1967,6 +1968,8 @@ xlog_recover_reorder_trans(
case XFS_LI_CUD:
case XFS_LI_BUI:
case XFS_LI_BUD:
+ case XFS_LI_ATTRI:
+ case XFS_LI_ATTRD:
trace_xfs_log_recover_item_reorder_tail(log,
trans, item, pass);
list_move_tail(&item->ri_list, &inode_list);
@@ -3497,6 +3500,117 @@ xlog_recover_efd_pass2(
return 0;
}
+STATIC int
+xlog_recover_attri_pass2(
+ struct xlog *log,
+ struct xlog_recover_item *item,
+ xfs_lsn_t lsn)
+{
+ int error;
+ struct xfs_mount *mp = log->l_mp;
+ struct xfs_attri_log_item *attrip;
+ struct xfs_attri_log_format *attri_formatp;
+ char *name = NULL;
+ char *value = NULL;
+ int region = 0;
+
+ attri_formatp = item->ri_buf[region].i_addr;
+
+ attrip = xfs_attri_init(mp);
+ error = xfs_attri_copy_format(&item->ri_buf[region], &attrip->format);
+ if (error) {
+ xfs_attri_item_free(attrip);
+ return error;
+ }
+
+ attrip->name_len = attri_formatp->alfi_name_len;
+ attrip->value_len = attri_formatp->alfi_value_len;
+ attrip = kmem_realloc(attrip, sizeof(struct xfs_attri_log_item) +
+ attrip->name_len + attrip->value_len, KM_SLEEP);
+
+ if (attrip->name_len > 0) {
+ region++;
+ name = ((char *)attrip) + sizeof(struct xfs_attri_log_item);
+ memcpy(name, item->ri_buf[region].i_addr,
+ attrip->name_len);
+ attrip->name = name;
+ }
+
+ if (attrip->value_len > 0) {
+ region++;
+ value = ((char *)attrip) + sizeof(struct xfs_attri_log_item) +
+ attrip->name_len;
+ memcpy(value, item->ri_buf[region].i_addr,
+ attrip->value_len);
+ attrip->value = value;
+ }
+
+ spin_lock(&log->l_ailp->ail_lock);
+ /*
+ * The ATTRI has two references. One for the ATTRD and one for ATTRI to
+ * ensure it makes it into the AIL. Insert the ATTRI into the AIL
+ * directly and drop the ATTRI reference. Note that
+ * xfs_trans_ail_update() drops the AIL lock.
+ */
+ xfs_trans_ail_update(log->l_ailp, &attrip->item, lsn);
+ xfs_attri_release(attrip);
+ return 0;
+}
+
+
+/*
+ * This routine is called when an ATTRD format structure is found in a committed
+ * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
+ * it was still in the log. To do this it searches the AIL for the ATTRI with
+ * an id equal to that in the ATTRD format structure. If we find it we drop
+ * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
+ */
+STATIC int
+xlog_recover_attrd_pass2(
+ struct xlog *log,
+ struct xlog_recover_item *item)
+{
+ struct xfs_attrd_log_format *attrd_formatp;
+ struct xfs_attri_log_item *attrip = NULL;
+ struct xfs_log_item *lip;
+ uint64_t attri_id;
+ struct xfs_ail_cursor cur;
+ struct xfs_ail *ailp = log->l_ailp;
+
+ attrd_formatp = item->ri_buf[0].i_addr;
+ ASSERT((item->ri_buf[0].i_len ==
+ (sizeof(struct xfs_attrd_log_format))));
+ attri_id = attrd_formatp->alfd_alf_id;
+
+ /*
+ * Search for the ATTRI with the id in the ATTRD format structure in the
+ * AIL.
+ */
+ spin_lock(&ailp->ail_lock);
+ lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
+ while (lip != NULL) {
+ if (lip->li_type == XFS_LI_ATTRI) {
+ attrip = (struct xfs_attri_log_item *)lip;
+ if (attrip->format.alfi_id == attri_id) {
+ /*
+ * Drop the ATTRD reference to the ATTRI. This
+ * removes the ATTRI from the AIL and frees it.
+ */
+ spin_unlock(&ailp->ail_lock);
+ xfs_attri_release(attrip);
+ spin_lock(&ailp->ail_lock);
+ break;
+ }
+ }
+ lip = xfs_trans_ail_cursor_next(ailp, &cur);
+ }
+
+ xfs_trans_ail_cursor_done(&cur);
+ spin_unlock(&ailp->ail_lock);
+
+ return 0;
+}
+
/*
* This routine is called to create an in-core extent rmap update
* item from the rui format structure which was logged on disk.
@@ -4050,6 +4164,8 @@ xlog_recover_ra_pass2(
break;
case XFS_LI_EFI:
case XFS_LI_EFD:
+ case XFS_LI_ATTRI:
+ case XFS_LI_ATTRD:
case XFS_LI_QUOTAOFF:
case XFS_LI_RUI:
case XFS_LI_RUD:
@@ -4078,6 +4194,8 @@ xlog_recover_commit_pass1(
case XFS_LI_INODE:
case XFS_LI_EFI:
case XFS_LI_EFD:
+ case XFS_LI_ATTRI:
+ case XFS_LI_ATTRD:
case XFS_LI_DQUOT:
case XFS_LI_ICREATE:
case XFS_LI_RUI:
@@ -4116,6 +4234,10 @@ xlog_recover_commit_pass2(
return xlog_recover_efi_pass2(log, item, trans->r_lsn);
case XFS_LI_EFD:
return xlog_recover_efd_pass2(log, item);
+ case XFS_LI_ATTRI:
+ return xlog_recover_attri_pass2(log, item, trans->r_lsn);
+ case XFS_LI_ATTRD:
+ return xlog_recover_attrd_pass2(log, item);
case XFS_LI_RUI:
return xlog_recover_rui_pass2(log, item, trans->r_lsn);
case XFS_LI_RUD:
@@ -4677,6 +4799,49 @@ xlog_recover_cancel_efi(
spin_lock(&ailp->ail_lock);
}
+/* Release the ATTRI since we're cancelling everything. */
+STATIC void
+xlog_recover_cancel_attri(
+ struct xfs_mount *mp,
+ struct xfs_ail *ailp,
+ struct xfs_log_item *lip)
+{
+ struct xfs_attri_log_item *attrip;
+
+ attrip = container_of(lip, struct xfs_attri_log_item, item);
+
+ spin_unlock(&ailp->ail_lock);
+ xfs_attri_release(attrip);
+ spin_lock(&ailp->ail_lock);
+}
+
+
+/* Recover the ATTRI if necessary. */
+STATIC int
+xlog_recover_process_attri(
+ struct xfs_mount *mp,
+ struct xfs_ail *ailp,
+ struct xfs_log_item *lip,
+ struct xfs_defer_ops *dfops)
+{
+ struct xfs_attri_log_item *attrip;
+ int error;
+
+ /*
+ * Skip ATTRIs that we've already processed.
+ */
+ attrip = container_of(lip, struct xfs_attri_log_item, item);
+ if (test_bit(XFS_ATTRI_RECOVERED, &attrip->flags))
+ return 0;
+
+ spin_unlock(&ailp->ail_lock);
+ error = xfs_attri_recover(mp, attrip, dfops);
+ spin_lock(&ailp->ail_lock);
+
+ return error;
+}
+
+
/* Recover the RUI if necessary. */
STATIC int
xlog_recover_process_rui(
@@ -4807,6 +4972,7 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
case XFS_LI_RUI:
case XFS_LI_CUI:
case XFS_LI_BUI:
+ case XFS_LI_ATTRI:
return true;
default:
return false;
@@ -4920,6 +5086,10 @@ xlog_recover_process_intents(
case XFS_LI_EFI:
error = xlog_recover_process_efi(log->l_mp, ailp, lip);
break;
+ case XFS_LI_ATTRI:
+ error = xlog_recover_process_attri(log->l_mp,
+ ailp, lip, &dfops);
+ break;
case XFS_LI_RUI:
error = xlog_recover_process_rui(log->l_mp, ailp, lip);
break;
@@ -4989,6 +5159,9 @@ xlog_recover_cancel_intents(
case XFS_LI_BUI:
xlog_recover_cancel_bui(log->l_mp, ailp, lip);
break;
+ case XFS_LI_ATTRI:
+ xlog_recover_cancel_attri(log->l_mp, ailp, lip);
+ break;
}
lip = xfs_trans_ail_cursor_next(ailp, &cur);
diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
index 0492436..3723d50 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -137,6 +137,8 @@ xfs_check_ondisk_structs(void)
XFS_CHECK_STRUCT_SIZE(struct xfs_inode_log_format, 56);
XFS_CHECK_STRUCT_SIZE(struct xfs_qoff_logformat, 20);
XFS_CHECK_STRUCT_SIZE(struct xfs_trans_header, 16);
+ XFS_CHECK_STRUCT_SIZE(struct xfs_attri_log_format, 40);
+ XFS_CHECK_STRUCT_SIZE(struct xfs_attrd_log_format, 16);
}
#endif /* __XFS_ONDISK_H */
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index d714240..dce3baf 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -2077,6 +2077,7 @@ init_xfs_fs(void)
xfs_rmap_update_init_defer_op();
xfs_refcount_update_init_defer_op();
xfs_bmap_update_init_defer_op();
+ xfs_attr_init_defer_op();
xfs_dir_startup();
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 9d542df..deaae6b 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -40,6 +40,9 @@ struct xfs_cud_log_item;
struct xfs_defer_ops;
struct xfs_bui_log_item;
struct xfs_bud_log_item;
+struct xfs_attrd_log_item;
+struct xfs_attri_log_item;
+
typedef struct xfs_log_item {
struct list_head li_ail; /* AIL pointers */
@@ -223,12 +226,23 @@ void xfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
void xfs_extent_free_init_defer_op(void);
+void xfs_attr_init_defer_op(void);
+
struct xfs_efd_log_item *xfs_trans_get_efd(struct xfs_trans *,
struct xfs_efi_log_item *,
uint);
int xfs_trans_free_extent(struct xfs_trans *,
struct xfs_efd_log_item *, xfs_fsblock_t,
xfs_extlen_t, struct xfs_owner_info *);
+struct xfs_attrd_log_item *
+xfs_trans_get_attrd(struct xfs_trans *tp,
+ struct xfs_attri_log_item *attrip);
+int xfs_trans_attr(struct xfs_trans *tp, struct xfs_defer_ops *dfops,
+ struct xfs_attrd_log_item *attrdp,
+ struct xfs_inode *ip, uint32_t attr_op_flags,
+ uint32_t flags, uint32_t name_len, uint32_t value_len,
+ char *name, char *value);
+
int xfs_trans_commit(struct xfs_trans *);
int xfs_trans_roll(struct xfs_trans **);
int xfs_trans_roll_inode(struct xfs_trans **, struct xfs_inode *);
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
new file mode 100644
index 0000000..7296414
--- /dev/null
+++ b/fs/xfs/xfs_trans_attr.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2017, Oracle Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation Inc.
+ */
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_bit.h"
+#include "xfs_mount.h"
+#include "xfs_defer.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_attr_item.h"
+#include "xfs_alloc.h"
+#include "xfs_bmap.h"
+#include "xfs_trace.h"
+#include "libxfs/xfs_da_format.h"
+#include "xfs_da_btree.h"
+#include "xfs_attr.h"
+#include "xfs_inode.h"
+#include "xfs_icache.h"
+#include "xfs_quota.h"
+
+/*
+ * This routine is called to allocate an "extent free done"
+ * log item that will hold nextents worth of extents. The
+ * caller must use all nextents extents, because we are not
+ * flexible about this at all.
+ */
+struct xfs_attrd_log_item *
+xfs_trans_get_attrd(struct xfs_trans *tp,
+ struct xfs_attri_log_item *attrip)
+{
+ struct xfs_attrd_log_item *attrdp;
+
+ ASSERT(tp != NULL);
+
+ attrdp = xfs_attrd_init(tp->t_mountp, attrip);
+ ASSERT(attrdp != NULL);
+
+ /*
+ * Get a log_item_desc to point at the new item.
+ */
+ xfs_trans_add_item(tp, &attrdp->item);
+ return attrdp;
+}
+
+/*
+ * Delete an attr and log it to the ATTRD. Note that the transaction is marked
+ * dirty regardless of whether the attr delete succeeds or fails to support the
+ * ATTRI/ATTRD lifecycle rules.
+ */
+int
+xfs_trans_attr(
+ struct xfs_trans *tp,
+ struct xfs_defer_ops *dfops,
+ struct xfs_attrd_log_item *attrdp,
+ struct xfs_inode *ip,
+ uint32_t op_flags,
+ uint32_t flags,
+ uint32_t name_len,
+ uint32_t value_len,
+ char *name,
+ char *value)
+{
+ int error;
+ int local;
+ struct xfs_da_args args;
+ xfs_fsblock_t firstblock = NULLFSBLOCK;
+ struct xfs_buf *leaf_bp = NULL;
+
+ error = xfs_attr_args_init(&args, ip, name, flags);
+ if (error)
+ goto out;
+
+ args.name = name;
+ args.namelen = name_len;
+ args.hashval = xfs_da_hashname(args.name, args.namelen);
+ args.value = value;
+ args.valuelen = value_len;
+ args.dfops = dfops;
+ args.firstblock = &firstblock;
+ args.op_flags = XFS_DA_OP_OKNOENT;
+ args.total = xfs_attr_calc_size(&args, &local);
+ args.trans = tp;
+ ASSERT(local);
+
+ error = xfs_qm_dqattach_locked(ip, 0);
+ if (error)
+ return error;
+
+ xfs_trans_ijoin(args.trans, ip, 0);
+ switch (op_flags) {
+ case XFS_ATTR_OP_FLAGS_SET:
+ args.op_flags |= XFS_DA_OP_ADDNAME;
+ error = xfs_attr_set_args(&args, flags,
+ leaf_bp, false);
+ break;
+ case XFS_ATTR_OP_FLAGS_REMOVE:
+ ASSERT(XFS_IFORK_Q((ip)));
+ error = xfs_attr_remove_args(&args, flags, false);
+ break;
+ default:
+ error = -EFSCORRUPTED;
+ }
+
+out:
+ if (error) {
+ if (leaf_bp)
+ xfs_trans_brelse(args.trans, leaf_bp);
+ }
+
+ /*
+ * Mark the transaction dirty, even on error. This ensures the
+ * transaction is aborted, which:
+ *
+ * 1.) releases the ATTRI and frees the ATTRD
+ * 2.) shuts down the filesystem
+ */
+ tp->t_flags |= XFS_TRANS_DIRTY;
+ attrdp->item.li_desc->lid_flags |= XFS_LID_DIRTY;
+ attrdp->name = name;
+ attrdp->value = value;
+ attrdp->name_len = name_len;
+ attrdp->value_len = value_len;
+ attrdp->next_attr++;
+
+ attrdp->attrip->name = name;
+ attrdp->attrip->value = value;
+ attrdp->attrip->name_len = name_len;
+ attrdp->attrip->value_len = value_len;
+
+ return error;
+}
+
+static int
+xfs_attr_diff_items(
+ void *priv,
+ struct list_head *a,
+ struct list_head *b)
+{
+ return 0;
+}
+
+/* Get an ATTRI. */
+STATIC void *
+xfs_attr_create_intent(
+ struct xfs_trans *tp,
+ unsigned int count)
+{
+ struct xfs_attri_log_item *attrip;
+
+ ASSERT(tp != NULL);
+ ASSERT(count == 1);
+
+ attrip = xfs_attri_init(tp->t_mountp);
+ ASSERT(attrip != NULL);
+
+ /*
+ * Get a log_item_desc to point at the new item.
+ */
+ xfs_trans_add_item(tp, &attrip->item);
+ return attrip;
+}
+
+/* Log an attr to the intent item. */
+STATIC void
+xfs_attr_log_item(
+ struct xfs_trans *tp,
+ void *intent,
+ struct list_head *item)
+{
+ struct xfs_attri_log_item *attrip = intent;
+ struct xfs_attr_item *free;
+ struct xfs_attri_log_format *attrp;
+ char *name_value;
+
+ free = container_of(item, struct xfs_attr_item, xattri_list);
+ name_value = ((char *)free) + sizeof(struct xfs_attr_item);
+
+ tp->t_flags |= XFS_TRANS_DIRTY;
+ attrip->item.li_desc->lid_flags |= XFS_LID_DIRTY;
+
+ attrp = &attrip->format;
+ attrp->alfi_ino = free->xattri_ip->i_ino;
+ attrp->alfi_op_flags = free->xattri_op_flags;
+ attrp->alfi_value_len = free->xattri_value_len;
+ attrp->alfi_name_len = free->xattri_name_len;
+ attrp->alfi_attr_flags = free->xattri_flags;
+
+ attrip->name = name_value;
+ attrip->value = &name_value[free->xattri_name_len];
+ attrip->name_len = free->xattri_name_len;
+ attrip->value_len = free->xattri_value_len;
+}
+
+/* Get an ATTRD so we can process all the attrs. */
+STATIC void *
+xfs_attr_create_done(
+ struct xfs_trans *tp,
+ void *intent,
+ unsigned int count)
+{
+ return xfs_trans_get_attrd(tp, intent);
+}
+
+/* Process an attr. */
+STATIC int
+xfs_attr_finish_item(
+ struct xfs_trans *tp,
+ struct xfs_defer_ops *dop,
+ struct list_head *item,
+ void *done_item,
+ void **state)
+{
+ struct xfs_attr_item *free;
+ char *name_value;
+ int error;
+
+ free = container_of(item, struct xfs_attr_item, xattri_list);
+ name_value = ((char *)free) + sizeof(struct xfs_attr_item);
+ error = xfs_trans_attr(tp, dop, done_item,
+ free->xattri_ip,
+ free->xattri_op_flags,
+ free->xattri_flags,
+ free->xattri_name_len,
+ free->xattri_value_len,
+ name_value,
+ &name_value[free->xattri_name_len]);
+ kmem_free(free);
+ return error;
+}
+
+/* Abort all pending ATTRs. */
+STATIC void
+xfs_attr_abort_intent(
+ void *intent)
+{
+ xfs_attri_release(intent);
+}
+
+/* Cancel an attr */
+STATIC void
+xfs_attr_cancel_item(
+ struct list_head *item)
+{
+ struct xfs_attr_item *free;
+
+ free = container_of(item, struct xfs_attr_item, xattri_list);
+ kmem_free(free);
+}
+
+static const struct xfs_defer_op_type xfs_attr_defer_type = {
+ .type = XFS_DEFER_OPS_TYPE_ATTR,
+ .max_items = XFS_ATTRI_MAX_FAST_ATTRS,
+ .diff_items = xfs_attr_diff_items,
+ .create_intent = xfs_attr_create_intent,
+ .abort_intent = xfs_attr_abort_intent,
+ .log_item = xfs_attr_log_item,
+ .create_done = xfs_attr_create_done,
+ .finish_item = xfs_attr_finish_item,
+ .cancel_item = xfs_attr_cancel_item,
+};
+
+/* Register the deferred op type. */
+void
+xfs_attr_init_defer_op(void)
+{
+ xfs_defer_init_op_type(&xfs_attr_defer_type);
+}
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 07/23] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (5 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 08/23] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
` (15 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
These routines set up set and start a new deferred attribute
operation. These functions are meant to be called by other
code needing to initiate a deferred attribute operation. We
will use these routines later in the parent pointer patches.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_attr.h | 5 ++++
2 files changed, 77 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 408a49d..c1844ae 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -477,6 +477,44 @@ xfs_attr_set(
return error;
}
+/* Sets an attribute for an inode as a deferred operation */
+int
+xfs_attr_set_deferred(
+ struct xfs_inode *dp,
+ struct xfs_defer_ops *dfops,
+ void *name,
+ unsigned int namelen,
+ void *value,
+ unsigned int valuelen,
+ int flags)
+{
+
+ struct xfs_attr_item *new;
+ char *name_value;
+
+ if (!namelen || !valuelen) {
+ ASSERT(0);
+ return -EFSCORRUPTED;
+ }
+
+ new = kmem_alloc(XFS_ATTR_ITEM_SIZEOF(namelen, valuelen),
+ KM_SLEEP|KM_NOFS);
+ name_value = ((char *)new) + sizeof(struct xfs_attr_item);
+ memset(new, 0, XFS_ATTR_ITEM_SIZEOF(namelen, valuelen));
+ new->xattri_ip = dp;
+ new->xattri_op_flags = XFS_ATTR_OP_FLAGS_SET;
+ new->xattri_name_len = namelen;
+ new->xattri_value_len = valuelen;
+ new->xattri_flags = flags;
+ memcpy(&name_value[0], name, namelen);
+ memcpy(&name_value[namelen], value, valuelen);
+
+ xfs_defer_ijoin(dfops, dp);
+ xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_ATTR, &new->xattri_list);
+
+ return 0;
+}
+
/*
* Generic handler routine to remove a name from an attribute list.
* Transitions attribute list from Btree to shortform as necessary.
@@ -565,6 +603,40 @@ xfs_attr_remove(
return error;
}
+/* Removes an attribute for an inode as a deferred operation */
+int
+xfs_attr_remove_deferred(
+ struct xfs_inode *dp,
+ struct xfs_defer_ops *dfops,
+ void *name,
+ unsigned int namelen,
+ int flags)
+{
+
+ struct xfs_attr_item *new;
+ char *name_value;
+
+ if (!namelen) {
+ ASSERT(0);
+ return -EFSCORRUPTED;
+ }
+
+ new = kmem_alloc(XFS_ATTR_ITEM_SIZEOF(namelen, 0), KM_SLEEP|KM_NOFS);
+ name_value = ((char *)new) + sizeof(struct xfs_attr_item);
+ memset(new, 0, XFS_ATTR_ITEM_SIZEOF(namelen, 0));
+ new->xattri_ip = dp;
+ new->xattri_op_flags = XFS_ATTR_OP_FLAGS_REMOVE;
+ new->xattri_name_len = namelen;
+ new->xattri_value_len = 0;
+ new->xattri_flags = flags;
+ memcpy(name_value, name, namelen);
+
+ xfs_defer_ijoin(dfops, dp);
+ xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_ATTR, &new->xattri_list);
+
+ return 0;
+}
+
/*========================================================================
* External routines when attribute list is inside the inode
*========================================================================*/
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 33b33d3..ec26565 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -183,5 +183,10 @@ int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
const unsigned char *name, int flags);
int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
+int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_defer_ops *dfops,
+ void *name, unsigned int name_len, void *value,
+ unsigned int valuelen, int flags);
+int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_defer_ops *dfops,
+ void *name, unsigned int namelen, int flags);
#endif /* __XFS_ATTR_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 08/23] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names.
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (6 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 07/23] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 09/23] xfs: get directory offset when adding directory name Allison Henderson
` (14 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
Parent pointer attributes use a binary name, so strlen will not work.
Calling functions will need to pass in the name length
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 12 ++++++++----
fs/xfs/libxfs/xfs_attr.h | 10 ++++++----
fs/xfs/xfs_acl.c | 12 +++++++-----
fs/xfs/xfs_ioctl.c | 13 ++++++++++---
fs/xfs/xfs_iops.c | 6 ++++--
fs/xfs/xfs_trans_attr.c | 2 +-
fs/xfs/xfs_xattr.c | 10 ++++++----
7 files changed, 42 insertions(+), 23 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index c1844ae..14cbda1 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -80,6 +80,7 @@ xfs_attr_args_init(
struct xfs_da_args *args,
struct xfs_inode *dp,
const unsigned char *name,
+ size_t namelen,
int flags)
{
@@ -92,7 +93,7 @@ xfs_attr_args_init(
args->dp = dp;
args->flags = flags;
args->name = name;
- args->namelen = strlen((const char *)name);
+ args->namelen = namelen;
if (args->namelen >= MAXNAMELEN)
return -EFAULT; /* match IRIX behaviour */
@@ -138,6 +139,7 @@ int
xfs_attr_get(
struct xfs_inode *ip,
const unsigned char *name,
+ size_t namelen,
unsigned char *value,
int *valuelenp,
int flags)
@@ -151,7 +153,7 @@ xfs_attr_get(
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
return -EIO;
- error = xfs_attr_args_init(&args, ip, name, flags);
+ error = xfs_attr_args_init(&args, ip, name, namelen, flags);
if (error)
return error;
@@ -375,6 +377,7 @@ int
xfs_attr_set(
struct xfs_inode *dp,
const unsigned char *name,
+ size_t namelen,
unsigned char *value,
int valuelen,
int flags)
@@ -393,7 +396,7 @@ xfs_attr_set(
if (XFS_FORCED_SHUTDOWN(dp->i_mount))
return -EIO;
- error = xfs_attr_args_init(&args, dp, name, flags);
+ error = xfs_attr_args_init(&args, dp, name, namelen, flags);
if (error)
return error;
@@ -523,6 +526,7 @@ int
xfs_attr_remove(
struct xfs_inode *dp,
const unsigned char *name,
+ size_t namelen,
int flags)
{
struct xfs_mount *mp = dp->i_mount;
@@ -536,7 +540,7 @@ xfs_attr_remove(
if (XFS_FORCED_SHUTDOWN(dp->i_mount))
return -EIO;
- error = xfs_attr_args_init(&args, dp, name, flags);
+ error = xfs_attr_args_init(&args, dp, name, namelen, flags);
if (error)
return error;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index ec26565..308a93e 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -171,17 +171,19 @@ int xfs_attr_list_int(struct xfs_attr_list_context *);
int xfs_inode_hasattr(struct xfs_inode *ip);
int xfs_attr_get_ilocked(struct xfs_inode *ip, struct xfs_da_args *args);
int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
- unsigned char *value, int *valuelenp, int flags);
+ size_t namelen, unsigned char *value, int *valuelenp,
+ int flags);
int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
- unsigned char *value, int valuelen, int flags);
+ size_t namelen, unsigned char *value, int valuelen, int flags);
int xfs_attr_set_args(struct xfs_da_args *args, int flags,
struct xfs_buf *leaf_bp, bool roll_trans);
-int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
+int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name,
+ size_t namelen, int flags);
int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int flags, struct attrlist_cursor_kern *cursor);
int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
- const unsigned char *name, int flags);
+ const unsigned char *name, size_t namelen, int flags);
int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_defer_ops *dfops,
void *name, unsigned int name_len, void *value,
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 3354140..e59b26d 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -153,8 +153,8 @@ xfs_get_acl(struct inode *inode, int type)
if (!xfs_acl)
return ERR_PTR(-ENOMEM);
- error = xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl,
- &len, ATTR_ROOT);
+ error = xfs_attr_get(ip, ea_name, strlen(ea_name),
+ (unsigned char *)xfs_acl, &len, ATTR_ROOT);
if (error) {
/*
* If the attribute doesn't exist make sure we have a negative
@@ -204,15 +204,17 @@ __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
len -= sizeof(struct xfs_acl_entry) *
(XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count);
- error = xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl,
- len, ATTR_ROOT);
+ error = xfs_attr_set(ip, ea_name, strlen(ea_name),
+ (unsigned char *)xfs_acl, len, ATTR_ROOT);
kmem_free(xfs_acl);
} else {
/*
* A NULL ACL argument means we want to remove the ACL.
*/
- error = xfs_attr_remove(ip, ea_name, ATTR_ROOT);
+ error = xfs_attr_remove(ip, ea_name,
+ strlen(ea_name),
+ ATTR_ROOT);
/*
* If the attribute didn't exist to start with that's fine.
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 89fb1eb..844480a 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -450,6 +450,7 @@ xfs_attrmulti_attr_get(
{
unsigned char *kbuf;
int error = -EFAULT;
+ size_t namelen;
if (*len > XFS_XATTR_SIZE_MAX)
return -EINVAL;
@@ -457,7 +458,9 @@ xfs_attrmulti_attr_get(
if (!kbuf)
return -ENOMEM;
- error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
+ namelen = strlen(name);
+ error = xfs_attr_get(XFS_I(inode), name, namelen,
+ kbuf, (int *)len, flags);
if (error)
goto out_kfree;
@@ -479,6 +482,7 @@ xfs_attrmulti_attr_set(
{
unsigned char *kbuf;
int error;
+ size_t namelen;
if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
return -EPERM;
@@ -489,7 +493,8 @@ xfs_attrmulti_attr_set(
if (IS_ERR(kbuf))
return PTR_ERR(kbuf);
- error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
+ namelen = strlen(name);
+ error = xfs_attr_set(XFS_I(inode), name, namelen, kbuf, len, flags);
if (!error)
xfs_forget_acl(inode, name, flags);
kfree(kbuf);
@@ -503,10 +508,12 @@ xfs_attrmulti_attr_remove(
uint32_t flags)
{
int error;
+ size_t namelen;
if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
return -EPERM;
- error = xfs_attr_remove(XFS_I(inode), name, flags);
+ namelen = strlen(name);
+ error = xfs_attr_remove(XFS_I(inode), name, namelen, flags);
if (!error)
xfs_forget_acl(inode, name, flags);
return error;
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index c45acf0..7920f19 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -71,8 +71,10 @@ xfs_initxattrs(
int error = 0;
for (xattr = xattr_array; xattr->name != NULL; xattr++) {
- error = xfs_attr_set(ip, xattr->name, xattr->value,
- xattr->value_len, ATTR_SECURE);
+ error = xfs_attr_set(ip, xattr->name,
+ strlen(xattr->name),
+ xattr->value, xattr->value_len,
+ ATTR_SECURE);
if (error < 0)
break;
}
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
index 7296414..848f086 100644
--- a/fs/xfs/xfs_trans_attr.c
+++ b/fs/xfs/xfs_trans_attr.c
@@ -84,7 +84,7 @@ xfs_trans_attr(
xfs_fsblock_t firstblock = NULLFSBLOCK;
struct xfs_buf *leaf_bp = NULL;
- error = xfs_attr_args_init(&args, ip, name, flags);
+ error = xfs_attr_args_init(&args, ip, name, name_len, flags);
if (error)
goto out;
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 0594db4..bc742aa 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -38,6 +38,7 @@ xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused,
int xflags = handler->flags;
struct xfs_inode *ip = XFS_I(inode);
int error, asize = size;
+ size_t namelen = strlen(name);
/* Convert Linux syscall to XFS internal ATTR flags */
if (!size) {
@@ -45,7 +46,7 @@ xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused,
value = NULL;
}
- error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
+ error = xfs_attr_get(ip, name, namelen, value, &asize, xflags);
if (error)
return error;
return asize;
@@ -81,6 +82,7 @@ xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
int xflags = handler->flags;
struct xfs_inode *ip = XFS_I(inode);
int error;
+ size_t namelen = strlen(name);
/* Convert Linux syscall to XFS internal ATTR flags */
if (flags & XATTR_CREATE)
@@ -89,9 +91,9 @@ xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
xflags |= ATTR_REPLACE;
if (!value)
- return xfs_attr_remove(ip, (unsigned char *)name, xflags);
- error = xfs_attr_set(ip, (unsigned char *)name,
- (void *)value, size, xflags);
+ return xfs_attr_remove(ip, name,
+ namelen, xflags);
+ error = xfs_attr_set(ip, name, namelen, (void *)value, size, xflags);
if (!error)
xfs_forget_acl(inode, name, xflags);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 09/23] xfs: get directory offset when adding directory name
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (7 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 08/23] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 10/23] xfs: get directory offset when removing " Allison Henderson
` (13 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Mark Tinguely <tinguely@sgi.com>
Return the directory offset information when adding an entry to the
directory.
This offset will be used as the parent pointer offset in xfs_create,
xfs_symlink, xfs_link and xfs_rename.
[dchinner: forward ported and cleaned up]
[dchinner: no s-o-b from Mark]
[bfoster: rebased, use args->geo in dir code]
[achender: rebased, chaged __uint32_t to xfs_dir2_dataptr_t]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_da_btree.h | 1 +
fs/xfs/libxfs/xfs_dir2.c | 9 +++++++--
fs/xfs/libxfs/xfs_dir2.h | 3 ++-
fs/xfs/libxfs/xfs_dir2_block.c | 1 +
fs/xfs/libxfs/xfs_dir2_leaf.c | 2 ++
fs/xfs/libxfs/xfs_dir2_node.c | 2 ++
fs/xfs/libxfs/xfs_dir2_sf.c | 2 ++
fs/xfs/xfs_inode.c | 9 +++++----
fs/xfs/xfs_symlink.c | 2 +-
9 files changed, 23 insertions(+), 8 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_da_btree.h b/fs/xfs/libxfs/xfs_da_btree.h
index ae6de17..bce96d6 100644
--- a/fs/xfs/libxfs/xfs_da_btree.h
+++ b/fs/xfs/libxfs/xfs_da_btree.h
@@ -86,6 +86,7 @@ typedef struct xfs_da_args {
int rmtvaluelen2; /* remote attr value length in bytes */
int op_flags; /* operation flags */
enum xfs_dacmp cmpresult; /* name compare result for lookups */
+ xfs_dir2_dataptr_t offset; /* OUT: offset in directory */
} xfs_da_args_t;
/*
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 92f94e1..409a1e7 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -257,7 +257,8 @@ xfs_dir_createname(
xfs_ino_t inum, /* new entry inode number */
xfs_fsblock_t *first, /* bmap's firstblock */
struct xfs_defer_ops *dfops, /* bmap's freeblock list */
- xfs_extlen_t total) /* bmap's total block count */
+ xfs_extlen_t total, /* bmap's total block count */
+ xfs_dir2_dataptr_t *offset) /* OUT entry's dir offset */
{
struct xfs_da_args *args;
int rval;
@@ -313,6 +314,10 @@ xfs_dir_createname(
rval = xfs_dir2_node_addname(args);
out_free:
+ /* return the location that this entry was place in the parent inode */
+ if (offset)
+ *offset = args->offset;
+
kmem_free(args);
return rval;
}
@@ -559,7 +564,7 @@ xfs_dir_canenter(
xfs_inode_t *dp,
struct xfs_name *name) /* name of entry to add */
{
- return xfs_dir_createname(tp, dp, name, 0, NULL, NULL, 0);
+ return xfs_dir_createname(tp, dp, name, 0, NULL, NULL, 0, NULL);
}
/*
diff --git a/fs/xfs/libxfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index 989e95a..c98a3ca 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -131,7 +131,8 @@ extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
xfs_fsblock_t *first,
- struct xfs_defer_ops *dfops, xfs_extlen_t tot);
+ struct xfs_defer_ops *dfops, xfs_extlen_t tot,
+ xfs_dir2_dataptr_t *offset);
extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t *inum,
struct xfs_name *ci_name);
diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index 875893d..9b7f173 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -559,6 +559,7 @@ xfs_dir2_block_addname(
dp->d_ops->data_put_ftype(dep, args->filetype);
tagp = dp->d_ops->data_entry_tag_p(dep);
*tagp = cpu_to_be16((char *)dep - (char *)hdr);
+ args->offset = xfs_dir2_byte_to_dataptr((char *)dep - (char *)hdr);
/*
* Clean up the bestfree array and log the header, tail, and entry.
*/
diff --git a/fs/xfs/libxfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index 50fc9c0..8ae2953 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -894,6 +894,8 @@ xfs_dir2_leaf_addname(
dp->d_ops->data_put_ftype(dep, args->filetype);
tagp = dp->d_ops->data_entry_tag_p(dep);
*tagp = cpu_to_be16((char *)dep - (char *)hdr);
+ args->offset = xfs_dir2_db_off_to_dataptr(args->geo, use_block,
+ (char *)dep - (char *)hdr);
/*
* Need to scan fix up the bestfree table.
*/
diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index 9df096c..4e544f7 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -2041,6 +2041,8 @@ xfs_dir2_node_addname_int(
dp->d_ops->data_put_ftype(dep, args->filetype);
tagp = dp->d_ops->data_entry_tag_p(dep);
*tagp = cpu_to_be16((char *)dep - (char *)hdr);
+ args->offset = xfs_dir2_db_off_to_dataptr(args->geo, dbno,
+ (char *)dep - (char *)hdr);
xfs_dir2_data_log_entry(args, dbp, dep);
/*
* Rescan the block for bestfree if needed.
diff --git a/fs/xfs/libxfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index 0c75a7f..222ccf5 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -405,6 +405,7 @@ xfs_dir2_sf_addname_easy(
memcpy(sfep->name, args->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
+ args->offset = xfs_dir2_byte_to_dataptr(offset);
/*
* Update the header and inode.
@@ -496,6 +497,7 @@ xfs_dir2_sf_addname_hard(
memcpy(sfep->name, args->name, sfep->namelen);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
+ args->offset = xfs_dir2_byte_to_dataptr(offset);
sfp->count++;
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
sfp->i8count++;
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 2b70c8b..fc07b4f 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1226,7 +1226,8 @@ xfs_create(
error = xfs_dir_createname(tp, dp, name, ip->i_ino,
&first_block, &dfops, resblks ?
- resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
+ resblks - XFS_IALLOC_SPACE_RES(mp) : 0,
+ NULL);
if (error) {
ASSERT(error != -ENOSPC);
goto out_trans_cancel;
@@ -1462,7 +1463,7 @@ xfs_link(
}
error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
- &first_block, &dfops, resblks);
+ &first_block, &dfops, resblks, NULL);
if (error)
goto error_return;
xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -3040,8 +3041,8 @@ xfs_rename(
* to account for the ".." reference from the new entry.
*/
error = xfs_dir_createname(tp, target_dp, target_name,
- src_ip->i_ino, &first_block,
- &dfops, spaceres);
+ src_ip->i_ino, &first_block, &dfops,
+ spaceres, NULL);
if (error)
goto out_bmap_cancel;
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 5b66ac1..b1d3301 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -350,7 +350,7 @@ xfs_symlink(
* Create the directory entry for the symlink.
*/
error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
- &first_block, &dfops, resblks);
+ &first_block, &dfops, resblks, NULL);
if (error)
goto out_bmap_cancel;
xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 10/23] xfs: get directory offset when removing directory name
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (8 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 09/23] xfs: get directory offset when adding directory name Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 11/23] xfs: get directory offset when replacing a " Allison Henderson
` (12 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Mark Tinguely <tinguely@sgi.com>
Return the directory offset information when removing an entry to the
directory.
This offset will be used as the parent pointer offset in xfs_remove.
[dchinner: forward ported and cleaned up]
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t,
Changed typedefs to raw struct types]
Signed-off-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dir2.c | 16 ++++++++++------
fs/xfs/libxfs/xfs_dir2.h | 4 +++-
fs/xfs/libxfs/xfs_dir2_block.c | 4 ++--
fs/xfs/libxfs/xfs_dir2_leaf.c | 5 +++--
fs/xfs/libxfs/xfs_dir2_node.c | 5 +++--
fs/xfs/libxfs/xfs_dir2_sf.c | 2 ++
fs/xfs/xfs_inode.c | 6 +++---
7 files changed, 26 insertions(+), 16 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 409a1e7..090ab0e 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -433,13 +433,14 @@ xfs_dir_lookup(
*/
int
xfs_dir_removename(
- xfs_trans_t *tp,
- xfs_inode_t *dp,
- struct xfs_name *name,
- xfs_ino_t ino,
- xfs_fsblock_t *first, /* bmap's firstblock */
+ struct xfs_trans *tp,
+ struct xfs_inode *dp,
+ struct xfs_name *name,
+ xfs_ino_t ino,
+ xfs_fsblock_t *first, /* bmap's firstblock */
struct xfs_defer_ops *dfops, /* bmap's freeblock list */
- xfs_extlen_t total) /* bmap's total block count */
+ xfs_extlen_t total, /* bmap's total block count */
+ xfs_dir2_dataptr_t *offset) /* OUT: offset in directory */
{
struct xfs_da_args *args;
int rval;
@@ -486,6 +487,9 @@ xfs_dir_removename(
else
rval = xfs_dir2_node_removename(args);
out_free:
+ if (offset)
+ *offset = args->offset;
+
kmem_free(args);
return rval;
}
diff --git a/fs/xfs/libxfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index c98a3ca..b73bdcb 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -139,7 +139,9 @@ extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t ino,
xfs_fsblock_t *first,
- struct xfs_defer_ops *dfops, xfs_extlen_t tot);
+ struct xfs_defer_ops *dfops,
+ xfs_extlen_t tot,
+ xfs_dir2_dataptr_t *offset);
extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
xfs_fsblock_t *first,
diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index 9b7f173..9c1e485 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -798,9 +798,9 @@ xfs_dir2_block_removename(
/*
* Point to the data entry using the leaf entry.
*/
+ args->offset = be32_to_cpu(blp[ent].address);
dep = (xfs_dir2_data_entry_t *)((char *)hdr +
- xfs_dir2_dataptr_to_off(args->geo,
- be32_to_cpu(blp[ent].address)));
+ xfs_dir2_dataptr_to_off(args->geo, args->offset));
/*
* Mark the data entry's space free.
*/
diff --git a/fs/xfs/libxfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index 8ae2953..c5595c1 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -1414,9 +1414,10 @@ xfs_dir2_leaf_removename(
* Point to the leaf entry, use that to point to the data entry.
*/
lep = &ents[index];
- db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
+ args->offset = be32_to_cpu(lep->address);
+ db = xfs_dir2_dataptr_to_db(args->geo, args->offset);
dep = (xfs_dir2_data_entry_t *)((char *)hdr +
- xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
+ xfs_dir2_dataptr_to_off(args->geo, args->offset));
needscan = needlog = 0;
oldbest = be16_to_cpu(bf[0].length);
ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index 4e544f7..eb8b240 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -1252,9 +1252,10 @@ xfs_dir2_leafn_remove(
/*
* Extract the data block and offset from the entry.
*/
- db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
+ args->offset = be32_to_cpu(lep->address);
+ db = xfs_dir2_dataptr_to_db(args->geo, args->offset);
ASSERT(dblk->blkno == db);
- off = xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address));
+ off = xfs_dir2_dataptr_to_off(args->geo, args->offset);
ASSERT(dblk->index == off);
/*
diff --git a/fs/xfs/libxfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index 222ccf5..1d0957c 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -917,6 +917,8 @@ xfs_dir2_sf_removename(
XFS_CMP_EXACT) {
ASSERT(dp->d_ops->sf_get_ino(sfp, sfep) ==
args->inumber);
+ args->offset = xfs_dir2_byte_to_dataptr(
+ xfs_dir2_sf_get_offset(sfep));
break;
}
}
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index fc07b4f..2ccfa90 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2648,8 +2648,8 @@ xfs_remove(
goto out_trans_cancel;
xfs_defer_init(&dfops, &first_block);
- error = xfs_dir_removename(tp, dp, name, ip->i_ino,
- &first_block, &dfops, resblks);
+ error = xfs_dir_removename(tp, dp, name, ip->i_ino, &first_block,
+ &dfops, resblks, NULL);
if (error) {
ASSERT(error != -ENOENT);
goto out_bmap_cancel;
@@ -3159,7 +3159,7 @@ xfs_rename(
&first_block, &dfops, spaceres);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
- &first_block, &dfops, spaceres);
+ &first_block, &dfops, spaceres, NULL);
if (error)
goto out_bmap_cancel;
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 11/23] xfs: get directory offset when replacing a directory name
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (9 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 10/23] xfs: get directory offset when removing " Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 12/23] xfs: add parent pointer support to attribute code Allison Henderson
` (11 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Mark Tinguely <tinguely@sgi.com>
Return the directory offset information when replacing an entry to the
directory.
This offset will be used as the parent pointer offset in xfs_rename.
[dchinner: forward ported and cleaned up]
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t,
Changed typedefs to raw struct types]
Signed-off-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dir2.c | 18 +++++++++++-------
fs/xfs/libxfs/xfs_dir2.h | 3 ++-
fs/xfs/libxfs/xfs_dir2_block.c | 4 ++--
fs/xfs/libxfs/xfs_dir2_leaf.c | 1 +
fs/xfs/libxfs/xfs_dir2_node.c | 1 +
fs/xfs/libxfs/xfs_dir2_sf.c | 2 ++
fs/xfs/xfs_inode.c | 28 +++++++++++++---------------
7 files changed, 32 insertions(+), 25 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 090ab0e..eebb83c 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -487,7 +487,7 @@ xfs_dir_removename(
else
rval = xfs_dir2_node_removename(args);
out_free:
- if (offset)
+ if (!rval && offset)
*offset = args->offset;
kmem_free(args);
@@ -499,13 +499,14 @@ xfs_dir_removename(
*/
int
xfs_dir_replace(
- xfs_trans_t *tp,
- xfs_inode_t *dp,
- struct xfs_name *name, /* name of entry to replace */
- xfs_ino_t inum, /* new inode number */
- xfs_fsblock_t *first, /* bmap's firstblock */
+ struct xfs_trans *tp,
+ struct xfs_inode *dp,
+ struct xfs_name *name, /* name of entry to replace */
+ xfs_ino_t inum, /* new inode number */
+ xfs_fsblock_t *first, /* bmap's firstblock */
struct xfs_defer_ops *dfops, /* bmap's freeblock list */
- xfs_extlen_t total) /* bmap's total block count */
+ xfs_extlen_t total, /* bmap's total block count */
+ xfs_dir2_dataptr_t *offset) /* OUT: offset in directory */
{
struct xfs_da_args *args;
int rval;
@@ -555,6 +556,9 @@ xfs_dir_replace(
else
rval = xfs_dir2_node_replace(args);
out_free:
+ if (offset)
+ *offset = args->offset;
+
kmem_free(args);
return rval;
}
diff --git a/fs/xfs/libxfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index b73bdcb..d361442 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -145,7 +145,8 @@ extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
xfs_fsblock_t *first,
- struct xfs_defer_ops *dfops, xfs_extlen_t tot);
+ struct xfs_defer_ops *dfops, xfs_extlen_t tot,
+ xfs_dir2_dataptr_t *offset);
extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name);
diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index 9c1e485..77744e5 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -872,9 +872,9 @@ xfs_dir2_block_replace(
/*
* Point to the data entry we need to change.
*/
+ args->offset = be32_to_cpu(blp[ent].address);
dep = (xfs_dir2_data_entry_t *)((char *)hdr +
- xfs_dir2_dataptr_to_off(args->geo,
- be32_to_cpu(blp[ent].address)));
+ xfs_dir2_dataptr_to_off(args->geo, args->offset));
ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
/*
* Change the inode number to the new value.
diff --git a/fs/xfs/libxfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index c5595c1..6ad7741 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -1550,6 +1550,7 @@ xfs_dir2_leaf_replace(
/*
* Point to the data entry.
*/
+ args->offset = be32_to_cpu(lep->address);
dep = (xfs_dir2_data_entry_t *)
((char *)dbp->b_addr +
xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index eb8b240..ccf220a 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -2256,6 +2256,7 @@ xfs_dir2_node_replace(
hdr = state->extrablk.bp->b_addr;
ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
+ args->offset = be32_to_cpu(lep->address);
dep = (xfs_dir2_data_entry_t *)
((char *)hdr +
xfs_dir2_dataptr_to_off(args->geo,
diff --git a/fs/xfs/libxfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index 1d0957c..73f1eef 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -1043,6 +1043,8 @@ xfs_dir2_sf_replace(
ASSERT(args->inumber != ino);
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype);
+ args->offset = xfs_dir2_byte_to_dataptr(
+ xfs_dir2_sf_get_offset(sfep));
break;
}
}
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 2ccfa90..1cd9429 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2783,16 +2783,14 @@ xfs_cross_rename(
int dp2_flags = 0;
/* Swap inode number for dirent in first parent */
- error = xfs_dir_replace(tp, dp1, name1,
- ip2->i_ino,
- first_block, dfops, spaceres);
+ error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, first_block, dfops,
+ spaceres, NULL);
if (error)
goto out_trans_abort;
/* Swap inode number for dirent in second parent */
- error = xfs_dir_replace(tp, dp2, name2,
- ip1->i_ino,
- first_block, dfops, spaceres);
+ error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, first_block, dfops,
+ spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -2806,8 +2804,8 @@ xfs_cross_rename(
if (S_ISDIR(VFS_I(ip2)->i_mode)) {
error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
- dp1->i_ino, first_block,
- dfops, spaceres);
+ dp1->i_ino, first_block, dfops,
+ spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -2833,8 +2831,8 @@ xfs_cross_rename(
if (S_ISDIR(VFS_I(ip1)->i_mode)) {
error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
- dp2->i_ino, first_block,
- dfops, spaceres);
+ dp2->i_ino, first_block, dfops,
+ spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -3081,8 +3079,8 @@ xfs_rename(
* name at the destination directory, remove it first.
*/
error = xfs_dir_replace(tp, target_dp, target_name,
- src_ip->i_ino,
- &first_block, &dfops, spaceres);
+ src_ip->i_ino, &first_block, &dfops,
+ spaceres, NULL);
if (error)
goto out_bmap_cancel;
@@ -3116,8 +3114,8 @@ xfs_rename(
* directory.
*/
error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
- target_dp->i_ino,
- &first_block, &dfops, spaceres);
+ target_dp->i_ino, &first_block, &dfops,
+ spaceres, NULL);
ASSERT(error != -EEXIST);
if (error)
goto out_bmap_cancel;
@@ -3156,7 +3154,7 @@ xfs_rename(
*/
if (wip) {
error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
- &first_block, &dfops, spaceres);
+ &first_block, &dfops, spaceres, NULL);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
&first_block, &dfops, spaceres, NULL);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 12/23] xfs: add parent pointer support to attribute code
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (10 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 11/23] xfs: get directory offset when replacing a " Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 13/23] xfs: define parent pointer xattr format Allison Henderson
` (10 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Mark Tinguely <tinguely@sgi.com>
Add the new parent attribute type. XFS_ATTR_PARENT is used only for
parent pointer entries; it uses reserved blocks like XFS_ATTR_ROOT.
[dchinner: forward ported and cleaned up]
[achender: rebased]
Signed-off-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 2 +-
fs/xfs/libxfs/xfs_attr.h | 2 ++
fs/xfs/libxfs/xfs_da_format.h | 12 ++++++++----
3 files changed, 11 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 14cbda1..a3656d8b 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -388,7 +388,7 @@ xfs_attr_set(
struct xfs_defer_ops dfops;
struct xfs_trans_res tres;
xfs_fsblock_t firstblock;
- int rsvd = (flags & ATTR_ROOT) != 0;
+ bool rsvd = (flags & (ATTR_ROOT | ATTR_PARENT)) != 0;
int error, local;
XFS_STATS_INC(mp, xs_attr_set);
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 308a93e..d041734 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -46,6 +46,7 @@ struct xfs_attr_list_context;
#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 ATTR_PARENT 0x0040 /* use attrs in parent namespace */
#define ATTR_KERNOTIME 0x1000 /* [kernel] don't update inode timestamps */
#define ATTR_KERNOVAL 0x2000 /* [kernel] get attr size only, not value */
@@ -59,6 +60,7 @@ struct xfs_attr_list_context;
{ ATTR_SECURE, "SECURE" }, \
{ ATTR_CREATE, "CREATE" }, \
{ ATTR_REPLACE, "REPLACE" }, \
+ { ATTR_PARENT, "PARENT" }, \
{ ATTR_KERNOTIME, "KERNOTIME" }, \
{ ATTR_KERNOVAL, "KERNOVAL" }, \
{ ATTR_INCOMPLETE, "INCOMPLETE" }
diff --git a/fs/xfs/libxfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index 7e77299..9bd2e6b 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -758,24 +758,28 @@ struct xfs_attr3_icleaf_hdr {
#define XFS_ATTR_LOCAL_BIT 0 /* attr is stored locally */
#define XFS_ATTR_ROOT_BIT 1 /* limit access to trusted attrs */
#define XFS_ATTR_SECURE_BIT 2 /* limit access to secure attrs */
+#define XFS_ATTR_PARENT_BIT 3 /* parent pointer secure attrs */
#define XFS_ATTR_INCOMPLETE_BIT 7 /* attr in middle of create/delete */
#define XFS_ATTR_LOCAL (1 << XFS_ATTR_LOCAL_BIT)
#define XFS_ATTR_ROOT (1 << XFS_ATTR_ROOT_BIT)
#define XFS_ATTR_SECURE (1 << XFS_ATTR_SECURE_BIT)
+#define XFS_ATTR_PARENT (1 << XFS_ATTR_PARENT_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_ARGS_MASK (ATTR_ROOT | ATTR_SECURE | XFS_ATTR_PARENT)
+#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT)
#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))
+ ((x) & ATTR_SECURE ? XFS_ATTR_SECURE : 0) | \
+ ((x) & ATTR_PARENT ? XFS_ATTR_PARENT : 0))
#define XFS_ATTR_NSP_ONDISK_TO_ARGS(x) (((x) & XFS_ATTR_ROOT ? ATTR_ROOT : 0) |\
- ((x) & XFS_ATTR_SECURE ? ATTR_SECURE : 0))
+ ((x) & XFS_ATTR_SECURE ? ATTR_SECURE : 0) | \
+ ((x) & XFS_ATTR_PARENT ? ATTR_PARENT : 0))
/*
* Alignment for namelist and valuelist entries (since they are mixed
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 13/23] xfs: define parent pointer xattr format
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (11 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 12/23] xfs: add parent pointer support to attribute code Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 14/23] xfs: extent transaction reservations for parent attributes Allison Henderson
` (9 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
We need to define the parent pointer attribute format before we
start adding support for it into all the code that needs to use it.
The EA format we will use encodes the following information:
name={parent inode #, parent inode generation, dirent offset}
value={dirent filename}
The inode/gen gives all the information we need to reliably identify
the parent without requiring child->parent lock ordering, and allows
userspace to do pathname component level reconstruction without the
kernel ever needing to verify the parent itself as part of ioctl
calls.
By using the dirent offset in the EA name, we have a method of
knowing the exact parent pointer EA we need to modify/remove in
rename/unlink without an unbound EA name search.
By keeping the dirent name in the value, we have enough information
to be able to validate and reconstruct damaged directory trees.
While the diroffset of a filename alone is not unique enough to
identify the child, the {diroffset,filename,child_inode} tuple is
sufficient. That is, if the diroffset gets reused and points to a
different filename, we can detect that from the contents of EA. If a
link of the same name is created, then we can check whether it
points at the same inode as the parent EA we current have.
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t,
changed p_ino to xfs_ino_t and p_namelen to uint8_t,
moved to xfs_da_format for xfs_dir2_dataptr_t]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong<darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_da_format.h | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index 9bd2e6b..bb5d8ec 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -885,4 +885,29 @@ static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)
return 1 << (sbp->sb_blocklog + sbp->sb_dirblklog);
}
+/*
+ * Parent pointer attribute format definition
+ *
+ * EA name encodes the parent inode number, generation and the offset of
+ * the dirent that points to the child inode. The EA value contains the
+ * same name as the dirent in the parent directory.
+ */
+struct xfs_parent_name_rec {
+ __be64 p_ino;
+ __be32 p_gen;
+ __be32 p_diroffset;
+};
+
+/*
+ * incore version of the above, also contains name pointers so callers
+ * can pass/obtain all the parent pointer information in a single structure
+ */
+struct xfs_parent_name_irec {
+ xfs_ino_t p_ino;
+ uint32_t p_gen;
+ xfs_dir2_dataptr_t p_diroffset;
+ const char *p_name;
+ uint8_t p_namelen;
+};
+
#endif /* __XFS_DA_FORMAT_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 14/23] xfs: extent transaction reservations for parent attributes
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (12 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 13/23] xfs: define parent pointer xattr format Allison Henderson
@ 2018-06-10 5:04 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 15/23] xfs: Hold inode locks in xfs_ialloc Allison Henderson
` (8 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:04 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
We need to add, remove or modify parent pointer attributes during
create/link/unlink/rename operations atomically with the dirents in the parent
directories being modified. This means they need to be modified in the same
transaction as the parent directories, and so we need to add the required
space for the attribute modifications to the transaction reservations.
[achender: rebased, added xfs_sb_version_hasparent stub]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_format.h | 5 ++
fs/xfs/libxfs/xfs_trans_resv.c | 111 ++++++++++++++++++++++++++++++++---------
fs/xfs/libxfs/xfs_trans_resv.h | 1 +
3 files changed, 94 insertions(+), 23 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 42956d8..5e946c8 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -559,6 +559,11 @@ static inline bool xfs_sb_version_hasreflink(struct xfs_sb *sbp)
(sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_REFLINK);
}
+static inline bool xfs_sb_version_hasparent(struct xfs_sb *sbp)
+{
+ return false; /* We'll enable this at the end of the set */
+}
+
/*
* end of superblock version macros
*/
diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index 3bccdf7..e98f22e 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -787,29 +787,30 @@ xfs_calc_sb_reservation(
return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
}
+/*
+ * Namespace reservations.
+ *
+ * These get tricky when parent pointers are enabled as we have attribute
+ * modifications occurring from within these transactions. Rather than confuse
+ * each of these reservation calculations with the conditional attribute
+ * reservations, add them here in a clear and concise manner. This assumes that
+ * the attribute reservations have already been calculated.
+ *
+ * Note that we only include the static attribute reservation here; the runtime
+ * reservation will have to be modified by the size of the attributes being
+ * added/removed/modified. See the comments on the attribute reservation
+ * calculations for more details.
+ *
+ * Note for rename: rename will vastly overestimate requirements. This will be
+ * addressed later when modifications are made to ensure parent attribute
+ * modifications can be done atomically with the rename operation.
+ */
void
-xfs_trans_resv_calc(
+xfs_calc_namespace_reservations(
struct xfs_mount *mp,
struct xfs_trans_resv *resp)
{
- /*
- * The following transactions are logged in physical format and
- * require a permanent reservation on space.
- */
- resp->tr_write.tr_logres = xfs_calc_write_reservation(mp);
- if (xfs_sb_version_hasreflink(&mp->m_sb))
- resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
- else
- resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT;
- resp->tr_write.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
-
- resp->tr_itruncate.tr_logres = xfs_calc_itruncate_reservation(mp);
- if (xfs_sb_version_hasreflink(&mp->m_sb))
- resp->tr_itruncate.tr_logcount =
- XFS_ITRUNCATE_LOG_COUNT_REFLINK;
- else
- resp->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT;
- resp->tr_itruncate.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+ ASSERT(resp->tr_attrsetm.tr_logres > 0);
resp->tr_rename.tr_logres = xfs_calc_rename_reservation(mp);
resp->tr_rename.tr_logcount = XFS_RENAME_LOG_COUNT;
@@ -831,15 +832,77 @@ xfs_trans_resv_calc(
resp->tr_create.tr_logcount = XFS_CREATE_LOG_COUNT;
resp->tr_create.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+ resp->tr_mkdir.tr_logres = xfs_calc_mkdir_reservation(mp);
+ resp->tr_mkdir.tr_logcount = XFS_MKDIR_LOG_COUNT;
+ resp->tr_mkdir.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+
+ xfs_calc_parent_ptr_reservations(mp);
+}
+
+void xfs_calc_parent_ptr_reservations(struct xfs_mount *mp)
+{
+ struct xfs_trans_resv *resp = M_RES(mp);
+
+ /* Calculate extra space needed for parent pointer attributes */
+ if (!xfs_sb_version_hasparent(&mp->m_sb))
+ return;
+
+ /* rename can add/remove/modify 4 parent attributes */
+ resp->tr_rename.tr_logres += 4 * max(resp->tr_attrsetm.tr_logres,
+ resp->tr_attrrm.tr_logres);
+ resp->tr_rename.tr_logcount += 4 * max(resp->tr_attrsetm.tr_logcount,
+ resp->tr_attrrm.tr_logcount);
+
+ /* create will add 1 parent attribute */
+ resp->tr_create.tr_logres += resp->tr_attrsetm.tr_logres;
+ resp->tr_create.tr_logcount += resp->tr_attrsetm.tr_logcount;
+
+ /* mkdir will add 1 parent attribute */
+ resp->tr_mkdir.tr_logres += resp->tr_attrsetm.tr_logres;
+ resp->tr_mkdir.tr_logcount += resp->tr_attrsetm.tr_logcount;
+
+ /* link will add 1 parent attribute */
+ resp->tr_link.tr_logres += resp->tr_attrsetm.tr_logres;
+ resp->tr_link.tr_logcount += resp->tr_attrsetm.tr_logcount;
+
+ /* symlink will add 1 parent attribute */
+ resp->tr_symlink.tr_logres += resp->tr_attrsetm.tr_logres;
+ resp->tr_symlink.tr_logcount += resp->tr_attrsetm.tr_logcount;
+
+ /* remove will remove 1 parent attribute */
+ resp->tr_remove.tr_logres += resp->tr_attrrm.tr_logres;
+ resp->tr_remove.tr_logcount += resp->tr_attrrm.tr_logcount;
+}
+
+void
+xfs_trans_resv_calc(
+ struct xfs_mount *mp,
+ struct xfs_trans_resv *resp)
+{
+ /*
+ * The following transactions are logged in physical format and
+ * require a permanent reservation on space.
+ */
+ resp->tr_write.tr_logres = xfs_calc_write_reservation(mp);
+ if (xfs_sb_version_hasreflink(&mp->m_sb))
+ resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
+ else
+ resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT;
+ resp->tr_write.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+
+ resp->tr_itruncate.tr_logres = xfs_calc_itruncate_reservation(mp);
+ if (xfs_sb_version_hasreflink(&mp->m_sb))
+ resp->tr_itruncate.tr_logcount =
+ XFS_ITRUNCATE_LOG_COUNT_REFLINK;
+ else
+ resp->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT;
+ resp->tr_itruncate.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+
resp->tr_create_tmpfile.tr_logres =
xfs_calc_create_tmpfile_reservation(mp);
resp->tr_create_tmpfile.tr_logcount = XFS_CREATE_TMPFILE_LOG_COUNT;
resp->tr_create_tmpfile.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
- resp->tr_mkdir.tr_logres = xfs_calc_mkdir_reservation(mp);
- resp->tr_mkdir.tr_logcount = XFS_MKDIR_LOG_COUNT;
- resp->tr_mkdir.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
-
resp->tr_ifree.tr_logres = xfs_calc_ifree_reservation(mp);
resp->tr_ifree.tr_logcount = XFS_INACTIVE_LOG_COUNT;
resp->tr_ifree.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
@@ -871,6 +934,8 @@ xfs_trans_resv_calc(
resp->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT;
resp->tr_qm_dqalloc.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
+ xfs_calc_namespace_reservations(mp, resp);
+
/*
* The following transactions are logged in logical format with
* a default log count.
diff --git a/fs/xfs/libxfs/xfs_trans_resv.h b/fs/xfs/libxfs/xfs_trans_resv.h
index b7e5357..c7190d6 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.h
+++ b/fs/xfs/libxfs/xfs_trans_resv.h
@@ -105,5 +105,6 @@ struct xfs_trans_resv {
void xfs_trans_resv_calc(struct xfs_mount *mp, struct xfs_trans_resv *resp);
uint xfs_allocfree_log_count(struct xfs_mount *mp, uint num_ops);
+void xfs_calc_parent_ptr_reservations(struct xfs_mount *mp);
#endif /* __XFS_TRANS_RESV_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 15/23] xfs: Hold inode locks in xfs_ialloc
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (13 preceding siblings ...)
2018-06-10 5:04 ` [PATCH v7 14/23] xfs: extent transaction reservations for parent attributes Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 16/23] xfs: parent pointer attribute creation Allison Henderson
` (7 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
Modify xfs_ialloc to hold locks after return. Caller
will be responsible for manual unlock. We will need
this later to hold locks across parent pointer operations
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/xfs_inode.c | 6 +++++-
fs/xfs/xfs_qm.c | 1 +
2 files changed, 6 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 1cd9429..946d2c0 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -756,6 +756,8 @@ xfs_lookup(
* to attach to or associate with (i.e. pip == NULL) because they
* are not linked into the directory structure - they are attached
* directly to the superblock - and so have no parent.
+ *
+ * Caller is responsible for unlocking the inode manually upon return
*/
static int
xfs_ialloc(
@@ -942,7 +944,7 @@ xfs_ialloc(
/*
* Log the new values stuffed into the inode.
*/
- xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, ip, 0);
xfs_trans_log_inode(tp, ip, flags);
/* now that we have an i_mode we can setup the inode structure */
@@ -1273,6 +1275,7 @@ xfs_create(
xfs_qm_dqrele(pdqp);
*ipp = ip;
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
return 0;
out_bmap_cancel:
@@ -1370,6 +1373,7 @@ xfs_create_tmpfile(
xfs_qm_dqrele(pdqp);
*ipp = ip;
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
return 0;
out_trans_cancel:
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index ec39ae2..3ae136b 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -827,6 +827,7 @@ xfs_qm_qino_alloc(
}
if (need_alloc)
xfs_finish_inode_setup(*ip);
+ xfs_iunlock(*ip, XFS_ILOCK_EXCL);
return error;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 16/23] xfs: parent pointer attribute creation
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (14 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 15/23] xfs: Hold inode locks in xfs_ialloc Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 17/23] xfs: add parent attributes to link Allison Henderson
` (6 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
Add parent pointer attribute during xfs_create, and
subroutines to initialize attributes
Kernel create routines take advantage of deferred attributes,
where as libxfs routines will add parent pointers directly.
[bfoster: rebase, use VFS inode generation]
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t,
fixed some null pointer bugs,
merged error handling patch,
added subroutines to handle attribute initialization,
remove unnecessary ENOSPC handling in xfs_attr_set_first_parent]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/Makefile | 2 +
fs/xfs/libxfs/xfs_parent.c | 161 +++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_parent.h | 36 ++++++++++
fs/xfs/xfs_inode.c | 18 ++++-
fs/xfs/xfs_parent_utils.c | 50 ++++++++++++++
fs/xfs/xfs_parent_utils.h | 26 ++++++++
6 files changed, 291 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index d3c0004..d092f72 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -53,6 +53,7 @@ xfs-y += $(addprefix libxfs/, \
xfs_inode_fork.o \
xfs_inode_buf.o \
xfs_log_rlimit.o \
+ xfs_parent.o \
xfs_ag_resv.o \
xfs_rmap.o \
xfs_rmap_btree.o \
@@ -92,6 +93,7 @@ xfs-y += xfs_aops.o \
xfs_message.o \
xfs_mount.o \
xfs_mru_cache.o \
+ xfs_parent_utils.o \
xfs_reflink.o \
xfs_stats.o \
xfs_super.o \
diff --git a/fs/xfs/libxfs/xfs_parent.c b/fs/xfs/libxfs/xfs_parent.c
new file mode 100644
index 0000000..9f0964a
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_parent.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2015 Red Hat, Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation
+ */
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_format.h"
+#include "xfs_da_format.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
+#include "xfs_mount.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_inode.h"
+#include "xfs_error.h"
+#include "xfs_trace.h"
+#include "xfs_trans.h"
+#include "xfs_attr.h"
+#include "xfs_da_btree.h"
+#include "xfs_attr_sf.h"
+#include "xfs_bmap.h"
+
+/*
+ * Parent pointer attribute handling.
+ *
+ * Because the attribute value is a filename component, it will never be longer
+ * than 255 bytes. This means the attribute will always be a local format
+ * attribute as it is xfs_attr_leaf_entsize_local_max() for v5 filesystems will
+ * always be larger than this (max is 75% of block size).
+ *
+ * Creating a new parent attribute will always create a new attribute - there
+ * should never, ever be an existing attribute in the tree for a new inode.
+ * ENOSPC behaviour is problematic - creating the inode without the parent
+ * pointer is effectively a corruption, so we allow parent attribute creation
+ * to dip into the reserve block pool to avoid unexpected ENOSPC errors from
+ * occurring.
+ */
+
+
+/* Initializes a xfs_parent_name_rec to be stored as an attribute name */
+void
+xfs_init_parent_name_rec(
+ struct xfs_parent_name_rec *rec,
+ struct xfs_inode *ip,
+ uint32_t p_diroffset)
+{
+ xfs_ino_t p_ino = ip->i_ino;
+ uint32_t p_gen = VFS_I(ip)->i_generation;
+
+ rec->p_ino = cpu_to_be64(p_ino);
+ rec->p_gen = cpu_to_be32(p_gen);
+ rec->p_diroffset = cpu_to_be32(p_diroffset);
+}
+
+/* Initializes a xfs_parent_name_irec from an xfs_parent_name_rec */
+void
+xfs_init_parent_name_irec(
+ struct xfs_parent_name_irec *irec,
+ struct xfs_parent_name_rec *rec)
+{
+ irec->p_ino = be64_to_cpu(rec->p_ino);
+ irec->p_gen = be32_to_cpu(rec->p_gen);
+ irec->p_diroffset = be32_to_cpu(rec->p_diroffset);
+}
+
+/*
+ * Directly add a parent pointer instead of as a deferred operation
+ * Currently only used during protofile creation
+ */
+int
+xfs_parent_add(
+ struct xfs_inode *parent,
+ struct xfs_inode *child,
+ struct xfs_name *child_name,
+ uint32_t diroffset,
+ xfs_fsblock_t *firstblock,
+ struct xfs_defer_ops *dfops)
+{
+ struct xfs_parent_name_rec rec;
+ int error;
+ struct xfs_da_args args;
+ int flags = ATTR_PARENT;
+ int local = 0;
+ int rsvd = 0;
+ struct xfs_buf *leaf_bp = NULL;
+ struct xfs_trans_res tres;
+ struct xfs_mount *mp = child->i_mount;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ error = xfs_attr_args_init(&args, child, (const unsigned char *)&rec,
+ sizeof(rec), flags);
+ if (error)
+ return error;
+
+ args.hashval = xfs_da_hashname(args.name, args.namelen);
+ args.value = (char *)child_name->name;
+ args.valuelen = child_name->len;
+ args.dfops = dfops;
+ args.op_flags = XFS_DA_OP_OKNOENT | XFS_DA_OP_ADDNAME;
+ args.firstblock = firstblock;
+ args.total = xfs_attr_calc_size(&args, &local);
+ ASSERT(local);
+
+ tres.tr_logres = M_RES(mp)->tr_attrsetm.tr_logres +
+ M_RES(mp)->tr_attrsetrt.tr_logres * args.total;
+ tres.tr_logcount = XFS_ATTRSET_LOG_COUNT;
+ tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
+
+ /*
+ * Root fork attributes can use reserved data blocks for this
+ * operation if necessary
+ */
+ error = xfs_trans_alloc(mp, &tres, args.total, 0,
+ rsvd ? XFS_TRANS_RESERVE : 0, &args.trans);
+ if (error)
+ goto out;
+
+ /*
+ * If the inode doesn't have an attribute fork, add one.
+ * (inode must not be locked when we call this routine)
+ */
+ if (XFS_IFORK_Q(child) == 0) {
+ int sf_size = sizeof(xfs_attr_sf_hdr_t) +
+ XFS_ATTR_SF_ENTSIZE_BYNAME(args.namelen, args.valuelen);
+
+ error = xfs_bmap_add_attrfork(child, sf_size, rsvd);
+ if (error)
+ return error;
+ }
+
+ xfs_trans_ijoin(args.trans, child, 0);
+
+ error = xfs_attr_set_args(&args, flags, leaf_bp, false);
+
+ if (error)
+ goto out;
+
+ xfs_trans_log_inode(args.trans, child, XFS_ILOG_CORE);
+
+ return error;
+
+out:
+ if (args.trans)
+ xfs_trans_cancel(args.trans);
+
+ return error;
+}
+
diff --git a/fs/xfs/libxfs/xfs_parent.h b/fs/xfs/libxfs/xfs_parent.h
new file mode 100644
index 0000000..6197817
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_parent.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018 Oracle, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation Inc.
+ */
+#ifndef __XFS_PARENT_H__
+#define __XFS_PARENT_H__
+
+#include "xfs_da_format.h"
+#include "xfs_format.h"
+
+/*
+ * Parent pointer attribute prototypes
+ */
+void xfs_init_parent_name_rec(struct xfs_parent_name_rec *rec,
+ struct xfs_inode *ip,
+ uint32_t p_diroffset);
+void xfs_init_parent_name_irec(struct xfs_parent_name_irec *irec,
+ struct xfs_parent_name_rec *rec);
+
+int xfs_parent_add(struct xfs_inode *parent,
+ struct xfs_inode *child, struct xfs_name *child_name,
+ uint32_t diroffset, xfs_fsblock_t *firstblock,
+ struct xfs_defer_ops *dfops);
+#endif /* __XFS_PARENT_H__ */
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 946d2c0..c87bc15 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -53,6 +53,7 @@
#include "xfs_bmap_btree.h"
#include "xfs_reflink.h"
#include "xfs_dir2_priv.h"
+#include "xfs_parent_utils.h"
kmem_zone_t *xfs_inode_zone;
@@ -1153,6 +1154,7 @@ xfs_create(
struct xfs_dquot *pdqp = NULL;
struct xfs_trans_res *tres;
uint resblks;
+ xfs_dir2_dataptr_t diroffset;
trace_xfs_create(dp, name);
@@ -1223,13 +1225,13 @@ xfs_create(
* the transaction cancel unlocking dp so don't do it explicitly in the
* error path.
*/
- xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, dp, 0);
unlock_dp_on_error = false;
error = xfs_dir_createname(tp, dp, name, ip->i_ino,
&first_block, &dfops, resblks ?
resblks - XFS_IALLOC_SPACE_RES(mp) : 0,
- NULL);
+ &diroffset);
if (error) {
ASSERT(error != -ENOSPC);
goto out_trans_cancel;
@@ -1248,6 +1250,17 @@ xfs_create(
}
/*
+ * If we have parent pointers, we need to add the attribute containing
+ * the parent information now.
+ */
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_add_deferred(dp, ip, name, diroffset,
+ &dfops);
+ if (error)
+ goto out_bmap_cancel;
+ }
+
+ /*
* If this is a synchronous mount, make sure that the
* create transaction goes to disk before returning to
* the user.
@@ -1276,6 +1289,7 @@ xfs_create(
*ipp = ip;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
return 0;
out_bmap_cancel:
diff --git a/fs/xfs/xfs_parent_utils.c b/fs/xfs/xfs_parent_utils.c
new file mode 100644
index 0000000..31ff5fe
--- /dev/null
+++ b/fs/xfs/xfs_parent_utils.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2015 Red Hat, Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation
+ */
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
+#include "xfs_mount.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_inode.h"
+#include "xfs_error.h"
+#include "xfs_trace.h"
+#include "xfs_trans.h"
+#include "xfs_attr.h"
+#include "xfs_parent.h"
+
+/*
+ * Add a parent record to an inode with existing parent records.
+ */
+int
+xfs_parent_add_deferred(
+ struct xfs_inode *parent,
+ struct xfs_inode *child,
+ struct xfs_name *child_name,
+ uint32_t diroffset,
+ struct xfs_defer_ops *dfops)
+{
+ struct xfs_parent_name_rec rec;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ return xfs_attr_set_deferred(child, dfops, &rec, sizeof(rec),
+ (void *)child_name->name, child_name->len, ATTR_PARENT);
+}
+
diff --git a/fs/xfs/xfs_parent_utils.h b/fs/xfs/xfs_parent_utils.h
new file mode 100644
index 0000000..a667d1d
--- /dev/null
+++ b/fs/xfs/xfs_parent_utils.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2017 Oracle, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation Inc.
+ */
+#ifndef __XFS_PARENT_UTILS_H__
+#define __XFS_PARENT_UTILS_H__
+
+/*
+ * Parent pointer attribute prototypes
+ */
+int xfs_parent_add_deferred(struct xfs_inode *parent, struct xfs_inode *child,
+ struct xfs_name *child_name, uint32_t diroffset,
+ struct xfs_defer_ops *dfops);
+#endif /* __XFS_PARENT_UTILS_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 17/23] xfs: add parent attributes to link
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (15 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 16/23] xfs: parent pointer attribute creation Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 18/23] xfs: remove parent pointers in unlink Allison Henderson
` (5 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
This patch modifies xfs_link to add a parent pointer to the inode.
xfs_link will also need to create an attribute fork if the inode does
not already have one.
[bfoster: rebase, use VFS inode fields, fix xfs_bmap_finish() usage]
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t,
fixed null pointer bugs]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/xfs_inode.c | 46 ++++++++++++++++++++++++++++++++--------------
1 file changed, 32 insertions(+), 14 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index c87bc15..10f885b 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1422,6 +1422,7 @@ xfs_link(
struct xfs_defer_ops dfops;
xfs_fsblock_t first_block;
int resblks;
+ xfs_dir2_dataptr_t diroffset;
trace_xfs_link(tdp, target_name);
@@ -1449,8 +1450,8 @@ xfs_link(
xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);
- xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
- xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, sip, 0);
+ xfs_trans_ijoin(tp, tdp, 0);
/*
* If we are using project inheritance, we only allow hard link
@@ -1469,8 +1470,6 @@ xfs_link(
goto error_return;
}
- xfs_defer_init(&dfops, &first_block);
-
/*
* Handle initial link state of O_TMPFILE inode
*/
@@ -1480,16 +1479,30 @@ xfs_link(
goto error_return;
}
+ xfs_defer_init(&dfops, &first_block);
error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
- &first_block, &dfops, resblks, NULL);
+ &first_block, &dfops, resblks, &diroffset);
if (error)
- goto error_return;
+ goto out_defer_cancel;
xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
error = xfs_bumplink(tp, sip);
if (error)
- goto error_return;
+ goto out_defer_cancel;
+
+ /*
+ * If we have parent pointers, we now need to add the parent record to
+ * the attribute fork of the inode. If this is the initial parent
+ * attribute, we need to create it correctly, otherwise we can just add
+ * the parent to the inode.
+ */
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_add_deferred(tdp, sip, target_name,
+ diroffset, &dfops);
+ if (error)
+ goto out_defer_cancel;
+ }
/*
* If this is a synchronous mount, make sure that the
@@ -1500,16 +1513,21 @@ xfs_link(
xfs_trans_set_sync(tp);
error = xfs_defer_finish(&tp, &dfops);
- if (error) {
- xfs_defer_cancel(&dfops);
- goto error_return;
- }
+ if (error)
+ goto out_defer_cancel;
- return xfs_trans_commit(tp);
+ error = xfs_trans_commit(tp);
+ xfs_iunlock(tdp, XFS_ILOCK_EXCL);
+ xfs_iunlock(sip, XFS_ILOCK_EXCL);
+ return error;
- error_return:
+out_defer_cancel:
+ xfs_defer_cancel(&dfops);
+error_return:
xfs_trans_cancel(tp);
- std_return:
+ xfs_iunlock(tdp, XFS_ILOCK_EXCL);
+ xfs_iunlock(sip, XFS_ILOCK_EXCL);
+std_return:
return error;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 18/23] xfs: remove parent pointers in unlink
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (16 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 17/23] xfs: add parent attributes to link Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 19/23] xfs: Add parent pointers to rename Allison Henderson
` (4 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
This patch removes the parent pointer attribute during unlink
[bfoster: rebase, use VFS inode generation]
[achender: rebased, changed __unint32_t to xfs_dir2_dataptr_t
implemented xfs_attr_remove_parent]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/xfs_inode.c | 23 ++++++++++++++++++-----
fs/xfs/xfs_parent_utils.c | 18 ++++++++++++++++++
fs/xfs/xfs_parent_utils.h | 4 ++++
3 files changed, 40 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 10f885b..aee05e5 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2605,6 +2605,7 @@ xfs_remove(
struct xfs_defer_ops dfops;
xfs_fsblock_t first_block;
uint resblks;
+ xfs_dir2_dataptr_t dir_offset;
trace_xfs_remove(dp, name);
@@ -2642,8 +2643,8 @@ xfs_remove(
xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
- xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
- xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, dp, 0);
+ xfs_trans_ijoin(tp, ip, 0);
/*
* If we're removing a directory perform some additional validation.
@@ -2685,12 +2686,18 @@ xfs_remove(
xfs_defer_init(&dfops, &first_block);
error = xfs_dir_removename(tp, dp, name, ip->i_ino, &first_block,
- &dfops, resblks, NULL);
+ &dfops, resblks, &dir_offset);
if (error) {
ASSERT(error != -ENOENT);
goto out_bmap_cancel;
}
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_remove_deferred(dp, ip, dir_offset, &dfops);
+ if (error)
+ goto out_bmap_cancel;
+ }
+
/*
* If this is a synchronous mount, make sure that the
* remove transaction goes to disk before returning to
@@ -2705,17 +2712,23 @@ xfs_remove(
error = xfs_trans_commit(tp);
if (error)
- goto std_return;
+ goto out_unlock;
if (is_dir && xfs_inode_is_filestream(ip))
xfs_filestream_deassociate(ip);
- return 0;
+ error = 0;
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(dp, XFS_ILOCK_EXCL);
+ return error;
out_bmap_cancel:
xfs_defer_cancel(&dfops);
out_trans_cancel:
xfs_trans_cancel(tp);
+out_unlock:
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(dp, XFS_ILOCK_EXCL);
std_return:
return error;
}
diff --git a/fs/xfs/xfs_parent_utils.c b/fs/xfs/xfs_parent_utils.c
index 31ff5fe..b89d4eb 100644
--- a/fs/xfs/xfs_parent_utils.c
+++ b/fs/xfs/xfs_parent_utils.c
@@ -48,3 +48,21 @@ xfs_parent_add_deferred(
(void *)child_name->name, child_name->len, ATTR_PARENT);
}
+/*
+ * Remove a parent record from a child inode.
+ */
+int
+xfs_parent_remove_deferred(
+ struct xfs_inode *parent,
+ struct xfs_inode *child,
+ xfs_dir2_dataptr_t diroffset,
+ struct xfs_defer_ops *dfops)
+{
+ struct xfs_parent_name_rec rec;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ return xfs_attr_remove_deferred(child, dfops, &rec, sizeof(rec),
+ ATTR_PARENT);
+}
+
diff --git a/fs/xfs/xfs_parent_utils.h b/fs/xfs/xfs_parent_utils.h
index a667d1d..9e0ac13 100644
--- a/fs/xfs/xfs_parent_utils.h
+++ b/fs/xfs/xfs_parent_utils.h
@@ -23,4 +23,8 @@
int xfs_parent_add_deferred(struct xfs_inode *parent, struct xfs_inode *child,
struct xfs_name *child_name, uint32_t diroffset,
struct xfs_defer_ops *dfops);
+int xfs_parent_remove_deferred(struct xfs_inode *parent,
+ struct xfs_inode *child,
+ xfs_dir2_dataptr_t diroffset,
+ struct xfs_defer_ops *dfops);
#endif /* __XFS_PARENT_UTILS_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 19/23] xfs: Add parent pointers to rename
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (17 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 18/23] xfs: remove parent pointers in unlink Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 13:39 ` Amir Goldstein
2018-06-10 5:05 ` [PATCH v7 20/23] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
` (3 subsequent siblings)
22 siblings, 1 reply; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
This patch removes the old parent pointer attribute during the
rename operation, and re-adds the updated parent pointer
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/xfs_inode.c | 68 +++++++++++++++++++++++++++++++++++++++++-------------
1 file changed, 52 insertions(+), 16 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index aee05e5..d93e387 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2987,6 +2987,8 @@ xfs_rename(
bool src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
int spaceres;
int error;
+ xfs_dir2_dataptr_t new_diroffset;
+ xfs_dir2_dataptr_t old_diroffset;
trace_xfs_rename(src_dp, target_dp, src_name, target_name);
@@ -3041,14 +3043,14 @@ xfs_rename(
* we can rely on either trans_commit or trans_cancel to unlock
* them.
*/
- xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, src_dp, 0);
if (new_parent)
- xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
- xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, target_dp, 0);
+ xfs_trans_ijoin(tp, src_ip, 0);
if (target_ip)
- xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, target_ip, 0);
if (wip)
- xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
+ xfs_trans_ijoin(tp, wip, 0);
/*
* If we are using project inheritance, we only allow renames
@@ -3058,17 +3060,18 @@ xfs_rename(
if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
(xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
error = -EXDEV;
- goto out_trans_cancel;
+ goto out_unlock;
}
xfs_defer_init(&dfops, &first_block);
/* RENAME_EXCHANGE is unique from here on. */
- if (flags & RENAME_EXCHANGE)
- return xfs_cross_rename(tp, src_dp, src_name, src_ip,
+ if (flags & RENAME_EXCHANGE) {
+ error = xfs_cross_rename(tp, src_dp, src_name, src_ip,
target_dp, target_name, target_ip,
&dfops, &first_block, spaceres);
-
+ goto out;
+ }
/*
* Set up the target.
*/
@@ -3080,7 +3083,7 @@ xfs_rename(
if (!spaceres) {
error = xfs_dir_canenter(tp, target_dp, target_name);
if (error)
- goto out_trans_cancel;
+ goto out_unlock;
}
/*
* If target does not exist and the rename crosses
@@ -3089,7 +3092,7 @@ xfs_rename(
*/
error = xfs_dir_createname(tp, target_dp, target_name,
src_ip->i_ino, &first_block, &dfops,
- spaceres, NULL);
+ spaceres, &new_diroffset);
if (error)
goto out_bmap_cancel;
@@ -3114,7 +3117,7 @@ xfs_rename(
if (!(xfs_dir_isempty(target_ip)) ||
(VFS_I(target_ip)->i_nlink > 2)) {
error = -EEXIST;
- goto out_trans_cancel;
+ goto out_unlock;
}
}
@@ -3129,7 +3132,7 @@ xfs_rename(
*/
error = xfs_dir_replace(tp, target_dp, target_name,
src_ip->i_ino, &first_block, &dfops,
- spaceres, NULL);
+ spaceres, &new_diroffset);
if (error)
goto out_bmap_cancel;
@@ -3164,7 +3167,7 @@ xfs_rename(
*/
error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
target_dp->i_ino, &first_block, &dfops,
- spaceres, NULL);
+ spaceres, &new_diroffset);
ASSERT(error != -EEXIST);
if (error)
goto out_bmap_cancel;
@@ -3203,10 +3206,11 @@ xfs_rename(
*/
if (wip) {
error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
- &first_block, &dfops, spaceres, NULL);
+ &first_block, &dfops, spaceres,
+ &old_diroffset);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
- &first_block, &dfops, spaceres, NULL);
+ &first_block, &dfops, spaceres, &old_diroffset);
if (error)
goto out_bmap_cancel;
@@ -3236,18 +3240,50 @@ xfs_rename(
VFS_I(wip)->i_state &= ~I_LINKABLE;
}
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_add_deferred(target_dp, src_ip, target_name,
+ new_diroffset, &dfops);
+ if (error)
+ goto out_bmap_cancel;
+
+ error = xfs_parent_remove_deferred(src_dp, src_ip,
+ old_diroffset, &dfops);
+ if (error)
+ goto out_bmap_cancel;
+ }
+
xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
if (new_parent)
xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
error = xfs_finish_rename(tp, &dfops);
+out:
if (wip)
IRELE(wip);
+ if (wip)
+ xfs_iunlock(wip, XFS_ILOCK_EXCL);
+ if (target_ip)
+ xfs_iunlock(target_ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(src_ip, XFS_ILOCK_EXCL);
+ if (new_parent)
+ xfs_iunlock(target_dp, XFS_ILOCK_EXCL);
+ xfs_iunlock(src_dp, XFS_ILOCK_EXCL);
+
return error;
out_bmap_cancel:
xfs_defer_cancel(&dfops);
+out_unlock:
+ if (wip)
+ xfs_iunlock(wip, XFS_ILOCK_EXCL);
+ if (target_ip)
+ xfs_iunlock(target_ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(src_ip, XFS_ILOCK_EXCL);
+ if (new_parent)
+ xfs_iunlock(target_dp, XFS_ILOCK_EXCL);
+ xfs_iunlock(src_dp, XFS_ILOCK_EXCL);
+
out_trans_cancel:
xfs_trans_cancel(tp);
out_release_wip:
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 20/23] xfs: Add the parent pointer support to the superblock version 5.
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (18 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 19/23] xfs: Add parent pointers to rename Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 21/23] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
` (2 subsequent siblings)
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
[dchinner: forward ported and cleaned up]
[achender: rebased and added parent pointer attribute to
compatible attributes mask]
Signed-off-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_format.h | 7 +++++--
fs/xfs/libxfs/xfs_fs.h | 1 +
fs/xfs/libxfs/xfs_sb.c | 2 ++
fs/xfs/xfs_super.c | 4 ++++
4 files changed, 12 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 5e946c8..d05ffc5 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -462,10 +462,12 @@ xfs_sb_has_compat_feature(
#define XFS_SB_FEAT_RO_COMPAT_FINOBT (1 << 0) /* free inode btree */
#define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1) /* reverse map btree */
#define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2) /* reflinked files */
+#define XFS_SB_FEAT_RO_COMPAT_PARENT (1 << 3) /* parent inode ptr */
#define XFS_SB_FEAT_RO_COMPAT_ALL \
(XFS_SB_FEAT_RO_COMPAT_FINOBT | \
XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
- XFS_SB_FEAT_RO_COMPAT_REFLINK)
+ XFS_SB_FEAT_RO_COMPAT_REFLINK| \
+ XFS_SB_FEAT_RO_COMPAT_PARENT)
#define XFS_SB_FEAT_RO_COMPAT_UNKNOWN ~XFS_SB_FEAT_RO_COMPAT_ALL
static inline bool
xfs_sb_has_ro_compat_feature(
@@ -561,7 +563,8 @@ static inline bool xfs_sb_version_hasreflink(struct xfs_sb *sbp)
static inline bool xfs_sb_version_hasparent(struct xfs_sb *sbp)
{
- return false; /* We'll enable this at the end of the set */
+ return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
+ (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_PARENT));
}
/*
diff --git a/fs/xfs/libxfs/xfs_fs.h b/fs/xfs/libxfs/xfs_fs.h
index faf1a4e..641e0af 100644
--- a/fs/xfs/libxfs/xfs_fs.h
+++ b/fs/xfs/libxfs/xfs_fs.h
@@ -222,6 +222,7 @@ typedef struct xfs_fsop_resblks {
#define XFS_FSOP_GEOM_FLAGS_SPINODES 0x40000 /* sparse inode chunks */
#define XFS_FSOP_GEOM_FLAGS_RMAPBT 0x80000 /* reverse mapping btree */
#define XFS_FSOP_GEOM_FLAGS_REFLINK 0x100000 /* files can share blocks */
+#define XFS_FSOP_GEOM_FLAGS_PARENT 0x200000 /* parent pointers */
/*
* Minimum and maximum sizes need for growth checks.
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index d9b94bd..e1f0ac1 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -955,6 +955,8 @@ xfs_fs_geometry(
geo->flags |= XFS_FSOP_GEOM_FLAGS_RMAPBT;
if (xfs_sb_version_hasreflink(sbp))
geo->flags |= XFS_FSOP_GEOM_FLAGS_REFLINK;
+ if(xfs_sb_version_hasparent(sbp))
+ geo->flags |= XFS_FSOP_GEOM_FLAGS_PARENT;
if (xfs_sb_version_hassector(sbp))
geo->logsectsize = sbp->sb_logsectsize;
else
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index dce3baf..366deee 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1731,6 +1731,10 @@ xfs_fs_fill_super(
goto out_filestream_unmount;
}
+ if (xfs_sb_version_hasparent(&mp->m_sb))
+ xfs_alert(mp,
+ "EXPERIMENTAL parent pointer feature enabled. Use at your own risk!");
+
error = xfs_mountfs(mp);
if (error)
goto out_filestream_unmount;
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 21/23] xfs: Add helper function xfs_attr_list_context_init
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (19 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 20/23] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 22/23] xfs: Add parent pointer ioctl Allison Henderson
2018-06-10 5:05 ` [PATCH v7 23/23] xfs: Add delayed attributes error tag Allison Henderson
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
This patch adds a helper function xfs_attr_list_context_init
used by xfs_attr_list. This function initializes the
xfs_attr_list_context structure passed to xfs_attr_list_int.
We will need this later to call xfs_attr_list_int_ilocked when
the node is already locked.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.h | 3 ++
fs/xfs/xfs_attr_list.c | 72 +++++++++++++++++++++++++++++++-----------------
2 files changed, 50 insertions(+), 25 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index d041734..79c516b 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -184,6 +184,9 @@ int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name,
int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
int flags, struct attrlist_cursor_kern *cursor);
+int xfs_attr_list_context_init(struct xfs_inode *dp, char *buffer, int bufsize,
+ int flags, struct attrlist_cursor_kern *cursor,
+ struct xfs_attr_list_context *context);
int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
const unsigned char *name, size_t namelen, int flags);
int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index 3e59a34..df8faf5 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -603,23 +603,19 @@ xfs_attr_put_listent(
}
/*
- * Generate a list of extended attribute names and optionally
- * also value lengths. Positive return value follows the XFS
- * convention of being an error, zero or negative return code
- * is the length of the buffer returned (negated), indicating
- * success.
+ * Initializes an xfs_attr_list_context suitable for
+ * use by xfs_attr_list
*/
int
-xfs_attr_list(
- xfs_inode_t *dp,
- char *buffer,
- int bufsize,
- int flags,
- attrlist_cursor_kern_t *cursor)
+xfs_attr_list_context_init(
+ xfs_inode_t *dp,
+ char *buffer,
+ int bufsize,
+ int flags,
+ struct attrlist_cursor_kern *cursor,
+ struct xfs_attr_list_context *context)
{
- xfs_attr_list_context_t context;
struct attrlist *alist;
- int error;
/*
* Validate the cursor.
@@ -645,20 +641,46 @@ xfs_attr_list(
/*
* Initialize the output buffer.
*/
- memset(&context, 0, sizeof(context));
- context.dp = dp;
- context.cursor = cursor;
- context.resynch = 1;
- context.flags = flags;
- context.alist = buffer;
- context.bufsize = (bufsize & ~(sizeof(int)-1)); /* align */
- context.firstu = context.bufsize;
- context.put_listent = xfs_attr_put_listent;
-
- alist = (struct attrlist *)context.alist;
+ memset(context, 0, sizeof(xfs_attr_list_context_t));
+ context->dp = dp;
+ context->cursor = cursor;
+ context->resynch = 1;
+ context->flags = flags;
+ context->alist = buffer;
+ context->bufsize = (bufsize & ~(sizeof(int)-1)); /* align */
+ context->firstu = context->bufsize;
+ context->put_listent = xfs_attr_put_listent;
+
+ alist = (struct attrlist *)context->alist;
alist->al_count = 0;
alist->al_more = 0;
- alist->al_offset[0] = context.bufsize;
+ alist->al_offset[0] = context->bufsize;
+
+ return 0;
+}
+
+/*
+ * Generate a list of extended attribute names and optionally
+ * also value lengths. Positive return value follows the XFS
+ * convention of being an error, zero or negative return code
+ * is the length of the buffer returned (negated), indicating
+ * success.
+ */
+int
+xfs_attr_list(
+ xfs_inode_t *dp,
+ char *buffer,
+ int bufsize,
+ int flags,
+ attrlist_cursor_kern_t *cursor)
+{
+ xfs_attr_list_context_t context;
+ int error;
+
+ error = xfs_attr_list_context_init(dp, buffer, bufsize, flags,
+ cursor, &context);
+ if (error)
+ return error;
error = xfs_attr_list_int(&context);
ASSERT(error <= 0);
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 22/23] xfs: Add parent pointer ioctl
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (20 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 21/23] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 23/23] xfs: Add delayed attributes error tag Allison Henderson
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
This patch adds a new file ioctl to retrieve the parent
pointer of a given inode
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_fs.h | 42 ++++++++++++++++++++++
fs/xfs/libxfs/xfs_parent.c | 10 ++++++
fs/xfs/libxfs/xfs_parent.h | 2 ++
fs/xfs/xfs_attr_list.c | 3 ++
fs/xfs/xfs_ioctl.c | 86 +++++++++++++++++++++++++++++++++++++++++++++-
fs/xfs/xfs_ondisk.h | 4 +++
fs/xfs/xfs_parent_utils.c | 82 +++++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_parent_utils.h | 2 ++
8 files changed, 230 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/libxfs/xfs_fs.h b/fs/xfs/libxfs/xfs_fs.h
index 641e0af..3fd036b 100644
--- a/fs/xfs/libxfs/xfs_fs.h
+++ b/fs/xfs/libxfs/xfs_fs.h
@@ -552,6 +552,47 @@ struct xfs_scrub_metadata {
XFS_SCRUB_OFLAG_WARNING)
#define XFS_SCRUB_FLAGS_ALL (XFS_SCRUB_FLAGS_IN | XFS_SCRUB_FLAGS_OUT)
+#define XFS_PPTR_MAXNAMELEN 256
+
+/* return parents of the handle, not the open fd */
+#define XFS_PPTR_IFLAG_HANDLE (1U << 0)
+
+/* target was the root directory */
+#define XFS_PPTR_OFLAG_ROOT (1U << 1)
+
+/* Get an inode parent pointer through ioctl */
+struct xfs_parent_ptr {
+ __u64 xpp_ino; /* Inode */
+ __u32 xpp_gen; /* Inode generation */
+ __u32 xpp_diroffset; /* Directory offset */
+ __u32 xpp_namelen; /* File name length */
+ __u32 xpp_pad;
+ __u8 xpp_name[XFS_PPTR_MAXNAMELEN]; /* File name */
+};
+
+/* Iterate through an inodes parent pointers */
+struct xfs_pptr_info {
+ struct xfs_handle pi_handle;
+ struct xfs_attrlist_cursor pi_cursor;
+ __u32 pi_flags;
+ __u32 pi_reserved;
+ __u32 pi_ptrs_size;
+ __u32 pi_ptrs_used;
+ __u64 pi_reserved2[6];
+
+ /*
+ * An array of struct xfs_parent_ptr follows the header
+ * information. Use XFS_PPINFO_TO_PP() to access the
+ * parent pointer array entries.
+ */
+};
+
+#define XFS_PPTR_INFO_SIZEOF(nr_ptrs) sizeof (struct xfs_pptr_info) + \
+ nr_ptrs * sizeof(struct xfs_parent_ptr)
+
+#define XFS_PPINFO_TO_PP(info, idx) \
+ (&(((struct xfs_parent_ptr *)((char *)(info) + sizeof(*(info))))[(idx)]))
+
/*
* ioctl limits
*/
@@ -596,6 +637,7 @@ struct xfs_scrub_metadata {
#define XFS_IOC_FREE_EOFBLOCKS _IOR ('X', 58, struct xfs_fs_eofblocks)
/* XFS_IOC_GETFSMAP ------ hoisted 59 */
#define XFS_IOC_SCRUB_METADATA _IOWR('X', 60, struct xfs_scrub_metadata)
+#define XFS_IOC_GETPPOINTER _IOR ('X', 61, struct xfs_parent_ptr)
/*
* ioctl commands that replace IRIX syssgi()'s
diff --git a/fs/xfs/libxfs/xfs_parent.c b/fs/xfs/libxfs/xfs_parent.c
index 9f0964a..9cb76b4 100644
--- a/fs/xfs/libxfs/xfs_parent.c
+++ b/fs/xfs/libxfs/xfs_parent.c
@@ -32,6 +32,16 @@
#include "xfs_attr_sf.h"
#include "xfs_bmap.h"
+/* Initializes a xfs_parent_ptr from an xfs_parent_name_rec */
+void
+xfs_init_parent_ptr(struct xfs_parent_ptr *xpp,
+ struct xfs_parent_name_rec *rec)
+{
+ xpp->xpp_ino = be64_to_cpu(rec->p_ino);
+ xpp->xpp_gen = be32_to_cpu(rec->p_gen);
+ xpp->xpp_diroffset = be32_to_cpu(rec->p_diroffset);
+}
+
/*
* Parent pointer attribute handling.
*
diff --git a/fs/xfs/libxfs/xfs_parent.h b/fs/xfs/libxfs/xfs_parent.h
index 6197817..7771719 100644
--- a/fs/xfs/libxfs/xfs_parent.h
+++ b/fs/xfs/libxfs/xfs_parent.h
@@ -33,4 +33,6 @@ int xfs_parent_add(struct xfs_inode *parent,
struct xfs_inode *child, struct xfs_name *child_name,
uint32_t diroffset, xfs_fsblock_t *firstblock,
struct xfs_defer_ops *dfops);
+void xfs_init_parent_ptr(struct xfs_parent_ptr *xpp,
+ struct xfs_parent_name_rec *rec);
#endif /* __XFS_PARENT_H__ */
diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index df8faf5..f02b12c 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -581,6 +581,9 @@ xfs_attr_put_listent(
if (((context->flags & ATTR_ROOT) == 0) !=
((flags & XFS_ATTR_ROOT) == 0))
return;
+ if (((context->flags & ATTR_PARENT) == 0) !=
+ ((flags & XFS_ATTR_PARENT) == 0))
+ return;
arraytop = sizeof(*alist) +
context->count * sizeof(alist->al_offset[0]);
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 844480a..b3071c0 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -46,6 +46,8 @@
#include "xfs_fsmap.h"
#include "scrub/xfs_scrub.h"
#include "xfs_sb.h"
+#include "xfs_da_format.h"
+#include "xfs_parent_utils.h"
#include <linux/capability.h>
#include <linux/cred.h>
@@ -1738,6 +1740,87 @@ xfs_ioc_scrub_metadata(
return 0;
}
+/*
+ * IOCTL routine to get the parent pointers of an inode and return it to user
+ * space. Caller must pass a buffer space containing a struct xfs_pptr_info,
+ * followed by a region large enough to contain an array of struct
+ * xfs_parent_ptr of a size specified in pi_ptrs_size. If the inode contains
+ * more parent pointers than can fit in the buffer space, caller may re-call
+ * the function using the returned pi_cursor to resume iteration. The
+ * number of xfs_parent_ptr returned will be stored in pi_ptrs_used.
+ *
+ * Returns 0 on success or non-zero on failure
+ */
+STATIC int
+xfs_ioc_get_parent_pointer(
+ struct file *filp,
+ void __user *arg)
+{
+ struct xfs_pptr_info *ppi = NULL;
+ int error = 0;
+ struct xfs_inode *ip = XFS_I(file_inode(filp));
+ struct xfs_mount *mp = ip->i_mount;
+
+ if (!capable(CAP_SYS_ADMIN))
+ return -EPERM;
+
+ /* Allocate an xfs_pptr_info to put the user data */
+ ppi = kmem_alloc(sizeof(struct xfs_pptr_info), KM_SLEEP);
+ if (!ppi)
+ return -ENOMEM;
+
+ /* Copy the data from the user */
+ error = copy_from_user(ppi, arg, sizeof(struct xfs_pptr_info));
+ if (error)
+ goto out;
+
+ /* Check size of buffer requested by user */
+ if (XFS_PPTR_INFO_SIZEOF(ppi->pi_ptrs_size) > XFS_XATTR_LIST_MAX) {
+ error = -ENOMEM;
+ goto out;
+ }
+
+ /*
+ * Now that we know how big the trailing buffer is, expand
+ * our kernel xfs_pptr_info to be the same size
+ */
+ ppi = kmem_realloc(ppi, XFS_PPTR_INFO_SIZEOF(ppi->pi_ptrs_size),
+ KM_SLEEP);
+ if (!ppi)
+ return -ENOMEM;
+
+ if (ppi->pi_flags != 0 && ppi->pi_flags != XFS_PPTR_IFLAG_HANDLE) {
+ error = -EINVAL;
+ goto out;
+ }
+
+ if (ppi->pi_flags == XFS_PPTR_IFLAG_HANDLE) {
+ error = xfs_iget(mp, NULL, ppi->pi_handle.ha_fid.fid_ino,
+ 0, 0, &ip);
+ if (error)
+ goto out;
+ }
+
+ if (ip->i_ino == mp->m_sb.sb_rootino)
+ ppi->pi_flags |= XFS_PPTR_OFLAG_ROOT;
+
+ /* Get the parent pointers */
+ error = xfs_attr_get_parent_pointer(ip, ppi);
+
+ if (error)
+ goto out;
+
+ /* Copy the parent pointers back to the user */
+ error = copy_to_user(arg, ppi,
+ XFS_PPTR_INFO_SIZEOF(ppi->pi_ptrs_size));
+ if (error)
+ goto out;
+
+out:
+ kmem_free(ppi);
+ return error;
+}
+
int
xfs_ioc_swapext(
xfs_swapext_t *sxp)
@@ -1894,7 +1977,8 @@ xfs_file_ioctl(
return xfs_ioc_getxflags(ip, arg);
case XFS_IOC_SETXFLAGS:
return xfs_ioc_setxflags(ip, filp, arg);
-
+ case XFS_IOC_GETPPOINTER:
+ return xfs_ioc_get_parent_pointer(filp, arg);
case XFS_IOC_FSSETDM: {
struct fsdmidata dmi;
diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
index 3723d50..a524db4 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -139,6 +139,10 @@ xfs_check_ondisk_structs(void)
XFS_CHECK_STRUCT_SIZE(struct xfs_trans_header, 16);
XFS_CHECK_STRUCT_SIZE(struct xfs_attri_log_format, 40);
XFS_CHECK_STRUCT_SIZE(struct xfs_attrd_log_format, 16);
+
+ /* parent pointer ioctls */
+ XFS_CHECK_STRUCT_SIZE(struct xfs_parent_ptr, 280);
+ XFS_CHECK_STRUCT_SIZE(struct xfs_pptr_info, 104);
}
#endif /* __XFS_ONDISK_H */
diff --git a/fs/xfs/xfs_parent_utils.c b/fs/xfs/xfs_parent_utils.c
index b89d4eb..57255cd 100644
--- a/fs/xfs/xfs_parent_utils.c
+++ b/fs/xfs/xfs_parent_utils.c
@@ -28,6 +28,7 @@
#include "xfs_trans.h"
#include "xfs_attr.h"
#include "xfs_parent.h"
+#include "xfs_da_btree.h"
/*
* Add a parent record to an inode with existing parent records.
@@ -66,3 +67,84 @@ xfs_parent_remove_deferred(
ATTR_PARENT);
}
+/*
+ * Get the parent pointers for a given inode
+ *
+ * Returns 0 on success and non zero on error
+ */
+int
+xfs_attr_get_parent_pointer(struct xfs_inode *ip,
+ struct xfs_pptr_info *ppi)
+
+{
+
+ struct attrlist *alist;
+ struct attrlist_ent *aent;
+ struct xfs_parent_ptr *xpp;
+ struct xfs_parent_name_rec *xpnr;
+ char *namebuf;
+ unsigned int namebuf_size;
+ int name_len;
+ int error = 0;
+ unsigned int flags = ATTR_PARENT;
+ int i;
+ struct xfs_attr_list_context context;
+ struct xfs_da_args args;
+
+ /* Allocate a buffer to store the attribute names */
+ namebuf_size = sizeof(struct attrlist) +
+ (ppi->pi_ptrs_size) * sizeof(struct attrlist_ent);
+ namebuf = kmem_zalloc_large(namebuf_size, KM_SLEEP);
+ if (!namebuf)
+ return -ENOMEM;
+
+ error = xfs_attr_list_context_init(ip, namebuf, namebuf_size, flags,
+ (attrlist_cursor_kern_t *)&ppi->pi_cursor, &context);
+ if (error)
+ goto out_kfree;
+
+ xfs_ilock(ip, XFS_ILOCK_EXCL);
+
+ error = xfs_attr_list_int_ilocked(&context);
+ if (error)
+ goto out_kfree;
+
+ alist = (struct attrlist *)namebuf;
+ for (i = 0; i < alist->al_count; i++) {
+ xpp = XFS_PPINFO_TO_PP(ppi, i);
+ memset(xpp, 0, sizeof(struct xfs_parent_ptr));
+ aent = (struct attrlist_ent *) &namebuf[alist->al_offset[i]];
+ xpnr = (struct xfs_parent_name_rec *)(aent->a_name);
+
+ if (aent->a_valuelen > XFS_PPTR_MAXNAMELEN) {
+ error = -ERANGE;
+ goto out_kfree;
+ }
+ name_len = aent->a_valuelen;
+
+ error = xfs_attr_args_init(&args, ip, (char *)xpnr,
+ sizeof(struct xfs_parent_name_rec), flags);
+ if (error)
+ goto out_kfree;
+
+ args.value = (unsigned char *)(xpp->xpp_name);
+ args.valuelen = name_len;
+ args.op_flags = XFS_DA_OP_OKNOENT;
+
+ error = xfs_attr_get_ilocked(ip, &args);
+ error = (error == -EEXIST ? 0 : error);
+ if (error)
+ goto out_kfree;
+
+ xpp->xpp_namelen = name_len;
+ xfs_init_parent_ptr(xpp, xpnr);
+ }
+ ppi->pi_ptrs_used = alist->al_count;
+
+out_kfree:
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ kmem_free(namebuf);
+
+ return error;
+}
+
diff --git a/fs/xfs/xfs_parent_utils.h b/fs/xfs/xfs_parent_utils.h
index 9e0ac13..33e3b2c 100644
--- a/fs/xfs/xfs_parent_utils.h
+++ b/fs/xfs/xfs_parent_utils.h
@@ -27,4 +27,6 @@ int xfs_parent_remove_deferred(struct xfs_inode *parent,
struct xfs_inode *child,
xfs_dir2_dataptr_t diroffset,
struct xfs_defer_ops *dfops);
+int xfs_attr_get_parent_pointer(struct xfs_inode *ip,
+ struct xfs_pptr_info *ppi);
#endif /* __XFS_PARENT_UTILS_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* [PATCH v7 23/23] xfs: Add delayed attributes error tag
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
` (21 preceding siblings ...)
2018-06-10 5:05 ` [PATCH v7 22/23] xfs: Add parent pointer ioctl Allison Henderson
@ 2018-06-10 5:05 ` Allison Henderson
22 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 5:05 UTC (permalink / raw)
To: linux-xfs
This patch adds an error tag that we can use to test
delayed attribute recovery and replay
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_errortag.h | 4 +++-
fs/xfs/xfs_error.c | 3 +++
fs/xfs/xfs_trans_attr.c | 8 ++++++++
3 files changed, 14 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/libxfs/xfs_errortag.h b/fs/xfs/libxfs/xfs_errortag.h
index bc1789d..40aecb3 100644
--- a/fs/xfs/libxfs/xfs_errortag.h
+++ b/fs/xfs/libxfs/xfs_errortag.h
@@ -65,7 +65,8 @@
#define XFS_ERRTAG_LOG_BAD_CRC 29
#define XFS_ERRTAG_LOG_ITEM_PIN 30
#define XFS_ERRTAG_BUF_LRU_REF 31
-#define XFS_ERRTAG_MAX 32
+#define XFS_ERRTAG_DELAYED_ATTR 32
+#define XFS_ERRTAG_MAX 33
/*
* Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -102,5 +103,6 @@
#define XFS_RANDOM_LOG_BAD_CRC 1
#define XFS_RANDOM_LOG_ITEM_PIN 1
#define XFS_RANDOM_BUF_LRU_REF 2
+#define XFS_RANDOM_DELAYED_ATTR 1
#endif /* __XFS_ERRORTAG_H_ */
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index a63f508..0752f20 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -61,6 +61,7 @@ static unsigned int xfs_errortag_random_default[] = {
XFS_RANDOM_LOG_BAD_CRC,
XFS_RANDOM_LOG_ITEM_PIN,
XFS_RANDOM_BUF_LRU_REF,
+ XFS_RANDOM_DELAYED_ATTR,
};
struct xfs_errortag_attr {
@@ -167,6 +168,7 @@ XFS_ERRORTAG_ATTR_RW(drop_writes, XFS_ERRTAG_DROP_WRITES);
XFS_ERRORTAG_ATTR_RW(log_bad_crc, XFS_ERRTAG_LOG_BAD_CRC);
XFS_ERRORTAG_ATTR_RW(log_item_pin, XFS_ERRTAG_LOG_ITEM_PIN);
XFS_ERRORTAG_ATTR_RW(buf_lru_ref, XFS_ERRTAG_BUF_LRU_REF);
+XFS_ERRORTAG_ATTR_RW(delayed_attr, XFS_ERRTAG_DELAYED_ATTR);
static struct attribute *xfs_errortag_attrs[] = {
XFS_ERRORTAG_ATTR_LIST(noerror),
@@ -201,6 +203,7 @@ static struct attribute *xfs_errortag_attrs[] = {
XFS_ERRORTAG_ATTR_LIST(log_bad_crc),
XFS_ERRORTAG_ATTR_LIST(log_item_pin),
XFS_ERRORTAG_ATTR_LIST(buf_lru_ref),
+ XFS_ERRORTAG_ATTR_LIST(delayed_attr),
NULL,
};
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
index 848f086..06ed2576 100644
--- a/fs/xfs/xfs_trans_attr.c
+++ b/fs/xfs/xfs_trans_attr.c
@@ -35,6 +35,8 @@
#include "xfs_inode.h"
#include "xfs_icache.h"
#include "xfs_quota.h"
+#include "xfs_errortag.h"
+#include "xfs_error.h"
/*
* This routine is called to allocate an "extent free done"
@@ -105,6 +107,12 @@ xfs_trans_attr(
return error;
xfs_trans_ijoin(args.trans, ip, 0);
+
+ if (XFS_TEST_ERROR(false, ip->i_mount, XFS_ERRTAG_DELAYED_ATTR)) {
+ error = -EIO;
+ goto out;
+ }
+
switch (op_flags) {
case XFS_ATTR_OP_FLAGS_SET:
args.op_flags |= XFS_DA_OP_ADDNAME;
--
2.7.4
^ permalink raw reply related [flat|nested] 33+ messages in thread
* Re: [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname
2018-06-10 5:04 ` [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
@ 2018-06-10 6:58 ` Amir Goldstein
2018-06-10 15:30 ` Allison Henderson
0 siblings, 1 reply; 33+ messages in thread
From: Amir Goldstein @ 2018-06-10 6:58 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Sun, Jun 10, 2018 at 8:04 AM, Allison Henderson
<allison.henderson@oracle.com> wrote:
> This patch adds a subroutine xfs_attr_try_sf_addname
> used by xfs_attr_set. This subrotine will attempt to
> add the attribute name specified in args in shortform,
> as well and perform error handling previously done in
> xfs_attr_set.
>
> This patch helps to pre-simplify xfs_attr_set for reviewing
> purposes and reduce indentation. New function will be added
> in the next patch.
>
> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
> ---
> fs/xfs/libxfs/xfs_attr.c | 64 +++++++++++++++++++++++++++++++-----------------
> 1 file changed, 41 insertions(+), 23 deletions(-)
>
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index ce4a34a..1524197 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -203,6 +203,44 @@ xfs_attr_calc_size(
> return nblks;
> }
>
> +STATIC int
> +xfs_attr_try_sf_addname(
> + struct xfs_inode *dp,
> + struct xfs_da_args *args,
> + int flags)
> +{
> +
> + struct xfs_mount *mp = dp->i_mount;
> + int error;
> + int err2;
> +
> + error = xfs_attr_shortform_addname(args);
> + if (error != -ENOSPC) {
Not sure it made sense before, but in the context of this helper
nesting most of the code path for the likely case is weird.
Please return error if (error == -ENOSPC)
> + /*
> + * Commit the shortform mods, and we're done.
> + * NOTE: this is also the error path
> + * (EEXIST, etc).
> + */
> + ASSERT(args->trans != NULL);
> +
> + /*
> + * If this is a synchronous mount, make sure
> + * that the transaction goes to disk before
> + * returning to the user.
> + */
> + if (mp->m_flags & XFS_MOUNT_WSYNC)
> + xfs_trans_set_sync(args->trans);
> +
> + if (!error && (flags & ATTR_KERNOTIME) == 0) {
> + xfs_trans_ichgtime(args->trans, dp,
> + XFS_ICHGTIME_CHG);
> + }
> + err2 = xfs_trans_commit(args->trans);
> + error = error ? error : err2;
> + }
> + return error;
> +}
> +
> int
> xfs_attr_set(
> struct xfs_inode *dp,
> @@ -218,7 +256,7 @@ xfs_attr_set(
> struct xfs_trans_res tres;
> xfs_fsblock_t firstblock;
> int rsvd = (flags & ATTR_ROOT) != 0;
> - int error, err2, local;
> + int error, local;
>
> XFS_STATS_INC(mp, xs_attr_set);
>
> @@ -297,30 +335,10 @@ xfs_attr_set(
> * Try to add the attr to the attribute list in
> * the inode.
> */
> - error = xfs_attr_shortform_addname(&args);
> + error = xfs_attr_try_sf_addname(dp, &args, flags);
> if (error != -ENOSPC) {
> - /*
> - * Commit the shortform mods, and we're done.
> - * NOTE: this is also the error path (EEXIST, etc).
> - */
> - ASSERT(args.trans != NULL);
> -
> - /*
> - * If this is a synchronous mount, make sure that
> - * the transaction goes to disk before returning
> - * to the user.
> - */
> - if (mp->m_flags & XFS_MOUNT_WSYNC)
> - xfs_trans_set_sync(args.trans);
> -
> - if (!error && (flags & ATTR_KERNOTIME) == 0) {
> - xfs_trans_ichgtime(args.trans, dp,
> - XFS_ICHGTIME_CHG);
> - }
> - err2 = xfs_trans_commit(args.trans);
> xfs_iunlock(dp, XFS_ILOCK_EXCL);
> -
> - return error ? error : err2;
> + return error;
> }
>
> /*
> --
> 2.7.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 19/23] xfs: Add parent pointers to rename
2018-06-10 5:05 ` [PATCH v7 19/23] xfs: Add parent pointers to rename Allison Henderson
@ 2018-06-10 13:39 ` Amir Goldstein
2018-06-10 17:34 ` Allison Henderson
0 siblings, 1 reply; 33+ messages in thread
From: Amir Goldstein @ 2018-06-10 13:39 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Sun, Jun 10, 2018 at 8:05 AM, Allison Henderson
<allison.henderson@oracle.com> wrote:
> This patch removes the old parent pointer attribute during the
> rename operation, and re-adds the updated parent pointer
>
> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
> ---
> fs/xfs/xfs_inode.c | 68 +++++++++++++++++++++++++++++++++++++++++-------------
> 1 file changed, 52 insertions(+), 16 deletions(-)
>
[...]
> xfs_defer_init(&dfops, &first_block);
>
> /* RENAME_EXCHANGE is unique from here on. */
> - if (flags & RENAME_EXCHANGE)
> - return xfs_cross_rename(tp, src_dp, src_name, src_ip,
> + if (flags & RENAME_EXCHANGE) {
> + error = xfs_cross_rename(tp, src_dp, src_name, src_ip,
> target_dp, target_name, target_ip,
> &dfops, &first_block, spaceres);
> -
You forgot to update parent pointers in RENAME_EXCHANGE
case, both src and target.
I commented that on v6, you must have missed that.
Thanks,
Amir.
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname
2018-06-10 6:58 ` Amir Goldstein
@ 2018-06-10 15:30 ` Allison Henderson
0 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 15:30 UTC (permalink / raw)
To: Amir Goldstein; +Cc: linux-xfs
On 06/09/2018 11:58 PM, Amir Goldstein wrote:
> On Sun, Jun 10, 2018 at 8:04 AM, Allison Henderson
> <allison.henderson@oracle.com> wrote:
>> This patch adds a subroutine xfs_attr_try_sf_addname
>> used by xfs_attr_set. This subrotine will attempt to
>> add the attribute name specified in args in shortform,
>> as well and perform error handling previously done in
>> xfs_attr_set.
>>
>> This patch helps to pre-simplify xfs_attr_set for reviewing
>> purposes and reduce indentation. New function will be added
>> in the next patch.
>>
>> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
>> ---
>> fs/xfs/libxfs/xfs_attr.c | 64 +++++++++++++++++++++++++++++++-----------------
>> 1 file changed, 41 insertions(+), 23 deletions(-)
>>
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index ce4a34a..1524197 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
>> @@ -203,6 +203,44 @@ xfs_attr_calc_size(
>> return nblks;
>> }
>>
>> +STATIC int
>> +xfs_attr_try_sf_addname(
>> + struct xfs_inode *dp,
>> + struct xfs_da_args *args,
>> + int flags)
>> +{
>> +
>> + struct xfs_mount *mp = dp->i_mount;
>> + int error;
>> + int err2;
>> +
>> + error = xfs_attr_shortform_addname(args);
>> + if (error != -ENOSPC) {
>
> Not sure it made sense before, but in the context of this helper
> nesting most of the code path for the likely case is weird.
> Please return error if (error == -ENOSPC)
Sure, maybe I could do that change in the next patch. I'm trying to
avoid moving code and then changing it at the same time because I think
it makes the reviews a little harder on folks. Will fix though. Thx!
Allison
>
>> + /*
>> + * Commit the shortform mods, and we're done.
>> + * NOTE: this is also the error path
>> + * (EEXIST, etc).
>> + */
>> + ASSERT(args->trans != NULL);
>> +
>> + /*
>> + * If this is a synchronous mount, make sure
>> + * that the transaction goes to disk before
>> + * returning to the user.
>> + */
>> + if (mp->m_flags & XFS_MOUNT_WSYNC)
>> + xfs_trans_set_sync(args->trans);
>> +
>> + if (!error && (flags & ATTR_KERNOTIME) == 0) {
>> + xfs_trans_ichgtime(args->trans, dp,
>> + XFS_ICHGTIME_CHG);
>> + }
>> + err2 = xfs_trans_commit(args->trans);
>> + error = error ? error : err2;
>> + }
>> + return error;
>> +}
>> +
>> int
>> xfs_attr_set(
>> struct xfs_inode *dp,
>> @@ -218,7 +256,7 @@ xfs_attr_set(
>> struct xfs_trans_res tres;
>> xfs_fsblock_t firstblock;
>> int rsvd = (flags & ATTR_ROOT) != 0;
>> - int error, err2, local;
>> + int error, local;
>>
>> XFS_STATS_INC(mp, xs_attr_set);
>>
>> @@ -297,30 +335,10 @@ xfs_attr_set(
>> * Try to add the attr to the attribute list in
>> * the inode.
>> */
>> - error = xfs_attr_shortform_addname(&args);
>> + error = xfs_attr_try_sf_addname(dp, &args, flags);
>> if (error != -ENOSPC) {
>> - /*
>> - * Commit the shortform mods, and we're done.
>> - * NOTE: this is also the error path (EEXIST, etc).
>> - */
>> - ASSERT(args.trans != NULL);
>> -
>> - /*
>> - * If this is a synchronous mount, make sure that
>> - * the transaction goes to disk before returning
>> - * to the user.
>> - */
>> - if (mp->m_flags & XFS_MOUNT_WSYNC)
>> - xfs_trans_set_sync(args.trans);
>> -
>> - if (!error && (flags & ATTR_KERNOTIME) == 0) {
>> - xfs_trans_ichgtime(args.trans, dp,
>> - XFS_ICHGTIME_CHG);
>> - }
>> - err2 = xfs_trans_commit(args.trans);
>> xfs_iunlock(dp, XFS_ILOCK_EXCL);
>> -
>> - return error ? error : err2;
>> + return error;
>> }
>>
>> /*
>> --
>> 2.7.4
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at https://urldefense.proofpoint.com/v2/url?u=http-3A__vger.kernel.org_majordomo-2Dinfo.html&d=DwIBaQ&c=RoP1YumCXCgaWHvlZYR8PZh8Bv7qIrMUB65eapI_JnE&r=LHZQ8fHvy6wDKXGTWcm97burZH5sQKHRDMaY1UthQxc&m=xVunh0uk8Pktex1LHFbHolstfv3eqBBkWt5RkoG7tPA&s=eaQpPcYIgNL0hFyZdNc-dOXhzugeysrtVYd50uOAO1Q&e=
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at https://urldefense.proofpoint.com/v2/url?u=http-3A__vger.kernel.org_majordomo-2Dinfo.html&d=DwIBaQ&c=RoP1YumCXCgaWHvlZYR8PZh8Bv7qIrMUB65eapI_JnE&r=LHZQ8fHvy6wDKXGTWcm97burZH5sQKHRDMaY1UthQxc&m=xVunh0uk8Pktex1LHFbHolstfv3eqBBkWt5RkoG7tPA&s=eaQpPcYIgNL0hFyZdNc-dOXhzugeysrtVYd50uOAO1Q&e=
>
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 19/23] xfs: Add parent pointers to rename
2018-06-10 13:39 ` Amir Goldstein
@ 2018-06-10 17:34 ` Allison Henderson
0 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-10 17:34 UTC (permalink / raw)
To: Amir Goldstein; +Cc: linux-xfs
On 06/10/2018 06:39 AM, Amir Goldstein wrote:
> On Sun, Jun 10, 2018 at 8:05 AM, Allison Henderson
> <allison.henderson@oracle.com> wrote:
>> This patch removes the old parent pointer attribute during the
>> rename operation, and re-adds the updated parent pointer
>>
>> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
>> ---
>> fs/xfs/xfs_inode.c | 68 +++++++++++++++++++++++++++++++++++++++++-------------
>> 1 file changed, 52 insertions(+), 16 deletions(-)
>>
> [...]
>> xfs_defer_init(&dfops, &first_block);
>>
>> /* RENAME_EXCHANGE is unique from here on. */
>> - if (flags & RENAME_EXCHANGE)
>> - return xfs_cross_rename(tp, src_dp, src_name, src_ip,
>> + if (flags & RENAME_EXCHANGE) {
>> + error = xfs_cross_rename(tp, src_dp, src_name, src_ip,
>> target_dp, target_name, target_ip,
>> &dfops, &first_block, spaceres);
>> -
>
> You forgot to update parent pointers in RENAME_EXCHANGE
> case, both src and target.
>
> I commented that on v6, you must have missed that.
>
> Thanks,
> Amir.
Alrighty, I may have over looked it in all the traffic, I will get it
updated. Thx!
Allison
>
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 03/23] xfs: Add trans toggle to attr routines
2018-06-10 5:04 ` [PATCH v7 03/23] xfs: Add trans toggle to attr routines Allison Henderson
@ 2018-06-13 12:11 ` Brian Foster
2018-06-14 1:27 ` Allison Henderson
0 siblings, 1 reply; 33+ messages in thread
From: Brian Foster @ 2018-06-13 12:11 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Sat, Jun 09, 2018 at 10:04:48PM -0700, Allison Henderson wrote:
> This patch adds a roll_trans parameter to all attribute routines.
> Calling functions may pass true to roll transactions as normal,
> or false to hold them. We will need this later for delayed
> attribute operations.
>
> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
> ---
> fs/xfs/libxfs/xfs_attr.c | 165 ++++++++++++++++++++++++------------------
> fs/xfs/libxfs/xfs_attr_leaf.c | 12 +--
> fs/xfs/libxfs/xfs_attr_leaf.h | 10 ++-
> 3 files changed, 108 insertions(+), 79 deletions(-)
>
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index 1524197..e8cb369 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -55,21 +55,21 @@
> /*
> * Internal routines when attribute list fits inside the inode.
> */
> -STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> +STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans);
>
> /*
> * Internal routines when attribute list is one block.
> */
> STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> +STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans);
> +STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans);
>
> /*
> * Internal routines when attribute list is more than one block.
> */
> STATIC int xfs_attr_node_get(xfs_da_args_t *args);
> -STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
> -STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
> +STATIC int xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans);
> +STATIC int xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans);
> STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
> STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
>
> @@ -207,15 +207,16 @@ STATIC int
> xfs_attr_try_sf_addname(
> struct xfs_inode *dp,
> struct xfs_da_args *args,
> - int flags)
> + int flags,
> + bool roll_trans)
> {
>
> struct xfs_mount *mp = dp->i_mount;
> int error;
> int err2;
>
> - error = xfs_attr_shortform_addname(args);
> - if (error != -ENOSPC) {
> + error = xfs_attr_shortform_addname(args, roll_trans);
> + if (error != -ENOSPC && roll_trans) {
Doesn't this change behavior beyond committing the transaction or not?
E.g., we skip the time call that follows if !roll_trans. Would the
!roll_trans caller know/care about that?
> /*
> * Commit the shortform mods, and we're done.
> * NOTE: this is also the error path
> @@ -335,7 +336,7 @@ xfs_attr_set(
> * Try to add the attr to the attribute list in
> * the inode.
> */
> - error = xfs_attr_try_sf_addname(dp, &args, flags);
> + error = xfs_attr_try_sf_addname(dp, &args, flags, true);
> if (error != -ENOSPC) {
> xfs_iunlock(dp, XFS_ILOCK_EXCL);
> return error;
> @@ -374,9 +375,9 @@ xfs_attr_set(
> }
>
> if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
> - error = xfs_attr_leaf_addname(&args);
> + error = xfs_attr_leaf_addname(&args, true);
> else
> - error = xfs_attr_node_addname(&args);
> + error = xfs_attr_node_addname(&args, true);
> if (error)
> goto out;
>
> @@ -471,11 +472,11 @@ xfs_attr_remove(
> error = -ENOATTR;
> } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> - error = xfs_attr_shortform_remove(&args);
> + error = xfs_attr_shortform_remove(&args, true);
> } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> - error = xfs_attr_leaf_removename(&args);
> + error = xfs_attr_leaf_removename(&args, true);
> } else {
> - error = xfs_attr_node_removename(&args);
> + error = xfs_attr_node_removename(&args, true);
> }
>
> if (error)
> @@ -516,7 +517,7 @@ xfs_attr_remove(
> * This is the external routine.
> */
> STATIC int
> -xfs_attr_shortform_addname(xfs_da_args_t *args)
> +xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans)
> {
> int newsize, forkoff, retval;
>
> @@ -528,7 +529,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
> } else if (retval == -EEXIST) {
> if (args->flags & ATTR_CREATE)
> return retval;
> - retval = xfs_attr_shortform_remove(args);
> + retval = xfs_attr_shortform_remove(args, roll_trans);
> ASSERT(retval == 0);
> }
>
> @@ -543,7 +544,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
> if (!forkoff)
> return -ENOSPC;
>
> - xfs_attr_shortform_add(args, forkoff);
> + xfs_attr_shortform_add(args, forkoff, roll_trans);
> return 0;
> }
>
> @@ -559,7 +560,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
> * if bmap_one_block() says there is only one block (ie: no remote blks).
> */
> STATIC int
> -xfs_attr_leaf_addname(xfs_da_args_t *args)
> +xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans)
> {
> xfs_inode_t *dp;
> struct xfs_buf *bp;
> @@ -622,36 +623,42 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
> * can manage its own transactions.
> */
> xfs_defer_init(args->dfops, args->firstblock);
> - error = xfs_attr3_leaf_to_node(args);
> + error = xfs_attr3_leaf_to_node(args, roll_trans);
> if (error)
> goto out_defer_cancel;
> xfs_defer_ijoin(args->dfops, dp);
> - error = xfs_defer_finish(&args->trans, args->dfops);
> - if (error)
> - goto out_defer_cancel;
> + if (roll_trans) {
> + error = xfs_defer_finish(&args->trans, args->dfops);
> + if (error)
> + goto out_defer_cancel;
>
> - /*
> - * Commit the current trans (including the inode) and start
> - * a new one.
> - */
> - error = xfs_trans_roll_inode(&args->trans, dp);
> - if (error)
> - return error;
> + /*
> + * Commit the current trans (including the inode) and
> + * start a new one.
> + */
> + error = xfs_trans_roll_inode(&args->trans, dp);
> + if (error)
> + return error;
> + }
>
> /*
> * Fob the whole rest of the problem off on the Btree code.
> */
> - error = xfs_attr_node_addname(args);
> + error = xfs_attr_node_addname(args, roll_trans);
> +
> return error;
> }
>
> - /*
> - * Commit the transaction that added the attr name so that
> - * later routines can manage their own transactions.
> - */
> - error = xfs_trans_roll_inode(&args->trans, dp);
> - if (error)
> - return error;
> +
> + if (roll_trans) {
> + /*
> + * Commit the transaction that added the attr name so that
> + * later routines can manage their own transactions.
> + */
> + error = xfs_trans_roll_inode(&args->trans, dp);
> + if (error)
> + return error;
> + }
>
> /*
> * If there was an out-of-line value, allocate the blocks we
> @@ -709,9 +716,11 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
> /*
> * If the result is small enough, shrink it all into the inode.
> */
> - if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
> + if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
> + roll_trans) {
Similar here (and one or two other places in the patch).. I haven't
looked ahead at the follow on code, but it seems a bit strange for a
"don't roll trans" flag to toggle attr fork behavior.
> xfs_defer_init(args->dfops, args->firstblock);
> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
> + roll_trans);
> /* bp is gone due to xfs_da_shrink_inode */
> if (error)
> goto out_defer_cancel;
> @@ -745,7 +754,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
> * if bmap_one_block() says there is only one block (ie: no remote blks).
> */
> STATIC int
> -xfs_attr_leaf_removename(xfs_da_args_t *args)
> +xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans)
> {
> xfs_inode_t *dp;
> struct xfs_buf *bp;
> @@ -774,15 +783,19 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
> * If the result is small enough, shrink it all into the inode.
> */
> if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
> - xfs_defer_init(args->dfops, args->firstblock);
> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
> + if (roll_trans)
> + xfs_defer_init(args->dfops, args->firstblock);
> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
> + roll_trans);
While here roll_trans seems to only control the transaction behavior.
Hm?
Brian
> /* bp is gone due to xfs_da_shrink_inode */
> if (error)
> goto out_defer_cancel;
> xfs_defer_ijoin(args->dfops, dp);
> - error = xfs_defer_finish(&args->trans, args->dfops);
> - if (error)
> - goto out_defer_cancel;
> + if (roll_trans) {
> + error = xfs_defer_finish(&args->trans, args->dfops);
> + if (error)
> + goto out_defer_cancel;
> + }
> }
> return 0;
> out_defer_cancel:
> @@ -837,7 +850,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
> * add a whole extra layer of confusion on top of that.
> */
> STATIC int
> -xfs_attr_node_addname(xfs_da_args_t *args)
> +xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans)
> {
> xfs_da_state_t *state;
> xfs_da_state_blk_t *blk;
> @@ -903,21 +916,24 @@ xfs_attr_node_addname(xfs_da_args_t *args)
> xfs_da_state_free(state);
> state = NULL;
> xfs_defer_init(args->dfops, args->firstblock);
> - error = xfs_attr3_leaf_to_node(args);
> + error = xfs_attr3_leaf_to_node(args, roll_trans);
> if (error)
> goto out_defer_cancel;
> xfs_defer_ijoin(args->dfops, dp);
> - error = xfs_defer_finish(&args->trans, args->dfops);
> - if (error)
> - goto out_defer_cancel;
> -
> - /*
> - * Commit the node conversion and start the next
> - * trans in the chain.
> - */
> - error = xfs_trans_roll_inode(&args->trans, dp);
> - if (error)
> - goto out;
> + if (roll_trans) {
> + error = xfs_defer_finish(&args->trans,
> + args->dfops);
> + if (error)
> + goto out_defer_cancel;
> +
> + /*
> + * Commit the node conversion and start the next
> + * trans in the chain.
> + */
> + error = xfs_trans_roll_inode(&args->trans, dp);
> + if (error)
> + goto out;
> + }
>
> goto restart;
> }
> @@ -933,9 +949,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
> if (error)
> goto out_defer_cancel;
> xfs_defer_ijoin(args->dfops, dp);
> - error = xfs_defer_finish(&args->trans, args->dfops);
> - if (error)
> - goto out_defer_cancel;
> + if (roll_trans) {
> + error = xfs_defer_finish(&args->trans, args->dfops);
> + if (error)
> + goto out_defer_cancel;
> + }
> } else {
> /*
> * Addition succeeded, update Btree hashvals.
> @@ -954,9 +972,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
> * Commit the leaf addition or btree split and start the next
> * trans in the chain.
> */
> - error = xfs_trans_roll_inode(&args->trans, dp);
> - if (error)
> - goto out;
> + if (roll_trans) {
> + error = xfs_trans_roll_inode(&args->trans, dp);
> + if (error)
> + goto out;
> + }
>
> /*
> * If there was an out-of-line value, allocate the blocks we
> @@ -1031,9 +1051,12 @@ xfs_attr_node_addname(xfs_da_args_t *args)
> if (error)
> goto out_defer_cancel;
> xfs_defer_ijoin(args->dfops, dp);
> - error = xfs_defer_finish(&args->trans, args->dfops);
> - if (error)
> - goto out_defer_cancel;
> + if (roll_trans) {
> + error = xfs_defer_finish(&args->trans,
> + args->dfops);
> + if (error)
> + goto out_defer_cancel;
> + }
> }
>
> /*
> @@ -1072,7 +1095,7 @@ xfs_attr_node_addname(xfs_da_args_t *args)
> * the root node (a special case of an intermediate node).
> */
> STATIC int
> -xfs_attr_node_removename(xfs_da_args_t *args)
> +xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans)
> {
> xfs_da_state_t *state;
> xfs_da_state_blk_t *blk;
> @@ -1181,9 +1204,11 @@ xfs_attr_node_removename(xfs_da_args_t *args)
> if (error)
> goto out;
>
> - if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
> + if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
> + roll_trans) {
> xfs_defer_init(args->dfops, args->firstblock);
> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
> + roll_trans);
> /* bp is gone due to xfs_da_shrink_inode */
> if (error)
> goto out_defer_cancel;
> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
> index 2135b8e..01935fe 100644
> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
> @@ -546,7 +546,7 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
> * Overflow from the inode has already been checked for.
> */
> void
> -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
> +xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff, bool roll_trans)
> {
> xfs_attr_shortform_t *sf;
> xfs_attr_sf_entry_t *sfe;
> @@ -618,7 +618,7 @@ xfs_attr_fork_remove(
> * Remove an attribute from the shortform attribute list structure.
> */
> int
> -xfs_attr_shortform_remove(xfs_da_args_t *args)
> +xfs_attr_shortform_remove(xfs_da_args_t *args, bool roll_trans)
> {
> xfs_attr_shortform_t *sf;
> xfs_attr_sf_entry_t *sfe;
> @@ -970,7 +970,8 @@ int
> xfs_attr3_leaf_to_shortform(
> struct xfs_buf *bp,
> struct xfs_da_args *args,
> - int forkoff)
> + int forkoff,
> + bool roll_trans)
> {
> struct xfs_attr_leafblock *leaf;
> struct xfs_attr3_icleaf_hdr ichdr;
> @@ -1039,7 +1040,7 @@ xfs_attr3_leaf_to_shortform(
> 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);
> - xfs_attr_shortform_add(&nargs, forkoff);
> + xfs_attr_shortform_add(&nargs, forkoff, roll_trans);
> }
> error = 0;
>
> @@ -1053,7 +1054,8 @@ xfs_attr3_leaf_to_shortform(
> */
> int
> xfs_attr3_leaf_to_node(
> - struct xfs_da_args *args)
> + struct xfs_da_args *args,
> + bool roll_trans)
> {
> struct xfs_attr_leafblock *leaf;
> struct xfs_attr3_icleaf_hdr icleafhdr;
> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
> index 4da08af..79c236c 100644
> --- a/fs/xfs/libxfs/xfs_attr_leaf.h
> +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
> @@ -45,12 +45,13 @@ typedef struct xfs_attr_inactive_list {
> * Internal routines when attribute fork size < XFS_LITINO(mp).
> */
> void xfs_attr_shortform_create(struct xfs_da_args *args);
> -void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff);
> +void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff,
> + bool roll_trans);
> int xfs_attr_shortform_lookup(struct xfs_da_args *args);
> int xfs_attr_shortform_getvalue(struct xfs_da_args *args);
> int xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
> struct xfs_buf **leaf_bp);
> -int xfs_attr_shortform_remove(struct xfs_da_args *args);
> +int xfs_attr_shortform_remove(struct xfs_da_args *args, bool roll_trans);
> int xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
> int xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
> xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
> @@ -59,9 +60,10 @@ void xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
> /*
> * Internal routines when attribute fork size == XFS_LBSIZE(mp).
> */
> -int xfs_attr3_leaf_to_node(struct xfs_da_args *args);
> +int xfs_attr3_leaf_to_node(struct xfs_da_args *args, bool roll_trans);
> int xfs_attr3_leaf_to_shortform(struct xfs_buf *bp,
> - struct xfs_da_args *args, int forkoff);
> + struct xfs_da_args *args, int forkoff,
> + bool roll_trans);
> int xfs_attr3_leaf_clearflag(struct xfs_da_args *args);
> int xfs_attr3_leaf_setflag(struct xfs_da_args *args);
> int xfs_attr3_leaf_flipflags(struct xfs_da_args *args);
> --
> 2.7.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations
2018-06-10 5:04 ` [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations Allison Henderson
@ 2018-06-13 15:18 ` Brian Foster
2018-06-14 1:28 ` Allison Henderson
0 siblings, 1 reply; 33+ messages in thread
From: Brian Foster @ 2018-06-13 15:18 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Sat, Jun 09, 2018 at 10:04:51PM -0700, Allison Henderson wrote:
> This patch adds two new log item types for setting or
> removing attributes as deferred operations. The
> xfs_attri_log_item logs an intent to set or remove an
> attribute. The corresponding xfs_attrd_log_item holds
> a reference to the xfs_attri_log_item and is freed once
> the transaction is done. Both log items use a generic
> xfs_attr_log_format structure that contains the attribute
> name, value, flags, inode, and an op_flag that indicates
> if the operations is a set or remove.
>
> At the moment, this feature will only be used by the parent
> pointer patch set which uses attributes to store information
> about an inodes parent.
>
> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
> ---
Looks mostly sane, though I haven't looked into all the details or the
recovery code yet. It does look like this needs to be rebased on top of
the recent elimination of the log item descriptor. A few comments in the
meantime...
> fs/xfs/Makefile | 2 +
> fs/xfs/libxfs/xfs_attr.c | 5 +-
> fs/xfs/libxfs/xfs_attr.h | 26 +-
> fs/xfs/libxfs/xfs_defer.h | 1 +
> fs/xfs/libxfs/xfs_log_format.h | 44 +++-
> fs/xfs/libxfs/xfs_types.h | 1 +
> fs/xfs/xfs_attr_item.c | 560 +++++++++++++++++++++++++++++++++++++++++
> fs/xfs/xfs_attr_item.h | 120 +++++++++
> fs/xfs/xfs_log_recover.c | 173 +++++++++++++
> fs/xfs/xfs_ondisk.h | 2 +
> fs/xfs/xfs_super.c | 1 +
> fs/xfs/xfs_trans.h | 14 ++
> fs/xfs/xfs_trans_attr.c | 285 +++++++++++++++++++++
> 13 files changed, 1229 insertions(+), 5 deletions(-)
>
> diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
> index 7ceb41a..d3c0004 100644
> --- a/fs/xfs/Makefile
> +++ b/fs/xfs/Makefile
> @@ -107,6 +107,7 @@ xfs-y += xfs_log.o \
> xfs_bmap_item.o \
> xfs_buf_item.o \
> xfs_extfree_item.o \
> + xfs_attr_item.o \
> xfs_icreate_item.o \
> xfs_inode_item.o \
> xfs_refcount_item.o \
> @@ -116,6 +117,7 @@ xfs-y += xfs_log.o \
> xfs_trans_bmap.o \
> xfs_trans_buf.o \
> xfs_trans_extfree.o \
> + xfs_trans_attr.o \
> xfs_trans_inode.o \
> xfs_trans_refcount.o \
> xfs_trans_rmap.o \
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index ab769e5..408a49d 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -41,6 +41,7 @@
> #include "xfs_quota.h"
> #include "xfs_trans_space.h"
> #include "xfs_trace.h"
> +#include "xfs_attr_item.h"
>
> /*
> * xfs_attr.c
> @@ -74,7 +75,7 @@ STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
> STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
>
>
> -STATIC int
> +int
> xfs_attr_args_init(
> struct xfs_da_args *args,
> struct xfs_inode *dp,
> @@ -170,7 +171,7 @@ xfs_attr_get(
> /*
> * Calculate how many blocks we need for the new attribute,
> */
> -STATIC int
> +int
> xfs_attr_calc_size(
> struct xfs_da_args *args,
> int *local)
> diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
> index ef6b47e..33b33d3 100644
> --- a/fs/xfs/libxfs/xfs_attr.h
> +++ b/fs/xfs/libxfs/xfs_attr.h
> @@ -18,6 +18,8 @@
> #ifndef __XFS_ATTR_H__
> #define __XFS_ATTR_H__
>
> +#include "libxfs/xfs_defer.h"
> +
Why is this necessary? I think we usually try to keep includes out of
header files, but I could be wrong.
> struct xfs_inode;
> struct xfs_da_args;
> struct xfs_attr_list_context;
> @@ -90,6 +92,26 @@ typedef struct attrlist_ent { /* data from attr_list() */
> } attrlist_ent_t;
>
> /*
> + * List of attrs to commit later.
> + */
> +struct xfs_attr_item {
> + struct xfs_inode *xattri_ip;
> + uint32_t xattri_op_flags;
> + uint32_t xattri_value_len; /* length of value */
> + uint32_t xattri_name_len; /* length of name */
> + uint32_t xattri_flags; /* attr flags */
> + struct list_head xattri_list;
> +
> + /*
> + * A byte array follows the header containing the file name and
> + * attribute value.
> + */
This isn't really a header though, right? This is more of an in-core
structure to carry the attr information into the dfops infrastructure..?
Hmm, I'm wondering if this would just be cleaner with separate
allocations so we can actually have name/value fields. Or perhaps a
compromise could be the current single alloc with name/value pointers
that are fixed up to refer to the memory after the static part of the
data structure? Then we could clean up some of the dfops callouts that
access this data a bit.
> +};
> +
> +#define XFS_ATTR_ITEM_SIZEOF(namelen, valuelen) \
> + (sizeof(struct xfs_attr_item) + (namelen) + (valuelen))
> +
> +/*
> * Given a pointer to the (char*) buffer containing the attr_list() result,
> * and an index, return a pointer to the indicated attribute in the buffer.
> */
> @@ -158,6 +180,8 @@ int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
> int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
> int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
> int flags, struct attrlist_cursor_kern *cursor);
> -
> +int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
> + const unsigned char *name, int flags);
> +int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
>
> #endif /* __XFS_ATTR_H__ */
> diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
> index 045beac..11e1690 100644
> --- a/fs/xfs/libxfs/xfs_defer.h
> +++ b/fs/xfs/libxfs/xfs_defer.h
> @@ -55,6 +55,7 @@ enum xfs_defer_ops_type {
> XFS_DEFER_OPS_TYPE_REFCOUNT,
> XFS_DEFER_OPS_TYPE_RMAP,
> XFS_DEFER_OPS_TYPE_FREE,
> + XFS_DEFER_OPS_TYPE_ATTR,
> XFS_DEFER_OPS_TYPE_MAX,
> };
>
> diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
> index 349d9f8..291e5ff 100644
> --- a/fs/xfs/libxfs/xfs_log_format.h
> +++ b/fs/xfs/libxfs/xfs_log_format.h
> @@ -116,7 +116,12 @@ static inline uint xlog_get_cycle(char *ptr)
> #define XLOG_REG_TYPE_CUD_FORMAT 24
> #define XLOG_REG_TYPE_BUI_FORMAT 25
> #define XLOG_REG_TYPE_BUD_FORMAT 26
> -#define XLOG_REG_TYPE_MAX 26
> +#define XLOG_REG_TYPE_ATTRI_FORMAT 27
> +#define XLOG_REG_TYPE_ATTRD_FORMAT 28
> +#define XLOG_REG_TYPE_ATTR_NAME 29
> +#define XLOG_REG_TYPE_ATTR_VALUE 30
> +#define XLOG_REG_TYPE_MAX 31
> +
>
> /*
> * Flags to log operation header
> @@ -239,6 +244,8 @@ typedef struct xfs_trans_header {
> #define XFS_LI_CUD 0x1243
> #define XFS_LI_BUI 0x1244 /* bmbt update intent */
> #define XFS_LI_BUD 0x1245
> +#define XFS_LI_ATTRI 0x1246 /* attr set/remove intent*/
> +#define XFS_LI_ATTRD 0x1247 /* attr set/remove done */
>
> #define XFS_LI_TYPE_DESC \
> { XFS_LI_EFI, "XFS_LI_EFI" }, \
> @@ -254,7 +261,9 @@ typedef struct xfs_trans_header {
> { XFS_LI_CUI, "XFS_LI_CUI" }, \
> { XFS_LI_CUD, "XFS_LI_CUD" }, \
> { XFS_LI_BUI, "XFS_LI_BUI" }, \
> - { XFS_LI_BUD, "XFS_LI_BUD" }
> + { XFS_LI_BUD, "XFS_LI_BUD" }, \
> + { XFS_LI_ATTRI, "XFS_LI_ATTRI" }, \
> + { XFS_LI_ATTRD, "XFS_LI_ATTRD" }
>
> /*
> * Inode Log Item Format definitions.
> @@ -852,4 +861,35 @@ struct xfs_icreate_log {
> __be32 icl_gen; /* inode generation number to use */
> };
>
> +/*
> + * Flags for deferred attribute operations.
> + * Upper bits are flags, lower byte is type code
> + */
> +#define XFS_ATTR_OP_FLAGS_SET 1 /* Set the attribute */
> +#define XFS_ATTR_OP_FLAGS_REMOVE 2 /* Remove the attribute */
> +#define XFS_ATTR_OP_FLAGS_TYPE_MASK 0x0FF /* Flags type mask */
> +
> +/*
> + * This is the structure used to lay out an attr log item in the
> + * log.
> + */
> +struct xfs_attri_log_format {
> + uint16_t alfi_type; /* attri log item type */
> + uint16_t alfi_size; /* size of this item */
> + uint32_t __pad; /* pad to 64 bit aligned */
> + uint64_t alfi_id; /* attri identifier */
> + xfs_ino_t alfi_ino; /* the inode for this attr operation */
> + uint32_t alfi_op_flags; /* marks the op as a set or remove */
> + uint32_t alfi_name_len; /* attr name length */
> + uint32_t alfi_value_len; /* attr value length */
> + uint32_t alfi_attr_flags;/* attr flags */
> +};
> +
> +struct xfs_attrd_log_format {
> + uint16_t alfd_type; /* attrd log item type */
> + uint16_t alfd_size; /* size of this item */
> + uint32_t __pad; /* pad to 64 bit aligned */
> + uint64_t alfd_alf_id; /* id of corresponding attrd */
> +};
> +
> #endif /* __XFS_LOG_FORMAT_H__ */
> diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
> index 3c56069..2905ce3 100644
> --- a/fs/xfs/libxfs/xfs_types.h
> +++ b/fs/xfs/libxfs/xfs_types.h
> @@ -23,6 +23,7 @@ typedef uint32_t prid_t; /* project ID */
> typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
> typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
> typedef uint32_t xfs_extlen_t; /* extent length in blocks */
> +typedef uint32_t xfs_attrlen_t; /* attr length */
> typedef uint32_t xfs_agnumber_t; /* allocation group number */
> typedef int32_t xfs_extnum_t; /* # of extents in a file */
> typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
> diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
> new file mode 100644
> index 0000000..e90d516
> --- /dev/null
> +++ b/fs/xfs/xfs_attr_item.c
> @@ -0,0 +1,560 @@
> +/*
> + * Copyright (c) 2017 Oracle, Inc.
> + * All Rights Reserved.
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it would be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write the Free Software Foundation Inc.
> + */
> +#include "xfs.h"
> +#include "xfs_fs.h"
> +#include "xfs_format.h"
> +#include "xfs_log_format.h"
> +#include "xfs_trans_resv.h"
> +#include "xfs_bit.h"
> +#include "xfs_mount.h"
> +#include "xfs_trans.h"
> +#include "xfs_trans_priv.h"
> +#include "xfs_buf_item.h"
> +#include "xfs_attr_item.h"
> +#include "xfs_log.h"
> +#include "xfs_btree.h"
> +#include "xfs_rmap.h"
> +#include "xfs_inode.h"
> +#include "xfs_icache.h"
> +
> +static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip)
> +{
> + return container_of(lip, struct xfs_attri_log_item, item);
> +}
> +
> +void
> +xfs_attri_item_free(
> + struct xfs_attri_log_item *attrip)
> +{
> + kmem_free(attrip->item.li_lv_shadow);
> + kmem_free(attrip);
> +}
> +
> +/*
> + * This returns the number of iovecs needed to log the given attri item.
> + * We only need 1 iovec for an attri item. It just logs the attr_log_format
> + * structure.
> + */
> +static inline int
> +xfs_attri_item_sizeof(
> + struct xfs_attri_log_item *attrip)
> +{
> + return sizeof(struct xfs_attri_log_format);
> +}
> +
> +STATIC void
> +xfs_attri_item_size(
> + struct xfs_log_item *lip,
> + int *nvecs,
> + int *nbytes)
> +{
> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> +
> + *nvecs += 1;
> + *nbytes += xfs_attri_item_sizeof(attrip);
> +
> + if (attrip->name_len > 0) {
> + *nvecs += 1;
> + nbytes += ATTR_NVEC_SIZE(attrip->name_len);
> + }
> +
> + if (attrip->value_len > 0) {
> + *nvecs += 1;
> + nbytes += ATTR_NVEC_SIZE(attrip->value_len);
> + }
> +}
> +
> +/*
> + * This is called to fill in the vector of log iovecs for the
> + * given attri log item. We use only 1 iovec, and we point that
> + * at the attri_log_format structure embedded in the attri item.
> + * It is at this point that we assert that all of the attr
> + * slots in the attri item have been filled.
> + */
> +STATIC void
> +xfs_attri_item_format(
> + struct xfs_log_item *lip,
> + struct xfs_log_vec *lv)
> +{
> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> + struct xfs_log_iovec *vecp = NULL;
> +
> + attrip->format.alfi_type = XFS_LI_ATTRI;
> + attrip->format.alfi_size = 1;
> + if (attrip->name_len > 0)
> + attrip->format.alfi_size++;
> + if (attrip->value_len > 0)
> + attrip->format.alfi_size++;
> +
> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT,
> + &attrip->format,
> + xfs_attri_item_sizeof(attrip));
> + if (attrip->name_len > 0)
> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_NAME,
> + attrip->name, ATTR_NVEC_SIZE(attrip->name_len));
> +
> + if (attrip->value_len > 0)
> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_VALUE,
> + attrip->value,
> + ATTR_NVEC_SIZE(attrip->value_len));
> +}
> +
> +
> +/*
> + * Pinning has no meaning for an attri item, so just return.
> + */
> +STATIC void
> +xfs_attri_item_pin(
> + struct xfs_log_item *lip)
> +{
> +}
> +
> +/*
> + * The unpin operation is the last place an ATTRI is manipulated in the log. It
> + * is either inserted in the AIL or aborted in the event of a log I/O error. In
> + * either case, the ATTRI transaction has been successfully committed to make it
> + * this far. Therefore, we expect whoever committed the ATTRI to either
> + * construct and commit the ATTRD or drop the ATTRD's reference in the event of
> + * error. Simply drop the log's ATTRI reference now that the log is done with
> + * it.
> + */
> +STATIC void
> +xfs_attri_item_unpin(
> + struct xfs_log_item *lip,
> + int remove)
> +{
> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> +
> + xfs_attri_release(attrip);
> +}
> +
> +/*
> + * attri items have no locking or pushing. However, since ATTRIs are pulled
> + * from the AIL when their corresponding ATTRDs are committed to disk, their
> + * situation is very similar to being pinned. Return XFS_ITEM_PINNED so that
> + * the caller will eventually flush the log. This should help in getting the
> + * ATTRI out of the AIL.
> + */
> +STATIC uint
> +xfs_attri_item_push(
> + struct xfs_log_item *lip,
> + struct list_head *buffer_list)
> +{
> + return XFS_ITEM_PINNED;
> +}
> +
> +/*
> + * The ATTRI has been either committed or aborted if the transaction has been
> + * cancelled. If the transaction was cancelled, an ATTRD isn't going to be
> + * constructed and thus we free the ATTRI here directly.
> + */
> +STATIC void
> +xfs_attri_item_unlock(
> + struct xfs_log_item *lip)
> +{
> + if (lip->li_flags & XFS_LI_ABORTED)
> + xfs_attri_release(ATTRI_ITEM(lip));
> +}
> +
> +/*
> + * The ATTRI is logged only once and cannot be moved in the log, so simply
> + * return the lsn at which it's been logged.
> + */
> +STATIC xfs_lsn_t
> +xfs_attri_item_committed(
> + struct xfs_log_item *lip,
> + xfs_lsn_t lsn)
> +{
> + return lsn;
> +}
> +
> +STATIC void
> +xfs_attri_item_committing(
> + struct xfs_log_item *lip,
> + xfs_lsn_t lsn)
> +{
> +}
> +
> +/*
> + * This is the ops vector shared by all attri log items.
> + */
> +static const struct xfs_item_ops xfs_attri_item_ops = {
> + .iop_size = xfs_attri_item_size,
> + .iop_format = xfs_attri_item_format,
> + .iop_pin = xfs_attri_item_pin,
> + .iop_unpin = xfs_attri_item_unpin,
> + .iop_unlock = xfs_attri_item_unlock,
> + .iop_committed = xfs_attri_item_committed,
> + .iop_push = xfs_attri_item_push,
> + .iop_committing = xfs_attri_item_committing
> +};
> +
> +
> +/*
> + * Allocate and initialize an attri item
> + */
> +struct xfs_attri_log_item *
> +xfs_attri_init(
> + struct xfs_mount *mp)
> +
> +{
> + struct xfs_attri_log_item *attrip;
> + uint size;
> +
> + size = (uint)(sizeof(struct xfs_attri_log_item));
> + attrip = kmem_zalloc(size, KM_SLEEP);
> +
> + xfs_log_item_init(mp, &(attrip->item), XFS_LI_ATTRI,
> + &xfs_attri_item_ops);
> + attrip->format.alfi_id = (uintptr_t)(void *)attrip;
> + atomic_set(&attrip->refcount, 2);
> +
> + return attrip;
> +}
> +
> +/*
> + * Copy an attr format buffer from the given buf, and into the destination
> + * attr format structure.
> + */
> +int
> +xfs_attri_copy_format(struct xfs_log_iovec *buf,
> + struct xfs_attri_log_format *dst_attr_fmt)
> +{
> + struct xfs_attri_log_format *src_attr_fmt = buf->i_addr;
> + uint len = sizeof(struct xfs_attri_log_format);
> +
> + if (buf->i_len == len) {
> + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
> + return 0;
> + }
> + return -EFSCORRUPTED;
> +}
> +
> +/*
> + * Copy an attr format buffer from the given buf, and into the destination
> + * attr format structure.
> + */
> +int
> +xfs_attrd_copy_format(struct xfs_log_iovec *buf,
> + struct xfs_attrd_log_format *dst_attr_fmt)
> +{
> + struct xfs_attrd_log_format *src_attr_fmt = buf->i_addr;
> + uint len = sizeof(struct xfs_attrd_log_format);
> +
> + if (buf->i_len == len) {
> + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
> + return 0;
> + }
> + return -EFSCORRUPTED;
> +}
> +
> +/*
> + * Freeing the attrip requires that we remove it from the AIL if it has already
> + * been placed there. However, the ATTRI may not yet have been placed in the AIL
> + * when called by xfs_attri_release() from ATTRD processing due to the ordering of
> + * committed vs unpin operations in bulk insert operations. Hence the reference
> + * count to ensure only the last caller frees the ATTRI.
> + */
> +void
> +xfs_attri_release(
> + struct xfs_attri_log_item *attrip)
> +{
> + ASSERT(atomic_read(&attrip->refcount) > 0);
> + if (atomic_dec_and_test(&attrip->refcount)) {
> + xfs_trans_ail_remove(&attrip->item, SHUTDOWN_LOG_IO_ERROR);
> + xfs_attri_item_free(attrip);
> + }
> +}
> +
Looks like minor whitespace damage on the line above.
> +static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip)
> +{
> + return container_of(lip, struct xfs_attrd_log_item, item);
> +}
> +
> +STATIC void
> +xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp)
> +{
> + kmem_free(attrdp->item.li_lv_shadow);
> + kmem_free(attrdp);
> +}
> +
> +/*
> + * This returns the number of iovecs needed to log the given attrd item.
> + * We only need 1 iovec for an attrd item. It just logs the attr_log_format
> + * structure.
> + */
> +static inline int
> +xfs_attrd_item_sizeof(
> + struct xfs_attrd_log_item *attrdp)
> +{
> + return sizeof(struct xfs_attrd_log_format);
> +}
> +
> +STATIC void
> +xfs_attrd_item_size(
> + struct xfs_log_item *lip,
> + int *nvecs,
> + int *nbytes)
> +{
> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> + *nvecs += 1;
> + *nbytes += xfs_attrd_item_sizeof(attrdp);
> +
> + if (attrdp->name_len > 0) {
> + *nvecs += 1;
> + nbytes += attrdp->name_len;
> + }
> +
> + if (attrdp->value_len > 0) {
> + *nvecs += 1;
> + nbytes += attrdp->value_len;
> + }
I don't think you need to incorporate the name/value lengths in the size
of the done item. The done item already refers to the intent item. The
purpose of the iop_size() call is to help the log infrastructure size
the vectors required for writing to the log, and as the
attrd_item_format() call shows below, we only format the vector with the
xfs_attrd_log_format.
> +}
> +
> +/*
> + * This is called to fill in the vector of log iovecs for the
> + * given attrd log item. We use only 1 iovec, and we point that
> + * at the attr_log_format structure embedded in the attrd item.
> + * It is at this point that we assert that all of the attr
> + * slots in the attrd item have been filled.
> + */
> +STATIC void
> +xfs_attrd_item_format(
> + struct xfs_log_item *lip,
> + struct xfs_log_vec *lv)
> +{
> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> + struct xfs_log_iovec *vecp = NULL;
> +
> + attrdp->format.alfd_type = XFS_LI_ATTRD;
> + attrdp->format.alfd_size = 1;
> +
> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT,
> + &attrdp->format,
> + xfs_attrd_item_sizeof(attrdp));
> +}
> +
> +/*
> + * Pinning has no meaning for an attrd item, so just return.
> + */
> +STATIC void
> +xfs_attrd_item_pin(
> + struct xfs_log_item *lip)
> +{
> +}
> +
> +/*
> + * Since pinning has no meaning for an attrd item, unpinning does
> + * not either.
> + */
> +STATIC void
> +xfs_attrd_item_unpin(
> + struct xfs_log_item *lip,
> + int remove)
> +{
> +}
> +
> +/*
> + * There isn't much you can do to push on an attrd item. It is simply stuck
> + * waiting for the log to be flushed to disk.
> + */
> +STATIC uint
> +xfs_attrd_item_push(
> + struct xfs_log_item *lip,
> + struct list_head *buffer_list)
> +{
> + return XFS_ITEM_PINNED;
> +}
> +
> +/*
> + * The ATTRD is either committed or aborted if the transaction is cancelled. If
> + * the transaction is cancelled, drop our reference to the ATTRI and free the
> + * ATTRD.
> + */
> +STATIC void
> +xfs_attrd_item_unlock(
> + struct xfs_log_item *lip)
> +{
> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> +
> + if (lip->li_flags & XFS_LI_ABORTED) {
> + xfs_attri_release(attrdp->attrip);
> + xfs_attrd_item_free(attrdp);
> + }
> +}
> +
> +/*
> + * When the attrd item is committed to disk, all we need to do is delete our
> + * reference to our partner attri item and then free ourselves. Since we're
> + * freeing ourselves we must return -1 to keep the transaction code from
> + * further referencing this item.
> + */
> +STATIC xfs_lsn_t
> +xfs_attrd_item_committed(
> + struct xfs_log_item *lip,
> + xfs_lsn_t lsn)
> +{
> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> +
> + /*
> + * Drop the ATTRI reference regardless of whether the ATTRD has been
> + * aborted. Once the ATTRD transaction is constructed, it is the sole
> + * responsibility of the ATTRD to release the ATTRI (even if the ATTRI
> + * is aborted due to log I/O error).
> + */
> + xfs_attri_release(attrdp->attrip);
> + xfs_attrd_item_free(attrdp);
> +
> + return (xfs_lsn_t)-1;
> +}
> +
> +STATIC void
> +xfs_attrd_item_committing(
> + struct xfs_log_item *lip,
> + xfs_lsn_t lsn)
> +{
> +}
> +
> +/*
> + * This is the ops vector shared by all attrd log items.
> + */
> +static const struct xfs_item_ops xfs_attrd_item_ops = {
> + .iop_size = xfs_attrd_item_size,
> + .iop_format = xfs_attrd_item_format,
> + .iop_pin = xfs_attrd_item_pin,
> + .iop_unpin = xfs_attrd_item_unpin,
> + .iop_unlock = xfs_attrd_item_unlock,
> + .iop_committed = xfs_attrd_item_committed,
> + .iop_push = xfs_attrd_item_push,
> + .iop_committing = xfs_attrd_item_committing
> +};
> +
> +/*
> + * Allocate and initialize an attrd item
> + */
> +struct xfs_attrd_log_item *
> +xfs_attrd_init(
> + struct xfs_mount *mp,
> + struct xfs_attri_log_item *attrip)
> +
> +{
> + struct xfs_attrd_log_item *attrdp;
> + uint size;
> +
> + size = (uint)(sizeof(struct xfs_attrd_log_item));
> + attrdp = kmem_zalloc(size, KM_SLEEP);
> +
> + xfs_log_item_init(mp, &attrdp->item, XFS_LI_ATTRD,
> + &xfs_attrd_item_ops);
> + attrdp->attrip = attrip;
> + attrdp->format.alfd_alf_id = attrip->format.alfi_id;
> +
> + return attrdp;
> +}
> +
> +/*
> + * Process an attr intent item that was recovered from
> + * the log. We need to delete the attr that it describes.
> + */
> +int
> +xfs_attri_recover(
> + struct xfs_mount *mp,
> + struct xfs_attri_log_item *attrip,
> + struct xfs_defer_ops *dfops)
> +{
> + struct xfs_inode *ip;
> + struct xfs_attrd_log_item *attrdp;
> + struct xfs_trans *tp;
> + int error = 0;
> + struct xfs_attri_log_format *attrp;
> +
> + ASSERT(!test_bit(XFS_ATTRI_RECOVERED, &attrip->flags));
> +
> + /*
> + * First check the validity of the attr described by the
> + * ATTRI. If any are bad, then assume that all are bad and
> + * just toss the ATTRI.
> + */
> + attrp = &attrip->format;
> + if (
> + /*
> + * Must have either XFS_ATTR_OP_FLAGS_SET or
> + * XFS_ATTR_OP_FLAGS_REMOVE set
> + */
> + !(attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET ||
> + attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE) ||
> +
> + /* Check size of value and name lengths */
> + (attrp->alfi_value_len > XATTR_SIZE_MAX ||
> + attrp->alfi_name_len > XATTR_NAME_MAX) ||
> +
> + /*
> + * If the XFS_ATTR_OP_FLAGS_SET flag is set,
> + * there must also be a name and value
> + */
> + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET &&
> + (attrp->alfi_value_len == 0 || attrp->alfi_name_len == 0)) ||
> +
> + /*
> + * If the XFS_ATTR_OP_FLAGS_REMOVE flag is set,
> + * there must also be a name
> + */
> + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE &&
> + (attrp->alfi_name_len == 0))
> + ) {
> + /*
> + * This will pull the ATTRI from the AIL and
> + * free the memory associated with it.
> + */
> + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
> + xfs_attri_release(attrip);
> + return -EIO;
> + }
> +
> + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
> + if (error)
> + return error;
> + attrdp = xfs_trans_get_attrd(tp, attrip);
> + attrp = &attrip->format;
> +
> + error = xfs_iget(mp, tp, attrp->alfi_ino, 0, 0, &ip);
> + if (error)
> + return error;
> +
> + xfs_ilock(ip, XFS_ILOCK_EXCL);
> +
> + error = xfs_trans_attr(tp, dfops, attrdp, ip,
> + attrp->alfi_op_flags,
> + attrp->alfi_attr_flags,
> + attrp->alfi_name_len,
> + attrp->alfi_value_len,
> + attrip->name,
> + attrip->value);
> + if (error)
> + goto abort_error;
> +
> +
> + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
> + error = xfs_trans_commit(tp);
> + xfs_iunlock(ip, XFS_ILOCK_EXCL);
> + return error;
> +
> +abort_error:
> + xfs_trans_cancel(tp);
> + xfs_iunlock(ip, XFS_ILOCK_EXCL);
> + return error;
> +}
> diff --git a/fs/xfs/xfs_attr_item.h b/fs/xfs/xfs_attr_item.h
> new file mode 100644
> index 0000000..184e6b1
> --- /dev/null
> +++ b/fs/xfs/xfs_attr_item.h
> @@ -0,0 +1,120 @@
> +/*
> + * Copyright (c) 2017 Oracle, Inc.
> + * All Rights Reserved.
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it would be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write the Free Software Foundation Inc.
> + */
> +#ifndef __XFS_ATTR_ITEM_H__
> +#define __XFS_ATTR_ITEM_H__
> +
> +/* kernel only ATTRI/ATTRD definitions */
> +
> +struct xfs_mount;
> +struct kmem_zone;
> +
> +/*
> + * Max number of attrs in fast allocation path.
> + */
> +#define XFS_ATTRI_MAX_FAST_ATTRS 1
> +
> +
> +/*
> + * Define ATTR flag bits. Manipulated by set/clear/test_bit operators.
> + */
> +#define XFS_ATTRI_RECOVERED 1
> +
> +
> +/* nvecs must be in multiples of 4 */
Why? Can you expand on the comment here? Also, any reason not to just
use round_up()?
> +#define ATTR_NVEC_SIZE(size) (size == sizeof(int32_t) ? sizeof(int32_t) : \
> + size + sizeof(int32_t) - \
> + (size % sizeof(int32_t)))
> +
> +/*
> + * This is the "attr intention" log item. It is used to log the fact
> + * that some attrs need to be processed. It is used in conjunction with the
> + * "attr done" log item described below.
> + *
> + * The ATTRI is reference counted so that it is not freed prior to both the
> + * ATTRI and ATTRD being committed and unpinned. This ensures the ATTRI is
> + * inserted into the AIL even in the event of out of order ATTRI/ATTRD
> + * processing. In other words, an ATTRI is born with two references:
> + *
> + * 1.) an ATTRI held reference to track ATTRI AIL insertion
> + * 2.) an ATTRD held reference to track ATTRD commit
> + *
> + * On allocation, both references are the responsibility of the caller. Once
> + * the ATTRI is added to and dirtied in a transaction, ownership of reference
> + * one transfers to the transaction. The reference is dropped once the ATTRI is
> + * inserted to the AIL or in the event of failure along the way (e.g., commit
> + * failure, log I/O error, etc.). Note that the caller remains responsible for
> + * the ATTRD reference under all circumstances to this point. The caller has no
> + * means to detect failure once the transaction is committed, however.
> + * Therefore, an ATTRD is required after this point, even in the event of
> + * unrelated failure.
> + *
> + * Once an ATTRD is allocated and dirtied in a transaction, reference two
> + * transfers to the transaction. The ATTRD reference is dropped once it reaches
> + * the unpin handler. Similar to the ATTRI, the reference also drops in the
> + * event of commit failure or log I/O errors. Note that the ATTRD is not
> + * inserted in the AIL, so at this point both the ATTI and ATTRD are freed.
> + */
> +struct xfs_attri_log_item {
> + xfs_log_item_t item;
> + atomic_t refcount;
> + unsigned long flags; /* misc flags */
> + int name_len;
> + void *name;
> + int value_len;
Do we need the name and value lengths here (and in the attrd) if they
also exist in the xfs_attri_log_format?
> + void *value;
> + struct xfs_attri_log_format format;
> +};
> +
> +/*
> + * This is the "attr done" log item. It is used to log
> + * the fact that some attrs earlier mentioned in an attri item
> + * have been freed.
> + */
> +struct xfs_attrd_log_item {
> + struct xfs_log_item item;
> + struct xfs_attri_log_item *attrip;
> + uint next_attr;
This doesn't seem to be used. Holdover from one of the other log_item
types perhaps?
> + int name_len;
> + void *name;
> + int value_len;
> + void *value;
> + struct xfs_attrd_log_format format;
> +};
> +
> +/*
> + * Max number of attrs in fast allocation path.
> + */
> +#define XFS_ATTRD_MAX_FAST_ATTRS 1
> +
> +extern struct kmem_zone *xfs_attri_zone;
> +extern struct kmem_zone *xfs_attrd_zone;
> +
> +struct xfs_attri_log_item *xfs_attri_init(struct xfs_mount *mp);
> +struct xfs_attrd_log_item *xfs_attrd_init(struct xfs_mount *mp,
> + struct xfs_attri_log_item *attrip);
> +int xfs_attri_copy_format(struct xfs_log_iovec *buf,
> + struct xfs_attri_log_format *dst_attri_fmt);
> +int xfs_attrd_copy_format(struct xfs_log_iovec *buf,
> + struct xfs_attrd_log_format *dst_attrd_fmt);
> +void xfs_attri_item_free(struct xfs_attri_log_item *attrip);
> +void xfs_attri_release(struct xfs_attri_log_item *attrip);
> +
> +int xfs_attri_recover(struct xfs_mount *mp,
> + struct xfs_attri_log_item *attrip,
> + struct xfs_defer_ops *dfops);
> +
> +#endif /* __XFS_ATTR_ITEM_H__ */
> diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
> index 2b2383f..b34e7f8 100644
> --- a/fs/xfs/xfs_log_recover.c
> +++ b/fs/xfs/xfs_log_recover.c
> @@ -34,6 +34,7 @@
> #include "xfs_log_recover.h"
> #include "xfs_inode_item.h"
> #include "xfs_extfree_item.h"
> +#include "xfs_attr_item.h"
> #include "xfs_trans_priv.h"
> #include "xfs_alloc.h"
> #include "xfs_ialloc.h"
> @@ -1967,6 +1968,8 @@ xlog_recover_reorder_trans(
> case XFS_LI_CUD:
> case XFS_LI_BUI:
> case XFS_LI_BUD:
> + case XFS_LI_ATTRI:
> + case XFS_LI_ATTRD:
> trace_xfs_log_recover_item_reorder_tail(log,
> trans, item, pass);
> list_move_tail(&item->ri_list, &inode_list);
> @@ -3497,6 +3500,117 @@ xlog_recover_efd_pass2(
> return 0;
> }
>
> +STATIC int
> +xlog_recover_attri_pass2(
> + struct xlog *log,
> + struct xlog_recover_item *item,
> + xfs_lsn_t lsn)
> +{
> + int error;
> + struct xfs_mount *mp = log->l_mp;
> + struct xfs_attri_log_item *attrip;
> + struct xfs_attri_log_format *attri_formatp;
> + char *name = NULL;
> + char *value = NULL;
> + int region = 0;
> +
> + attri_formatp = item->ri_buf[region].i_addr;
> +
> + attrip = xfs_attri_init(mp);
> + error = xfs_attri_copy_format(&item->ri_buf[region], &attrip->format);
> + if (error) {
> + xfs_attri_item_free(attrip);
> + return error;
> + }
> +
> + attrip->name_len = attri_formatp->alfi_name_len;
> + attrip->value_len = attri_formatp->alfi_value_len;
> + attrip = kmem_realloc(attrip, sizeof(struct xfs_attri_log_item) +
> + attrip->name_len + attrip->value_len, KM_SLEEP);
> +
> + if (attrip->name_len > 0) {
> + region++;
> + name = ((char *)attrip) + sizeof(struct xfs_attri_log_item);
> + memcpy(name, item->ri_buf[region].i_addr,
> + attrip->name_len);
> + attrip->name = name;
> + }
> +
> + if (attrip->value_len > 0) {
> + region++;
> + value = ((char *)attrip) + sizeof(struct xfs_attri_log_item) +
> + attrip->name_len;
> + memcpy(value, item->ri_buf[region].i_addr,
> + attrip->value_len);
> + attrip->value = value;
> + }
> +
> + spin_lock(&log->l_ailp->ail_lock);
> + /*
> + * The ATTRI has two references. One for the ATTRD and one for ATTRI to
> + * ensure it makes it into the AIL. Insert the ATTRI into the AIL
> + * directly and drop the ATTRI reference. Note that
> + * xfs_trans_ail_update() drops the AIL lock.
> + */
> + xfs_trans_ail_update(log->l_ailp, &attrip->item, lsn);
> + xfs_attri_release(attrip);
> + return 0;
> +}
> +
> +
> +/*
> + * This routine is called when an ATTRD format structure is found in a committed
> + * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
> + * it was still in the log. To do this it searches the AIL for the ATTRI with
> + * an id equal to that in the ATTRD format structure. If we find it we drop
> + * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
> + */
> +STATIC int
> +xlog_recover_attrd_pass2(
> + struct xlog *log,
> + struct xlog_recover_item *item)
> +{
> + struct xfs_attrd_log_format *attrd_formatp;
> + struct xfs_attri_log_item *attrip = NULL;
> + struct xfs_log_item *lip;
> + uint64_t attri_id;
> + struct xfs_ail_cursor cur;
> + struct xfs_ail *ailp = log->l_ailp;
> +
> + attrd_formatp = item->ri_buf[0].i_addr;
> + ASSERT((item->ri_buf[0].i_len ==
> + (sizeof(struct xfs_attrd_log_format))));
> + attri_id = attrd_formatp->alfd_alf_id;
> +
> + /*
> + * Search for the ATTRI with the id in the ATTRD format structure in the
> + * AIL.
> + */
> + spin_lock(&ailp->ail_lock);
> + lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
> + while (lip != NULL) {
> + if (lip->li_type == XFS_LI_ATTRI) {
> + attrip = (struct xfs_attri_log_item *)lip;
> + if (attrip->format.alfi_id == attri_id) {
> + /*
> + * Drop the ATTRD reference to the ATTRI. This
> + * removes the ATTRI from the AIL and frees it.
> + */
> + spin_unlock(&ailp->ail_lock);
> + xfs_attri_release(attrip);
> + spin_lock(&ailp->ail_lock);
> + break;
> + }
> + }
> + lip = xfs_trans_ail_cursor_next(ailp, &cur);
> + }
> +
> + xfs_trans_ail_cursor_done(&cur);
> + spin_unlock(&ailp->ail_lock);
> +
> + return 0;
> +}
> +
> /*
> * This routine is called to create an in-core extent rmap update
> * item from the rui format structure which was logged on disk.
> @@ -4050,6 +4164,8 @@ xlog_recover_ra_pass2(
> break;
> case XFS_LI_EFI:
> case XFS_LI_EFD:
> + case XFS_LI_ATTRI:
> + case XFS_LI_ATTRD:
> case XFS_LI_QUOTAOFF:
> case XFS_LI_RUI:
> case XFS_LI_RUD:
> @@ -4078,6 +4194,8 @@ xlog_recover_commit_pass1(
> case XFS_LI_INODE:
> case XFS_LI_EFI:
> case XFS_LI_EFD:
> + case XFS_LI_ATTRI:
> + case XFS_LI_ATTRD:
> case XFS_LI_DQUOT:
> case XFS_LI_ICREATE:
> case XFS_LI_RUI:
> @@ -4116,6 +4234,10 @@ xlog_recover_commit_pass2(
> return xlog_recover_efi_pass2(log, item, trans->r_lsn);
> case XFS_LI_EFD:
> return xlog_recover_efd_pass2(log, item);
> + case XFS_LI_ATTRI:
> + return xlog_recover_attri_pass2(log, item, trans->r_lsn);
> + case XFS_LI_ATTRD:
> + return xlog_recover_attrd_pass2(log, item);
> case XFS_LI_RUI:
> return xlog_recover_rui_pass2(log, item, trans->r_lsn);
> case XFS_LI_RUD:
> @@ -4677,6 +4799,49 @@ xlog_recover_cancel_efi(
> spin_lock(&ailp->ail_lock);
> }
>
> +/* Release the ATTRI since we're cancelling everything. */
> +STATIC void
> +xlog_recover_cancel_attri(
> + struct xfs_mount *mp,
> + struct xfs_ail *ailp,
> + struct xfs_log_item *lip)
> +{
> + struct xfs_attri_log_item *attrip;
> +
> + attrip = container_of(lip, struct xfs_attri_log_item, item);
> +
> + spin_unlock(&ailp->ail_lock);
> + xfs_attri_release(attrip);
> + spin_lock(&ailp->ail_lock);
> +}
> +
> +
> +/* Recover the ATTRI if necessary. */
> +STATIC int
> +xlog_recover_process_attri(
> + struct xfs_mount *mp,
> + struct xfs_ail *ailp,
> + struct xfs_log_item *lip,
> + struct xfs_defer_ops *dfops)
> +{
> + struct xfs_attri_log_item *attrip;
> + int error;
> +
> + /*
> + * Skip ATTRIs that we've already processed.
> + */
> + attrip = container_of(lip, struct xfs_attri_log_item, item);
> + if (test_bit(XFS_ATTRI_RECOVERED, &attrip->flags))
> + return 0;
> +
> + spin_unlock(&ailp->ail_lock);
> + error = xfs_attri_recover(mp, attrip, dfops);
> + spin_lock(&ailp->ail_lock);
> +
> + return error;
> +}
> +
> +
> /* Recover the RUI if necessary. */
> STATIC int
> xlog_recover_process_rui(
> @@ -4807,6 +4972,7 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
> case XFS_LI_RUI:
> case XFS_LI_CUI:
> case XFS_LI_BUI:
> + case XFS_LI_ATTRI:
> return true;
> default:
> return false;
> @@ -4920,6 +5086,10 @@ xlog_recover_process_intents(
> case XFS_LI_EFI:
> error = xlog_recover_process_efi(log->l_mp, ailp, lip);
> break;
> + case XFS_LI_ATTRI:
> + error = xlog_recover_process_attri(log->l_mp,
> + ailp, lip, &dfops);
> + break;
> case XFS_LI_RUI:
> error = xlog_recover_process_rui(log->l_mp, ailp, lip);
> break;
> @@ -4989,6 +5159,9 @@ xlog_recover_cancel_intents(
> case XFS_LI_BUI:
> xlog_recover_cancel_bui(log->l_mp, ailp, lip);
> break;
> + case XFS_LI_ATTRI:
> + xlog_recover_cancel_attri(log->l_mp, ailp, lip);
> + break;
> }
>
> lip = xfs_trans_ail_cursor_next(ailp, &cur);
> diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
> index 0492436..3723d50 100644
> --- a/fs/xfs/xfs_ondisk.h
> +++ b/fs/xfs/xfs_ondisk.h
> @@ -137,6 +137,8 @@ xfs_check_ondisk_structs(void)
> XFS_CHECK_STRUCT_SIZE(struct xfs_inode_log_format, 56);
> XFS_CHECK_STRUCT_SIZE(struct xfs_qoff_logformat, 20);
> XFS_CHECK_STRUCT_SIZE(struct xfs_trans_header, 16);
> + XFS_CHECK_STRUCT_SIZE(struct xfs_attri_log_format, 40);
> + XFS_CHECK_STRUCT_SIZE(struct xfs_attrd_log_format, 16);
> }
>
> #endif /* __XFS_ONDISK_H */
> diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
> index d714240..dce3baf 100644
> --- a/fs/xfs/xfs_super.c
> +++ b/fs/xfs/xfs_super.c
> @@ -2077,6 +2077,7 @@ init_xfs_fs(void)
> xfs_rmap_update_init_defer_op();
> xfs_refcount_update_init_defer_op();
> xfs_bmap_update_init_defer_op();
> + xfs_attr_init_defer_op();
>
> xfs_dir_startup();
>
> diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
> index 9d542df..deaae6b 100644
> --- a/fs/xfs/xfs_trans.h
> +++ b/fs/xfs/xfs_trans.h
> @@ -40,6 +40,9 @@ struct xfs_cud_log_item;
> struct xfs_defer_ops;
> struct xfs_bui_log_item;
> struct xfs_bud_log_item;
> +struct xfs_attrd_log_item;
> +struct xfs_attri_log_item;
> +
>
> typedef struct xfs_log_item {
> struct list_head li_ail; /* AIL pointers */
> @@ -223,12 +226,23 @@ void xfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
> void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
>
> void xfs_extent_free_init_defer_op(void);
> +void xfs_attr_init_defer_op(void);
> +
> struct xfs_efd_log_item *xfs_trans_get_efd(struct xfs_trans *,
> struct xfs_efi_log_item *,
> uint);
> int xfs_trans_free_extent(struct xfs_trans *,
> struct xfs_efd_log_item *, xfs_fsblock_t,
> xfs_extlen_t, struct xfs_owner_info *);
> +struct xfs_attrd_log_item *
> +xfs_trans_get_attrd(struct xfs_trans *tp,
> + struct xfs_attri_log_item *attrip);
> +int xfs_trans_attr(struct xfs_trans *tp, struct xfs_defer_ops *dfops,
> + struct xfs_attrd_log_item *attrdp,
> + struct xfs_inode *ip, uint32_t attr_op_flags,
> + uint32_t flags, uint32_t name_len, uint32_t value_len,
> + char *name, char *value);
> +
> int xfs_trans_commit(struct xfs_trans *);
> int xfs_trans_roll(struct xfs_trans **);
> int xfs_trans_roll_inode(struct xfs_trans **, struct xfs_inode *);
> diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
> new file mode 100644
> index 0000000..7296414
> --- /dev/null
> +++ b/fs/xfs/xfs_trans_attr.c
> @@ -0,0 +1,285 @@
> +/*
> + * Copyright (c) 2017, Oracle Inc.
> + * All Rights Reserved.
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it would be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write the Free Software Foundation Inc.
> + */
> +#include "xfs.h"
> +#include "xfs_fs.h"
> +#include "xfs_shared.h"
> +#include "xfs_format.h"
> +#include "xfs_log_format.h"
> +#include "xfs_trans_resv.h"
> +#include "xfs_bit.h"
> +#include "xfs_mount.h"
> +#include "xfs_defer.h"
> +#include "xfs_trans.h"
> +#include "xfs_trans_priv.h"
> +#include "xfs_attr_item.h"
> +#include "xfs_alloc.h"
> +#include "xfs_bmap.h"
> +#include "xfs_trace.h"
> +#include "libxfs/xfs_da_format.h"
> +#include "xfs_da_btree.h"
> +#include "xfs_attr.h"
> +#include "xfs_inode.h"
> +#include "xfs_icache.h"
> +#include "xfs_quota.h"
> +
> +/*
> + * This routine is called to allocate an "extent free done"
> + * log item that will hold nextents worth of extents. The
> + * caller must use all nextents extents, because we are not
> + * flexible about this at all.
> + */
Stale comment...
Also, the use of the variable name "free" throughout this file for the
xfs_attr_item is a bit of an ugly holdover from (I'm guessing) the
extent free code. attr or something of that nature might be more
relevant.
Brian
> +struct xfs_attrd_log_item *
> +xfs_trans_get_attrd(struct xfs_trans *tp,
> + struct xfs_attri_log_item *attrip)
> +{
> + struct xfs_attrd_log_item *attrdp;
> +
> + ASSERT(tp != NULL);
> +
> + attrdp = xfs_attrd_init(tp->t_mountp, attrip);
> + ASSERT(attrdp != NULL);
> +
> + /*
> + * Get a log_item_desc to point at the new item.
> + */
> + xfs_trans_add_item(tp, &attrdp->item);
> + return attrdp;
> +}
> +
> +/*
> + * Delete an attr and log it to the ATTRD. Note that the transaction is marked
> + * dirty regardless of whether the attr delete succeeds or fails to support the
> + * ATTRI/ATTRD lifecycle rules.
> + */
> +int
> +xfs_trans_attr(
> + struct xfs_trans *tp,
> + struct xfs_defer_ops *dfops,
> + struct xfs_attrd_log_item *attrdp,
> + struct xfs_inode *ip,
> + uint32_t op_flags,
> + uint32_t flags,
> + uint32_t name_len,
> + uint32_t value_len,
> + char *name,
> + char *value)
> +{
> + int error;
> + int local;
> + struct xfs_da_args args;
> + xfs_fsblock_t firstblock = NULLFSBLOCK;
> + struct xfs_buf *leaf_bp = NULL;
> +
> + error = xfs_attr_args_init(&args, ip, name, flags);
> + if (error)
> + goto out;
> +
> + args.name = name;
> + args.namelen = name_len;
> + args.hashval = xfs_da_hashname(args.name, args.namelen);
> + args.value = value;
> + args.valuelen = value_len;
> + args.dfops = dfops;
> + args.firstblock = &firstblock;
> + args.op_flags = XFS_DA_OP_OKNOENT;
> + args.total = xfs_attr_calc_size(&args, &local);
> + args.trans = tp;
> + ASSERT(local);
> +
> + error = xfs_qm_dqattach_locked(ip, 0);
> + if (error)
> + return error;
> +
> + xfs_trans_ijoin(args.trans, ip, 0);
> + switch (op_flags) {
> + case XFS_ATTR_OP_FLAGS_SET:
> + args.op_flags |= XFS_DA_OP_ADDNAME;
> + error = xfs_attr_set_args(&args, flags,
> + leaf_bp, false);
> + break;
> + case XFS_ATTR_OP_FLAGS_REMOVE:
> + ASSERT(XFS_IFORK_Q((ip)));
> + error = xfs_attr_remove_args(&args, flags, false);
> + break;
> + default:
> + error = -EFSCORRUPTED;
> + }
> +
> +out:
> + if (error) {
> + if (leaf_bp)
> + xfs_trans_brelse(args.trans, leaf_bp);
> + }
> +
> + /*
> + * Mark the transaction dirty, even on error. This ensures the
> + * transaction is aborted, which:
> + *
> + * 1.) releases the ATTRI and frees the ATTRD
> + * 2.) shuts down the filesystem
> + */
> + tp->t_flags |= XFS_TRANS_DIRTY;
> + attrdp->item.li_desc->lid_flags |= XFS_LID_DIRTY;
> + attrdp->name = name;
> + attrdp->value = value;
> + attrdp->name_len = name_len;
> + attrdp->value_len = value_len;
> + attrdp->next_attr++;
> +
> + attrdp->attrip->name = name;
> + attrdp->attrip->value = value;
> + attrdp->attrip->name_len = name_len;
> + attrdp->attrip->value_len = value_len;
> +
> + return error;
> +}
> +
> +static int
> +xfs_attr_diff_items(
> + void *priv,
> + struct list_head *a,
> + struct list_head *b)
> +{
> + return 0;
> +}
> +
> +/* Get an ATTRI. */
> +STATIC void *
> +xfs_attr_create_intent(
> + struct xfs_trans *tp,
> + unsigned int count)
> +{
> + struct xfs_attri_log_item *attrip;
> +
> + ASSERT(tp != NULL);
> + ASSERT(count == 1);
> +
> + attrip = xfs_attri_init(tp->t_mountp);
> + ASSERT(attrip != NULL);
> +
> + /*
> + * Get a log_item_desc to point at the new item.
> + */
> + xfs_trans_add_item(tp, &attrip->item);
> + return attrip;
> +}
> +
> +/* Log an attr to the intent item. */
> +STATIC void
> +xfs_attr_log_item(
> + struct xfs_trans *tp,
> + void *intent,
> + struct list_head *item)
> +{
> + struct xfs_attri_log_item *attrip = intent;
> + struct xfs_attr_item *free;
> + struct xfs_attri_log_format *attrp;
> + char *name_value;
> +
> + free = container_of(item, struct xfs_attr_item, xattri_list);
> + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
> +
> + tp->t_flags |= XFS_TRANS_DIRTY;
> + attrip->item.li_desc->lid_flags |= XFS_LID_DIRTY;
> +
> + attrp = &attrip->format;
> + attrp->alfi_ino = free->xattri_ip->i_ino;
> + attrp->alfi_op_flags = free->xattri_op_flags;
> + attrp->alfi_value_len = free->xattri_value_len;
> + attrp->alfi_name_len = free->xattri_name_len;
> + attrp->alfi_attr_flags = free->xattri_flags;
> +
> + attrip->name = name_value;
> + attrip->value = &name_value[free->xattri_name_len];
> + attrip->name_len = free->xattri_name_len;
> + attrip->value_len = free->xattri_value_len;
> +}
> +
> +/* Get an ATTRD so we can process all the attrs. */
> +STATIC void *
> +xfs_attr_create_done(
> + struct xfs_trans *tp,
> + void *intent,
> + unsigned int count)
> +{
> + return xfs_trans_get_attrd(tp, intent);
> +}
> +
> +/* Process an attr. */
> +STATIC int
> +xfs_attr_finish_item(
> + struct xfs_trans *tp,
> + struct xfs_defer_ops *dop,
> + struct list_head *item,
> + void *done_item,
> + void **state)
> +{
> + struct xfs_attr_item *free;
> + char *name_value;
> + int error;
> +
> + free = container_of(item, struct xfs_attr_item, xattri_list);
> + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
> + error = xfs_trans_attr(tp, dop, done_item,
> + free->xattri_ip,
> + free->xattri_op_flags,
> + free->xattri_flags,
> + free->xattri_name_len,
> + free->xattri_value_len,
> + name_value,
> + &name_value[free->xattri_name_len]);
> + kmem_free(free);
> + return error;
> +}
> +
> +/* Abort all pending ATTRs. */
> +STATIC void
> +xfs_attr_abort_intent(
> + void *intent)
> +{
> + xfs_attri_release(intent);
> +}
> +
> +/* Cancel an attr */
> +STATIC void
> +xfs_attr_cancel_item(
> + struct list_head *item)
> +{
> + struct xfs_attr_item *free;
> +
> + free = container_of(item, struct xfs_attr_item, xattri_list);
> + kmem_free(free);
> +}
> +
> +static const struct xfs_defer_op_type xfs_attr_defer_type = {
> + .type = XFS_DEFER_OPS_TYPE_ATTR,
> + .max_items = XFS_ATTRI_MAX_FAST_ATTRS,
> + .diff_items = xfs_attr_diff_items,
> + .create_intent = xfs_attr_create_intent,
> + .abort_intent = xfs_attr_abort_intent,
> + .log_item = xfs_attr_log_item,
> + .create_done = xfs_attr_create_done,
> + .finish_item = xfs_attr_finish_item,
> + .cancel_item = xfs_attr_cancel_item,
> +};
> +
> +/* Register the deferred op type. */
> +void
> +xfs_attr_init_defer_op(void)
> +{
> + xfs_defer_init_op_type(&xfs_attr_defer_type);
> +}
> --
> 2.7.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 03/23] xfs: Add trans toggle to attr routines
2018-06-13 12:11 ` Brian Foster
@ 2018-06-14 1:27 ` Allison Henderson
0 siblings, 0 replies; 33+ messages in thread
From: Allison Henderson @ 2018-06-14 1:27 UTC (permalink / raw)
To: Brian Foster; +Cc: linux-xfs
On 06/13/2018 05:11 AM, Brian Foster wrote:
> On Sat, Jun 09, 2018 at 10:04:48PM -0700, Allison Henderson wrote:
>> This patch adds a roll_trans parameter to all attribute routines.
>> Calling functions may pass true to roll transactions as normal,
>> or false to hold them. We will need this later for delayed
>> attribute operations.
>>
>> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
>> ---
>> fs/xfs/libxfs/xfs_attr.c | 165 ++++++++++++++++++++++++------------------
>> fs/xfs/libxfs/xfs_attr_leaf.c | 12 +--
>> fs/xfs/libxfs/xfs_attr_leaf.h | 10 ++-
>> 3 files changed, 108 insertions(+), 79 deletions(-)
>>
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index 1524197..e8cb369 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
>> @@ -55,21 +55,21 @@
>> /*
>> * Internal routines when attribute list fits inside the inode.
>> */
>> -STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>> +STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans);
>>
>> /*
>> * Internal routines when attribute list is one block.
>> */
>> STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>> -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>> -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>> +STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans);
>> +STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans);
>>
>> /*
>> * Internal routines when attribute list is more than one block.
>> */
>> STATIC int xfs_attr_node_get(xfs_da_args_t *args);
>> -STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
>> -STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
>> +STATIC int xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans);
>> +STATIC int xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans);
>> STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
>> STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
>>
>> @@ -207,15 +207,16 @@ STATIC int
>> xfs_attr_try_sf_addname(
>> struct xfs_inode *dp,
>> struct xfs_da_args *args,
>> - int flags)
>> + int flags,
>> + bool roll_trans)
>> {
>>
>> struct xfs_mount *mp = dp->i_mount;
>> int error;
>> int err2;
>>
>> - error = xfs_attr_shortform_addname(args);
>> - if (error != -ENOSPC) {
>> + error = xfs_attr_shortform_addname(args, roll_trans);
>> + if (error != -ENOSPC && roll_trans) {
>
> Doesn't this change behavior beyond committing the transaction or not?
> E.g., we skip the time call that follows if !roll_trans. Would the
> !roll_trans caller know/care about that?
Oh ok, I think you're right, the time call may need to move upwards in
both cases you pointed out. I may not have this patch in the next set
though if I can work out a better solution. But thanks for the catch :-)
Allison
>
>> /*
>> * Commit the shortform mods, and we're done.
>> * NOTE: this is also the error path
>> @@ -335,7 +336,7 @@ xfs_attr_set(
>> * Try to add the attr to the attribute list in
>> * the inode.
>> */
>> - error = xfs_attr_try_sf_addname(dp, &args, flags);
>> + error = xfs_attr_try_sf_addname(dp, &args, flags, true);
>> if (error != -ENOSPC) {
>> xfs_iunlock(dp, XFS_ILOCK_EXCL);
>> return error;
>> @@ -374,9 +375,9 @@ xfs_attr_set(
>> }
>>
>> if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
>> - error = xfs_attr_leaf_addname(&args);
>> + error = xfs_attr_leaf_addname(&args, true);
>> else
>> - error = xfs_attr_node_addname(&args);
>> + error = xfs_attr_node_addname(&args, true);
>> if (error)
>> goto out;
>>
>> @@ -471,11 +472,11 @@ xfs_attr_remove(
>> error = -ENOATTR;
>> } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>> ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>> - error = xfs_attr_shortform_remove(&args);
>> + error = xfs_attr_shortform_remove(&args, true);
>> } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>> - error = xfs_attr_leaf_removename(&args);
>> + error = xfs_attr_leaf_removename(&args, true);
>> } else {
>> - error = xfs_attr_node_removename(&args);
>> + error = xfs_attr_node_removename(&args, true);
>> }
>>
>> if (error)
>> @@ -516,7 +517,7 @@ xfs_attr_remove(
>> * This is the external routine.
>> */
>> STATIC int
>> -xfs_attr_shortform_addname(xfs_da_args_t *args)
>> +xfs_attr_shortform_addname(xfs_da_args_t *args, bool roll_trans)
>> {
>> int newsize, forkoff, retval;
>>
>> @@ -528,7 +529,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
>> } else if (retval == -EEXIST) {
>> if (args->flags & ATTR_CREATE)
>> return retval;
>> - retval = xfs_attr_shortform_remove(args);
>> + retval = xfs_attr_shortform_remove(args, roll_trans);
>> ASSERT(retval == 0);
>> }
>>
>> @@ -543,7 +544,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
>> if (!forkoff)
>> return -ENOSPC;
>>
>> - xfs_attr_shortform_add(args, forkoff);
>> + xfs_attr_shortform_add(args, forkoff, roll_trans);
>> return 0;
>> }
>>
>> @@ -559,7 +560,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
>> * if bmap_one_block() says there is only one block (ie: no remote blks).
>> */
>> STATIC int
>> -xfs_attr_leaf_addname(xfs_da_args_t *args)
>> +xfs_attr_leaf_addname(xfs_da_args_t *args, bool roll_trans)
>> {
>> xfs_inode_t *dp;
>> struct xfs_buf *bp;
>> @@ -622,36 +623,42 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
>> * can manage its own transactions.
>> */
>> xfs_defer_init(args->dfops, args->firstblock);
>> - error = xfs_attr3_leaf_to_node(args);
>> + error = xfs_attr3_leaf_to_node(args, roll_trans);
>> if (error)
>> goto out_defer_cancel;
>> xfs_defer_ijoin(args->dfops, dp);
>> - error = xfs_defer_finish(&args->trans, args->dfops);
>> - if (error)
>> - goto out_defer_cancel;
>> + if (roll_trans) {
>> + error = xfs_defer_finish(&args->trans, args->dfops);
>> + if (error)
>> + goto out_defer_cancel;
>>
>> - /*
>> - * Commit the current trans (including the inode) and start
>> - * a new one.
>> - */
>> - error = xfs_trans_roll_inode(&args->trans, dp);
>> - if (error)
>> - return error;
>> + /*
>> + * Commit the current trans (including the inode) and
>> + * start a new one.
>> + */
>> + error = xfs_trans_roll_inode(&args->trans, dp);
>> + if (error)
>> + return error;
>> + }
>>
>> /*
>> * Fob the whole rest of the problem off on the Btree code.
>> */
>> - error = xfs_attr_node_addname(args);
>> + error = xfs_attr_node_addname(args, roll_trans);
>> +
>> return error;
>> }
>>
>> - /*
>> - * Commit the transaction that added the attr name so that
>> - * later routines can manage their own transactions.
>> - */
>> - error = xfs_trans_roll_inode(&args->trans, dp);
>> - if (error)
>> - return error;
>> +
>> + if (roll_trans) {
>> + /*
>> + * Commit the transaction that added the attr name so that
>> + * later routines can manage their own transactions.
>> + */
>> + error = xfs_trans_roll_inode(&args->trans, dp);
>> + if (error)
>> + return error;
>> + }
>>
>> /*
>> * If there was an out-of-line value, allocate the blocks we
>> @@ -709,9 +716,11 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
>> /*
>> * If the result is small enough, shrink it all into the inode.
>> */
>> - if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
>> + if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
>> + roll_trans) {
>
> Similar here (and one or two other places in the patch).. I haven't
> looked ahead at the follow on code, but it seems a bit strange for a
> "don't roll trans" flag to toggle attr fork behavior.
>
>> xfs_defer_init(args->dfops, args->firstblock);
>> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
>> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
>> + roll_trans);
>> /* bp is gone due to xfs_da_shrink_inode */
>> if (error)
>> goto out_defer_cancel;
>> @@ -745,7 +754,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
>> * if bmap_one_block() says there is only one block (ie: no remote blks).
>> */
>> STATIC int
>> -xfs_attr_leaf_removename(xfs_da_args_t *args)
>> +xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans)
>> {
>> xfs_inode_t *dp;
>> struct xfs_buf *bp;
>> @@ -774,15 +783,19 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
>> * If the result is small enough, shrink it all into the inode.
>> */
>> if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
>> - xfs_defer_init(args->dfops, args->firstblock);
>> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
>> + if (roll_trans)
>> + xfs_defer_init(args->dfops, args->firstblock);
>> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
>> + roll_trans);
>
> While here roll_trans seems to only control the transaction behavior.
> Hm?
>
> Brian
>
>> /* bp is gone due to xfs_da_shrink_inode */
>> if (error)
>> goto out_defer_cancel;
>> xfs_defer_ijoin(args->dfops, dp);
>> - error = xfs_defer_finish(&args->trans, args->dfops);
>> - if (error)
>> - goto out_defer_cancel;
>> + if (roll_trans) {
>> + error = xfs_defer_finish(&args->trans, args->dfops);
>> + if (error)
>> + goto out_defer_cancel;
>> + }
>> }
>> return 0;
>> out_defer_cancel:
>> @@ -837,7 +850,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>> * add a whole extra layer of confusion on top of that.
>> */
>> STATIC int
>> -xfs_attr_node_addname(xfs_da_args_t *args)
>> +xfs_attr_node_addname(xfs_da_args_t *args, bool roll_trans)
>> {
>> xfs_da_state_t *state;
>> xfs_da_state_blk_t *blk;
>> @@ -903,21 +916,24 @@ xfs_attr_node_addname(xfs_da_args_t *args)
>> xfs_da_state_free(state);
>> state = NULL;
>> xfs_defer_init(args->dfops, args->firstblock);
>> - error = xfs_attr3_leaf_to_node(args);
>> + error = xfs_attr3_leaf_to_node(args, roll_trans);
>> if (error)
>> goto out_defer_cancel;
>> xfs_defer_ijoin(args->dfops, dp);
>> - error = xfs_defer_finish(&args->trans, args->dfops);
>> - if (error)
>> - goto out_defer_cancel;
>> -
>> - /*
>> - * Commit the node conversion and start the next
>> - * trans in the chain.
>> - */
>> - error = xfs_trans_roll_inode(&args->trans, dp);
>> - if (error)
>> - goto out;
>> + if (roll_trans) {
>> + error = xfs_defer_finish(&args->trans,
>> + args->dfops);
>> + if (error)
>> + goto out_defer_cancel;
>> +
>> + /*
>> + * Commit the node conversion and start the next
>> + * trans in the chain.
>> + */
>> + error = xfs_trans_roll_inode(&args->trans, dp);
>> + if (error)
>> + goto out;
>> + }
>>
>> goto restart;
>> }
>> @@ -933,9 +949,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
>> if (error)
>> goto out_defer_cancel;
>> xfs_defer_ijoin(args->dfops, dp);
>> - error = xfs_defer_finish(&args->trans, args->dfops);
>> - if (error)
>> - goto out_defer_cancel;
>> + if (roll_trans) {
>> + error = xfs_defer_finish(&args->trans, args->dfops);
>> + if (error)
>> + goto out_defer_cancel;
>> + }
>> } else {
>> /*
>> * Addition succeeded, update Btree hashvals.
>> @@ -954,9 +972,11 @@ xfs_attr_node_addname(xfs_da_args_t *args)
>> * Commit the leaf addition or btree split and start the next
>> * trans in the chain.
>> */
>> - error = xfs_trans_roll_inode(&args->trans, dp);
>> - if (error)
>> - goto out;
>> + if (roll_trans) {
>> + error = xfs_trans_roll_inode(&args->trans, dp);
>> + if (error)
>> + goto out;
>> + }
>>
>> /*
>> * If there was an out-of-line value, allocate the blocks we
>> @@ -1031,9 +1051,12 @@ xfs_attr_node_addname(xfs_da_args_t *args)
>> if (error)
>> goto out_defer_cancel;
>> xfs_defer_ijoin(args->dfops, dp);
>> - error = xfs_defer_finish(&args->trans, args->dfops);
>> - if (error)
>> - goto out_defer_cancel;
>> + if (roll_trans) {
>> + error = xfs_defer_finish(&args->trans,
>> + args->dfops);
>> + if (error)
>> + goto out_defer_cancel;
>> + }
>> }
>>
>> /*
>> @@ -1072,7 +1095,7 @@ xfs_attr_node_addname(xfs_da_args_t *args)
>> * the root node (a special case of an intermediate node).
>> */
>> STATIC int
>> -xfs_attr_node_removename(xfs_da_args_t *args)
>> +xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans)
>> {
>> xfs_da_state_t *state;
>> xfs_da_state_blk_t *blk;
>> @@ -1181,9 +1204,11 @@ xfs_attr_node_removename(xfs_da_args_t *args)
>> if (error)
>> goto out;
>>
>> - if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
>> + if ((forkoff = xfs_attr_shortform_allfit(bp, dp)) &&
>> + roll_trans) {
>> xfs_defer_init(args->dfops, args->firstblock);
>> - error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
>> + error = xfs_attr3_leaf_to_shortform(bp, args, forkoff,
>> + roll_trans);
>> /* bp is gone due to xfs_da_shrink_inode */
>> if (error)
>> goto out_defer_cancel;
>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
>> index 2135b8e..01935fe 100644
>> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
>> @@ -546,7 +546,7 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
>> * Overflow from the inode has already been checked for.
>> */
>> void
>> -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>> +xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff, bool roll_trans)
>> {
>> xfs_attr_shortform_t *sf;
>> xfs_attr_sf_entry_t *sfe;
>> @@ -618,7 +618,7 @@ xfs_attr_fork_remove(
>> * Remove an attribute from the shortform attribute list structure.
>> */
>> int
>> -xfs_attr_shortform_remove(xfs_da_args_t *args)
>> +xfs_attr_shortform_remove(xfs_da_args_t *args, bool roll_trans)
>> {
>> xfs_attr_shortform_t *sf;
>> xfs_attr_sf_entry_t *sfe;
>> @@ -970,7 +970,8 @@ int
>> xfs_attr3_leaf_to_shortform(
>> struct xfs_buf *bp,
>> struct xfs_da_args *args,
>> - int forkoff)
>> + int forkoff,
>> + bool roll_trans)
>> {
>> struct xfs_attr_leafblock *leaf;
>> struct xfs_attr3_icleaf_hdr ichdr;
>> @@ -1039,7 +1040,7 @@ xfs_attr3_leaf_to_shortform(
>> 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);
>> - xfs_attr_shortform_add(&nargs, forkoff);
>> + xfs_attr_shortform_add(&nargs, forkoff, roll_trans);
>> }
>> error = 0;
>>
>> @@ -1053,7 +1054,8 @@ xfs_attr3_leaf_to_shortform(
>> */
>> int
>> xfs_attr3_leaf_to_node(
>> - struct xfs_da_args *args)
>> + struct xfs_da_args *args,
>> + bool roll_trans)
>> {
>> struct xfs_attr_leafblock *leaf;
>> struct xfs_attr3_icleaf_hdr icleafhdr;
>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
>> index 4da08af..79c236c 100644
>> --- a/fs/xfs/libxfs/xfs_attr_leaf.h
>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
>> @@ -45,12 +45,13 @@ typedef struct xfs_attr_inactive_list {
>> * Internal routines when attribute fork size < XFS_LITINO(mp).
>> */
>> void xfs_attr_shortform_create(struct xfs_da_args *args);
>> -void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff);
>> +void xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff,
>> + bool roll_trans);
>> int xfs_attr_shortform_lookup(struct xfs_da_args *args);
>> int xfs_attr_shortform_getvalue(struct xfs_da_args *args);
>> int xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
>> struct xfs_buf **leaf_bp);
>> -int xfs_attr_shortform_remove(struct xfs_da_args *args);
>> +int xfs_attr_shortform_remove(struct xfs_da_args *args, bool roll_trans);
>> int xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
>> int xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
>> xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
>> @@ -59,9 +60,10 @@ void xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
>> /*
>> * Internal routines when attribute fork size == XFS_LBSIZE(mp).
>> */
>> -int xfs_attr3_leaf_to_node(struct xfs_da_args *args);
>> +int xfs_attr3_leaf_to_node(struct xfs_da_args *args, bool roll_trans);
>> int xfs_attr3_leaf_to_shortform(struct xfs_buf *bp,
>> - struct xfs_da_args *args, int forkoff);
>> + struct xfs_da_args *args, int forkoff,
>> + bool roll_trans);
>> int xfs_attr3_leaf_clearflag(struct xfs_da_args *args);
>> int xfs_attr3_leaf_setflag(struct xfs_da_args *args);
>> int xfs_attr3_leaf_flipflags(struct xfs_da_args *args);
>> --
>> 2.7.4
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at https://urldefense.proofpoint.com/v2/url?u=http-3A__vger.kernel.org_majordomo-2Dinfo.html&d=DwIBAg&c=RoP1YumCXCgaWHvlZYR8PZh8Bv7qIrMUB65eapI_JnE&r=LHZQ8fHvy6wDKXGTWcm97burZH5sQKHRDMaY1UthQxc&m=_Y5y0YcW5ilokzV2Epi1rHWmFcw8-yYhRjAmXTVZLHQ&s=9XINqnuINAJpBbkLnTfoAClgLIQI0eejUxkjnLdnC7g&e=
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations
2018-06-13 15:18 ` Brian Foster
@ 2018-06-14 1:28 ` Allison Henderson
2018-06-14 11:13 ` Brian Foster
0 siblings, 1 reply; 33+ messages in thread
From: Allison Henderson @ 2018-06-14 1:28 UTC (permalink / raw)
To: Brian Foster; +Cc: linux-xfs
On 06/13/2018 08:18 AM, Brian Foster wrote:
> On Sat, Jun 09, 2018 at 10:04:51PM -0700, Allison Henderson wrote:
>> This patch adds two new log item types for setting or
>> removing attributes as deferred operations. The
>> xfs_attri_log_item logs an intent to set or remove an
>> attribute. The corresponding xfs_attrd_log_item holds
>> a reference to the xfs_attri_log_item and is freed once
>> the transaction is done. Both log items use a generic
>> xfs_attr_log_format structure that contains the attribute
>> name, value, flags, inode, and an op_flag that indicates
>> if the operations is a set or remove.
>>
>> At the moment, this feature will only be used by the parent
>> pointer patch set which uses attributes to store information
>> about an inodes parent.
>>
>> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
>> ---
>
> Looks mostly sane, though I haven't looked into all the details or the
> recovery code yet. It does look like this needs to be rebased on top of
> the recent elimination of the log item descriptor. A few comments in the
> meantime...
>
>> fs/xfs/Makefile | 2 +
>> fs/xfs/libxfs/xfs_attr.c | 5 +-
>> fs/xfs/libxfs/xfs_attr.h | 26 +-
>> fs/xfs/libxfs/xfs_defer.h | 1 +
>> fs/xfs/libxfs/xfs_log_format.h | 44 +++-
>> fs/xfs/libxfs/xfs_types.h | 1 +
>> fs/xfs/xfs_attr_item.c | 560 +++++++++++++++++++++++++++++++++++++++++
>> fs/xfs/xfs_attr_item.h | 120 +++++++++
>> fs/xfs/xfs_log_recover.c | 173 +++++++++++++
>> fs/xfs/xfs_ondisk.h | 2 +
>> fs/xfs/xfs_super.c | 1 +
>> fs/xfs/xfs_trans.h | 14 ++
>> fs/xfs/xfs_trans_attr.c | 285 +++++++++++++++++++++
>> 13 files changed, 1229 insertions(+), 5 deletions(-)
>>
>> diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
>> index 7ceb41a..d3c0004 100644
>> --- a/fs/xfs/Makefile
>> +++ b/fs/xfs/Makefile
>> @@ -107,6 +107,7 @@ xfs-y += xfs_log.o \
>> xfs_bmap_item.o \
>> xfs_buf_item.o \
>> xfs_extfree_item.o \
>> + xfs_attr_item.o \
>> xfs_icreate_item.o \
>> xfs_inode_item.o \
>> xfs_refcount_item.o \
>> @@ -116,6 +117,7 @@ xfs-y += xfs_log.o \
>> xfs_trans_bmap.o \
>> xfs_trans_buf.o \
>> xfs_trans_extfree.o \
>> + xfs_trans_attr.o \
>> xfs_trans_inode.o \
>> xfs_trans_refcount.o \
>> xfs_trans_rmap.o \
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index ab769e5..408a49d 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
>> @@ -41,6 +41,7 @@
>> #include "xfs_quota.h"
>> #include "xfs_trans_space.h"
>> #include "xfs_trace.h"
>> +#include "xfs_attr_item.h"
>>
>> /*
>> * xfs_attr.c
>> @@ -74,7 +75,7 @@ STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
>> STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
>>
>>
>> -STATIC int
>> +int
>> xfs_attr_args_init(
>> struct xfs_da_args *args,
>> struct xfs_inode *dp,
>> @@ -170,7 +171,7 @@ xfs_attr_get(
>> /*
>> * Calculate how many blocks we need for the new attribute,
>> */
>> -STATIC int
>> +int
>> xfs_attr_calc_size(
>> struct xfs_da_args *args,
>> int *local)
>> diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
>> index ef6b47e..33b33d3 100644
>> --- a/fs/xfs/libxfs/xfs_attr.h
>> +++ b/fs/xfs/libxfs/xfs_attr.h
>> @@ -18,6 +18,8 @@
>> #ifndef __XFS_ATTR_H__
>> #define __XFS_ATTR_H__
>>
>> +#include "libxfs/xfs_defer.h"
>> +
>
> Why is this necessary? I think we usually try to keep includes out of
> header files, but I could be wrong.
I think this was left over from another piece of code I had tried here.
I will see if I can take it out
>
>> struct xfs_inode;
>> struct xfs_da_args;
>> struct xfs_attr_list_context;
>> @@ -90,6 +92,26 @@ typedef struct attrlist_ent { /* data from attr_list() */
>> } attrlist_ent_t;
>>
>> /*
>> + * List of attrs to commit later.
>> + */
>> +struct xfs_attr_item {
>> + struct xfs_inode *xattri_ip;
>> + uint32_t xattri_op_flags;
>> + uint32_t xattri_value_len; /* length of value */
>> + uint32_t xattri_name_len; /* length of name */
>> + uint32_t xattri_flags; /* attr flags */
>> + struct list_head xattri_list;
>> +
>> + /*
>> + * A byte array follows the header containing the file name and
>> + * attribute value.
>> + */
>
> This isn't really a header though, right? This is more of an in-core
> structure to carry the attr information into the dfops infrastructure..?
>
> Hmm, I'm wondering if this would just be cleaner with separate
> allocations so we can actually have name/value fields. Or perhaps a
> compromise could be the current single alloc with name/value pointers
> that are fixed up to refer to the memory after the static part of the
> data structure? Then we could clean up some of the dfops callouts that
> access this data a bit.
>
I think I recall us discussing this in another review a long time ago,
and what we ended up doing was creating the name value pointers in
xfs_attri_log_item and then pointing them here. I suppose we could put
another set in here too if it makes it easier, but then it's more
pointers to initialize and manage too.
>> +};
>> +
>> +#define XFS_ATTR_ITEM_SIZEOF(namelen, valuelen) \
>> + (sizeof(struct xfs_attr_item) + (namelen) + (valuelen))
>> +
>> +/*
>> * Given a pointer to the (char*) buffer containing the attr_list() result,
>> * and an index, return a pointer to the indicated attribute in the buffer.
>> */
>> @@ -158,6 +180,8 @@ int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
>> int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
>> int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
>> int flags, struct attrlist_cursor_kern *cursor);
>> -
>> +int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
>> + const unsigned char *name, int flags);
>> +int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
>>
>> #endif /* __XFS_ATTR_H__ */
>> diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
>> index 045beac..11e1690 100644
>> --- a/fs/xfs/libxfs/xfs_defer.h
>> +++ b/fs/xfs/libxfs/xfs_defer.h
>> @@ -55,6 +55,7 @@ enum xfs_defer_ops_type {
>> XFS_DEFER_OPS_TYPE_REFCOUNT,
>> XFS_DEFER_OPS_TYPE_RMAP,
>> XFS_DEFER_OPS_TYPE_FREE,
>> + XFS_DEFER_OPS_TYPE_ATTR,
>> XFS_DEFER_OPS_TYPE_MAX,
>> };
>>
>> diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
>> index 349d9f8..291e5ff 100644
>> --- a/fs/xfs/libxfs/xfs_log_format.h
>> +++ b/fs/xfs/libxfs/xfs_log_format.h
>> @@ -116,7 +116,12 @@ static inline uint xlog_get_cycle(char *ptr)
>> #define XLOG_REG_TYPE_CUD_FORMAT 24
>> #define XLOG_REG_TYPE_BUI_FORMAT 25
>> #define XLOG_REG_TYPE_BUD_FORMAT 26
>> -#define XLOG_REG_TYPE_MAX 26
>> +#define XLOG_REG_TYPE_ATTRI_FORMAT 27
>> +#define XLOG_REG_TYPE_ATTRD_FORMAT 28
>> +#define XLOG_REG_TYPE_ATTR_NAME 29
>> +#define XLOG_REG_TYPE_ATTR_VALUE 30
>> +#define XLOG_REG_TYPE_MAX 31
>> +
>>
>> /*
>> * Flags to log operation header
>> @@ -239,6 +244,8 @@ typedef struct xfs_trans_header {
>> #define XFS_LI_CUD 0x1243
>> #define XFS_LI_BUI 0x1244 /* bmbt update intent */
>> #define XFS_LI_BUD 0x1245
>> +#define XFS_LI_ATTRI 0x1246 /* attr set/remove intent*/
>> +#define XFS_LI_ATTRD 0x1247 /* attr set/remove done */
>>
>> #define XFS_LI_TYPE_DESC \
>> { XFS_LI_EFI, "XFS_LI_EFI" }, \
>> @@ -254,7 +261,9 @@ typedef struct xfs_trans_header {
>> { XFS_LI_CUI, "XFS_LI_CUI" }, \
>> { XFS_LI_CUD, "XFS_LI_CUD" }, \
>> { XFS_LI_BUI, "XFS_LI_BUI" }, \
>> - { XFS_LI_BUD, "XFS_LI_BUD" }
>> + { XFS_LI_BUD, "XFS_LI_BUD" }, \
>> + { XFS_LI_ATTRI, "XFS_LI_ATTRI" }, \
>> + { XFS_LI_ATTRD, "XFS_LI_ATTRD" }
>>
>> /*
>> * Inode Log Item Format definitions.
>> @@ -852,4 +861,35 @@ struct xfs_icreate_log {
>> __be32 icl_gen; /* inode generation number to use */
>> };
>>
>> +/*
>> + * Flags for deferred attribute operations.
>> + * Upper bits are flags, lower byte is type code
>> + */
>> +#define XFS_ATTR_OP_FLAGS_SET 1 /* Set the attribute */
>> +#define XFS_ATTR_OP_FLAGS_REMOVE 2 /* Remove the attribute */
>> +#define XFS_ATTR_OP_FLAGS_TYPE_MASK 0x0FF /* Flags type mask */
>> +
>> +/*
>> + * This is the structure used to lay out an attr log item in the
>> + * log.
>> + */
>> +struct xfs_attri_log_format {
>> + uint16_t alfi_type; /* attri log item type */
>> + uint16_t alfi_size; /* size of this item */
>> + uint32_t __pad; /* pad to 64 bit aligned */
>> + uint64_t alfi_id; /* attri identifier */
>> + xfs_ino_t alfi_ino; /* the inode for this attr operation */
>> + uint32_t alfi_op_flags; /* marks the op as a set or remove */
>> + uint32_t alfi_name_len; /* attr name length */
>> + uint32_t alfi_value_len; /* attr value length */
>> + uint32_t alfi_attr_flags;/* attr flags */
>> +};
>> +
>> +struct xfs_attrd_log_format {
>> + uint16_t alfd_type; /* attrd log item type */
>> + uint16_t alfd_size; /* size of this item */
>> + uint32_t __pad; /* pad to 64 bit aligned */
>> + uint64_t alfd_alf_id; /* id of corresponding attrd */
>> +};
>> +
>> #endif /* __XFS_LOG_FORMAT_H__ */
>> diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
>> index 3c56069..2905ce3 100644
>> --- a/fs/xfs/libxfs/xfs_types.h
>> +++ b/fs/xfs/libxfs/xfs_types.h
>> @@ -23,6 +23,7 @@ typedef uint32_t prid_t; /* project ID */
>> typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
>> typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
>> typedef uint32_t xfs_extlen_t; /* extent length in blocks */
>> +typedef uint32_t xfs_attrlen_t; /* attr length */
>> typedef uint32_t xfs_agnumber_t; /* allocation group number */
>> typedef int32_t xfs_extnum_t; /* # of extents in a file */
>> typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
>> diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
>> new file mode 100644
>> index 0000000..e90d516
>> --- /dev/null
>> +++ b/fs/xfs/xfs_attr_item.c
>> @@ -0,0 +1,560 @@
>> +/*
>> + * Copyright (c) 2017 Oracle, Inc.
>> + * All Rights Reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU General Public License as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it would be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU General Public License
>> + * along with this program; if not, write the Free Software Foundation Inc.
>> + */
>> +#include "xfs.h"
>> +#include "xfs_fs.h"
>> +#include "xfs_format.h"
>> +#include "xfs_log_format.h"
>> +#include "xfs_trans_resv.h"
>> +#include "xfs_bit.h"
>> +#include "xfs_mount.h"
>> +#include "xfs_trans.h"
>> +#include "xfs_trans_priv.h"
>> +#include "xfs_buf_item.h"
>> +#include "xfs_attr_item.h"
>> +#include "xfs_log.h"
>> +#include "xfs_btree.h"
>> +#include "xfs_rmap.h"
>> +#include "xfs_inode.h"
>> +#include "xfs_icache.h"
>> +
>> +static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip)
>> +{
>> + return container_of(lip, struct xfs_attri_log_item, item);
>> +}
>> +
>> +void
>> +xfs_attri_item_free(
>> + struct xfs_attri_log_item *attrip)
>> +{
>> + kmem_free(attrip->item.li_lv_shadow);
>> + kmem_free(attrip);
>> +}
>> +
>> +/*
>> + * This returns the number of iovecs needed to log the given attri item.
>> + * We only need 1 iovec for an attri item. It just logs the attr_log_format
>> + * structure.
>> + */
>> +static inline int
>> +xfs_attri_item_sizeof(
>> + struct xfs_attri_log_item *attrip)
>> +{
>> + return sizeof(struct xfs_attri_log_format);
>> +}
>> +
>> +STATIC void
>> +xfs_attri_item_size(
>> + struct xfs_log_item *lip,
>> + int *nvecs,
>> + int *nbytes)
>> +{
>> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
>> +
>> + *nvecs += 1;
>> + *nbytes += xfs_attri_item_sizeof(attrip);
>> +
>> + if (attrip->name_len > 0) {
>> + *nvecs += 1;
>> + nbytes += ATTR_NVEC_SIZE(attrip->name_len);
>> + }
>> +
>> + if (attrip->value_len > 0) {
>> + *nvecs += 1;
>> + nbytes += ATTR_NVEC_SIZE(attrip->value_len);
>> + }
>> +}
>> +
>> +/*
>> + * This is called to fill in the vector of log iovecs for the
>> + * given attri log item. We use only 1 iovec, and we point that
>> + * at the attri_log_format structure embedded in the attri item.
>> + * It is at this point that we assert that all of the attr
>> + * slots in the attri item have been filled.
>> + */
>> +STATIC void
>> +xfs_attri_item_format(
>> + struct xfs_log_item *lip,
>> + struct xfs_log_vec *lv)
>> +{
>> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
>> + struct xfs_log_iovec *vecp = NULL;
>> +
>> + attrip->format.alfi_type = XFS_LI_ATTRI;
>> + attrip->format.alfi_size = 1;
>> + if (attrip->name_len > 0)
>> + attrip->format.alfi_size++;
>> + if (attrip->value_len > 0)
>> + attrip->format.alfi_size++;
>> +
>> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT,
>> + &attrip->format,
>> + xfs_attri_item_sizeof(attrip));
>> + if (attrip->name_len > 0)
>> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_NAME,
>> + attrip->name, ATTR_NVEC_SIZE(attrip->name_len));
>> +
>> + if (attrip->value_len > 0)
>> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_VALUE,
>> + attrip->value,
>> + ATTR_NVEC_SIZE(attrip->value_len));
>> +}
>> +
>> +
>> +/*
>> + * Pinning has no meaning for an attri item, so just return.
>> + */
>> +STATIC void
>> +xfs_attri_item_pin(
>> + struct xfs_log_item *lip)
>> +{
>> +}
>> +
>> +/*
>> + * The unpin operation is the last place an ATTRI is manipulated in the log. It
>> + * is either inserted in the AIL or aborted in the event of a log I/O error. In
>> + * either case, the ATTRI transaction has been successfully committed to make it
>> + * this far. Therefore, we expect whoever committed the ATTRI to either
>> + * construct and commit the ATTRD or drop the ATTRD's reference in the event of
>> + * error. Simply drop the log's ATTRI reference now that the log is done with
>> + * it.
>> + */
>> +STATIC void
>> +xfs_attri_item_unpin(
>> + struct xfs_log_item *lip,
>> + int remove)
>> +{
>> + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
>> +
>> + xfs_attri_release(attrip);
>> +}
>> +
>> +/*
>> + * attri items have no locking or pushing. However, since ATTRIs are pulled
>> + * from the AIL when their corresponding ATTRDs are committed to disk, their
>> + * situation is very similar to being pinned. Return XFS_ITEM_PINNED so that
>> + * the caller will eventually flush the log. This should help in getting the
>> + * ATTRI out of the AIL.
>> + */
>> +STATIC uint
>> +xfs_attri_item_push(
>> + struct xfs_log_item *lip,
>> + struct list_head *buffer_list)
>> +{
>> + return XFS_ITEM_PINNED;
>> +}
>> +
>> +/*
>> + * The ATTRI has been either committed or aborted if the transaction has been
>> + * cancelled. If the transaction was cancelled, an ATTRD isn't going to be
>> + * constructed and thus we free the ATTRI here directly.
>> + */
>> +STATIC void
>> +xfs_attri_item_unlock(
>> + struct xfs_log_item *lip)
>> +{
>> + if (lip->li_flags & XFS_LI_ABORTED)
>> + xfs_attri_release(ATTRI_ITEM(lip));
>> +}
>> +
>> +/*
>> + * The ATTRI is logged only once and cannot be moved in the log, so simply
>> + * return the lsn at which it's been logged.
>> + */
>> +STATIC xfs_lsn_t
>> +xfs_attri_item_committed(
>> + struct xfs_log_item *lip,
>> + xfs_lsn_t lsn)
>> +{
>> + return lsn;
>> +}
>> +
>> +STATIC void
>> +xfs_attri_item_committing(
>> + struct xfs_log_item *lip,
>> + xfs_lsn_t lsn)
>> +{
>> +}
>> +
>> +/*
>> + * This is the ops vector shared by all attri log items.
>> + */
>> +static const struct xfs_item_ops xfs_attri_item_ops = {
>> + .iop_size = xfs_attri_item_size,
>> + .iop_format = xfs_attri_item_format,
>> + .iop_pin = xfs_attri_item_pin,
>> + .iop_unpin = xfs_attri_item_unpin,
>> + .iop_unlock = xfs_attri_item_unlock,
>> + .iop_committed = xfs_attri_item_committed,
>> + .iop_push = xfs_attri_item_push,
>> + .iop_committing = xfs_attri_item_committing
>> +};
>> +
>> +
>> +/*
>> + * Allocate and initialize an attri item
>> + */
>> +struct xfs_attri_log_item *
>> +xfs_attri_init(
>> + struct xfs_mount *mp)
>> +
>> +{
>> + struct xfs_attri_log_item *attrip;
>> + uint size;
>> +
>> + size = (uint)(sizeof(struct xfs_attri_log_item));
>> + attrip = kmem_zalloc(size, KM_SLEEP);
>> +
>> + xfs_log_item_init(mp, &(attrip->item), XFS_LI_ATTRI,
>> + &xfs_attri_item_ops);
>> + attrip->format.alfi_id = (uintptr_t)(void *)attrip;
>> + atomic_set(&attrip->refcount, 2);
>> +
>> + return attrip;
>> +}
>> +
>> +/*
>> + * Copy an attr format buffer from the given buf, and into the destination
>> + * attr format structure.
>> + */
>> +int
>> +xfs_attri_copy_format(struct xfs_log_iovec *buf,
>> + struct xfs_attri_log_format *dst_attr_fmt)
>> +{
>> + struct xfs_attri_log_format *src_attr_fmt = buf->i_addr;
>> + uint len = sizeof(struct xfs_attri_log_format);
>> +
>> + if (buf->i_len == len) {
>> + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
>> + return 0;
>> + }
>> + return -EFSCORRUPTED;
>> +}
>> +
>> +/*
>> + * Copy an attr format buffer from the given buf, and into the destination
>> + * attr format structure.
>> + */
>> +int
>> +xfs_attrd_copy_format(struct xfs_log_iovec *buf,
>> + struct xfs_attrd_log_format *dst_attr_fmt)
>> +{
>> + struct xfs_attrd_log_format *src_attr_fmt = buf->i_addr;
>> + uint len = sizeof(struct xfs_attrd_log_format);
>> +
>> + if (buf->i_len == len) {
>> + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
>> + return 0;
>> + }
>> + return -EFSCORRUPTED;
>> +}
>> +
>> +/*
>> + * Freeing the attrip requires that we remove it from the AIL if it has already
>> + * been placed there. However, the ATTRI may not yet have been placed in the AIL
>> + * when called by xfs_attri_release() from ATTRD processing due to the ordering of
>> + * committed vs unpin operations in bulk insert operations. Hence the reference
>> + * count to ensure only the last caller frees the ATTRI.
>> + */
>> +void
>> +xfs_attri_release(
>> + struct xfs_attri_log_item *attrip)
>> +{
>> + ASSERT(atomic_read(&attrip->refcount) > 0);
>> + if (atomic_dec_and_test(&attrip->refcount)) {
>> + xfs_trans_ail_remove(&attrip->item, SHUTDOWN_LOG_IO_ERROR);
>> + xfs_attri_item_free(attrip);
>> + }
>> +}
>> +
>
> Looks like minor whitespace damage on the line above.
>
>> +static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip)
>> +{
>> + return container_of(lip, struct xfs_attrd_log_item, item);
>> +}
>> +
>> +STATIC void
>> +xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp)
>> +{
>> + kmem_free(attrdp->item.li_lv_shadow);
>> + kmem_free(attrdp);
>> +}
>> +
>> +/*
>> + * This returns the number of iovecs needed to log the given attrd item.
>> + * We only need 1 iovec for an attrd item. It just logs the attr_log_format
>> + * structure.
>> + */
>> +static inline int
>> +xfs_attrd_item_sizeof(
>> + struct xfs_attrd_log_item *attrdp)
>> +{
>> + return sizeof(struct xfs_attrd_log_format);
>> +}
>> +
>> +STATIC void
>> +xfs_attrd_item_size(
>> + struct xfs_log_item *lip,
>> + int *nvecs,
>> + int *nbytes)
>> +{
>> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
>> + *nvecs += 1;
>> + *nbytes += xfs_attrd_item_sizeof(attrdp);
>> +
>> + if (attrdp->name_len > 0) {
>> + *nvecs += 1;
>> + nbytes += attrdp->name_len;
>> + }
>> +
>> + if (attrdp->value_len > 0) {
>> + *nvecs += 1;
>> + nbytes += attrdp->value_len;
>> + }
>
> I don't think you need to incorporate the name/value lengths in the size
> of the done item. The done item already refers to the intent item. The
> purpose of the iop_size() call is to help the log infrastructure size
> the vectors required for writing to the log, and as the
> attrd_item_format() call shows below, we only format the vector with the
> xfs_attrd_log_format.
>
>> +}
>> +
>> +/*
>> + * This is called to fill in the vector of log iovecs for the
>> + * given attrd log item. We use only 1 iovec, and we point that
>> + * at the attr_log_format structure embedded in the attrd item.
>> + * It is at this point that we assert that all of the attr
>> + * slots in the attrd item have been filled.
>> + */
>> +STATIC void
>> +xfs_attrd_item_format(
>> + struct xfs_log_item *lip,
>> + struct xfs_log_vec *lv)
>> +{
>> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
>> + struct xfs_log_iovec *vecp = NULL;
>> +
>> + attrdp->format.alfd_type = XFS_LI_ATTRD;
>> + attrdp->format.alfd_size = 1;
>> +
>> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT,
>> + &attrdp->format,
>> + xfs_attrd_item_sizeof(attrdp));
>> +}
>> +
>> +/*
>> + * Pinning has no meaning for an attrd item, so just return.
>> + */
>> +STATIC void
>> +xfs_attrd_item_pin(
>> + struct xfs_log_item *lip)
>> +{
>> +}
>> +
>> +/*
>> + * Since pinning has no meaning for an attrd item, unpinning does
>> + * not either.
>> + */
>> +STATIC void
>> +xfs_attrd_item_unpin(
>> + struct xfs_log_item *lip,
>> + int remove)
>> +{
>> +}
>> +
>> +/*
>> + * There isn't much you can do to push on an attrd item. It is simply stuck
>> + * waiting for the log to be flushed to disk.
>> + */
>> +STATIC uint
>> +xfs_attrd_item_push(
>> + struct xfs_log_item *lip,
>> + struct list_head *buffer_list)
>> +{
>> + return XFS_ITEM_PINNED;
>> +}
>> +
>> +/*
>> + * The ATTRD is either committed or aborted if the transaction is cancelled. If
>> + * the transaction is cancelled, drop our reference to the ATTRI and free the
>> + * ATTRD.
>> + */
>> +STATIC void
>> +xfs_attrd_item_unlock(
>> + struct xfs_log_item *lip)
>> +{
>> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
>> +
>> + if (lip->li_flags & XFS_LI_ABORTED) {
>> + xfs_attri_release(attrdp->attrip);
>> + xfs_attrd_item_free(attrdp);
>> + }
>> +}
>> +
>> +/*
>> + * When the attrd item is committed to disk, all we need to do is delete our
>> + * reference to our partner attri item and then free ourselves. Since we're
>> + * freeing ourselves we must return -1 to keep the transaction code from
>> + * further referencing this item.
>> + */
>> +STATIC xfs_lsn_t
>> +xfs_attrd_item_committed(
>> + struct xfs_log_item *lip,
>> + xfs_lsn_t lsn)
>> +{
>> + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
>> +
>> + /*
>> + * Drop the ATTRI reference regardless of whether the ATTRD has been
>> + * aborted. Once the ATTRD transaction is constructed, it is the sole
>> + * responsibility of the ATTRD to release the ATTRI (even if the ATTRI
>> + * is aborted due to log I/O error).
>> + */
>> + xfs_attri_release(attrdp->attrip);
>> + xfs_attrd_item_free(attrdp);
>> +
>> + return (xfs_lsn_t)-1;
>> +}
>> +
>> +STATIC void
>> +xfs_attrd_item_committing(
>> + struct xfs_log_item *lip,
>> + xfs_lsn_t lsn)
>> +{
>> +}
>> +
>> +/*
>> + * This is the ops vector shared by all attrd log items.
>> + */
>> +static const struct xfs_item_ops xfs_attrd_item_ops = {
>> + .iop_size = xfs_attrd_item_size,
>> + .iop_format = xfs_attrd_item_format,
>> + .iop_pin = xfs_attrd_item_pin,
>> + .iop_unpin = xfs_attrd_item_unpin,
>> + .iop_unlock = xfs_attrd_item_unlock,
>> + .iop_committed = xfs_attrd_item_committed,
>> + .iop_push = xfs_attrd_item_push,
>> + .iop_committing = xfs_attrd_item_committing
>> +};
>> +
>> +/*
>> + * Allocate and initialize an attrd item
>> + */
>> +struct xfs_attrd_log_item *
>> +xfs_attrd_init(
>> + struct xfs_mount *mp,
>> + struct xfs_attri_log_item *attrip)
>> +
>> +{
>> + struct xfs_attrd_log_item *attrdp;
>> + uint size;
>> +
>> + size = (uint)(sizeof(struct xfs_attrd_log_item));
>> + attrdp = kmem_zalloc(size, KM_SLEEP);
>> +
>> + xfs_log_item_init(mp, &attrdp->item, XFS_LI_ATTRD,
>> + &xfs_attrd_item_ops);
>> + attrdp->attrip = attrip;
>> + attrdp->format.alfd_alf_id = attrip->format.alfi_id;
>> +
>> + return attrdp;
>> +}
>> +
>> +/*
>> + * Process an attr intent item that was recovered from
>> + * the log. We need to delete the attr that it describes.
>> + */
>> +int
>> +xfs_attri_recover(
>> + struct xfs_mount *mp,
>> + struct xfs_attri_log_item *attrip,
>> + struct xfs_defer_ops *dfops)
>> +{
>> + struct xfs_inode *ip;
>> + struct xfs_attrd_log_item *attrdp;
>> + struct xfs_trans *tp;
>> + int error = 0;
>> + struct xfs_attri_log_format *attrp;
>> +
>> + ASSERT(!test_bit(XFS_ATTRI_RECOVERED, &attrip->flags));
>> +
>> + /*
>> + * First check the validity of the attr described by the
>> + * ATTRI. If any are bad, then assume that all are bad and
>> + * just toss the ATTRI.
>> + */
>> + attrp = &attrip->format;
>> + if (
>> + /*
>> + * Must have either XFS_ATTR_OP_FLAGS_SET or
>> + * XFS_ATTR_OP_FLAGS_REMOVE set
>> + */
>> + !(attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET ||
>> + attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE) ||
>> +
>> + /* Check size of value and name lengths */
>> + (attrp->alfi_value_len > XATTR_SIZE_MAX ||
>> + attrp->alfi_name_len > XATTR_NAME_MAX) ||
>> +
>> + /*
>> + * If the XFS_ATTR_OP_FLAGS_SET flag is set,
>> + * there must also be a name and value
>> + */
>> + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET &&
>> + (attrp->alfi_value_len == 0 || attrp->alfi_name_len == 0)) ||
>> +
>> + /*
>> + * If the XFS_ATTR_OP_FLAGS_REMOVE flag is set,
>> + * there must also be a name
>> + */
>> + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE &&
>> + (attrp->alfi_name_len == 0))
>> + ) {
>> + /*
>> + * This will pull the ATTRI from the AIL and
>> + * free the memory associated with it.
>> + */
>> + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
>> + xfs_attri_release(attrip);
>> + return -EIO;
>> + }
>> +
>> + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
>> + if (error)
>> + return error;
>> + attrdp = xfs_trans_get_attrd(tp, attrip);
>> + attrp = &attrip->format;
>> +
>> + error = xfs_iget(mp, tp, attrp->alfi_ino, 0, 0, &ip);
>> + if (error)
>> + return error;
>> +
>> + xfs_ilock(ip, XFS_ILOCK_EXCL);
>> +
>> + error = xfs_trans_attr(tp, dfops, attrdp, ip,
>> + attrp->alfi_op_flags,
>> + attrp->alfi_attr_flags,
>> + attrp->alfi_name_len,
>> + attrp->alfi_value_len,
>> + attrip->name,
>> + attrip->value);
>> + if (error)
>> + goto abort_error;
>> +
>> +
>> + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
>> + error = xfs_trans_commit(tp);
>> + xfs_iunlock(ip, XFS_ILOCK_EXCL);
>> + return error;
>> +
>> +abort_error:
>> + xfs_trans_cancel(tp);
>> + xfs_iunlock(ip, XFS_ILOCK_EXCL);
>> + return error;
>> +}
>> diff --git a/fs/xfs/xfs_attr_item.h b/fs/xfs/xfs_attr_item.h
>> new file mode 100644
>> index 0000000..184e6b1
>> --- /dev/null
>> +++ b/fs/xfs/xfs_attr_item.h
>> @@ -0,0 +1,120 @@
>> +/*
>> + * Copyright (c) 2017 Oracle, Inc.
>> + * All Rights Reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU General Public License as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it would be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU General Public License
>> + * along with this program; if not, write the Free Software Foundation Inc.
>> + */
>> +#ifndef __XFS_ATTR_ITEM_H__
>> +#define __XFS_ATTR_ITEM_H__
>> +
>> +/* kernel only ATTRI/ATTRD definitions */
>> +
>> +struct xfs_mount;
>> +struct kmem_zone;
>> +
>> +/*
>> + * Max number of attrs in fast allocation path.
>> + */
>> +#define XFS_ATTRI_MAX_FAST_ATTRS 1
>> +
>> +
>> +/*
>> + * Define ATTR flag bits. Manipulated by set/clear/test_bit operators.
>> + */
>> +#define XFS_ATTRI_RECOVERED 1
>> +
>> +
>> +/* nvecs must be in multiples of 4 */
>
> Why? Can you expand on the comment here? Also, any reason not to just
> use round_up()?
>
>> +#define ATTR_NVEC_SIZE(size) (size == sizeof(int32_t) ? sizeof(int32_t) : \
>> + size + sizeof(int32_t) - \
>> + (size % sizeof(int32_t)))
>> +
>> +/*
>> + * This is the "attr intention" log item. It is used to log the fact
>> + * that some attrs need to be processed. It is used in conjunction with the
>> + * "attr done" log item described below.
>> + *
>> + * The ATTRI is reference counted so that it is not freed prior to both the
>> + * ATTRI and ATTRD being committed and unpinned. This ensures the ATTRI is
>> + * inserted into the AIL even in the event of out of order ATTRI/ATTRD
>> + * processing. In other words, an ATTRI is born with two references:
>> + *
>> + * 1.) an ATTRI held reference to track ATTRI AIL insertion
>> + * 2.) an ATTRD held reference to track ATTRD commit
>> + *
>> + * On allocation, both references are the responsibility of the caller. Once
>> + * the ATTRI is added to and dirtied in a transaction, ownership of reference
>> + * one transfers to the transaction. The reference is dropped once the ATTRI is
>> + * inserted to the AIL or in the event of failure along the way (e.g., commit
>> + * failure, log I/O error, etc.). Note that the caller remains responsible for
>> + * the ATTRD reference under all circumstances to this point. The caller has no
>> + * means to detect failure once the transaction is committed, however.
>> + * Therefore, an ATTRD is required after this point, even in the event of
>> + * unrelated failure.
>> + *
>> + * Once an ATTRD is allocated and dirtied in a transaction, reference two
>> + * transfers to the transaction. The ATTRD reference is dropped once it reaches
>> + * the unpin handler. Similar to the ATTRI, the reference also drops in the
>> + * event of commit failure or log I/O errors. Note that the ATTRD is not
>> + * inserted in the AIL, so at this point both the ATTI and ATTRD are freed.
>> + */
>> +struct xfs_attri_log_item {
>> + xfs_log_item_t item;
>> + atomic_t refcount;
>> + unsigned long flags; /* misc flags */
>> + int name_len;
>> + void *name;
>> + int value_len;
>
I think maybe we can get along with out them. I will see if I can
simplify these structs a bit.
> Do we need the name and value lengths here (and in the attrd) if they
> also exist in the xfs_attri_log_format?
>
>> + void *value;
>> + struct xfs_attri_log_format format;
>> +};
>> +
>> +/*
>> + * This is the "attr done" log item. It is used to log
>> + * the fact that some attrs earlier mentioned in an attri item
>> + * have been freed.
>> + */
>> +struct xfs_attrd_log_item {
>> + struct xfs_log_item item;
>> + struct xfs_attri_log_item *attrip;
>> + uint next_attr;
>
> This doesn't seem to be used. Holdover from one of the other log_item
> types perhaps?
I think so. Will clean out. Thx for the review!
Allison
>
>> + int name_len;
>> + void *name;
>> + int value_len;
>> + void *value;
>> + struct xfs_attrd_log_format format;
>> +};
>> +
>> +/*
>> + * Max number of attrs in fast allocation path.
>> + */
>> +#define XFS_ATTRD_MAX_FAST_ATTRS 1
>> +
>> +extern struct kmem_zone *xfs_attri_zone;
>> +extern struct kmem_zone *xfs_attrd_zone;
>> +
>> +struct xfs_attri_log_item *xfs_attri_init(struct xfs_mount *mp);
>> +struct xfs_attrd_log_item *xfs_attrd_init(struct xfs_mount *mp,
>> + struct xfs_attri_log_item *attrip);
>> +int xfs_attri_copy_format(struct xfs_log_iovec *buf,
>> + struct xfs_attri_log_format *dst_attri_fmt);
>> +int xfs_attrd_copy_format(struct xfs_log_iovec *buf,
>> + struct xfs_attrd_log_format *dst_attrd_fmt);
>> +void xfs_attri_item_free(struct xfs_attri_log_item *attrip);
>> +void xfs_attri_release(struct xfs_attri_log_item *attrip);
>> +
>> +int xfs_attri_recover(struct xfs_mount *mp,
>> + struct xfs_attri_log_item *attrip,
>> + struct xfs_defer_ops *dfops);
>> +
>> +#endif /* __XFS_ATTR_ITEM_H__ */
>> diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
>> index 2b2383f..b34e7f8 100644
>> --- a/fs/xfs/xfs_log_recover.c
>> +++ b/fs/xfs/xfs_log_recover.c
>> @@ -34,6 +34,7 @@
>> #include "xfs_log_recover.h"
>> #include "xfs_inode_item.h"
>> #include "xfs_extfree_item.h"
>> +#include "xfs_attr_item.h"
>> #include "xfs_trans_priv.h"
>> #include "xfs_alloc.h"
>> #include "xfs_ialloc.h"
>> @@ -1967,6 +1968,8 @@ xlog_recover_reorder_trans(
>> case XFS_LI_CUD:
>> case XFS_LI_BUI:
>> case XFS_LI_BUD:
>> + case XFS_LI_ATTRI:
>> + case XFS_LI_ATTRD:
>> trace_xfs_log_recover_item_reorder_tail(log,
>> trans, item, pass);
>> list_move_tail(&item->ri_list, &inode_list);
>> @@ -3497,6 +3500,117 @@ xlog_recover_efd_pass2(
>> return 0;
>> }
>>
>> +STATIC int
>> +xlog_recover_attri_pass2(
>> + struct xlog *log,
>> + struct xlog_recover_item *item,
>> + xfs_lsn_t lsn)
>> +{
>> + int error;
>> + struct xfs_mount *mp = log->l_mp;
>> + struct xfs_attri_log_item *attrip;
>> + struct xfs_attri_log_format *attri_formatp;
>> + char *name = NULL;
>> + char *value = NULL;
>> + int region = 0;
>> +
>> + attri_formatp = item->ri_buf[region].i_addr;
>> +
>> + attrip = xfs_attri_init(mp);
>> + error = xfs_attri_copy_format(&item->ri_buf[region], &attrip->format);
>> + if (error) {
>> + xfs_attri_item_free(attrip);
>> + return error;
>> + }
>> +
>> + attrip->name_len = attri_formatp->alfi_name_len;
>> + attrip->value_len = attri_formatp->alfi_value_len;
>> + attrip = kmem_realloc(attrip, sizeof(struct xfs_attri_log_item) +
>> + attrip->name_len + attrip->value_len, KM_SLEEP);
>> +
>> + if (attrip->name_len > 0) {
>> + region++;
>> + name = ((char *)attrip) + sizeof(struct xfs_attri_log_item);
>> + memcpy(name, item->ri_buf[region].i_addr,
>> + attrip->name_len);
>> + attrip->name = name;
>> + }
>> +
>> + if (attrip->value_len > 0) {
>> + region++;
>> + value = ((char *)attrip) + sizeof(struct xfs_attri_log_item) +
>> + attrip->name_len;
>> + memcpy(value, item->ri_buf[region].i_addr,
>> + attrip->value_len);
>> + attrip->value = value;
>> + }
>> +
>> + spin_lock(&log->l_ailp->ail_lock);
>> + /*
>> + * The ATTRI has two references. One for the ATTRD and one for ATTRI to
>> + * ensure it makes it into the AIL. Insert the ATTRI into the AIL
>> + * directly and drop the ATTRI reference. Note that
>> + * xfs_trans_ail_update() drops the AIL lock.
>> + */
>> + xfs_trans_ail_update(log->l_ailp, &attrip->item, lsn);
>> + xfs_attri_release(attrip);
>> + return 0;
>> +}
>> +
>> +
>> +/*
>> + * This routine is called when an ATTRD format structure is found in a committed
>> + * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
>> + * it was still in the log. To do this it searches the AIL for the ATTRI with
>> + * an id equal to that in the ATTRD format structure. If we find it we drop
>> + * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
>> + */
>> +STATIC int
>> +xlog_recover_attrd_pass2(
>> + struct xlog *log,
>> + struct xlog_recover_item *item)
>> +{
>> + struct xfs_attrd_log_format *attrd_formatp;
>> + struct xfs_attri_log_item *attrip = NULL;
>> + struct xfs_log_item *lip;
>> + uint64_t attri_id;
>> + struct xfs_ail_cursor cur;
>> + struct xfs_ail *ailp = log->l_ailp;
>> +
>> + attrd_formatp = item->ri_buf[0].i_addr;
>> + ASSERT((item->ri_buf[0].i_len ==
>> + (sizeof(struct xfs_attrd_log_format))));
>> + attri_id = attrd_formatp->alfd_alf_id;
>> +
>> + /*
>> + * Search for the ATTRI with the id in the ATTRD format structure in the
>> + * AIL.
>> + */
>> + spin_lock(&ailp->ail_lock);
>> + lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
>> + while (lip != NULL) {
>> + if (lip->li_type == XFS_LI_ATTRI) {
>> + attrip = (struct xfs_attri_log_item *)lip;
>> + if (attrip->format.alfi_id == attri_id) {
>> + /*
>> + * Drop the ATTRD reference to the ATTRI. This
>> + * removes the ATTRI from the AIL and frees it.
>> + */
>> + spin_unlock(&ailp->ail_lock);
>> + xfs_attri_release(attrip);
>> + spin_lock(&ailp->ail_lock);
>> + break;
>> + }
>> + }
>> + lip = xfs_trans_ail_cursor_next(ailp, &cur);
>> + }
>> +
>> + xfs_trans_ail_cursor_done(&cur);
>> + spin_unlock(&ailp->ail_lock);
>> +
>> + return 0;
>> +}
>> +
>> /*
>> * This routine is called to create an in-core extent rmap update
>> * item from the rui format structure which was logged on disk.
>> @@ -4050,6 +4164,8 @@ xlog_recover_ra_pass2(
>> break;
>> case XFS_LI_EFI:
>> case XFS_LI_EFD:
>> + case XFS_LI_ATTRI:
>> + case XFS_LI_ATTRD:
>> case XFS_LI_QUOTAOFF:
>> case XFS_LI_RUI:
>> case XFS_LI_RUD:
>> @@ -4078,6 +4194,8 @@ xlog_recover_commit_pass1(
>> case XFS_LI_INODE:
>> case XFS_LI_EFI:
>> case XFS_LI_EFD:
>> + case XFS_LI_ATTRI:
>> + case XFS_LI_ATTRD:
>> case XFS_LI_DQUOT:
>> case XFS_LI_ICREATE:
>> case XFS_LI_RUI:
>> @@ -4116,6 +4234,10 @@ xlog_recover_commit_pass2(
>> return xlog_recover_efi_pass2(log, item, trans->r_lsn);
>> case XFS_LI_EFD:
>> return xlog_recover_efd_pass2(log, item);
>> + case XFS_LI_ATTRI:
>> + return xlog_recover_attri_pass2(log, item, trans->r_lsn);
>> + case XFS_LI_ATTRD:
>> + return xlog_recover_attrd_pass2(log, item);
>> case XFS_LI_RUI:
>> return xlog_recover_rui_pass2(log, item, trans->r_lsn);
>> case XFS_LI_RUD:
>> @@ -4677,6 +4799,49 @@ xlog_recover_cancel_efi(
>> spin_lock(&ailp->ail_lock);
>> }
>>
>> +/* Release the ATTRI since we're cancelling everything. */
>> +STATIC void
>> +xlog_recover_cancel_attri(
>> + struct xfs_mount *mp,
>> + struct xfs_ail *ailp,
>> + struct xfs_log_item *lip)
>> +{
>> + struct xfs_attri_log_item *attrip;
>> +
>> + attrip = container_of(lip, struct xfs_attri_log_item, item);
>> +
>> + spin_unlock(&ailp->ail_lock);
>> + xfs_attri_release(attrip);
>> + spin_lock(&ailp->ail_lock);
>> +}
>> +
>> +
>> +/* Recover the ATTRI if necessary. */
>> +STATIC int
>> +xlog_recover_process_attri(
>> + struct xfs_mount *mp,
>> + struct xfs_ail *ailp,
>> + struct xfs_log_item *lip,
>> + struct xfs_defer_ops *dfops)
>> +{
>> + struct xfs_attri_log_item *attrip;
>> + int error;
>> +
>> + /*
>> + * Skip ATTRIs that we've already processed.
>> + */
>> + attrip = container_of(lip, struct xfs_attri_log_item, item);
>> + if (test_bit(XFS_ATTRI_RECOVERED, &attrip->flags))
>> + return 0;
>> +
>> + spin_unlock(&ailp->ail_lock);
>> + error = xfs_attri_recover(mp, attrip, dfops);
>> + spin_lock(&ailp->ail_lock);
>> +
>> + return error;
>> +}
>> +
>> +
>> /* Recover the RUI if necessary. */
>> STATIC int
>> xlog_recover_process_rui(
>> @@ -4807,6 +4972,7 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
>> case XFS_LI_RUI:
>> case XFS_LI_CUI:
>> case XFS_LI_BUI:
>> + case XFS_LI_ATTRI:
>> return true;
>> default:
>> return false;
>> @@ -4920,6 +5086,10 @@ xlog_recover_process_intents(
>> case XFS_LI_EFI:
>> error = xlog_recover_process_efi(log->l_mp, ailp, lip);
>> break;
>> + case XFS_LI_ATTRI:
>> + error = xlog_recover_process_attri(log->l_mp,
>> + ailp, lip, &dfops);
>> + break;
>> case XFS_LI_RUI:
>> error = xlog_recover_process_rui(log->l_mp, ailp, lip);
>> break;
>> @@ -4989,6 +5159,9 @@ xlog_recover_cancel_intents(
>> case XFS_LI_BUI:
>> xlog_recover_cancel_bui(log->l_mp, ailp, lip);
>> break;
>> + case XFS_LI_ATTRI:
>> + xlog_recover_cancel_attri(log->l_mp, ailp, lip);
>> + break;
>> }
>>
>> lip = xfs_trans_ail_cursor_next(ailp, &cur);
>> diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
>> index 0492436..3723d50 100644
>> --- a/fs/xfs/xfs_ondisk.h
>> +++ b/fs/xfs/xfs_ondisk.h
>> @@ -137,6 +137,8 @@ xfs_check_ondisk_structs(void)
>> XFS_CHECK_STRUCT_SIZE(struct xfs_inode_log_format, 56);
>> XFS_CHECK_STRUCT_SIZE(struct xfs_qoff_logformat, 20);
>> XFS_CHECK_STRUCT_SIZE(struct xfs_trans_header, 16);
>> + XFS_CHECK_STRUCT_SIZE(struct xfs_attri_log_format, 40);
>> + XFS_CHECK_STRUCT_SIZE(struct xfs_attrd_log_format, 16);
>> }
>>
>> #endif /* __XFS_ONDISK_H */
>> diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
>> index d714240..dce3baf 100644
>> --- a/fs/xfs/xfs_super.c
>> +++ b/fs/xfs/xfs_super.c
>> @@ -2077,6 +2077,7 @@ init_xfs_fs(void)
>> xfs_rmap_update_init_defer_op();
>> xfs_refcount_update_init_defer_op();
>> xfs_bmap_update_init_defer_op();
>> + xfs_attr_init_defer_op();
>>
>> xfs_dir_startup();
>>
>> diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
>> index 9d542df..deaae6b 100644
>> --- a/fs/xfs/xfs_trans.h
>> +++ b/fs/xfs/xfs_trans.h
>> @@ -40,6 +40,9 @@ struct xfs_cud_log_item;
>> struct xfs_defer_ops;
>> struct xfs_bui_log_item;
>> struct xfs_bud_log_item;
>> +struct xfs_attrd_log_item;
>> +struct xfs_attri_log_item;
>> +
>>
>> typedef struct xfs_log_item {
>> struct list_head li_ail; /* AIL pointers */
>> @@ -223,12 +226,23 @@ void xfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
>> void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
>>
>> void xfs_extent_free_init_defer_op(void);
>> +void xfs_attr_init_defer_op(void);
>> +
>> struct xfs_efd_log_item *xfs_trans_get_efd(struct xfs_trans *,
>> struct xfs_efi_log_item *,
>> uint);
>> int xfs_trans_free_extent(struct xfs_trans *,
>> struct xfs_efd_log_item *, xfs_fsblock_t,
>> xfs_extlen_t, struct xfs_owner_info *);
>> +struct xfs_attrd_log_item *
>> +xfs_trans_get_attrd(struct xfs_trans *tp,
>> + struct xfs_attri_log_item *attrip);
>> +int xfs_trans_attr(struct xfs_trans *tp, struct xfs_defer_ops *dfops,
>> + struct xfs_attrd_log_item *attrdp,
>> + struct xfs_inode *ip, uint32_t attr_op_flags,
>> + uint32_t flags, uint32_t name_len, uint32_t value_len,
>> + char *name, char *value);
>> +
>> int xfs_trans_commit(struct xfs_trans *);
>> int xfs_trans_roll(struct xfs_trans **);
>> int xfs_trans_roll_inode(struct xfs_trans **, struct xfs_inode *);
>> diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
>> new file mode 100644
>> index 0000000..7296414
>> --- /dev/null
>> +++ b/fs/xfs/xfs_trans_attr.c
>> @@ -0,0 +1,285 @@
>> +/*
>> + * Copyright (c) 2017, Oracle Inc.
>> + * All Rights Reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU General Public License as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it would be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU General Public License
>> + * along with this program; if not, write the Free Software Foundation Inc.
>> + */
>> +#include "xfs.h"
>> +#include "xfs_fs.h"
>> +#include "xfs_shared.h"
>> +#include "xfs_format.h"
>> +#include "xfs_log_format.h"
>> +#include "xfs_trans_resv.h"
>> +#include "xfs_bit.h"
>> +#include "xfs_mount.h"
>> +#include "xfs_defer.h"
>> +#include "xfs_trans.h"
>> +#include "xfs_trans_priv.h"
>> +#include "xfs_attr_item.h"
>> +#include "xfs_alloc.h"
>> +#include "xfs_bmap.h"
>> +#include "xfs_trace.h"
>> +#include "libxfs/xfs_da_format.h"
>> +#include "xfs_da_btree.h"
>> +#include "xfs_attr.h"
>> +#include "xfs_inode.h"
>> +#include "xfs_icache.h"
>> +#include "xfs_quota.h"
>> +
>> +/*
>> + * This routine is called to allocate an "extent free done"
>> + * log item that will hold nextents worth of extents. The
>> + * caller must use all nextents extents, because we are not
>> + * flexible about this at all.
>> + */
>
> Stale comment...
>
> Also, the use of the variable name "free" throughout this file for the
> xfs_attr_item is a bit of an ugly holdover from (I'm guessing) the
> extent free code. attr or something of that nature might be more
> relevant.
>
> Brian
>
>> +struct xfs_attrd_log_item *
>> +xfs_trans_get_attrd(struct xfs_trans *tp,
>> + struct xfs_attri_log_item *attrip)
>> +{
>> + struct xfs_attrd_log_item *attrdp;
>> +
>> + ASSERT(tp != NULL);
>> +
>> + attrdp = xfs_attrd_init(tp->t_mountp, attrip);
>> + ASSERT(attrdp != NULL);
>> +
>> + /*
>> + * Get a log_item_desc to point at the new item.
>> + */
>> + xfs_trans_add_item(tp, &attrdp->item);
>> + return attrdp;
>> +}
>> +
>> +/*
>> + * Delete an attr and log it to the ATTRD. Note that the transaction is marked
>> + * dirty regardless of whether the attr delete succeeds or fails to support the
>> + * ATTRI/ATTRD lifecycle rules.
>> + */
>> +int
>> +xfs_trans_attr(
>> + struct xfs_trans *tp,
>> + struct xfs_defer_ops *dfops,
>> + struct xfs_attrd_log_item *attrdp,
>> + struct xfs_inode *ip,
>> + uint32_t op_flags,
>> + uint32_t flags,
>> + uint32_t name_len,
>> + uint32_t value_len,
>> + char *name,
>> + char *value)
>> +{
>> + int error;
>> + int local;
>> + struct xfs_da_args args;
>> + xfs_fsblock_t firstblock = NULLFSBLOCK;
>> + struct xfs_buf *leaf_bp = NULL;
>> +
>> + error = xfs_attr_args_init(&args, ip, name, flags);
>> + if (error)
>> + goto out;
>> +
>> + args.name = name;
>> + args.namelen = name_len;
>> + args.hashval = xfs_da_hashname(args.name, args.namelen);
>> + args.value = value;
>> + args.valuelen = value_len;
>> + args.dfops = dfops;
>> + args.firstblock = &firstblock;
>> + args.op_flags = XFS_DA_OP_OKNOENT;
>> + args.total = xfs_attr_calc_size(&args, &local);
>> + args.trans = tp;
>> + ASSERT(local);
>> +
>> + error = xfs_qm_dqattach_locked(ip, 0);
>> + if (error)
>> + return error;
>> +
>> + xfs_trans_ijoin(args.trans, ip, 0);
>> + switch (op_flags) {
>> + case XFS_ATTR_OP_FLAGS_SET:
>> + args.op_flags |= XFS_DA_OP_ADDNAME;
>> + error = xfs_attr_set_args(&args, flags,
>> + leaf_bp, false);
>> + break;
>> + case XFS_ATTR_OP_FLAGS_REMOVE:
>> + ASSERT(XFS_IFORK_Q((ip)));
>> + error = xfs_attr_remove_args(&args, flags, false);
>> + break;
>> + default:
>> + error = -EFSCORRUPTED;
>> + }
>> +
>> +out:
>> + if (error) {
>> + if (leaf_bp)
>> + xfs_trans_brelse(args.trans, leaf_bp);
>> + }
>> +
>> + /*
>> + * Mark the transaction dirty, even on error. This ensures the
>> + * transaction is aborted, which:
>> + *
>> + * 1.) releases the ATTRI and frees the ATTRD
>> + * 2.) shuts down the filesystem
>> + */
>> + tp->t_flags |= XFS_TRANS_DIRTY;
>> + attrdp->item.li_desc->lid_flags |= XFS_LID_DIRTY;
>> + attrdp->name = name;
>> + attrdp->value = value;
>> + attrdp->name_len = name_len;
>> + attrdp->value_len = value_len;
>> + attrdp->next_attr++;
>> +
>> + attrdp->attrip->name = name;
>> + attrdp->attrip->value = value;
>> + attrdp->attrip->name_len = name_len;
>> + attrdp->attrip->value_len = value_len;
>> +
>> + return error;
>> +}
>> +
>> +static int
>> +xfs_attr_diff_items(
>> + void *priv,
>> + struct list_head *a,
>> + struct list_head *b)
>> +{
>> + return 0;
>> +}
>> +
>> +/* Get an ATTRI. */
>> +STATIC void *
>> +xfs_attr_create_intent(
>> + struct xfs_trans *tp,
>> + unsigned int count)
>> +{
>> + struct xfs_attri_log_item *attrip;
>> +
>> + ASSERT(tp != NULL);
>> + ASSERT(count == 1);
>> +
>> + attrip = xfs_attri_init(tp->t_mountp);
>> + ASSERT(attrip != NULL);
>> +
>> + /*
>> + * Get a log_item_desc to point at the new item.
>> + */
>> + xfs_trans_add_item(tp, &attrip->item);
>> + return attrip;
>> +}
>> +
>> +/* Log an attr to the intent item. */
>> +STATIC void
>> +xfs_attr_log_item(
>> + struct xfs_trans *tp,
>> + void *intent,
>> + struct list_head *item)
>> +{
>> + struct xfs_attri_log_item *attrip = intent;
>> + struct xfs_attr_item *free;
>> + struct xfs_attri_log_format *attrp;
>> + char *name_value;
>> +
>> + free = container_of(item, struct xfs_attr_item, xattri_list);
>> + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
>> +
>> + tp->t_flags |= XFS_TRANS_DIRTY;
>> + attrip->item.li_desc->lid_flags |= XFS_LID_DIRTY;
>> +
>> + attrp = &attrip->format;
>> + attrp->alfi_ino = free->xattri_ip->i_ino;
>> + attrp->alfi_op_flags = free->xattri_op_flags;
>> + attrp->alfi_value_len = free->xattri_value_len;
>> + attrp->alfi_name_len = free->xattri_name_len;
>> + attrp->alfi_attr_flags = free->xattri_flags;
>> +
>> + attrip->name = name_value;
>> + attrip->value = &name_value[free->xattri_name_len];
>> + attrip->name_len = free->xattri_name_len;
>> + attrip->value_len = free->xattri_value_len;
>> +}
>> +
>> +/* Get an ATTRD so we can process all the attrs. */
>> +STATIC void *
>> +xfs_attr_create_done(
>> + struct xfs_trans *tp,
>> + void *intent,
>> + unsigned int count)
>> +{
>> + return xfs_trans_get_attrd(tp, intent);
>> +}
>> +
>> +/* Process an attr. */
>> +STATIC int
>> +xfs_attr_finish_item(
>> + struct xfs_trans *tp,
>> + struct xfs_defer_ops *dop,
>> + struct list_head *item,
>> + void *done_item,
>> + void **state)
>> +{
>> + struct xfs_attr_item *free;
>> + char *name_value;
>> + int error;
>> +
>> + free = container_of(item, struct xfs_attr_item, xattri_list);
>> + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
>> + error = xfs_trans_attr(tp, dop, done_item,
>> + free->xattri_ip,
>> + free->xattri_op_flags,
>> + free->xattri_flags,
>> + free->xattri_name_len,
>> + free->xattri_value_len,
>> + name_value,
>> + &name_value[free->xattri_name_len]);
>> + kmem_free(free);
>> + return error;
>> +}
>> +
>> +/* Abort all pending ATTRs. */
>> +STATIC void
>> +xfs_attr_abort_intent(
>> + void *intent)
>> +{
>> + xfs_attri_release(intent);
>> +}
>> +
>> +/* Cancel an attr */
>> +STATIC void
>> +xfs_attr_cancel_item(
>> + struct list_head *item)
>> +{
>> + struct xfs_attr_item *free;
>> +
>> + free = container_of(item, struct xfs_attr_item, xattri_list);
>> + kmem_free(free);
>> +}
>> +
>> +static const struct xfs_defer_op_type xfs_attr_defer_type = {
>> + .type = XFS_DEFER_OPS_TYPE_ATTR,
>> + .max_items = XFS_ATTRI_MAX_FAST_ATTRS,
>> + .diff_items = xfs_attr_diff_items,
>> + .create_intent = xfs_attr_create_intent,
>> + .abort_intent = xfs_attr_abort_intent,
>> + .log_item = xfs_attr_log_item,
>> + .create_done = xfs_attr_create_done,
>> + .finish_item = xfs_attr_finish_item,
>> + .cancel_item = xfs_attr_cancel_item,
>> +};
>> +
>> +/* Register the deferred op type. */
>> +void
>> +xfs_attr_init_defer_op(void)
>> +{
>> + xfs_defer_init_op_type(&xfs_attr_defer_type);
>> +}
>> --
>> 2.7.4
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at https://urldefense.proofpoint.com/v2/url?u=http-3A__vger.kernel.org_majordomo-2Dinfo.html&d=DwIBAg&c=RoP1YumCXCgaWHvlZYR8PZh8Bv7qIrMUB65eapI_JnE&r=LHZQ8fHvy6wDKXGTWcm97burZH5sQKHRDMaY1UthQxc&m=WNyr4I99lOPWy3CEyGiGB-PXxqVQekB-idls3xgYVKo&s=88noL8uUCtH6GyRq653iitg0whoYcu6m5yxuaLaQvio&e=
^ permalink raw reply [flat|nested] 33+ messages in thread
* Re: [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations
2018-06-14 1:28 ` Allison Henderson
@ 2018-06-14 11:13 ` Brian Foster
0 siblings, 0 replies; 33+ messages in thread
From: Brian Foster @ 2018-06-14 11:13 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Wed, Jun 13, 2018 at 06:28:38PM -0700, Allison Henderson wrote:
> On 06/13/2018 08:18 AM, Brian Foster wrote:
> > On Sat, Jun 09, 2018 at 10:04:51PM -0700, Allison Henderson wrote:
> > > This patch adds two new log item types for setting or
> > > removing attributes as deferred operations. The
> > > xfs_attri_log_item logs an intent to set or remove an
> > > attribute. The corresponding xfs_attrd_log_item holds
> > > a reference to the xfs_attri_log_item and is freed once
> > > the transaction is done. Both log items use a generic
> > > xfs_attr_log_format structure that contains the attribute
> > > name, value, flags, inode, and an op_flag that indicates
> > > if the operations is a set or remove.
> > >
> > > At the moment, this feature will only be used by the parent
> > > pointer patch set which uses attributes to store information
> > > about an inodes parent.
> > >
> > > Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
> > > ---
> >
> > Looks mostly sane, though I haven't looked into all the details or the
> > recovery code yet. It does look like this needs to be rebased on top of
> > the recent elimination of the log item descriptor. A few comments in the
> > meantime...
> >
> > > fs/xfs/Makefile | 2 +
> > > fs/xfs/libxfs/xfs_attr.c | 5 +-
> > > fs/xfs/libxfs/xfs_attr.h | 26 +-
> > > fs/xfs/libxfs/xfs_defer.h | 1 +
> > > fs/xfs/libxfs/xfs_log_format.h | 44 +++-
> > > fs/xfs/libxfs/xfs_types.h | 1 +
> > > fs/xfs/xfs_attr_item.c | 560 +++++++++++++++++++++++++++++++++++++++++
> > > fs/xfs/xfs_attr_item.h | 120 +++++++++
> > > fs/xfs/xfs_log_recover.c | 173 +++++++++++++
> > > fs/xfs/xfs_ondisk.h | 2 +
> > > fs/xfs/xfs_super.c | 1 +
> > > fs/xfs/xfs_trans.h | 14 ++
> > > fs/xfs/xfs_trans_attr.c | 285 +++++++++++++++++++++
> > > 13 files changed, 1229 insertions(+), 5 deletions(-)
> > >
> > > diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
> > > index 7ceb41a..d3c0004 100644
> > > --- a/fs/xfs/Makefile
> > > +++ b/fs/xfs/Makefile
> > > @@ -107,6 +107,7 @@ xfs-y += xfs_log.o \
> > > xfs_bmap_item.o \
> > > xfs_buf_item.o \
> > > xfs_extfree_item.o \
> > > + xfs_attr_item.o \
> > > xfs_icreate_item.o \
> > > xfs_inode_item.o \
> > > xfs_refcount_item.o \
> > > @@ -116,6 +117,7 @@ xfs-y += xfs_log.o \
> > > xfs_trans_bmap.o \
> > > xfs_trans_buf.o \
> > > xfs_trans_extfree.o \
> > > + xfs_trans_attr.o \
> > > xfs_trans_inode.o \
> > > xfs_trans_refcount.o \
> > > xfs_trans_rmap.o \
> > > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > > index ab769e5..408a49d 100644
> > > --- a/fs/xfs/libxfs/xfs_attr.c
> > > +++ b/fs/xfs/libxfs/xfs_attr.c
> > > @@ -41,6 +41,7 @@
> > > #include "xfs_quota.h"
> > > #include "xfs_trans_space.h"
> > > #include "xfs_trace.h"
> > > +#include "xfs_attr_item.h"
> > > /*
> > > * xfs_attr.c
> > > @@ -74,7 +75,7 @@ STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
> > > STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
> > > -STATIC int
> > > +int
> > > xfs_attr_args_init(
> > > struct xfs_da_args *args,
> > > struct xfs_inode *dp,
> > > @@ -170,7 +171,7 @@ xfs_attr_get(
> > > /*
> > > * Calculate how many blocks we need for the new attribute,
> > > */
> > > -STATIC int
> > > +int
> > > xfs_attr_calc_size(
> > > struct xfs_da_args *args,
> > > int *local)
> > > diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
> > > index ef6b47e..33b33d3 100644
> > > --- a/fs/xfs/libxfs/xfs_attr.h
> > > +++ b/fs/xfs/libxfs/xfs_attr.h
> > > @@ -18,6 +18,8 @@
> > > #ifndef __XFS_ATTR_H__
> > > #define __XFS_ATTR_H__
> > > +#include "libxfs/xfs_defer.h"
> > > +
> >
> > Why is this necessary? I think we usually try to keep includes out of
> > header files, but I could be wrong.
> I think this was left over from another piece of code I had tried here. I
> will see if I can take it out
>
> >
> > > struct xfs_inode;
> > > struct xfs_da_args;
> > > struct xfs_attr_list_context;
> > > @@ -90,6 +92,26 @@ typedef struct attrlist_ent { /* data from attr_list() */
> > > } attrlist_ent_t;
> > > /*
> > > + * List of attrs to commit later.
> > > + */
> > > +struct xfs_attr_item {
> > > + struct xfs_inode *xattri_ip;
> > > + uint32_t xattri_op_flags;
> > > + uint32_t xattri_value_len; /* length of value */
> > > + uint32_t xattri_name_len; /* length of name */
> > > + uint32_t xattri_flags; /* attr flags */
> > > + struct list_head xattri_list;
> > > +
> > > + /*
> > > + * A byte array follows the header containing the file name and
> > > + * attribute value.
> > > + */
> >
> > This isn't really a header though, right? This is more of an in-core
> > structure to carry the attr information into the dfops infrastructure..?
> >
> > Hmm, I'm wondering if this would just be cleaner with separate
> > allocations so we can actually have name/value fields. Or perhaps a
> > compromise could be the current single alloc with name/value pointers
> > that are fixed up to refer to the memory after the static part of the
> > data structure? Then we could clean up some of the dfops callouts that
> > access this data a bit.
> >
> I think I recall us discussing this in another review a long time ago, and
> what we ended up doing was creating the name value pointers in
> xfs_attri_log_item and then pointing them here. I suppose we could put
> another set in here too if it makes it easier, but then it's more pointers
> to initialize and manage too.
>
Perhaps, it's certainly been long enough that I've lost track. ;)
My expectation is that the pointer initialization would be a one-time
thing at xfs_attr_item allocation time. From then on,
xfs_attr_item->[name|value] point to the respective data and we don't
have to do things like this in the dfops code:
name_value = ((char *)free) + sizeof(struct xfs_attr_item);
...
attrip->value = &name_value[free->xattri_name_len];
... but rather something like:
attrip->name = attr->name;
attrip->value = attr->value;
... which IMO makes the code more simple overall. We could also consider
something like accessor inlines or macros to avoid open-coding the
above, but personally I find the pointers more clean.
Brian
> > > +};
> > > +
> > > +#define XFS_ATTR_ITEM_SIZEOF(namelen, valuelen) \
> > > + (sizeof(struct xfs_attr_item) + (namelen) + (valuelen))
> > > +
> > > +/*
> > > * Given a pointer to the (char*) buffer containing the attr_list() result,
> > > * and an index, return a pointer to the indicated attribute in the buffer.
> > > */
> > > @@ -158,6 +180,8 @@ int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
> > > int xfs_attr_remove_args(struct xfs_da_args *args, int flags, bool roll_trans);
> > > int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
> > > int flags, struct attrlist_cursor_kern *cursor);
> > > -
> > > +int xfs_attr_args_init(struct xfs_da_args *args, struct xfs_inode *dp,
> > > + const unsigned char *name, int flags);
> > > +int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
> > > #endif /* __XFS_ATTR_H__ */
> > > diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
> > > index 045beac..11e1690 100644
> > > --- a/fs/xfs/libxfs/xfs_defer.h
> > > +++ b/fs/xfs/libxfs/xfs_defer.h
> > > @@ -55,6 +55,7 @@ enum xfs_defer_ops_type {
> > > XFS_DEFER_OPS_TYPE_REFCOUNT,
> > > XFS_DEFER_OPS_TYPE_RMAP,
> > > XFS_DEFER_OPS_TYPE_FREE,
> > > + XFS_DEFER_OPS_TYPE_ATTR,
> > > XFS_DEFER_OPS_TYPE_MAX,
> > > };
> > > diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
> > > index 349d9f8..291e5ff 100644
> > > --- a/fs/xfs/libxfs/xfs_log_format.h
> > > +++ b/fs/xfs/libxfs/xfs_log_format.h
> > > @@ -116,7 +116,12 @@ static inline uint xlog_get_cycle(char *ptr)
> > > #define XLOG_REG_TYPE_CUD_FORMAT 24
> > > #define XLOG_REG_TYPE_BUI_FORMAT 25
> > > #define XLOG_REG_TYPE_BUD_FORMAT 26
> > > -#define XLOG_REG_TYPE_MAX 26
> > > +#define XLOG_REG_TYPE_ATTRI_FORMAT 27
> > > +#define XLOG_REG_TYPE_ATTRD_FORMAT 28
> > > +#define XLOG_REG_TYPE_ATTR_NAME 29
> > > +#define XLOG_REG_TYPE_ATTR_VALUE 30
> > > +#define XLOG_REG_TYPE_MAX 31
> > > +
> > > /*
> > > * Flags to log operation header
> > > @@ -239,6 +244,8 @@ typedef struct xfs_trans_header {
> > > #define XFS_LI_CUD 0x1243
> > > #define XFS_LI_BUI 0x1244 /* bmbt update intent */
> > > #define XFS_LI_BUD 0x1245
> > > +#define XFS_LI_ATTRI 0x1246 /* attr set/remove intent*/
> > > +#define XFS_LI_ATTRD 0x1247 /* attr set/remove done */
> > > #define XFS_LI_TYPE_DESC \
> > > { XFS_LI_EFI, "XFS_LI_EFI" }, \
> > > @@ -254,7 +261,9 @@ typedef struct xfs_trans_header {
> > > { XFS_LI_CUI, "XFS_LI_CUI" }, \
> > > { XFS_LI_CUD, "XFS_LI_CUD" }, \
> > > { XFS_LI_BUI, "XFS_LI_BUI" }, \
> > > - { XFS_LI_BUD, "XFS_LI_BUD" }
> > > + { XFS_LI_BUD, "XFS_LI_BUD" }, \
> > > + { XFS_LI_ATTRI, "XFS_LI_ATTRI" }, \
> > > + { XFS_LI_ATTRD, "XFS_LI_ATTRD" }
> > > /*
> > > * Inode Log Item Format definitions.
> > > @@ -852,4 +861,35 @@ struct xfs_icreate_log {
> > > __be32 icl_gen; /* inode generation number to use */
> > > };
> > > +/*
> > > + * Flags for deferred attribute operations.
> > > + * Upper bits are flags, lower byte is type code
> > > + */
> > > +#define XFS_ATTR_OP_FLAGS_SET 1 /* Set the attribute */
> > > +#define XFS_ATTR_OP_FLAGS_REMOVE 2 /* Remove the attribute */
> > > +#define XFS_ATTR_OP_FLAGS_TYPE_MASK 0x0FF /* Flags type mask */
> > > +
> > > +/*
> > > + * This is the structure used to lay out an attr log item in the
> > > + * log.
> > > + */
> > > +struct xfs_attri_log_format {
> > > + uint16_t alfi_type; /* attri log item type */
> > > + uint16_t alfi_size; /* size of this item */
> > > + uint32_t __pad; /* pad to 64 bit aligned */
> > > + uint64_t alfi_id; /* attri identifier */
> > > + xfs_ino_t alfi_ino; /* the inode for this attr operation */
> > > + uint32_t alfi_op_flags; /* marks the op as a set or remove */
> > > + uint32_t alfi_name_len; /* attr name length */
> > > + uint32_t alfi_value_len; /* attr value length */
> > > + uint32_t alfi_attr_flags;/* attr flags */
> > > +};
> > > +
> > > +struct xfs_attrd_log_format {
> > > + uint16_t alfd_type; /* attrd log item type */
> > > + uint16_t alfd_size; /* size of this item */
> > > + uint32_t __pad; /* pad to 64 bit aligned */
> > > + uint64_t alfd_alf_id; /* id of corresponding attrd */
> > > +};
> > > +
> > > #endif /* __XFS_LOG_FORMAT_H__ */
> > > diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
> > > index 3c56069..2905ce3 100644
> > > --- a/fs/xfs/libxfs/xfs_types.h
> > > +++ b/fs/xfs/libxfs/xfs_types.h
> > > @@ -23,6 +23,7 @@ typedef uint32_t prid_t; /* project ID */
> > > typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
> > > typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
> > > typedef uint32_t xfs_extlen_t; /* extent length in blocks */
> > > +typedef uint32_t xfs_attrlen_t; /* attr length */
> > > typedef uint32_t xfs_agnumber_t; /* allocation group number */
> > > typedef int32_t xfs_extnum_t; /* # of extents in a file */
> > > typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
> > > diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
> > > new file mode 100644
> > > index 0000000..e90d516
> > > --- /dev/null
> > > +++ b/fs/xfs/xfs_attr_item.c
> > > @@ -0,0 +1,560 @@
> > > +/*
> > > + * Copyright (c) 2017 Oracle, Inc.
> > > + * All Rights Reserved.
> > > + *
> > > + * This program is free software; you can redistribute it and/or
> > > + * modify it under the terms of the GNU General Public License as
> > > + * published by the Free Software Foundation.
> > > + *
> > > + * This program is distributed in the hope that it would be useful,
> > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> > > + * GNU General Public License for more details.
> > > + *
> > > + * You should have received a copy of the GNU General Public License
> > > + * along with this program; if not, write the Free Software Foundation Inc.
> > > + */
> > > +#include "xfs.h"
> > > +#include "xfs_fs.h"
> > > +#include "xfs_format.h"
> > > +#include "xfs_log_format.h"
> > > +#include "xfs_trans_resv.h"
> > > +#include "xfs_bit.h"
> > > +#include "xfs_mount.h"
> > > +#include "xfs_trans.h"
> > > +#include "xfs_trans_priv.h"
> > > +#include "xfs_buf_item.h"
> > > +#include "xfs_attr_item.h"
> > > +#include "xfs_log.h"
> > > +#include "xfs_btree.h"
> > > +#include "xfs_rmap.h"
> > > +#include "xfs_inode.h"
> > > +#include "xfs_icache.h"
> > > +
> > > +static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip)
> > > +{
> > > + return container_of(lip, struct xfs_attri_log_item, item);
> > > +}
> > > +
> > > +void
> > > +xfs_attri_item_free(
> > > + struct xfs_attri_log_item *attrip)
> > > +{
> > > + kmem_free(attrip->item.li_lv_shadow);
> > > + kmem_free(attrip);
> > > +}
> > > +
> > > +/*
> > > + * This returns the number of iovecs needed to log the given attri item.
> > > + * We only need 1 iovec for an attri item. It just logs the attr_log_format
> > > + * structure.
> > > + */
> > > +static inline int
> > > +xfs_attri_item_sizeof(
> > > + struct xfs_attri_log_item *attrip)
> > > +{
> > > + return sizeof(struct xfs_attri_log_format);
> > > +}
> > > +
> > > +STATIC void
> > > +xfs_attri_item_size(
> > > + struct xfs_log_item *lip,
> > > + int *nvecs,
> > > + int *nbytes)
> > > +{
> > > + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> > > +
> > > + *nvecs += 1;
> > > + *nbytes += xfs_attri_item_sizeof(attrip);
> > > +
> > > + if (attrip->name_len > 0) {
> > > + *nvecs += 1;
> > > + nbytes += ATTR_NVEC_SIZE(attrip->name_len);
> > > + }
> > > +
> > > + if (attrip->value_len > 0) {
> > > + *nvecs += 1;
> > > + nbytes += ATTR_NVEC_SIZE(attrip->value_len);
> > > + }
> > > +}
> > > +
> > > +/*
> > > + * This is called to fill in the vector of log iovecs for the
> > > + * given attri log item. We use only 1 iovec, and we point that
> > > + * at the attri_log_format structure embedded in the attri item.
> > > + * It is at this point that we assert that all of the attr
> > > + * slots in the attri item have been filled.
> > > + */
> > > +STATIC void
> > > +xfs_attri_item_format(
> > > + struct xfs_log_item *lip,
> > > + struct xfs_log_vec *lv)
> > > +{
> > > + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> > > + struct xfs_log_iovec *vecp = NULL;
> > > +
> > > + attrip->format.alfi_type = XFS_LI_ATTRI;
> > > + attrip->format.alfi_size = 1;
> > > + if (attrip->name_len > 0)
> > > + attrip->format.alfi_size++;
> > > + if (attrip->value_len > 0)
> > > + attrip->format.alfi_size++;
> > > +
> > > + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRI_FORMAT,
> > > + &attrip->format,
> > > + xfs_attri_item_sizeof(attrip));
> > > + if (attrip->name_len > 0)
> > > + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_NAME,
> > > + attrip->name, ATTR_NVEC_SIZE(attrip->name_len));
> > > +
> > > + if (attrip->value_len > 0)
> > > + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTR_VALUE,
> > > + attrip->value,
> > > + ATTR_NVEC_SIZE(attrip->value_len));
> > > +}
> > > +
> > > +
> > > +/*
> > > + * Pinning has no meaning for an attri item, so just return.
> > > + */
> > > +STATIC void
> > > +xfs_attri_item_pin(
> > > + struct xfs_log_item *lip)
> > > +{
> > > +}
> > > +
> > > +/*
> > > + * The unpin operation is the last place an ATTRI is manipulated in the log. It
> > > + * is either inserted in the AIL or aborted in the event of a log I/O error. In
> > > + * either case, the ATTRI transaction has been successfully committed to make it
> > > + * this far. Therefore, we expect whoever committed the ATTRI to either
> > > + * construct and commit the ATTRD or drop the ATTRD's reference in the event of
> > > + * error. Simply drop the log's ATTRI reference now that the log is done with
> > > + * it.
> > > + */
> > > +STATIC void
> > > +xfs_attri_item_unpin(
> > > + struct xfs_log_item *lip,
> > > + int remove)
> > > +{
> > > + struct xfs_attri_log_item *attrip = ATTRI_ITEM(lip);
> > > +
> > > + xfs_attri_release(attrip);
> > > +}
> > > +
> > > +/*
> > > + * attri items have no locking or pushing. However, since ATTRIs are pulled
> > > + * from the AIL when their corresponding ATTRDs are committed to disk, their
> > > + * situation is very similar to being pinned. Return XFS_ITEM_PINNED so that
> > > + * the caller will eventually flush the log. This should help in getting the
> > > + * ATTRI out of the AIL.
> > > + */
> > > +STATIC uint
> > > +xfs_attri_item_push(
> > > + struct xfs_log_item *lip,
> > > + struct list_head *buffer_list)
> > > +{
> > > + return XFS_ITEM_PINNED;
> > > +}
> > > +
> > > +/*
> > > + * The ATTRI has been either committed or aborted if the transaction has been
> > > + * cancelled. If the transaction was cancelled, an ATTRD isn't going to be
> > > + * constructed and thus we free the ATTRI here directly.
> > > + */
> > > +STATIC void
> > > +xfs_attri_item_unlock(
> > > + struct xfs_log_item *lip)
> > > +{
> > > + if (lip->li_flags & XFS_LI_ABORTED)
> > > + xfs_attri_release(ATTRI_ITEM(lip));
> > > +}
> > > +
> > > +/*
> > > + * The ATTRI is logged only once and cannot be moved in the log, so simply
> > > + * return the lsn at which it's been logged.
> > > + */
> > > +STATIC xfs_lsn_t
> > > +xfs_attri_item_committed(
> > > + struct xfs_log_item *lip,
> > > + xfs_lsn_t lsn)
> > > +{
> > > + return lsn;
> > > +}
> > > +
> > > +STATIC void
> > > +xfs_attri_item_committing(
> > > + struct xfs_log_item *lip,
> > > + xfs_lsn_t lsn)
> > > +{
> > > +}
> > > +
> > > +/*
> > > + * This is the ops vector shared by all attri log items.
> > > + */
> > > +static const struct xfs_item_ops xfs_attri_item_ops = {
> > > + .iop_size = xfs_attri_item_size,
> > > + .iop_format = xfs_attri_item_format,
> > > + .iop_pin = xfs_attri_item_pin,
> > > + .iop_unpin = xfs_attri_item_unpin,
> > > + .iop_unlock = xfs_attri_item_unlock,
> > > + .iop_committed = xfs_attri_item_committed,
> > > + .iop_push = xfs_attri_item_push,
> > > + .iop_committing = xfs_attri_item_committing
> > > +};
> > > +
> > > +
> > > +/*
> > > + * Allocate and initialize an attri item
> > > + */
> > > +struct xfs_attri_log_item *
> > > +xfs_attri_init(
> > > + struct xfs_mount *mp)
> > > +
> > > +{
> > > + struct xfs_attri_log_item *attrip;
> > > + uint size;
> > > +
> > > + size = (uint)(sizeof(struct xfs_attri_log_item));
> > > + attrip = kmem_zalloc(size, KM_SLEEP);
> > > +
> > > + xfs_log_item_init(mp, &(attrip->item), XFS_LI_ATTRI,
> > > + &xfs_attri_item_ops);
> > > + attrip->format.alfi_id = (uintptr_t)(void *)attrip;
> > > + atomic_set(&attrip->refcount, 2);
> > > +
> > > + return attrip;
> > > +}
> > > +
> > > +/*
> > > + * Copy an attr format buffer from the given buf, and into the destination
> > > + * attr format structure.
> > > + */
> > > +int
> > > +xfs_attri_copy_format(struct xfs_log_iovec *buf,
> > > + struct xfs_attri_log_format *dst_attr_fmt)
> > > +{
> > > + struct xfs_attri_log_format *src_attr_fmt = buf->i_addr;
> > > + uint len = sizeof(struct xfs_attri_log_format);
> > > +
> > > + if (buf->i_len == len) {
> > > + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
> > > + return 0;
> > > + }
> > > + return -EFSCORRUPTED;
> > > +}
> > > +
> > > +/*
> > > + * Copy an attr format buffer from the given buf, and into the destination
> > > + * attr format structure.
> > > + */
> > > +int
> > > +xfs_attrd_copy_format(struct xfs_log_iovec *buf,
> > > + struct xfs_attrd_log_format *dst_attr_fmt)
> > > +{
> > > + struct xfs_attrd_log_format *src_attr_fmt = buf->i_addr;
> > > + uint len = sizeof(struct xfs_attrd_log_format);
> > > +
> > > + if (buf->i_len == len) {
> > > + memcpy((char *)dst_attr_fmt, (char *)src_attr_fmt, len);
> > > + return 0;
> > > + }
> > > + return -EFSCORRUPTED;
> > > +}
> > > +
> > > +/*
> > > + * Freeing the attrip requires that we remove it from the AIL if it has already
> > > + * been placed there. However, the ATTRI may not yet have been placed in the AIL
> > > + * when called by xfs_attri_release() from ATTRD processing due to the ordering of
> > > + * committed vs unpin operations in bulk insert operations. Hence the reference
> > > + * count to ensure only the last caller frees the ATTRI.
> > > + */
> > > +void
> > > +xfs_attri_release(
> > > + struct xfs_attri_log_item *attrip)
> > > +{
> > > + ASSERT(atomic_read(&attrip->refcount) > 0);
> > > + if (atomic_dec_and_test(&attrip->refcount)) {
> > > + xfs_trans_ail_remove(&attrip->item, SHUTDOWN_LOG_IO_ERROR);
> > > + xfs_attri_item_free(attrip);
> > > + }
> > > +}
> > > +
> >
> > Looks like minor whitespace damage on the line above.
> >
> > > +static inline struct xfs_attrd_log_item *ATTRD_ITEM(struct xfs_log_item *lip)
> > > +{
> > > + return container_of(lip, struct xfs_attrd_log_item, item);
> > > +}
> > > +
> > > +STATIC void
> > > +xfs_attrd_item_free(struct xfs_attrd_log_item *attrdp)
> > > +{
> > > + kmem_free(attrdp->item.li_lv_shadow);
> > > + kmem_free(attrdp);
> > > +}
> > > +
> > > +/*
> > > + * This returns the number of iovecs needed to log the given attrd item.
> > > + * We only need 1 iovec for an attrd item. It just logs the attr_log_format
> > > + * structure.
> > > + */
> > > +static inline int
> > > +xfs_attrd_item_sizeof(
> > > + struct xfs_attrd_log_item *attrdp)
> > > +{
> > > + return sizeof(struct xfs_attrd_log_format);
> > > +}
> > > +
> > > +STATIC void
> > > +xfs_attrd_item_size(
> > > + struct xfs_log_item *lip,
> > > + int *nvecs,
> > > + int *nbytes)
> > > +{
> > > + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> > > + *nvecs += 1;
> > > + *nbytes += xfs_attrd_item_sizeof(attrdp);
> > > +
> > > + if (attrdp->name_len > 0) {
> > > + *nvecs += 1;
> > > + nbytes += attrdp->name_len;
> > > + }
> > > +
> > > + if (attrdp->value_len > 0) {
> > > + *nvecs += 1;
> > > + nbytes += attrdp->value_len;
> > > + }
> >
> > I don't think you need to incorporate the name/value lengths in the size
> > of the done item. The done item already refers to the intent item. The
> > purpose of the iop_size() call is to help the log infrastructure size
> > the vectors required for writing to the log, and as the
> > attrd_item_format() call shows below, we only format the vector with the
> > xfs_attrd_log_format.
> >
> > > +}
> > > +
> > > +/*
> > > + * This is called to fill in the vector of log iovecs for the
> > > + * given attrd log item. We use only 1 iovec, and we point that
> > > + * at the attr_log_format structure embedded in the attrd item.
> > > + * It is at this point that we assert that all of the attr
> > > + * slots in the attrd item have been filled.
> > > + */
> > > +STATIC void
> > > +xfs_attrd_item_format(
> > > + struct xfs_log_item *lip,
> > > + struct xfs_log_vec *lv)
> > > +{
> > > + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> > > + struct xfs_log_iovec *vecp = NULL;
> > > +
> > > + attrdp->format.alfd_type = XFS_LI_ATTRD;
> > > + attrdp->format.alfd_size = 1;
> > > +
> > > + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_ATTRD_FORMAT,
> > > + &attrdp->format,
> > > + xfs_attrd_item_sizeof(attrdp));
> > > +}
> > > +
> > > +/*
> > > + * Pinning has no meaning for an attrd item, so just return.
> > > + */
> > > +STATIC void
> > > +xfs_attrd_item_pin(
> > > + struct xfs_log_item *lip)
> > > +{
> > > +}
> > > +
> > > +/*
> > > + * Since pinning has no meaning for an attrd item, unpinning does
> > > + * not either.
> > > + */
> > > +STATIC void
> > > +xfs_attrd_item_unpin(
> > > + struct xfs_log_item *lip,
> > > + int remove)
> > > +{
> > > +}
> > > +
> > > +/*
> > > + * There isn't much you can do to push on an attrd item. It is simply stuck
> > > + * waiting for the log to be flushed to disk.
> > > + */
> > > +STATIC uint
> > > +xfs_attrd_item_push(
> > > + struct xfs_log_item *lip,
> > > + struct list_head *buffer_list)
> > > +{
> > > + return XFS_ITEM_PINNED;
> > > +}
> > > +
> > > +/*
> > > + * The ATTRD is either committed or aborted if the transaction is cancelled. If
> > > + * the transaction is cancelled, drop our reference to the ATTRI and free the
> > > + * ATTRD.
> > > + */
> > > +STATIC void
> > > +xfs_attrd_item_unlock(
> > > + struct xfs_log_item *lip)
> > > +{
> > > + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> > > +
> > > + if (lip->li_flags & XFS_LI_ABORTED) {
> > > + xfs_attri_release(attrdp->attrip);
> > > + xfs_attrd_item_free(attrdp);
> > > + }
> > > +}
> > > +
> > > +/*
> > > + * When the attrd item is committed to disk, all we need to do is delete our
> > > + * reference to our partner attri item and then free ourselves. Since we're
> > > + * freeing ourselves we must return -1 to keep the transaction code from
> > > + * further referencing this item.
> > > + */
> > > +STATIC xfs_lsn_t
> > > +xfs_attrd_item_committed(
> > > + struct xfs_log_item *lip,
> > > + xfs_lsn_t lsn)
> > > +{
> > > + struct xfs_attrd_log_item *attrdp = ATTRD_ITEM(lip);
> > > +
> > > + /*
> > > + * Drop the ATTRI reference regardless of whether the ATTRD has been
> > > + * aborted. Once the ATTRD transaction is constructed, it is the sole
> > > + * responsibility of the ATTRD to release the ATTRI (even if the ATTRI
> > > + * is aborted due to log I/O error).
> > > + */
> > > + xfs_attri_release(attrdp->attrip);
> > > + xfs_attrd_item_free(attrdp);
> > > +
> > > + return (xfs_lsn_t)-1;
> > > +}
> > > +
> > > +STATIC void
> > > +xfs_attrd_item_committing(
> > > + struct xfs_log_item *lip,
> > > + xfs_lsn_t lsn)
> > > +{
> > > +}
> > > +
> > > +/*
> > > + * This is the ops vector shared by all attrd log items.
> > > + */
> > > +static const struct xfs_item_ops xfs_attrd_item_ops = {
> > > + .iop_size = xfs_attrd_item_size,
> > > + .iop_format = xfs_attrd_item_format,
> > > + .iop_pin = xfs_attrd_item_pin,
> > > + .iop_unpin = xfs_attrd_item_unpin,
> > > + .iop_unlock = xfs_attrd_item_unlock,
> > > + .iop_committed = xfs_attrd_item_committed,
> > > + .iop_push = xfs_attrd_item_push,
> > > + .iop_committing = xfs_attrd_item_committing
> > > +};
> > > +
> > > +/*
> > > + * Allocate and initialize an attrd item
> > > + */
> > > +struct xfs_attrd_log_item *
> > > +xfs_attrd_init(
> > > + struct xfs_mount *mp,
> > > + struct xfs_attri_log_item *attrip)
> > > +
> > > +{
> > > + struct xfs_attrd_log_item *attrdp;
> > > + uint size;
> > > +
> > > + size = (uint)(sizeof(struct xfs_attrd_log_item));
> > > + attrdp = kmem_zalloc(size, KM_SLEEP);
> > > +
> > > + xfs_log_item_init(mp, &attrdp->item, XFS_LI_ATTRD,
> > > + &xfs_attrd_item_ops);
> > > + attrdp->attrip = attrip;
> > > + attrdp->format.alfd_alf_id = attrip->format.alfi_id;
> > > +
> > > + return attrdp;
> > > +}
> > > +
> > > +/*
> > > + * Process an attr intent item that was recovered from
> > > + * the log. We need to delete the attr that it describes.
> > > + */
> > > +int
> > > +xfs_attri_recover(
> > > + struct xfs_mount *mp,
> > > + struct xfs_attri_log_item *attrip,
> > > + struct xfs_defer_ops *dfops)
> > > +{
> > > + struct xfs_inode *ip;
> > > + struct xfs_attrd_log_item *attrdp;
> > > + struct xfs_trans *tp;
> > > + int error = 0;
> > > + struct xfs_attri_log_format *attrp;
> > > +
> > > + ASSERT(!test_bit(XFS_ATTRI_RECOVERED, &attrip->flags));
> > > +
> > > + /*
> > > + * First check the validity of the attr described by the
> > > + * ATTRI. If any are bad, then assume that all are bad and
> > > + * just toss the ATTRI.
> > > + */
> > > + attrp = &attrip->format;
> > > + if (
> > > + /*
> > > + * Must have either XFS_ATTR_OP_FLAGS_SET or
> > > + * XFS_ATTR_OP_FLAGS_REMOVE set
> > > + */
> > > + !(attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET ||
> > > + attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE) ||
> > > +
> > > + /* Check size of value and name lengths */
> > > + (attrp->alfi_value_len > XATTR_SIZE_MAX ||
> > > + attrp->alfi_name_len > XATTR_NAME_MAX) ||
> > > +
> > > + /*
> > > + * If the XFS_ATTR_OP_FLAGS_SET flag is set,
> > > + * there must also be a name and value
> > > + */
> > > + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_SET &&
> > > + (attrp->alfi_value_len == 0 || attrp->alfi_name_len == 0)) ||
> > > +
> > > + /*
> > > + * If the XFS_ATTR_OP_FLAGS_REMOVE flag is set,
> > > + * there must also be a name
> > > + */
> > > + (attrp->alfi_op_flags == XFS_ATTR_OP_FLAGS_REMOVE &&
> > > + (attrp->alfi_name_len == 0))
> > > + ) {
> > > + /*
> > > + * This will pull the ATTRI from the AIL and
> > > + * free the memory associated with it.
> > > + */
> > > + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
> > > + xfs_attri_release(attrip);
> > > + return -EIO;
> > > + }
> > > +
> > > + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
> > > + if (error)
> > > + return error;
> > > + attrdp = xfs_trans_get_attrd(tp, attrip);
> > > + attrp = &attrip->format;
> > > +
> > > + error = xfs_iget(mp, tp, attrp->alfi_ino, 0, 0, &ip);
> > > + if (error)
> > > + return error;
> > > +
> > > + xfs_ilock(ip, XFS_ILOCK_EXCL);
> > > +
> > > + error = xfs_trans_attr(tp, dfops, attrdp, ip,
> > > + attrp->alfi_op_flags,
> > > + attrp->alfi_attr_flags,
> > > + attrp->alfi_name_len,
> > > + attrp->alfi_value_len,
> > > + attrip->name,
> > > + attrip->value);
> > > + if (error)
> > > + goto abort_error;
> > > +
> > > +
> > > + set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
> > > + error = xfs_trans_commit(tp);
> > > + xfs_iunlock(ip, XFS_ILOCK_EXCL);
> > > + return error;
> > > +
> > > +abort_error:
> > > + xfs_trans_cancel(tp);
> > > + xfs_iunlock(ip, XFS_ILOCK_EXCL);
> > > + return error;
> > > +}
> > > diff --git a/fs/xfs/xfs_attr_item.h b/fs/xfs/xfs_attr_item.h
> > > new file mode 100644
> > > index 0000000..184e6b1
> > > --- /dev/null
> > > +++ b/fs/xfs/xfs_attr_item.h
> > > @@ -0,0 +1,120 @@
> > > +/*
> > > + * Copyright (c) 2017 Oracle, Inc.
> > > + * All Rights Reserved.
> > > + *
> > > + * This program is free software; you can redistribute it and/or
> > > + * modify it under the terms of the GNU General Public License as
> > > + * published by the Free Software Foundation.
> > > + *
> > > + * This program is distributed in the hope that it would be useful,
> > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> > > + * GNU General Public License for more details.
> > > + *
> > > + * You should have received a copy of the GNU General Public License
> > > + * along with this program; if not, write the Free Software Foundation Inc.
> > > + */
> > > +#ifndef __XFS_ATTR_ITEM_H__
> > > +#define __XFS_ATTR_ITEM_H__
> > > +
> > > +/* kernel only ATTRI/ATTRD definitions */
> > > +
> > > +struct xfs_mount;
> > > +struct kmem_zone;
> > > +
> > > +/*
> > > + * Max number of attrs in fast allocation path.
> > > + */
> > > +#define XFS_ATTRI_MAX_FAST_ATTRS 1
> > > +
> > > +
> > > +/*
> > > + * Define ATTR flag bits. Manipulated by set/clear/test_bit operators.
> > > + */
> > > +#define XFS_ATTRI_RECOVERED 1
> > > +
> > > +
> > > +/* nvecs must be in multiples of 4 */
> >
> > Why? Can you expand on the comment here? Also, any reason not to just
> > use round_up()?
> >
> > > +#define ATTR_NVEC_SIZE(size) (size == sizeof(int32_t) ? sizeof(int32_t) : \
> > > + size + sizeof(int32_t) - \
> > > + (size % sizeof(int32_t)))
> > > +
> > > +/*
> > > + * This is the "attr intention" log item. It is used to log the fact
> > > + * that some attrs need to be processed. It is used in conjunction with the
> > > + * "attr done" log item described below.
> > > + *
> > > + * The ATTRI is reference counted so that it is not freed prior to both the
> > > + * ATTRI and ATTRD being committed and unpinned. This ensures the ATTRI is
> > > + * inserted into the AIL even in the event of out of order ATTRI/ATTRD
> > > + * processing. In other words, an ATTRI is born with two references:
> > > + *
> > > + * 1.) an ATTRI held reference to track ATTRI AIL insertion
> > > + * 2.) an ATTRD held reference to track ATTRD commit
> > > + *
> > > + * On allocation, both references are the responsibility of the caller. Once
> > > + * the ATTRI is added to and dirtied in a transaction, ownership of reference
> > > + * one transfers to the transaction. The reference is dropped once the ATTRI is
> > > + * inserted to the AIL or in the event of failure along the way (e.g., commit
> > > + * failure, log I/O error, etc.). Note that the caller remains responsible for
> > > + * the ATTRD reference under all circumstances to this point. The caller has no
> > > + * means to detect failure once the transaction is committed, however.
> > > + * Therefore, an ATTRD is required after this point, even in the event of
> > > + * unrelated failure.
> > > + *
> > > + * Once an ATTRD is allocated and dirtied in a transaction, reference two
> > > + * transfers to the transaction. The ATTRD reference is dropped once it reaches
> > > + * the unpin handler. Similar to the ATTRI, the reference also drops in the
> > > + * event of commit failure or log I/O errors. Note that the ATTRD is not
> > > + * inserted in the AIL, so at this point both the ATTI and ATTRD are freed.
> > > + */
> > > +struct xfs_attri_log_item {
> > > + xfs_log_item_t item;
> > > + atomic_t refcount;
> > > + unsigned long flags; /* misc flags */
> > > + int name_len;
> > > + void *name;
> > > + int value_len;
> >
> I think maybe we can get along with out them. I will see if I can simplify
> these structs a bit.
>
> > Do we need the name and value lengths here (and in the attrd) if they
> > also exist in the xfs_attri_log_format?
> >
> > > + void *value;
> > > + struct xfs_attri_log_format format;
> > > +};
> > > +
> > > +/*
> > > + * This is the "attr done" log item. It is used to log
> > > + * the fact that some attrs earlier mentioned in an attri item
> > > + * have been freed.
> > > + */
> > > +struct xfs_attrd_log_item {
> > > + struct xfs_log_item item;
> > > + struct xfs_attri_log_item *attrip;
> > > + uint next_attr;
> >
> > This doesn't seem to be used. Holdover from one of the other log_item
> > types perhaps?
> I think so. Will clean out. Thx for the review!
>
> Allison
>
> >
> > > + int name_len;
> > > + void *name;
> > > + int value_len;
> > > + void *value;
> > > + struct xfs_attrd_log_format format;
> > > +};
> > > +
> > > +/*
> > > + * Max number of attrs in fast allocation path.
> > > + */
> > > +#define XFS_ATTRD_MAX_FAST_ATTRS 1
> > > +
> > > +extern struct kmem_zone *xfs_attri_zone;
> > > +extern struct kmem_zone *xfs_attrd_zone;
> > > +
> > > +struct xfs_attri_log_item *xfs_attri_init(struct xfs_mount *mp);
> > > +struct xfs_attrd_log_item *xfs_attrd_init(struct xfs_mount *mp,
> > > + struct xfs_attri_log_item *attrip);
> > > +int xfs_attri_copy_format(struct xfs_log_iovec *buf,
> > > + struct xfs_attri_log_format *dst_attri_fmt);
> > > +int xfs_attrd_copy_format(struct xfs_log_iovec *buf,
> > > + struct xfs_attrd_log_format *dst_attrd_fmt);
> > > +void xfs_attri_item_free(struct xfs_attri_log_item *attrip);
> > > +void xfs_attri_release(struct xfs_attri_log_item *attrip);
> > > +
> > > +int xfs_attri_recover(struct xfs_mount *mp,
> > > + struct xfs_attri_log_item *attrip,
> > > + struct xfs_defer_ops *dfops);
> > > +
> > > +#endif /* __XFS_ATTR_ITEM_H__ */
> > > diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
> > > index 2b2383f..b34e7f8 100644
> > > --- a/fs/xfs/xfs_log_recover.c
> > > +++ b/fs/xfs/xfs_log_recover.c
> > > @@ -34,6 +34,7 @@
> > > #include "xfs_log_recover.h"
> > > #include "xfs_inode_item.h"
> > > #include "xfs_extfree_item.h"
> > > +#include "xfs_attr_item.h"
> > > #include "xfs_trans_priv.h"
> > > #include "xfs_alloc.h"
> > > #include "xfs_ialloc.h"
> > > @@ -1967,6 +1968,8 @@ xlog_recover_reorder_trans(
> > > case XFS_LI_CUD:
> > > case XFS_LI_BUI:
> > > case XFS_LI_BUD:
> > > + case XFS_LI_ATTRI:
> > > + case XFS_LI_ATTRD:
> > > trace_xfs_log_recover_item_reorder_tail(log,
> > > trans, item, pass);
> > > list_move_tail(&item->ri_list, &inode_list);
> > > @@ -3497,6 +3500,117 @@ xlog_recover_efd_pass2(
> > > return 0;
> > > }
> > > +STATIC int
> > > +xlog_recover_attri_pass2(
> > > + struct xlog *log,
> > > + struct xlog_recover_item *item,
> > > + xfs_lsn_t lsn)
> > > +{
> > > + int error;
> > > + struct xfs_mount *mp = log->l_mp;
> > > + struct xfs_attri_log_item *attrip;
> > > + struct xfs_attri_log_format *attri_formatp;
> > > + char *name = NULL;
> > > + char *value = NULL;
> > > + int region = 0;
> > > +
> > > + attri_formatp = item->ri_buf[region].i_addr;
> > > +
> > > + attrip = xfs_attri_init(mp);
> > > + error = xfs_attri_copy_format(&item->ri_buf[region], &attrip->format);
> > > + if (error) {
> > > + xfs_attri_item_free(attrip);
> > > + return error;
> > > + }
> > > +
> > > + attrip->name_len = attri_formatp->alfi_name_len;
> > > + attrip->value_len = attri_formatp->alfi_value_len;
> > > + attrip = kmem_realloc(attrip, sizeof(struct xfs_attri_log_item) +
> > > + attrip->name_len + attrip->value_len, KM_SLEEP);
> > > +
> > > + if (attrip->name_len > 0) {
> > > + region++;
> > > + name = ((char *)attrip) + sizeof(struct xfs_attri_log_item);
> > > + memcpy(name, item->ri_buf[region].i_addr,
> > > + attrip->name_len);
> > > + attrip->name = name;
> > > + }
> > > +
> > > + if (attrip->value_len > 0) {
> > > + region++;
> > > + value = ((char *)attrip) + sizeof(struct xfs_attri_log_item) +
> > > + attrip->name_len;
> > > + memcpy(value, item->ri_buf[region].i_addr,
> > > + attrip->value_len);
> > > + attrip->value = value;
> > > + }
> > > +
> > > + spin_lock(&log->l_ailp->ail_lock);
> > > + /*
> > > + * The ATTRI has two references. One for the ATTRD and one for ATTRI to
> > > + * ensure it makes it into the AIL. Insert the ATTRI into the AIL
> > > + * directly and drop the ATTRI reference. Note that
> > > + * xfs_trans_ail_update() drops the AIL lock.
> > > + */
> > > + xfs_trans_ail_update(log->l_ailp, &attrip->item, lsn);
> > > + xfs_attri_release(attrip);
> > > + return 0;
> > > +}
> > > +
> > > +
> > > +/*
> > > + * This routine is called when an ATTRD format structure is found in a committed
> > > + * transaction in the log. Its purpose is to cancel the corresponding ATTRI if
> > > + * it was still in the log. To do this it searches the AIL for the ATTRI with
> > > + * an id equal to that in the ATTRD format structure. If we find it we drop
> > > + * the ATTRD reference, which removes the ATTRI from the AIL and frees it.
> > > + */
> > > +STATIC int
> > > +xlog_recover_attrd_pass2(
> > > + struct xlog *log,
> > > + struct xlog_recover_item *item)
> > > +{
> > > + struct xfs_attrd_log_format *attrd_formatp;
> > > + struct xfs_attri_log_item *attrip = NULL;
> > > + struct xfs_log_item *lip;
> > > + uint64_t attri_id;
> > > + struct xfs_ail_cursor cur;
> > > + struct xfs_ail *ailp = log->l_ailp;
> > > +
> > > + attrd_formatp = item->ri_buf[0].i_addr;
> > > + ASSERT((item->ri_buf[0].i_len ==
> > > + (sizeof(struct xfs_attrd_log_format))));
> > > + attri_id = attrd_formatp->alfd_alf_id;
> > > +
> > > + /*
> > > + * Search for the ATTRI with the id in the ATTRD format structure in the
> > > + * AIL.
> > > + */
> > > + spin_lock(&ailp->ail_lock);
> > > + lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
> > > + while (lip != NULL) {
> > > + if (lip->li_type == XFS_LI_ATTRI) {
> > > + attrip = (struct xfs_attri_log_item *)lip;
> > > + if (attrip->format.alfi_id == attri_id) {
> > > + /*
> > > + * Drop the ATTRD reference to the ATTRI. This
> > > + * removes the ATTRI from the AIL and frees it.
> > > + */
> > > + spin_unlock(&ailp->ail_lock);
> > > + xfs_attri_release(attrip);
> > > + spin_lock(&ailp->ail_lock);
> > > + break;
> > > + }
> > > + }
> > > + lip = xfs_trans_ail_cursor_next(ailp, &cur);
> > > + }
> > > +
> > > + xfs_trans_ail_cursor_done(&cur);
> > > + spin_unlock(&ailp->ail_lock);
> > > +
> > > + return 0;
> > > +}
> > > +
> > > /*
> > > * This routine is called to create an in-core extent rmap update
> > > * item from the rui format structure which was logged on disk.
> > > @@ -4050,6 +4164,8 @@ xlog_recover_ra_pass2(
> > > break;
> > > case XFS_LI_EFI:
> > > case XFS_LI_EFD:
> > > + case XFS_LI_ATTRI:
> > > + case XFS_LI_ATTRD:
> > > case XFS_LI_QUOTAOFF:
> > > case XFS_LI_RUI:
> > > case XFS_LI_RUD:
> > > @@ -4078,6 +4194,8 @@ xlog_recover_commit_pass1(
> > > case XFS_LI_INODE:
> > > case XFS_LI_EFI:
> > > case XFS_LI_EFD:
> > > + case XFS_LI_ATTRI:
> > > + case XFS_LI_ATTRD:
> > > case XFS_LI_DQUOT:
> > > case XFS_LI_ICREATE:
> > > case XFS_LI_RUI:
> > > @@ -4116,6 +4234,10 @@ xlog_recover_commit_pass2(
> > > return xlog_recover_efi_pass2(log, item, trans->r_lsn);
> > > case XFS_LI_EFD:
> > > return xlog_recover_efd_pass2(log, item);
> > > + case XFS_LI_ATTRI:
> > > + return xlog_recover_attri_pass2(log, item, trans->r_lsn);
> > > + case XFS_LI_ATTRD:
> > > + return xlog_recover_attrd_pass2(log, item);
> > > case XFS_LI_RUI:
> > > return xlog_recover_rui_pass2(log, item, trans->r_lsn);
> > > case XFS_LI_RUD:
> > > @@ -4677,6 +4799,49 @@ xlog_recover_cancel_efi(
> > > spin_lock(&ailp->ail_lock);
> > > }
> > > +/* Release the ATTRI since we're cancelling everything. */
> > > +STATIC void
> > > +xlog_recover_cancel_attri(
> > > + struct xfs_mount *mp,
> > > + struct xfs_ail *ailp,
> > > + struct xfs_log_item *lip)
> > > +{
> > > + struct xfs_attri_log_item *attrip;
> > > +
> > > + attrip = container_of(lip, struct xfs_attri_log_item, item);
> > > +
> > > + spin_unlock(&ailp->ail_lock);
> > > + xfs_attri_release(attrip);
> > > + spin_lock(&ailp->ail_lock);
> > > +}
> > > +
> > > +
> > > +/* Recover the ATTRI if necessary. */
> > > +STATIC int
> > > +xlog_recover_process_attri(
> > > + struct xfs_mount *mp,
> > > + struct xfs_ail *ailp,
> > > + struct xfs_log_item *lip,
> > > + struct xfs_defer_ops *dfops)
> > > +{
> > > + struct xfs_attri_log_item *attrip;
> > > + int error;
> > > +
> > > + /*
> > > + * Skip ATTRIs that we've already processed.
> > > + */
> > > + attrip = container_of(lip, struct xfs_attri_log_item, item);
> > > + if (test_bit(XFS_ATTRI_RECOVERED, &attrip->flags))
> > > + return 0;
> > > +
> > > + spin_unlock(&ailp->ail_lock);
> > > + error = xfs_attri_recover(mp, attrip, dfops);
> > > + spin_lock(&ailp->ail_lock);
> > > +
> > > + return error;
> > > +}
> > > +
> > > +
> > > /* Recover the RUI if necessary. */
> > > STATIC int
> > > xlog_recover_process_rui(
> > > @@ -4807,6 +4972,7 @@ static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
> > > case XFS_LI_RUI:
> > > case XFS_LI_CUI:
> > > case XFS_LI_BUI:
> > > + case XFS_LI_ATTRI:
> > > return true;
> > > default:
> > > return false;
> > > @@ -4920,6 +5086,10 @@ xlog_recover_process_intents(
> > > case XFS_LI_EFI:
> > > error = xlog_recover_process_efi(log->l_mp, ailp, lip);
> > > break;
> > > + case XFS_LI_ATTRI:
> > > + error = xlog_recover_process_attri(log->l_mp,
> > > + ailp, lip, &dfops);
> > > + break;
> > > case XFS_LI_RUI:
> > > error = xlog_recover_process_rui(log->l_mp, ailp, lip);
> > > break;
> > > @@ -4989,6 +5159,9 @@ xlog_recover_cancel_intents(
> > > case XFS_LI_BUI:
> > > xlog_recover_cancel_bui(log->l_mp, ailp, lip);
> > > break;
> > > + case XFS_LI_ATTRI:
> > > + xlog_recover_cancel_attri(log->l_mp, ailp, lip);
> > > + break;
> > > }
> > > lip = xfs_trans_ail_cursor_next(ailp, &cur);
> > > diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
> > > index 0492436..3723d50 100644
> > > --- a/fs/xfs/xfs_ondisk.h
> > > +++ b/fs/xfs/xfs_ondisk.h
> > > @@ -137,6 +137,8 @@ xfs_check_ondisk_structs(void)
> > > XFS_CHECK_STRUCT_SIZE(struct xfs_inode_log_format, 56);
> > > XFS_CHECK_STRUCT_SIZE(struct xfs_qoff_logformat, 20);
> > > XFS_CHECK_STRUCT_SIZE(struct xfs_trans_header, 16);
> > > + XFS_CHECK_STRUCT_SIZE(struct xfs_attri_log_format, 40);
> > > + XFS_CHECK_STRUCT_SIZE(struct xfs_attrd_log_format, 16);
> > > }
> > > #endif /* __XFS_ONDISK_H */
> > > diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
> > > index d714240..dce3baf 100644
> > > --- a/fs/xfs/xfs_super.c
> > > +++ b/fs/xfs/xfs_super.c
> > > @@ -2077,6 +2077,7 @@ init_xfs_fs(void)
> > > xfs_rmap_update_init_defer_op();
> > > xfs_refcount_update_init_defer_op();
> > > xfs_bmap_update_init_defer_op();
> > > + xfs_attr_init_defer_op();
> > > xfs_dir_startup();
> > > diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
> > > index 9d542df..deaae6b 100644
> > > --- a/fs/xfs/xfs_trans.h
> > > +++ b/fs/xfs/xfs_trans.h
> > > @@ -40,6 +40,9 @@ struct xfs_cud_log_item;
> > > struct xfs_defer_ops;
> > > struct xfs_bui_log_item;
> > > struct xfs_bud_log_item;
> > > +struct xfs_attrd_log_item;
> > > +struct xfs_attri_log_item;
> > > +
> > > typedef struct xfs_log_item {
> > > struct list_head li_ail; /* AIL pointers */
> > > @@ -223,12 +226,23 @@ void xfs_trans_dirty_buf(struct xfs_trans *, struct xfs_buf *);
> > > void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
> > > void xfs_extent_free_init_defer_op(void);
> > > +void xfs_attr_init_defer_op(void);
> > > +
> > > struct xfs_efd_log_item *xfs_trans_get_efd(struct xfs_trans *,
> > > struct xfs_efi_log_item *,
> > > uint);
> > > int xfs_trans_free_extent(struct xfs_trans *,
> > > struct xfs_efd_log_item *, xfs_fsblock_t,
> > > xfs_extlen_t, struct xfs_owner_info *);
> > > +struct xfs_attrd_log_item *
> > > +xfs_trans_get_attrd(struct xfs_trans *tp,
> > > + struct xfs_attri_log_item *attrip);
> > > +int xfs_trans_attr(struct xfs_trans *tp, struct xfs_defer_ops *dfops,
> > > + struct xfs_attrd_log_item *attrdp,
> > > + struct xfs_inode *ip, uint32_t attr_op_flags,
> > > + uint32_t flags, uint32_t name_len, uint32_t value_len,
> > > + char *name, char *value);
> > > +
> > > int xfs_trans_commit(struct xfs_trans *);
> > > int xfs_trans_roll(struct xfs_trans **);
> > > int xfs_trans_roll_inode(struct xfs_trans **, struct xfs_inode *);
> > > diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
> > > new file mode 100644
> > > index 0000000..7296414
> > > --- /dev/null
> > > +++ b/fs/xfs/xfs_trans_attr.c
> > > @@ -0,0 +1,285 @@
> > > +/*
> > > + * Copyright (c) 2017, Oracle Inc.
> > > + * All Rights Reserved.
> > > + *
> > > + * This program is free software; you can redistribute it and/or
> > > + * modify it under the terms of the GNU General Public License as
> > > + * published by the Free Software Foundation.
> > > + *
> > > + * This program is distributed in the hope that it would be useful,
> > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> > > + * GNU General Public License for more details.
> > > + *
> > > + * You should have received a copy of the GNU General Public License
> > > + * along with this program; if not, write the Free Software Foundation Inc.
> > > + */
> > > +#include "xfs.h"
> > > +#include "xfs_fs.h"
> > > +#include "xfs_shared.h"
> > > +#include "xfs_format.h"
> > > +#include "xfs_log_format.h"
> > > +#include "xfs_trans_resv.h"
> > > +#include "xfs_bit.h"
> > > +#include "xfs_mount.h"
> > > +#include "xfs_defer.h"
> > > +#include "xfs_trans.h"
> > > +#include "xfs_trans_priv.h"
> > > +#include "xfs_attr_item.h"
> > > +#include "xfs_alloc.h"
> > > +#include "xfs_bmap.h"
> > > +#include "xfs_trace.h"
> > > +#include "libxfs/xfs_da_format.h"
> > > +#include "xfs_da_btree.h"
> > > +#include "xfs_attr.h"
> > > +#include "xfs_inode.h"
> > > +#include "xfs_icache.h"
> > > +#include "xfs_quota.h"
> > > +
> > > +/*
> > > + * This routine is called to allocate an "extent free done"
> > > + * log item that will hold nextents worth of extents. The
> > > + * caller must use all nextents extents, because we are not
> > > + * flexible about this at all.
> > > + */
> >
> > Stale comment...
> >
> > Also, the use of the variable name "free" throughout this file for the
> > xfs_attr_item is a bit of an ugly holdover from (I'm guessing) the
> > extent free code. attr or something of that nature might be more
> > relevant.
> >
> > Brian
> >
> > > +struct xfs_attrd_log_item *
> > > +xfs_trans_get_attrd(struct xfs_trans *tp,
> > > + struct xfs_attri_log_item *attrip)
> > > +{
> > > + struct xfs_attrd_log_item *attrdp;
> > > +
> > > + ASSERT(tp != NULL);
> > > +
> > > + attrdp = xfs_attrd_init(tp->t_mountp, attrip);
> > > + ASSERT(attrdp != NULL);
> > > +
> > > + /*
> > > + * Get a log_item_desc to point at the new item.
> > > + */
> > > + xfs_trans_add_item(tp, &attrdp->item);
> > > + return attrdp;
> > > +}
> > > +
> > > +/*
> > > + * Delete an attr and log it to the ATTRD. Note that the transaction is marked
> > > + * dirty regardless of whether the attr delete succeeds or fails to support the
> > > + * ATTRI/ATTRD lifecycle rules.
> > > + */
> > > +int
> > > +xfs_trans_attr(
> > > + struct xfs_trans *tp,
> > > + struct xfs_defer_ops *dfops,
> > > + struct xfs_attrd_log_item *attrdp,
> > > + struct xfs_inode *ip,
> > > + uint32_t op_flags,
> > > + uint32_t flags,
> > > + uint32_t name_len,
> > > + uint32_t value_len,
> > > + char *name,
> > > + char *value)
> > > +{
> > > + int error;
> > > + int local;
> > > + struct xfs_da_args args;
> > > + xfs_fsblock_t firstblock = NULLFSBLOCK;
> > > + struct xfs_buf *leaf_bp = NULL;
> > > +
> > > + error = xfs_attr_args_init(&args, ip, name, flags);
> > > + if (error)
> > > + goto out;
> > > +
> > > + args.name = name;
> > > + args.namelen = name_len;
> > > + args.hashval = xfs_da_hashname(args.name, args.namelen);
> > > + args.value = value;
> > > + args.valuelen = value_len;
> > > + args.dfops = dfops;
> > > + args.firstblock = &firstblock;
> > > + args.op_flags = XFS_DA_OP_OKNOENT;
> > > + args.total = xfs_attr_calc_size(&args, &local);
> > > + args.trans = tp;
> > > + ASSERT(local);
> > > +
> > > + error = xfs_qm_dqattach_locked(ip, 0);
> > > + if (error)
> > > + return error;
> > > +
> > > + xfs_trans_ijoin(args.trans, ip, 0);
> > > + switch (op_flags) {
> > > + case XFS_ATTR_OP_FLAGS_SET:
> > > + args.op_flags |= XFS_DA_OP_ADDNAME;
> > > + error = xfs_attr_set_args(&args, flags,
> > > + leaf_bp, false);
> > > + break;
> > > + case XFS_ATTR_OP_FLAGS_REMOVE:
> > > + ASSERT(XFS_IFORK_Q((ip)));
> > > + error = xfs_attr_remove_args(&args, flags, false);
> > > + break;
> > > + default:
> > > + error = -EFSCORRUPTED;
> > > + }
> > > +
> > > +out:
> > > + if (error) {
> > > + if (leaf_bp)
> > > + xfs_trans_brelse(args.trans, leaf_bp);
> > > + }
> > > +
> > > + /*
> > > + * Mark the transaction dirty, even on error. This ensures the
> > > + * transaction is aborted, which:
> > > + *
> > > + * 1.) releases the ATTRI and frees the ATTRD
> > > + * 2.) shuts down the filesystem
> > > + */
> > > + tp->t_flags |= XFS_TRANS_DIRTY;
> > > + attrdp->item.li_desc->lid_flags |= XFS_LID_DIRTY;
> > > + attrdp->name = name;
> > > + attrdp->value = value;
> > > + attrdp->name_len = name_len;
> > > + attrdp->value_len = value_len;
> > > + attrdp->next_attr++;
> > > +
> > > + attrdp->attrip->name = name;
> > > + attrdp->attrip->value = value;
> > > + attrdp->attrip->name_len = name_len;
> > > + attrdp->attrip->value_len = value_len;
> > > +
> > > + return error;
> > > +}
> > > +
> > > +static int
> > > +xfs_attr_diff_items(
> > > + void *priv,
> > > + struct list_head *a,
> > > + struct list_head *b)
> > > +{
> > > + return 0;
> > > +}
> > > +
> > > +/* Get an ATTRI. */
> > > +STATIC void *
> > > +xfs_attr_create_intent(
> > > + struct xfs_trans *tp,
> > > + unsigned int count)
> > > +{
> > > + struct xfs_attri_log_item *attrip;
> > > +
> > > + ASSERT(tp != NULL);
> > > + ASSERT(count == 1);
> > > +
> > > + attrip = xfs_attri_init(tp->t_mountp);
> > > + ASSERT(attrip != NULL);
> > > +
> > > + /*
> > > + * Get a log_item_desc to point at the new item.
> > > + */
> > > + xfs_trans_add_item(tp, &attrip->item);
> > > + return attrip;
> > > +}
> > > +
> > > +/* Log an attr to the intent item. */
> > > +STATIC void
> > > +xfs_attr_log_item(
> > > + struct xfs_trans *tp,
> > > + void *intent,
> > > + struct list_head *item)
> > > +{
> > > + struct xfs_attri_log_item *attrip = intent;
> > > + struct xfs_attr_item *free;
> > > + struct xfs_attri_log_format *attrp;
> > > + char *name_value;
> > > +
> > > + free = container_of(item, struct xfs_attr_item, xattri_list);
> > > + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
> > > +
> > > + tp->t_flags |= XFS_TRANS_DIRTY;
> > > + attrip->item.li_desc->lid_flags |= XFS_LID_DIRTY;
> > > +
> > > + attrp = &attrip->format;
> > > + attrp->alfi_ino = free->xattri_ip->i_ino;
> > > + attrp->alfi_op_flags = free->xattri_op_flags;
> > > + attrp->alfi_value_len = free->xattri_value_len;
> > > + attrp->alfi_name_len = free->xattri_name_len;
> > > + attrp->alfi_attr_flags = free->xattri_flags;
> > > +
> > > + attrip->name = name_value;
> > > + attrip->value = &name_value[free->xattri_name_len];
> > > + attrip->name_len = free->xattri_name_len;
> > > + attrip->value_len = free->xattri_value_len;
> > > +}
> > > +
> > > +/* Get an ATTRD so we can process all the attrs. */
> > > +STATIC void *
> > > +xfs_attr_create_done(
> > > + struct xfs_trans *tp,
> > > + void *intent,
> > > + unsigned int count)
> > > +{
> > > + return xfs_trans_get_attrd(tp, intent);
> > > +}
> > > +
> > > +/* Process an attr. */
> > > +STATIC int
> > > +xfs_attr_finish_item(
> > > + struct xfs_trans *tp,
> > > + struct xfs_defer_ops *dop,
> > > + struct list_head *item,
> > > + void *done_item,
> > > + void **state)
> > > +{
> > > + struct xfs_attr_item *free;
> > > + char *name_value;
> > > + int error;
> > > +
> > > + free = container_of(item, struct xfs_attr_item, xattri_list);
> > > + name_value = ((char *)free) + sizeof(struct xfs_attr_item);
> > > + error = xfs_trans_attr(tp, dop, done_item,
> > > + free->xattri_ip,
> > > + free->xattri_op_flags,
> > > + free->xattri_flags,
> > > + free->xattri_name_len,
> > > + free->xattri_value_len,
> > > + name_value,
> > > + &name_value[free->xattri_name_len]);
> > > + kmem_free(free);
> > > + return error;
> > > +}
> > > +
> > > +/* Abort all pending ATTRs. */
> > > +STATIC void
> > > +xfs_attr_abort_intent(
> > > + void *intent)
> > > +{
> > > + xfs_attri_release(intent);
> > > +}
> > > +
> > > +/* Cancel an attr */
> > > +STATIC void
> > > +xfs_attr_cancel_item(
> > > + struct list_head *item)
> > > +{
> > > + struct xfs_attr_item *free;
> > > +
> > > + free = container_of(item, struct xfs_attr_item, xattri_list);
> > > + kmem_free(free);
> > > +}
> > > +
> > > +static const struct xfs_defer_op_type xfs_attr_defer_type = {
> > > + .type = XFS_DEFER_OPS_TYPE_ATTR,
> > > + .max_items = XFS_ATTRI_MAX_FAST_ATTRS,
> > > + .diff_items = xfs_attr_diff_items,
> > > + .create_intent = xfs_attr_create_intent,
> > > + .abort_intent = xfs_attr_abort_intent,
> > > + .log_item = xfs_attr_log_item,
> > > + .create_done = xfs_attr_create_done,
> > > + .finish_item = xfs_attr_finish_item,
> > > + .cancel_item = xfs_attr_cancel_item,
> > > +};
> > > +
> > > +/* Register the deferred op type. */
> > > +void
> > > +xfs_attr_init_defer_op(void)
> > > +{
> > > + xfs_defer_init_op_type(&xfs_attr_defer_type);
> > > +}
> > > --
> > > 2.7.4
> > >
> > > --
> > > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> > > the body of a message to majordomo@vger.kernel.org
> > > More majordomo info at https://urldefense.proofpoint.com/v2/url?u=http-3A__vger.kernel.org_majordomo-2Dinfo.html&d=DwIBAg&c=RoP1YumCXCgaWHvlZYR8PZh8Bv7qIrMUB65eapI_JnE&r=LHZQ8fHvy6wDKXGTWcm97burZH5sQKHRDMaY1UthQxc&m=WNyr4I99lOPWy3CEyGiGB-PXxqVQekB-idls3xgYVKo&s=88noL8uUCtH6GyRq653iitg0whoYcu6m5yxuaLaQvio&e=
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 33+ messages in thread
end of thread, other threads:[~2018-06-14 11:13 UTC | newest]
Thread overview: 33+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-06-10 5:04 [PATCH v7 00/23] Parent Pointers v7 Allison Henderson
2018-06-10 5:04 ` [PATCH v7 01/23] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
2018-06-10 5:04 ` [PATCH v7 02/23] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
2018-06-10 6:58 ` Amir Goldstein
2018-06-10 15:30 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 03/23] xfs: Add trans toggle to attr routines Allison Henderson
2018-06-13 12:11 ` Brian Foster
2018-06-14 1:27 ` Allison Henderson
2018-06-10 5:04 ` [PATCH v7 04/23] xfs: Add attibute set and helper functions Allison Henderson
2018-06-10 5:04 ` [PATCH v7 05/23] xfs: Add attibute remove " Allison Henderson
2018-06-10 5:04 ` [PATCH v7 06/23] xfs: Set up infastructure for deferred attribute operations Allison Henderson
2018-06-13 15:18 ` Brian Foster
2018-06-14 1:28 ` Allison Henderson
2018-06-14 11:13 ` Brian Foster
2018-06-10 5:04 ` [PATCH v7 07/23] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
2018-06-10 5:04 ` [PATCH v7 08/23] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
2018-06-10 5:04 ` [PATCH v7 09/23] xfs: get directory offset when adding directory name Allison Henderson
2018-06-10 5:04 ` [PATCH v7 10/23] xfs: get directory offset when removing " Allison Henderson
2018-06-10 5:04 ` [PATCH v7 11/23] xfs: get directory offset when replacing a " Allison Henderson
2018-06-10 5:04 ` [PATCH v7 12/23] xfs: add parent pointer support to attribute code Allison Henderson
2018-06-10 5:04 ` [PATCH v7 13/23] xfs: define parent pointer xattr format Allison Henderson
2018-06-10 5:04 ` [PATCH v7 14/23] xfs: extent transaction reservations for parent attributes Allison Henderson
2018-06-10 5:05 ` [PATCH v7 15/23] xfs: Hold inode locks in xfs_ialloc Allison Henderson
2018-06-10 5:05 ` [PATCH v7 16/23] xfs: parent pointer attribute creation Allison Henderson
2018-06-10 5:05 ` [PATCH v7 17/23] xfs: add parent attributes to link Allison Henderson
2018-06-10 5:05 ` [PATCH v7 18/23] xfs: remove parent pointers in unlink Allison Henderson
2018-06-10 5:05 ` [PATCH v7 19/23] xfs: Add parent pointers to rename Allison Henderson
2018-06-10 13:39 ` Amir Goldstein
2018-06-10 17:34 ` Allison Henderson
2018-06-10 5:05 ` [PATCH v7 20/23] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
2018-06-10 5:05 ` [PATCH v7 21/23] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
2018-06-10 5:05 ` [PATCH v7 22/23] xfs: Add parent pointer ioctl Allison Henderson
2018-06-10 5:05 ` [PATCH v7 23/23] xfs: Add delayed attributes error tag Allison Henderson
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.