* [PATCH v8 00/28] Parent Pointers v8
@ 2018-08-28 19:22 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 01/28] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
` (29 more replies)
0 siblings, 30 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
Hi all,
This is the 8th 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 v7:
I've integrated most of the feedback provided on v7 and done a lot of
stabilizing. In the last version, I had plumbed in a "roll_trans" boolean
into the attribute routines to prevent transactions from being rolled during the
defer finish. Some concerns were raised in the reviews because this caused
attribute operations to become one large transaction. The new proposal
was to have the attribute code periodically return EAGAIN to get the defer
finish routine to cycle out the transaction.
So in this solution setting an attribute is broken into 3 transactions.
I'm thinking that ideally it should send back the EAGAIN where ever the
existing code used to roll the transaction, but that gets more complex
since they're nested in sub functions. So I wanted to see what people
thought of this implementation first before proceeding any further.
This design has the following complexities that I think should be considered:
The attribute routines tend to pass around structures like xfs_da_args, and
xfs_buf (for holding and releasing leaf buffers). These structures need to
remain instantiated across the EAGAIN returns until the entire attribute
operation is complete. Additionally, this solution adds a state machine to
keep track of where to resume executing before we bailed out with the EAGAIN.
At the moment, I've put these items in the xfs_attr_item structure (patch 10).
Since the defer finish routine passes it back through through the
*_finish_item callback, xfs_attr_finish_item can plumb them back in from there
(patch 11). This works for now though maybe not the most appropriate place to
put it? Maybe we can move it if people have opinions about it.
Also, since this solution alters the behavior of the attribute set and remove
sub-routines, normal attribute operations have been made to use delayed
operations the same way parent pointers do. However, since delayed operations
cant return error codes, we need to take care of any condition that would
normally return an error to the user. For example ENOATTR if trying to remove
a non existent attribute. For this reason, all such error conditions need to
be resolved before calling the delayed operation. So I've added some extra
routines to check for that in xfs_attr_remove (added in patch 9).
I struggled a little with how to present this set in a way that broke the logic
down into manageable sized patches. In this solution, I chose to keep the
roll_trans boolean temporarily (patch 6), and then remove it later (in patch 12)
after all the code paths have been made to pass a false value. I thought this
helped to break up the changes into smaller patches without having to deal with
all affected code paths at once. Maybe if people are comfortable with the
changes going on in 6 though 12, we could consider collapsing them together
later.
For the most part I would appreciate review focus on patches 6 though 12,
since that is where most of the activity has been this for the revision.
Folks are certainly welcome to pour through the rest of it, but I know
it's a lot. I've tried to arrange the set such that 1-12 sets up delayed
attributes, and 13-28 adds the parent pointers. I don't have the xfsprogs
side just yet because this set is sitting a little upstream from where
xfsprogs is ATM and it had quite a few conflicts trying to sync it with
xfsprogs. So I'm just going to wait a bit for now until that catches up.
As always, comments and feedback are appreciated. Thank you!
Allison Henderson (19):
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 attibute set and helper functions
xfs: Add attibute remove and helper functions
xfs: Hold inode locks in xfs_ialloc
xfs: Add trans toggle to attr routines
xfs: Set up infastructure for deferred attribute operations
xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred
xfs: Add xfs_has_attr and subroutines
xfs: Add attr context to log item
xfs: Roll delayed attr operations by returning EAGAIN
xfs: Remove roll_trans boolean
xfs: Remove all strlen calls in all xfs_attr_* functions for attr
names.
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: Increase XFS_DEFER_OPS_NR_INODES to 4
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 | 496 ++++++++++++++++++++++-----------
fs/xfs/libxfs/xfs_attr.h | 203 ++++++++++++++
fs/xfs/libxfs/xfs_attr_leaf.c | 49 +++-
fs/xfs/libxfs/xfs_attr_leaf.h | 3 +-
fs/xfs/libxfs/xfs_attr_remote.c | 20 --
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 | 21 +-
fs/xfs/libxfs/xfs_dir2.h | 7 +-
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 | 111 ++++++++
fs/xfs/libxfs/xfs_parent.h | 37 +++
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/scrub/common.c | 2 +
fs/xfs/xfs_acl.c | 14 +-
fs/xfs/xfs_attr.h | 148 ----------
fs/xfs/xfs_attr_item.c | 598 ++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr_item.h | 114 ++++++++
fs/xfs/xfs_attr_list.c | 75 +++--
fs/xfs/xfs_error.c | 3 +
fs/xfs/xfs_inode.c | 159 ++++++++---
fs/xfs/xfs_ioctl.c | 101 ++++++-
fs/xfs/xfs_ioctl32.c | 2 +
fs/xfs/xfs_iops.c | 7 +-
fs/xfs/xfs_log_recover.c | 172 ++++++++++++
fs/xfs/xfs_ondisk.h | 6 +
fs/xfs/xfs_parent_utils.c | 152 ++++++++++
fs/xfs/xfs_parent_utils.h | 32 +++
fs/xfs/xfs_qm.c | 1 +
fs/xfs/xfs_super.c | 5 +
fs/xfs/xfs_symlink.c | 6 +-
fs/xfs/xfs_trans.h | 16 +-
fs/xfs/xfs_trans_attr.c | 275 ++++++++++++++++++
fs/xfs/xfs_xattr.c | 11 +-
48 files changed, 2700 insertions(+), 486 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] 38+ messages in thread
* [PATCH v8 01/28] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 02/28] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
` (28 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 148 +++++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr.h | 148 -----------------------------------------------
2 files changed, 148 insertions(+), 148 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
new file mode 100644
index 0000000..033ff8c
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ */
+#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 033ff8c..0000000
--- a/fs/xfs/xfs_attr.h
+++ /dev/null
@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2000,2002-2003,2005 Silicon Graphics, Inc.
- * All Rights Reserved.
- */
-#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] 38+ messages in thread
* [PATCH v8 02/28] xfs: Add helper function xfs_attr_try_sf_addname
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 01/28] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 03/28] xfs: Add attibute set and helper functions Allison Henderson
` (27 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 61 +++++++++++++++++++++++++++++++-----------------
1 file changed, 40 insertions(+), 21 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 1e671d4..f0675be 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -191,6 +191,42 @@ xfs_attr_calc_size(
return nblks;
}
+STATIC int
+xfs_attr_try_sf_addname(
+ struct xfs_inode *dp,
+ struct xfs_da_args *args)
+{
+
+ struct xfs_mount *mp = dp->i_mount;
+ int error;
+
+ error = xfs_attr_shortform_addname(args);
+ if (error == -ENOSPC)
+ return error;
+
+ /*
+ * 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 && (args->flags & ATTR_KERNOTIME) == 0) {
+ xfs_trans_ichgtime(args->trans, dp,
+ XFS_ICHGTIME_CHG);
+ }
+
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -281,30 +317,13 @@ 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);
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);
+ error = error ? error : err2;
- return error ? error : err2;
+ xfs_iunlock(dp, XFS_ILOCK_EXCL);
+ return error;
}
/*
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 03/28] xfs: Add attibute set and helper functions
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 01/28] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
2018-08-28 19:22 ` [PATCH v8 02/28] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 04/28] xfs: Add attibute remove " Allison Henderson
` (26 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 152 ++++++++++++++++++++++++++++-------------------
fs/xfs/libxfs/xfs_attr.h | 1 +
fs/xfs/libxfs/xfs_bmap.c | 49 +++++++++------
fs/xfs/libxfs/xfs_bmap.h | 1 +
4 files changed, 122 insertions(+), 81 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index f0675be..bc70151 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -227,6 +227,94 @@ xfs_attr_try_sf_addname(
return error;
}
+/*
+ * Set the attribute specified in @args.
+ */
+int
+xfs_attr_set_args(
+ struct xfs_da_args *args,
+ struct xfs_buf **leaf_bp)
+{
+ struct xfs_inode *dp = args->dp;
+ int error;
+ 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);
+ 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;
+
+ /*
+ * 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);
+ if (error)
+ 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_trans_bjoin(args->trans, *leaf_bp);
+ *leaf_bp = NULL;
+ }
+
+ if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
+ error = xfs_attr_leaf_addname(args);
+ else
+ error = xfs_attr_node_addname(args);
+ if (error)
+ goto out;
+
+out:
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -240,7 +328,7 @@ xfs_attr_set(
struct xfs_da_args args;
struct xfs_trans_res tres;
int rsvd = (flags & ATTR_ROOT) != 0;
- int error, err2, local;
+ int error, local;
XFS_STATS_INC(mp, xs_attr_set);
@@ -298,67 +386,7 @@ 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);
- if (error != -ENOSPC) {
- err2 = xfs_trans_commit(args.trans);
- error = error ? error : err2;
-
- 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.
- */
- error = xfs_attr_shortform_to_leaf(&args, &leaf_bp);
- if (error)
- goto out;
- /*
- * 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);
- if (error)
- goto out;
-
- /*
- * 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);
- else
- error = xfs_attr_node_addname(&args);
+ error = xfs_attr_set_args(&args, &leaf_bp);
if (error)
goto out;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 033ff8c..f608ac8 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -140,6 +140,7 @@ 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, struct xfs_buf **leaf_bp);
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 5648a17..85b803b 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -1009,6 +1009,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.
@@ -1060,26 +1088,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 b6e9b63..488dc88 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -183,6 +183,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_trans *tp, xfs_fsblock_t bno,
xfs_filblks_t len, struct xfs_owner_info *oinfo,
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 04/28] xfs: Add attibute remove and helper functions
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (2 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 03/28] xfs: Add attibute set and helper functions Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 05/28] xfs: Hold inode locks in xfs_ialloc Allison Henderson
` (25 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 36 +++++++++++++++++++++++++-----------
fs/xfs/libxfs/xfs_attr.h | 1 +
2 files changed, 26 insertions(+), 11 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index bc70151..cecf950 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -315,6 +315,30 @@ xfs_attr_set_args(
return error;
}
+/*
+ * Remove the attribute specified in @args.
+ */
+int
+xfs_attr_remove_args(
+ struct xfs_da_args *args)
+{
+ 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);
+ } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
+ error = xfs_attr_leaf_removename(args);
+ } else {
+ error = xfs_attr_node_removename(args);
+ }
+
+ return error;
+}
+
int
xfs_attr_set(
struct xfs_inode *dp,
@@ -470,17 +494,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);
- } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
- error = xfs_attr_leaf_removename(&args);
- } else {
- error = xfs_attr_node_removename(&args);
- }
-
+ error = xfs_attr_remove_args(&args);
if (error)
goto out;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index f608ac8..bdf52a3 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -142,6 +142,7 @@ 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, struct xfs_buf **leaf_bp);
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 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] 38+ messages in thread
* [PATCH v8 05/28] xfs: Hold inode locks in xfs_ialloc
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (3 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 04/28] xfs: Add attibute remove " Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 06/28] xfs: Add trans toggle to attr routines Allison Henderson
` (24 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 +
fs/xfs/xfs_symlink.c | 3 +++
3 files changed, 9 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index d957a46..1ef9d03 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -744,6 +744,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 */
@@ -1264,6 +1266,7 @@ xfs_create(
xfs_qm_dqrele(pdqp);
*ipp = ip;
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
return 0;
out_trans_cancel:
@@ -1359,6 +1362,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 52ed790..69006e5 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -820,6 +820,7 @@ xfs_qm_qino_alloc(
}
if (need_alloc)
xfs_finish_inode_setup(*ip);
+ xfs_iunlock(*ip, XFS_ILOCK_EXCL);
return error;
}
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index a3e98c6..07b1036 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -352,6 +352,7 @@ xfs_symlink(
xfs_qm_dqrele(pdqp);
*ipp = ip;
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
return 0;
out_trans_cancel:
@@ -373,6 +374,8 @@ xfs_symlink(
if (unlock_dp_on_error)
xfs_iunlock(dp, XFS_ILOCK_EXCL);
+ if (ip)
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
return error;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 06/28] xfs: Add trans toggle to attr routines
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (4 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 05/28] xfs: Hold inode locks in xfs_ialloc Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 07/28] xfs: Set up infastructure for deferred attribute operations Allison Henderson
` (23 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
This patch adds a roll_trans parameter to all attribute routines
that may roll a transaction. Calling functions may pass true to
roll transactions as normal, or false to hold them.
This patch is temporary and will be removed later when all code
paths have been made to pass a false value. The temporary boolean
assists us to introduce changes across multiple smaller patches instead
of handling all affected code paths in one large patch.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 244 +++++++++++++++++++++++-----------------
fs/xfs/libxfs/xfs_attr.h | 5 +-
fs/xfs/libxfs/xfs_attr_leaf.c | 20 +++-
fs/xfs/libxfs/xfs_attr_leaf.h | 8 +-
fs/xfs/libxfs/xfs_attr_remote.c | 50 ++++----
fs/xfs/libxfs/xfs_attr_remote.h | 4 +-
6 files changed, 195 insertions(+), 136 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index cecf950..03e0aff 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -49,15 +49,15 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
* 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);
@@ -233,10 +233,11 @@ xfs_attr_try_sf_addname(
int
xfs_attr_set_args(
struct xfs_da_args *args,
- struct xfs_buf **leaf_bp)
+ struct xfs_buf **leaf_bp,
+ bool roll_trans)
{
struct xfs_inode *dp = args->dp;
- int error;
+ int error = 0;
int sf_size;
/*
@@ -281,33 +282,35 @@ xfs_attr_set_args(
if (error)
goto out;
- /*
- * 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);
+ 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);
- if (error)
- goto out;
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ 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_trans_bjoin(args->trans, *leaf_bp);
- *leaf_bp = NULL;
+ /*
+ * 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_trans_bjoin(args->trans, *leaf_bp);
+ *leaf_bp = NULL;
+ }
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
- error = xfs_attr_leaf_addname(args);
+ error = xfs_attr_leaf_addname(args, roll_trans);
else
- error = xfs_attr_node_addname(args);
+ error = xfs_attr_node_addname(args, roll_trans);
if (error)
goto out;
@@ -320,7 +323,8 @@ xfs_attr_set_args(
*/
int
xfs_attr_remove_args(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_inode *dp = args->dp;
int error;
@@ -331,9 +335,9 @@ xfs_attr_remove_args(
ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
error = xfs_attr_shortform_remove(args);
} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
- error = xfs_attr_leaf_removename(args);
+ error = xfs_attr_leaf_removename(args, roll_trans);
} else {
- error = xfs_attr_node_removename(args);
+ error = xfs_attr_node_removename(args, roll_trans);
}
return error;
@@ -410,7 +414,7 @@ xfs_attr_set(
}
xfs_trans_ijoin(args.trans, dp, 0);
- error = xfs_attr_set_args(&args, &leaf_bp);
+ error = xfs_attr_set_args(&args, &leaf_bp, true);
if (error)
goto out;
@@ -494,7 +498,8 @@ xfs_attr_remove(
*/
xfs_trans_ijoin(args.trans, dp, 0);
- error = xfs_attr_remove_args(&args);
+ error = xfs_attr_remove_args(&args, true);
+
if (error)
goto out;
@@ -584,7 +589,8 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
*/
STATIC int
xfs_attr_leaf_addname(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_inode *dp;
struct xfs_buf *bp;
@@ -649,32 +655,39 @@ xfs_attr_leaf_addname(
error = xfs_attr3_leaf_to_node(args);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- 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;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ 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
@@ -683,7 +696,7 @@ xfs_attr_leaf_addname(
* maximum size of a transaction and/or hit a deadlock.
*/
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_set(args);
+ error = xfs_attr_rmtval_set(args, roll_trans);
if (error)
return error;
}
@@ -699,7 +712,7 @@ xfs_attr_leaf_addname(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args);
+ error = xfs_attr3_leaf_flipflags(args, roll_trans);
if (error)
return error;
@@ -713,7 +726,7 @@ xfs_attr_leaf_addname(
args->rmtblkcnt = args->rmtblkcnt2;
args->rmtvaluelen = args->rmtvaluelen2;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(args);
+ error = xfs_attr_rmtval_remove(args, roll_trans);
if (error)
return error;
}
@@ -737,21 +750,25 @@ xfs_attr_leaf_addname(
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
+
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ return error;
+ }
}
/*
* Commit the remove and start the next trans in series.
*/
- error = xfs_trans_roll_inode(&args->trans, dp);
+ if (roll_trans)
+ error = xfs_trans_roll_inode(&args->trans, dp);
} else if (args->rmtblkno > 0) {
/*
* Added a "remote" value, just clear the incomplete flag.
*/
- error = xfs_attr3_leaf_clearflag(args);
+ error = xfs_attr3_leaf_clearflag(args, roll_trans);
}
return error;
out_defer_cancel:
@@ -767,7 +784,8 @@ xfs_attr_leaf_addname(
*/
STATIC int
xfs_attr_leaf_removename(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_inode *dp;
struct xfs_buf *bp;
@@ -800,9 +818,11 @@ xfs_attr_leaf_removename(
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ return error;
+ }
}
return 0;
out_defer_cancel:
@@ -858,7 +878,8 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
*/
STATIC int
xfs_attr_node_addname(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_da_state *state;
struct xfs_da_state_blk *blk;
@@ -923,20 +944,24 @@ xfs_attr_node_addname(
*/
xfs_da_state_free(state);
state = NULL;
+
error = xfs_attr3_leaf_to_node(args);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- /*
- * 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);
+ if (error)
+ goto out;
+
+ /*
+ * 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;
}
@@ -950,9 +975,12 @@ xfs_attr_node_addname(
error = xfs_da3_split(state);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
+
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ goto out;
+ }
} else {
/*
* Addition succeeded, update Btree hashvals.
@@ -971,9 +999,11 @@ xfs_attr_node_addname(
* 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
@@ -982,7 +1012,7 @@ xfs_attr_node_addname(
* maximum size of a transaction and/or hit a deadlock.
*/
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_set(args);
+ error = xfs_attr_rmtval_set(args, roll_trans);
if (error)
return error;
}
@@ -998,7 +1028,7 @@ xfs_attr_node_addname(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args);
+ error = xfs_attr3_leaf_flipflags(args, roll_trans);
if (error)
goto out;
@@ -1012,7 +1042,7 @@ xfs_attr_node_addname(
args->rmtblkcnt = args->rmtblkcnt2;
args->rmtvaluelen = args->rmtvaluelen2;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(args);
+ error = xfs_attr_rmtval_remove(args, roll_trans);
if (error)
return error;
}
@@ -1046,9 +1076,11 @@ xfs_attr_node_addname(
error = xfs_da3_join(state);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ goto out;
+ }
}
/*
@@ -1062,7 +1094,7 @@ xfs_attr_node_addname(
/*
* Added a "remote" value, just clear the incomplete flag.
*/
- error = xfs_attr3_leaf_clearflag(args);
+ error = xfs_attr3_leaf_clearflag(args, roll_trans);
if (error)
goto out;
}
@@ -1088,7 +1120,8 @@ xfs_attr_node_addname(
*/
STATIC int
xfs_attr_node_removename(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_da_state *state;
struct xfs_da_state_blk *blk;
@@ -1138,10 +1171,10 @@ xfs_attr_node_removename(
* Mark the attribute as INCOMPLETE, then bunmapi() the
* remote value.
*/
- error = xfs_attr3_leaf_setflag(args);
+ error = xfs_attr3_leaf_setflag(args, roll_trans);
if (error)
goto out;
- error = xfs_attr_rmtval_remove(args);
+ error = xfs_attr_rmtval_remove(args, roll_trans);
if (error)
goto out;
@@ -1169,15 +1202,19 @@ xfs_attr_node_removename(
error = xfs_da3_join(state);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- /*
- * Commit the Btree join operation and start a new trans.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- goto out;
+
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ goto out;
+ /*
+ * Commit the Btree join operation and
+ * start a new trans.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ goto out;
+ }
}
/*
@@ -1200,9 +1237,12 @@ xfs_attr_node_removename(
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
+
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ goto out;
+ }
} else
xfs_trans_brelse(args->trans, bp);
}
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index bdf52a3..92a796a 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -140,9 +140,10 @@ 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, struct xfs_buf **leaf_bp);
+int xfs_attr_set_args(struct xfs_da_args *args, 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 xfs_attr_remove_args(struct xfs_da_args *args, bool roll_trans);
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_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 6fc5425..d127f2c 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -2639,7 +2639,8 @@ xfs_attr_leaf_newentsize(
*/
int
xfs_attr3_leaf_clearflag(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr_leaf_entry *entry;
@@ -2700,7 +2701,9 @@ xfs_attr3_leaf_clearflag(
/*
* Commit the flag value change and start the next trans in series.
*/
- return xfs_trans_roll_inode(&args->trans, args->dp);
+ if (roll_trans)
+ error = xfs_trans_roll_inode(&args->trans, args->dp);
+ return error;
}
/*
@@ -2708,7 +2711,8 @@ xfs_attr3_leaf_clearflag(
*/
int
xfs_attr3_leaf_setflag(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr_leaf_entry *entry;
@@ -2751,7 +2755,9 @@ xfs_attr3_leaf_setflag(
/*
* Commit the flag value change and start the next trans in series.
*/
- return xfs_trans_roll_inode(&args->trans, args->dp);
+ if (roll_trans)
+ error = xfs_trans_roll_inode(&args->trans, args->dp);
+ return error;
}
/*
@@ -2763,7 +2769,8 @@ xfs_attr3_leaf_setflag(
*/
int
xfs_attr3_leaf_flipflags(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_attr_leafblock *leaf1;
struct xfs_attr_leafblock *leaf2;
@@ -2869,7 +2876,8 @@ xfs_attr3_leaf_flipflags(
/*
* Commit the flag value change and start the next trans in series.
*/
- error = xfs_trans_roll_inode(&args->trans, args->dp);
+ if (roll_trans)
+ error = xfs_trans_roll_inode(&args->trans, args->dp);
return error;
}
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index 7b74e18..9d830ec 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
@@ -49,10 +49,10 @@ void xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
*/
int xfs_attr3_leaf_to_node(struct xfs_da_args *args);
int xfs_attr3_leaf_to_shortform(struct xfs_buf *bp,
- struct xfs_da_args *args, int forkoff);
-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);
+ struct xfs_da_args *args, int forkoff);
+int xfs_attr3_leaf_clearflag(struct xfs_da_args *args, bool roll_trans);
+int xfs_attr3_leaf_setflag(struct xfs_da_args *args, bool roll_trans);
+int xfs_attr3_leaf_flipflags(struct xfs_da_args *args, bool roll_trans);
/*
* Routines used for growing the Btree.
diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index af09406..e13000a 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -433,7 +433,8 @@ xfs_attr_rmtval_get(
*/
int
xfs_attr_rmtval_set(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_inode *dp = args->dp;
struct xfs_mount *mp = dp->i_mount;
@@ -486,9 +487,12 @@ xfs_attr_rmtval_set(
&nmap);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
+
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ return error;
+ }
ASSERT(nmap == 1);
ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
@@ -496,12 +500,14 @@ xfs_attr_rmtval_set(
lblkno += map.br_blockcount;
blkcnt -= map.br_blockcount;
- /*
- * Start the next trans in the chain.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- return error;
+ if (roll_trans) {
+ /*
+ * Start the next trans in the chain.
+ */
+ error = xfs_trans_roll_inode(&args->trans, dp);
+ if (error)
+ return error;
+ }
}
/*
@@ -564,7 +570,8 @@ xfs_attr_rmtval_set(
*/
int
xfs_attr_rmtval_remove(
- struct xfs_da_args *args)
+ struct xfs_da_args *args,
+ bool roll_trans)
{
struct xfs_mount *mp = args->dp->i_mount;
xfs_dablk_t lblkno;
@@ -626,16 +633,19 @@ xfs_attr_rmtval_remove(
XFS_BMAPI_ATTRFORK, 1, &done);
if (error)
goto out_defer_cancel;
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
- /*
- * Close out trans and start the next one in the chain.
- */
- error = xfs_trans_roll_inode(&args->trans, args->dp);
- if (error)
- return error;
+ if (roll_trans) {
+ error = xfs_defer_finish(&args->trans);
+ if (error)
+ return error;
+
+ /*
+ * Close out trans and start the next one in the chain.
+ */
+ error = xfs_trans_roll_inode(&args->trans, args->dp);
+ if (error)
+ return error;
+ }
}
return 0;
out_defer_cancel:
diff --git a/fs/xfs/libxfs/xfs_attr_remote.h b/fs/xfs/libxfs/xfs_attr_remote.h
index 9d20b66..c7c073d 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.h
+++ b/fs/xfs/libxfs/xfs_attr_remote.h
@@ -9,7 +9,7 @@
int xfs_attr3_rmt_blocks(struct xfs_mount *mp, int attrlen);
int xfs_attr_rmtval_get(struct xfs_da_args *args);
-int xfs_attr_rmtval_set(struct xfs_da_args *args);
-int xfs_attr_rmtval_remove(struct xfs_da_args *args);
+int xfs_attr_rmtval_set(struct xfs_da_args *args, bool roll_trans);
+int xfs_attr_rmtval_remove(struct xfs_da_args *args, bool roll_trans);
#endif /* __XFS_ATTR_REMOTE_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 07/28] xfs: Set up infastructure for deferred attribute operations
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (5 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 06/28] xfs: Add trans toggle to attr routines Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 08/28] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
` (22 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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.
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 | 569 +++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_attr_item.h | 114 +++++++++
fs/xfs/xfs_log_recover.c | 172 +++++++++++++
fs/xfs/xfs_ondisk.h | 2 +
fs/xfs/xfs_super.c | 1 +
fs/xfs/xfs_trans.h | 12 +
fs/xfs/xfs_trans_attr.c | 258 +++++++++++++++++++
13 files changed, 1202 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 7f96bda..022e0b4 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -97,6 +97,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 \
@@ -106,6 +107,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 03e0aff..94fbde4 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -29,6 +29,7 @@
#include "xfs_quota.h"
#include "xfs_trans_space.h"
#include "xfs_trace.h"
+#include "xfs_attr_item.h"
/*
* xfs_attr.c
@@ -62,7 +63,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,
@@ -158,7 +159,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 92a796a..5a5adc0 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -78,6 +78,28 @@ 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;
+ void* xattri_value; /* attr value */
+ uint32_t xattri_value_len; /* length of value */
+ void* xattri_name; /* attr name */
+ 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.
*/
@@ -146,6 +168,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, 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 2584a5b9..326fa2b 100644
--- a/fs/xfs/libxfs/xfs_defer.h
+++ b/fs/xfs/libxfs/xfs_defer.h
@@ -31,6 +31,7 @@ enum xfs_defer_ops_type {
XFS_DEFER_OPS_TYPE_RMAP,
XFS_DEFER_OPS_TYPE_FREE,
XFS_DEFER_OPS_TYPE_AGFL_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 e5f97c6..76d42e6 100644
--- a/fs/xfs/libxfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -117,7 +117,12 @@ struct xfs_unmount_log_format {
#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
@@ -240,6 +245,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" }, \
@@ -255,7 +262,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.
@@ -853,4 +862,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 b9e6c89..6f33dd6 100644
--- a/fs/xfs/libxfs/xfs_types.h
+++ b/fs/xfs/libxfs/xfs_types.h
@@ -11,6 +11,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..dc09b52
--- /dev/null
+++ b/fs/xfs/xfs_attr_item.c
@@ -0,0 +1,569 @@
+/*
+ * 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"
+#include "xfs_attr.h"
+#include "xfs_shared.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.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 (test_bit(XFS_LI_ABORTED, &lip->li_flags))
+ 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);
+}
+
+/*
+ * 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 (test_bit(XFS_LI_ABORTED, &lip->li_flags)) {
+ 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_inode *ip;
+ struct xfs_attrd_log_item *attrdp;
+ struct xfs_da_args args;
+ struct xfs_attri_log_format *attrp;
+ struct xfs_trans_res tres;
+ int local;
+ int error = 0;
+ int rsvd = 0;
+
+ 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;
+ }
+
+ attrp = &attrip->format;
+ error = xfs_iget(mp, 0, attrp->alfi_ino, 0, 0, &ip);
+ if (error)
+ return error;
+
+ error = xfs_attr_args_init(&args, ip, attrip->name,
+ attrp->alfi_attr_flags);
+ if (error)
+ return error;
+
+ args.hashval = xfs_da_hashname(args.name, args.namelen);
+ args.value = attrip->value;
+ args.valuelen = attrp->alfi_value_len;
+ args.op_flags = XFS_DA_OP_OKNOENT;
+ args.total = xfs_attr_calc_size(&args, &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;
+
+ error = xfs_trans_alloc(mp, &tres, args.total, 0,
+ rsvd ? XFS_TRANS_RESERVE : 0, &args.trans);
+ if (error)
+ return error;
+ attrdp = xfs_trans_get_attrd(args.trans, attrip);
+
+ xfs_ilock(ip, XFS_ILOCK_EXCL);
+
+ xfs_trans_ijoin(args.trans, ip, 0);
+ error = xfs_trans_attr(&args, attrdp, attrp->alfi_op_flags);
+ if (error)
+ goto abort_error;
+
+
+ set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
+ xfs_trans_log_inode(args.trans, ip, XFS_ILOG_CORE | XFS_ILOG_ADATA);
+ error = xfs_trans_commit(args.trans);
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ return error;
+
+abort_error:
+ xfs_trans_cancel(args.trans);
+ 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..ed93714
--- /dev/null
+++ b/fs/xfs/xfs_attr_item.h
@@ -0,0 +1,114 @@
+/*
+ * 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;
+ 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);
+
+#endif /* __XFS_ATTR_ITEM_H__ */
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index a21dc61..cd9d375 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -22,6 +22,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"
@@ -1975,6 +1976,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);
@@ -3510,6 +3513,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.
@@ -4063,6 +4177,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:
@@ -4091,6 +4207,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:
@@ -4129,6 +4247,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:
@@ -4690,6 +4812,48 @@ 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_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);
+ spin_lock(&ailp->ail_lock);
+
+ return error;
+}
+
+
/* Recover the RUI if necessary. */
STATIC int
xlog_recover_process_rui(
@@ -4818,6 +4982,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;
@@ -4936,6 +5101,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);
+ break;
case XFS_LI_RUI:
error = xlog_recover_process_rui(log->l_mp, ailp, lip);
break;
@@ -5002,6 +5171,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 d3e04d2..9397b6b 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -125,6 +125,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 207ee30..41f53d7 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -2057,6 +2057,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 c3d278e..433bada 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -26,6 +26,9 @@ struct xfs_cui_log_item;
struct xfs_cud_log_item;
struct xfs_bui_log_item;
struct xfs_bud_log_item;
+struct xfs_attrd_log_item;
+struct xfs_attri_log_item;
+struct xfs_da_args;
typedef struct xfs_log_item {
struct list_head li_ail; /* AIL pointers */
@@ -223,6 +226,8 @@ 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);
@@ -230,6 +235,13 @@ int xfs_trans_free_extent(struct xfs_trans *,
struct xfs_efd_log_item *, xfs_fsblock_t,
xfs_extlen_t, struct xfs_owner_info *,
bool);
+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_da_args *args,
+ struct xfs_attrd_log_item *attrdp,
+ uint32_t attr_op_flags);
+
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..87607b2
--- /dev/null
+++ b/fs/xfs/xfs_trans_attr.c
@@ -0,0 +1,258 @@
+/*
+ * 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 "attr free done"
+ * log item.
+ */
+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_da_args *args,
+ struct xfs_attrd_log_item *attrdp,
+ uint32_t op_flags)
+{
+ int error;
+ struct xfs_buf *leaf_bp = NULL;
+
+ error = xfs_qm_dqattach_locked(args->dp, 0);
+ if (error)
+ return error;
+
+ switch (op_flags) {
+ case XFS_ATTR_OP_FLAGS_SET:
+ args->op_flags |= XFS_DA_OP_ADDNAME;
+ error = xfs_attr_set_args(args,&leaf_bp, false);
+ break;
+ case XFS_ATTR_OP_FLAGS_REMOVE:
+ ASSERT(XFS_IFORK_Q((args->dp)));
+ error = xfs_attr_remove_args(args, false);
+ break;
+ default:
+ error = -EFSCORRUPTED;
+ }
+
+ 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
+ */
+ args->trans->t_flags |= XFS_TRANS_DIRTY;
+ set_bit(XFS_LI_DIRTY, &attrdp->item.li_flags);
+
+ attrdp->attrip->name = (void *)args->name;
+ attrdp->attrip->value = (void *)args->value;
+ attrdp->attrip->name_len = args->namelen;
+ attrdp->attrip->value_len = args->valuelen;
+
+ 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 *attr;
+ struct xfs_attri_log_format *attrp;
+ char *name_value;
+
+ attr = container_of(item, struct xfs_attr_item, xattri_list);
+ name_value = ((char *)attr) + sizeof(struct xfs_attr_item);
+
+ tp->t_flags |= XFS_TRANS_DIRTY;
+ set_bit(XFS_LI_DIRTY, &attrip->item.li_flags);
+
+ attrp = &attrip->format;
+ attrp->alfi_ino = attr->xattri_ip->i_ino;
+ attrp->alfi_op_flags = attr->xattri_op_flags;
+ attrp->alfi_value_len = attr->xattri_value_len;
+ attrp->alfi_name_len = attr->xattri_name_len;
+ attrp->alfi_attr_flags = attr->xattri_flags;
+
+ attrip->name = name_value;
+ attrip->value = &name_value[attr->xattri_name_len];
+ attrip->name_len = attr->xattri_name_len;
+ attrip->value_len = attr->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 list_head *item,
+ void *done_item,
+ void **state)
+{
+ struct xfs_attr_item *attr;
+ char *name_value;
+ int error;
+ int local;
+ struct xfs_da_args args;
+
+ attr = container_of(item, struct xfs_attr_item, xattri_list);
+ name_value = ((char *)attr) + sizeof(struct xfs_attr_item);
+
+ error = xfs_attr_args_init(&args, attr->xattri_ip, name_value,
+ attr->xattri_flags);
+ if (error)
+ goto out;
+
+ args.hashval = xfs_da_hashname(args.name, args.namelen);
+ args.value = &name_value[attr->xattri_name_len];
+ args.valuelen = attr->xattri_value_len;
+ args.op_flags = XFS_DA_OP_OKNOENT;
+ args.total = xfs_attr_calc_size(&args, &local);
+ args.trans = tp;
+
+ error = xfs_trans_attr(&args, done_item,
+ attr->xattri_op_flags);
+out:
+ kmem_free(attr);
+ 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 *attr;
+
+ attr = container_of(item, struct xfs_attr_item, xattri_list);
+ kmem_free(attr);
+}
+
+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] 38+ messages in thread
* [PATCH v8 08/28] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (6 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 07/28] xfs: Set up infastructure for deferred attribute operations Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 09/28] xfs: Add xfs_has_attr and subroutines Allison Henderson
` (21 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 79 ++++++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_attr.h | 5 +++
2 files changed, 84 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 94fbde4..afcb4e9 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -447,6 +447,52 @@ 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_trans *tp,
+ void *name,
+ unsigned int namelen,
+ void *value,
+ unsigned int valuelen,
+ int flags)
+{
+
+ struct xfs_attr_item *new;
+ char *name_value;
+
+ /*
+ * All set operations must have a name
+ * but not necessarily a value.
+ * Generic 062
+ */
+ if (!namelen) {
+ 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);
+ new->xattri_name = name_value;
+ new->xattri_value = name_value + namelen;
+
+ if (valuelen > 0)
+ memcpy(&name_value[namelen], value, valuelen);
+
+ xfs_defer_add(tp, 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.
@@ -530,6 +576,39 @@ 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_trans *tp,
+ 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_add(tp, 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 5a5adc0..5c49120 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -171,5 +171,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_trans *tp,
+ void *name, unsigned int name_len, void *value,
+ unsigned int valuelen, int flags);
+int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
+ void *name, unsigned int namelen, int flags);
#endif /* __XFS_ATTR_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 09/28] xfs: Add xfs_has_attr and subroutines
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (7 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 08/28] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 10/28] xfs: Add attr context to log item Allison Henderson
` (20 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
This patch adds a new functions to check for the existence of
an attribute. Subroutines are also added to handle the cases
of leaf blocks, nodes or shortform. We will need this later
for delayed attributes since delayed operations cannot return
error codes.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 80 +++++++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_attr.h | 1 +
fs/xfs/libxfs/xfs_attr_leaf.c | 34 ++++++++++++++++++
fs/xfs/libxfs/xfs_attr_leaf.h | 1 +
4 files changed, 116 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index afcb4e9..09c0de8 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -52,6 +52,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
STATIC int xfs_attr_leaf_get(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);
+STATIC int xfs_leaf_has_attr(xfs_da_args_t *args);
/*
* Internal routines when attribute list is more than one block.
@@ -59,6 +60,7 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans);
STATIC int xfs_attr_node_get(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_node_hasname(xfs_da_args_t *args);
STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
@@ -320,6 +322,29 @@ xfs_attr_set_args(
}
/*
+ * Return successful if attr is found, or ENOATTR if not
+ */
+int
+xfs_has_attr(
+ struct xfs_da_args *args)
+{
+ 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_shortform_has_attr(args);
+ } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
+ error = xfs_leaf_has_attr(args);
+ else
+ error = xfs_attr_node_hasname(args);
+
+ return error;
+}
+
+/*
* Remove the attribute specified in @args.
*/
int
@@ -857,6 +882,31 @@ xfs_attr_leaf_addname(
}
/*
+ * Return successful if attr is found, or ENOATTR if not
+ */
+STATIC int
+xfs_leaf_has_attr(
+ struct xfs_da_args *args)
+{
+ struct xfs_inode *dp;
+ struct xfs_buf *bp;
+ int error = 0;
+
+ dp = args->dp;
+ args->blkno = 0;
+ error = xfs_attr3_leaf_read(args->trans, args->dp,
+ args->blkno, -1, &bp);
+ if (error)
+ return error;
+
+ error = xfs_attr3_leaf_lookup_int(bp, args);
+ error = (error == -ENOATTR) ? -ENOATTR : 0;
+ xfs_trans_brelse(args->trans, bp);
+
+ return error;
+}
+
+/*
* Remove a name from the leaf attribute list structure
*
* This leaf block cannot have a "remote" value, we only call this routine
@@ -1192,6 +1242,36 @@ xfs_attr_node_addname(
}
/*
+ * Return successful if attr is found, or ENOATTR if not
+ */
+STATIC int
+xfs_attr_node_hasname(
+ struct xfs_da_args *args)
+{
+ struct xfs_da_state *state;
+ struct xfs_inode *dp;
+ int retval, error;
+
+ /*
+ * Tie a string around our finger to remind us where we are.
+ */
+ dp = args->dp;
+ state = xfs_da_state_alloc();
+ state->args = args;
+ state->mp = dp->i_mount;
+
+ /*
+ * Search to see if name exists, and get back a pointer to it.
+ */
+ error = xfs_da3_node_lookup_int(state, &retval);
+ if (error || (retval != -EEXIST)) {
+ if (error == 0)
+ error = retval;
+ }
+ return error;
+}
+
+/*
* Remove a name from a B-tree attribute list.
*
* This will involve walking down the Btree, and may involve joining
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 5c49120..dcf1794 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -165,6 +165,7 @@ int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,
int xfs_attr_set_args(struct xfs_da_args *args, struct xfs_buf **leaf_bp,
bool roll_trans);
int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
+int xfs_has_attr(struct xfs_da_args *args);
int xfs_attr_remove_args(struct xfs_da_args *args, bool roll_trans);
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_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index d127f2c..43fafa9 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -624,6 +624,40 @@ xfs_attr_fork_remove(
}
/*
+ * Return successful if attr is found, or ENOATTR if not
+ */
+int
+xfs_shortform_has_attr(xfs_da_args_t *args)
+{
+ xfs_attr_shortform_t *sf;
+ xfs_attr_sf_entry_t *sfe;
+ int base, size = 0, end, i;
+ xfs_mount_t *mp;
+ xfs_inode_t *dp;
+
+ dp = args->dp;
+ mp = dp->i_mount;
+ base = sizeof(xfs_attr_sf_hdr_t);
+ sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
+ sfe = &sf->list[0];
+ end = sf->hdr.count;
+ for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
+ base += size, i++) {
+ size = XFS_ATTR_SF_ENTSIZE(sfe);
+ if (sfe->namelen != args->namelen)
+ continue;
+ if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
+ continue;
+ if (!xfs_attr_namesp_match(args->flags, sfe->flags))
+ continue;
+ break;
+ }
+ if (i == end)
+ return -ENOATTR;
+ return 0;
+}
+
+/*
* Remove an attribute from the shortform attribute list structure.
*/
int
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index 9d830ec..98dd169 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
@@ -39,6 +39,7 @@ 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_shortform_has_attr(struct xfs_da_args *args);
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);
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 10/28] xfs: Add attr context to log item
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (8 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 09/28] xfs: Add xfs_has_attr and subroutines Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 11/28] xfs: Roll delayed attr operations by returning EAGAIN Allison Henderson
` (19 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
This patch modifies xfs_attr_item to store a xfs_da_args, a xfs_buf pointer
and a new state type. We will use these in the next patch when
we modify xfs_set_attr_args to roll transactions by returning EAGAIN.
Because the subroutines of this function modify the contents of these
structures, we need to find a place to store them where they remain
instantiated across multiple calls to xfs_set_attr_args.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.h | 17 ++++++++++++++++-
fs/xfs/scrub/common.c | 2 ++
fs/xfs/xfs_acl.c | 2 ++
fs/xfs/xfs_attr_item.c | 2 +-
fs/xfs/xfs_ioctl.c | 2 ++
fs/xfs/xfs_ioctl32.c | 2 ++
fs/xfs/xfs_iops.c | 1 +
fs/xfs/xfs_xattr.c | 1 +
8 files changed, 27 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index dcf1794..38ba5df 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -77,6 +77,12 @@ typedef struct attrlist_ent { /* data from attr_list() */
char a_name[1]; /* attr name (NULL terminated) */
} attrlist_ent_t;
+/* Attr state machine types */
+typedef enum {
+ XFS_ATTR_STATE1 = 1,
+ XFS_ATTR_STATE2 = 2,
+} xfs_attr_state_t;
+
/*
* List of attrs to commit later.
*/
@@ -88,7 +94,16 @@ struct xfs_attr_item {
void* xattri_name; /* attr name */
uint32_t xattri_name_len; /* length of name */
uint32_t xattri_flags; /* attr flags */
- struct list_head xattri_list;
+
+ /*
+ * Delayed attr parameters that need to remain instantiated
+ * across transaction rolls during the defer finish
+ */
+ struct xfs_buf *xattri_leaf_bp; /* Leaf buf to release */
+ xfs_attr_state_t xattri_state; /* state machine marker */
+ struct xfs_da_args xattri_args; /* args context */
+
+ struct list_head xattri_list;
/*
* A byte array follows the header containing the file name and
diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
index 346b02a..5d07411 100644
--- a/fs/xfs/scrub/common.c
+++ b/fs/xfs/scrub/common.c
@@ -30,6 +30,8 @@
#include "xfs_rmap_btree.h"
#include "xfs_log.h"
#include "xfs_trans_priv.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_reflink.h"
#include "scrub/xfs_scrub.h"
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 8039e35..48166df 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -10,6 +10,8 @@
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_acl.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_trace.h"
#include <linux/slab.h>
diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
index dc09b52..56fc0b0 100644
--- a/fs/xfs/xfs_attr_item.c
+++ b/fs/xfs/xfs_attr_item.c
@@ -30,10 +30,10 @@
#include "xfs_rmap.h"
#include "xfs_inode.h"
#include "xfs_icache.h"
-#include "xfs_attr.h"
#include "xfs_shared.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
+#include "xfs_attr.h"
static inline struct xfs_attri_log_item *ATTRI_ITEM(struct xfs_log_item *lip)
{
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 0ef5ece..6cd9218 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -16,6 +16,8 @@
#include "xfs_rtalloc.h"
#include "xfs_itable.h"
#include "xfs_error.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_bmap.h"
#include "xfs_bmap_util.h"
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index fba115f..42889fc 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -21,6 +21,8 @@
#include "xfs_fsops.h"
#include "xfs_alloc.h"
#include "xfs_rtalloc.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_ioctl.h"
#include "xfs_ioctl32.h"
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 0ef5ad7..ab605fe 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -17,6 +17,7 @@
#include "xfs_acl.h"
#include "xfs_quota.h"
#include "xfs_error.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_trans.h"
#include "xfs_trace.h"
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 63ee1d5..031f720 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -11,6 +11,7 @@
#include "xfs_mount.h"
#include "xfs_da_format.h"
#include "xfs_inode.h"
+#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_attr_leaf.h"
#include "xfs_acl.h"
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 11/28] xfs: Roll delayed attr operations by returning EAGAIN
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (9 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 10/28] xfs: Add attr context to log item Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 12/28] xfs: Remove roll_trans boolean Allison Henderson
` (18 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
This patch modifies xfs_attr_set_args to return -EAGAIN
when a transaction needs to be rolled. A state parameter
is used to keep track of where we left off before the return.
All functions currently calling xfs_attr_set_args are modified
to use the deferred attr operation, or handle the -EAGAIN
return code
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 43 ++++++++++++++++++++++++++++---------
fs/xfs/libxfs/xfs_attr.h | 2 +-
fs/xfs/xfs_attr_item.c | 41 ++++++++++++++++++++++++++++++------
fs/xfs/xfs_trans.h | 2 ++
fs/xfs/xfs_trans_attr.c | 55 ++++++++++++++++++++++++++++--------------------
5 files changed, 103 insertions(+), 40 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 09c0de8..0e5bce9 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -237,12 +237,20 @@ int
xfs_attr_set_args(
struct xfs_da_args *args,
struct xfs_buf **leaf_bp,
+ xfs_attr_state_t *state,
bool roll_trans)
{
struct xfs_inode *dp = args->dp;
int error = 0;
int sf_size;
+ switch (*state) {
+ case (XFS_ATTR_STATE1):
+ goto state1;
+ case (XFS_ATTR_STATE2):
+ goto state2;
+ }
+
/*
* New inodes setting the parent pointer attr will
* not have an attribute fork yet. So set the attribute
@@ -263,7 +271,6 @@ xfs_attr_set_args(
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).
*/
@@ -277,6 +284,9 @@ xfs_attr_set_args(
if (error != -ENOSPC)
goto out;
+ *state = XFS_ATTR_STATE1;
+ return -EAGAIN;
+state1:
/*
* It won't fit in the shortform, transform to a leaf block.
* GROT: another possible req'mt for a double-split btree op.
@@ -285,14 +295,14 @@ xfs_attr_set_args(
if (error)
goto out;
- 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);
+ /*
+ * 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);
+ if (roll_trans) {
error = xfs_defer_finish(&args->trans);
if (error)
goto out;
@@ -308,6 +318,12 @@ xfs_attr_set_args(
xfs_trans_bjoin(args->trans, *leaf_bp);
*leaf_bp = NULL;
}
+
+ *state = XFS_ATTR_STATE2;
+ return -EAGAIN;
+state2:
+ if (*leaf_bp != NULL)
+ xfs_trans_brelse(args->trans, *leaf_bp);
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
@@ -440,7 +456,9 @@ xfs_attr_set(
}
xfs_trans_ijoin(args.trans, dp, 0);
- error = xfs_attr_set_args(&args, &leaf_bp, true);
+
+ error = xfs_attr_set_deferred(dp, args.trans, name, strlen(name),
+ value, valuelen, flags);
if (error)
goto out;
@@ -570,8 +588,13 @@ xfs_attr_remove(
*/
xfs_trans_ijoin(args.trans, dp, 0);
- error = xfs_attr_remove_args(&args, true);
+ error = xfs_has_attr(&args);
+ if (error)
+ goto out;
+
+ error = xfs_attr_remove_deferred(dp, args.trans,
+ name, strlen(name), flags);
if (error)
goto out;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 38ba5df..76fad8f 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -178,7 +178,7 @@ int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
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, struct xfs_buf **leaf_bp,
- bool roll_trans);
+ xfs_attr_state_t *state, bool roll_trans);
int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
int xfs_has_attr(struct xfs_da_args *args);
int xfs_attr_remove_args(struct xfs_da_args *args, bool roll_trans);
diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
index 56fc0b0..b8db2da 100644
--- a/fs/xfs/xfs_attr_item.c
+++ b/fs/xfs/xfs_attr_item.c
@@ -475,8 +475,11 @@ xfs_attri_recover(
struct xfs_attri_log_format *attrp;
struct xfs_trans_res tres;
int local;
- int error = 0;
+ int error, err2 = 0;
int rsvd = 0;
+ xfs_attr_state_t state = 0;
+ struct xfs_buf *leaf_bp = NULL;
+
ASSERT(!test_bit(XFS_ATTRI_RECOVERED, &attrip->flags));
@@ -551,14 +554,40 @@ xfs_attri_recover(
xfs_ilock(ip, XFS_ILOCK_EXCL);
xfs_trans_ijoin(args.trans, ip, 0);
- error = xfs_trans_attr(&args, attrdp, attrp->alfi_op_flags);
- if (error)
- goto abort_error;
+ do {
+ leaf_bp = NULL;
+
+ error = xfs_trans_attr(&args, attrdp, &leaf_bp, &state,
+ attrp->alfi_op_flags);
+ if (error && error != -EAGAIN)
+ goto abort_error;
+
+ xfs_trans_log_inode(args.trans, ip,
+ XFS_ILOG_CORE | XFS_ILOG_ADATA);
+
+ err2 = xfs_trans_commit(args.trans);
+ if (err2) {
+ error = err2;
+ goto abort_error;
+ }
+
+ if (error == -EAGAIN) {
+ err2 = xfs_trans_alloc(mp, &tres, args.total, 0,
+ XFS_TRANS_PERM_LOG_RES, &args.trans);
+ if (err2) {
+ error = err2;
+ goto abort_error;
+ }
+ xfs_trans_ijoin(args.trans, ip, 0);
+ }
+
+ } while (error == -EAGAIN);
+
+ if (leaf_bp)
+ xfs_trans_brelse(args.trans, leaf_bp);
set_bit(XFS_ATTRI_RECOVERED, &attrip->flags);
- xfs_trans_log_inode(args.trans, ip, XFS_ILOG_CORE | XFS_ILOG_ADATA);
- error = xfs_trans_commit(args.trans);
xfs_iunlock(ip, XFS_ILOCK_EXCL);
return error;
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 433bada..cc38d45 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -240,6 +240,8 @@ xfs_trans_get_attrd(struct xfs_trans *tp,
struct xfs_attri_log_item *attrip);
int xfs_trans_attr( struct xfs_da_args *args,
struct xfs_attrd_log_item *attrdp,
+ struct xfs_buf **leaf_bp,
+ void *state,
uint32_t attr_op_flags);
int xfs_trans_commit(struct xfs_trans *);
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
index 87607b2..db6cb6d 100644
--- a/fs/xfs/xfs_trans_attr.c
+++ b/fs/xfs/xfs_trans_attr.c
@@ -67,10 +67,11 @@ int
xfs_trans_attr(
struct xfs_da_args *args,
struct xfs_attrd_log_item *attrdp,
+ struct xfs_buf **leaf_bp,
+ void *state,
uint32_t op_flags)
{
int error;
- struct xfs_buf *leaf_bp = NULL;
error = xfs_qm_dqattach_locked(args->dp, 0);
if (error)
@@ -79,7 +80,8 @@ xfs_trans_attr(
switch (op_flags) {
case XFS_ATTR_OP_FLAGS_SET:
args->op_flags |= XFS_DA_OP_ADDNAME;
- error = xfs_attr_set_args(args,&leaf_bp, false);
+ error = xfs_attr_set_args(args, leaf_bp,
+ (xfs_attr_state_t *)state, false);
break;
case XFS_ATTR_OP_FLAGS_REMOVE:
ASSERT(XFS_IFORK_Q((args->dp)));
@@ -89,11 +91,6 @@ xfs_trans_attr(
error = -EFSCORRUPTED;
}
- 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:
@@ -195,27 +192,39 @@ xfs_attr_finish_item(
char *name_value;
int error;
int local;
- struct xfs_da_args args;
+ struct xfs_da_args *args;
attr = container_of(item, struct xfs_attr_item, xattri_list);
- name_value = ((char *)attr) + sizeof(struct xfs_attr_item);
-
- error = xfs_attr_args_init(&args, attr->xattri_ip, name_value,
- attr->xattri_flags);
- if (error)
- goto out;
+ args = &attr->xattri_args;
+
+ if (attr->xattri_state == 0) {
+ /* Only need to initialize args context once */
+ name_value = ((char *)attr) + sizeof(struct xfs_attr_item);
+ error = xfs_attr_args_init(args, attr->xattri_ip, name_value,
+ attr->xattri_flags);
+ if (error)
+ goto out;
+
+ args->hashval = xfs_da_hashname(args->name, args->namelen);
+ args->value = &name_value[attr->xattri_name_len];
+ args->valuelen = attr->xattri_value_len;
+ args->op_flags = XFS_DA_OP_OKNOENT;
+ args->total = xfs_attr_calc_size(args, &local);
+ attr->xattri_leaf_bp = NULL;
+ }
- args.hashval = xfs_da_hashname(args.name, args.namelen);
- args.value = &name_value[attr->xattri_name_len];
- args.valuelen = attr->xattri_value_len;
- args.op_flags = XFS_DA_OP_OKNOENT;
- args.total = xfs_attr_calc_size(&args, &local);
- args.trans = tp;
+ /*
+ * Always reset trans after EAGAIN cycle
+ * since the transaction is new
+ */
+ args->trans = tp;
- error = xfs_trans_attr(&args, done_item,
- attr->xattri_op_flags);
+ error = xfs_trans_attr(args, done_item, &attr->xattri_leaf_bp,
+ &attr->xattri_state, attr->xattri_op_flags);
out:
- kmem_free(attr);
+ if (error != -EAGAIN)
+ kmem_free(attr);
+
return error;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 12/28] xfs: Remove roll_trans boolean
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (10 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 11/28] xfs: Roll delayed attr operations by returning EAGAIN Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 13/28] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
` (17 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
All calls to functions using this parameter are now passing a
false value. We can now remove the boolean and all affected
code
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/libxfs/xfs_attr.c | 168 ++++++----------------------------------
fs/xfs/libxfs/xfs_attr.h | 4 +-
fs/xfs/libxfs/xfs_attr_leaf.c | 25 +-----
fs/xfs/libxfs/xfs_attr_leaf.h | 6 +-
fs/xfs/libxfs/xfs_attr_remote.c | 34 +-------
fs/xfs/libxfs/xfs_attr_remote.h | 4 +-
fs/xfs/xfs_trans_attr.c | 4 +-
7 files changed, 39 insertions(+), 206 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 0e5bce9..79e7650 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -50,16 +50,16 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
* 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, bool roll_trans);
-STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args, bool roll_trans);
+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_leaf_has_attr(xfs_da_args_t *args);
/*
* 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, bool roll_trans);
-STATIC int xfs_attr_node_removename(xfs_da_args_t *args, bool roll_trans);
+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_hasname(xfs_da_args_t *args);
STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
@@ -237,8 +237,7 @@ int
xfs_attr_set_args(
struct xfs_da_args *args,
struct xfs_buf **leaf_bp,
- xfs_attr_state_t *state,
- bool roll_trans)
+ xfs_attr_state_t *state)
{
struct xfs_inode *dp = args->dp;
int error = 0;
@@ -302,23 +301,6 @@ xfs_attr_set_args(
*/
xfs_trans_bhold(args->trans, *leaf_bp);
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- 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_trans_bjoin(args->trans, *leaf_bp);
- *leaf_bp = NULL;
- }
-
*state = XFS_ATTR_STATE2;
return -EAGAIN;
state2:
@@ -327,9 +309,9 @@ xfs_attr_set_args(
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
- error = xfs_attr_leaf_addname(args, roll_trans);
+ error = xfs_attr_leaf_addname(args);
else
- error = xfs_attr_node_addname(args, roll_trans);
+ error = xfs_attr_node_addname(args);
if (error)
goto out;
@@ -365,8 +347,7 @@ xfs_has_attr(
*/
int
xfs_attr_remove_args(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_inode *dp = args->dp;
int error;
@@ -377,9 +358,9 @@ xfs_attr_remove_args(
ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
error = xfs_attr_shortform_remove(args);
} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
- error = xfs_attr_leaf_removename(args, roll_trans);
+ error = xfs_attr_leaf_removename(args);
} else {
- error = xfs_attr_node_removename(args, roll_trans);
+ error = xfs_attr_node_removename(args);
}
return error;
@@ -717,8 +698,7 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
*/
STATIC int
xfs_attr_leaf_addname(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_inode *dp;
struct xfs_buf *bp;
@@ -784,39 +764,14 @@ xfs_attr_leaf_addname(
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- 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, roll_trans);
+ error = xfs_attr_node_addname(args);
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
* identified for its storage and copy the value. This is done
@@ -824,7 +779,7 @@ xfs_attr_leaf_addname(
* maximum size of a transaction and/or hit a deadlock.
*/
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_set(args, roll_trans);
+ error = xfs_attr_rmtval_set(args);
if (error)
return error;
}
@@ -840,7 +795,7 @@ xfs_attr_leaf_addname(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args, roll_trans);
+ error = xfs_attr3_leaf_flipflags(args);
if (error)
return error;
@@ -854,7 +809,7 @@ xfs_attr_leaf_addname(
args->rmtblkcnt = args->rmtblkcnt2;
args->rmtvaluelen = args->rmtvaluelen2;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(args, roll_trans);
+ error = xfs_attr_rmtval_remove(args);
if (error)
return error;
}
@@ -878,25 +833,13 @@ xfs_attr_leaf_addname(
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
-
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
- }
}
- /*
- * Commit the remove and start the next trans in series.
- */
- if (roll_trans)
- error = xfs_trans_roll_inode(&args->trans, dp);
-
} else if (args->rmtblkno > 0) {
/*
* Added a "remote" value, just clear the incomplete flag.
*/
- error = xfs_attr3_leaf_clearflag(args, roll_trans);
+ error = xfs_attr3_leaf_clearflag(args);
}
return error;
out_defer_cancel:
@@ -937,8 +880,7 @@ xfs_leaf_has_attr(
*/
STATIC int
xfs_attr_leaf_removename(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_inode *dp;
struct xfs_buf *bp;
@@ -971,11 +913,6 @@ xfs_attr_leaf_removename(
/* bp is gone due to xfs_da_shrink_inode */
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
- }
}
return 0;
out_defer_cancel:
@@ -1031,8 +968,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
*/
STATIC int
xfs_attr_node_addname(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_da_state *state;
struct xfs_da_state_blk *blk;
@@ -1102,20 +1038,6 @@ xfs_attr_node_addname(
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
-
- /*
- * 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;
}
@@ -1128,12 +1050,6 @@ xfs_attr_node_addname(
error = xfs_da3_split(state);
if (error)
goto out_defer_cancel;
-
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- }
} else {
/*
* Addition succeeded, update Btree hashvals.
@@ -1149,23 +1065,13 @@ xfs_attr_node_addname(
state = NULL;
/*
- * Commit the leaf addition or btree split and start the next
- * trans in the chain.
- */
- 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
* identified for its storage and copy the value. This is done
* after we create the attribute so that we don't overflow the
* maximum size of a transaction and/or hit a deadlock.
*/
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_set(args, roll_trans);
+ error = xfs_attr_rmtval_set(args);
if (error)
return error;
}
@@ -1181,7 +1087,7 @@ xfs_attr_node_addname(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args, roll_trans);
+ error = xfs_attr3_leaf_flipflags(args);
if (error)
goto out;
@@ -1195,7 +1101,7 @@ xfs_attr_node_addname(
args->rmtblkcnt = args->rmtblkcnt2;
args->rmtvaluelen = args->rmtvaluelen2;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(args, roll_trans);
+ error = xfs_attr_rmtval_remove(args);
if (error)
return error;
}
@@ -1229,11 +1135,6 @@ xfs_attr_node_addname(
error = xfs_da3_join(state);
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- }
}
/*
@@ -1247,7 +1148,7 @@ xfs_attr_node_addname(
/*
* Added a "remote" value, just clear the incomplete flag.
*/
- error = xfs_attr3_leaf_clearflag(args, roll_trans);
+ error = xfs_attr3_leaf_clearflag(args);
if (error)
goto out;
}
@@ -1303,8 +1204,7 @@ xfs_attr_node_hasname(
*/
STATIC int
xfs_attr_node_removename(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_da_state *state;
struct xfs_da_state_blk *blk;
@@ -1354,10 +1254,10 @@ xfs_attr_node_removename(
* Mark the attribute as INCOMPLETE, then bunmapi() the
* remote value.
*/
- error = xfs_attr3_leaf_setflag(args, roll_trans);
+ error = xfs_attr3_leaf_setflag(args);
if (error)
goto out;
- error = xfs_attr_rmtval_remove(args, roll_trans);
+ error = xfs_attr_rmtval_remove(args);
if (error)
goto out;
@@ -1385,19 +1285,6 @@ xfs_attr_node_removename(
error = xfs_da3_join(state);
if (error)
goto out_defer_cancel;
-
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- /*
- * Commit the Btree join operation and
- * start a new trans.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- goto out;
- }
}
/*
@@ -1421,11 +1308,6 @@ xfs_attr_node_removename(
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- goto out;
- }
} else
xfs_trans_brelse(args->trans, bp);
}
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 76fad8f..3a51c84 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -178,10 +178,10 @@ int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,
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, struct xfs_buf **leaf_bp,
- xfs_attr_state_t *state, bool roll_trans);
+ xfs_attr_state_t *state);
int xfs_attr_remove(struct xfs_inode *dp, const unsigned char *name, int flags);
int xfs_has_attr(struct xfs_da_args *args);
-int xfs_attr_remove_args(struct xfs_da_args *args, bool roll_trans);
+int xfs_attr_remove_args(struct xfs_da_args *args);
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,
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 43fafa9..09483fe 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -2673,8 +2673,7 @@ xfs_attr_leaf_newentsize(
*/
int
xfs_attr3_leaf_clearflag(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr_leaf_entry *entry;
@@ -2732,11 +2731,6 @@ xfs_attr3_leaf_clearflag(
XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
}
- /*
- * Commit the flag value change and start the next trans in series.
- */
- if (roll_trans)
- error = xfs_trans_roll_inode(&args->trans, args->dp);
return error;
}
@@ -2745,8 +2739,7 @@ xfs_attr3_leaf_clearflag(
*/
int
xfs_attr3_leaf_setflag(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_attr_leafblock *leaf;
struct xfs_attr_leaf_entry *entry;
@@ -2786,11 +2779,6 @@ xfs_attr3_leaf_setflag(
XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
}
- /*
- * Commit the flag value change and start the next trans in series.
- */
- if (roll_trans)
- error = xfs_trans_roll_inode(&args->trans, args->dp);
return error;
}
@@ -2803,8 +2791,7 @@ xfs_attr3_leaf_setflag(
*/
int
xfs_attr3_leaf_flipflags(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_attr_leafblock *leaf1;
struct xfs_attr_leafblock *leaf2;
@@ -2907,11 +2894,5 @@ xfs_attr3_leaf_flipflags(
XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
}
- /*
- * Commit the flag value change and start the next trans in series.
- */
- if (roll_trans)
- error = xfs_trans_roll_inode(&args->trans, args->dp);
-
return error;
}
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index 98dd169..d38c558 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
@@ -51,9 +51,9 @@ void xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
int xfs_attr3_leaf_to_node(struct xfs_da_args *args);
int xfs_attr3_leaf_to_shortform(struct xfs_buf *bp,
struct xfs_da_args *args, int forkoff);
-int xfs_attr3_leaf_clearflag(struct xfs_da_args *args, bool roll_trans);
-int xfs_attr3_leaf_setflag(struct xfs_da_args *args, bool roll_trans);
-int xfs_attr3_leaf_flipflags(struct xfs_da_args *args, 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);
/*
* Routines used for growing the Btree.
diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index e13000a..0e91605 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -433,8 +433,7 @@ xfs_attr_rmtval_get(
*/
int
xfs_attr_rmtval_set(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_inode *dp = args->dp;
struct xfs_mount *mp = dp->i_mount;
@@ -488,26 +487,11 @@ xfs_attr_rmtval_set(
if (error)
goto out_defer_cancel;
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
- }
-
ASSERT(nmap == 1);
ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
(map.br_startblock != HOLESTARTBLOCK));
lblkno += map.br_blockcount;
blkcnt -= map.br_blockcount;
-
- if (roll_trans) {
- /*
- * Start the next trans in the chain.
- */
- error = xfs_trans_roll_inode(&args->trans, dp);
- if (error)
- return error;
- }
}
/*
@@ -570,8 +554,7 @@ xfs_attr_rmtval_set(
*/
int
xfs_attr_rmtval_remove(
- struct xfs_da_args *args,
- bool roll_trans)
+ struct xfs_da_args *args)
{
struct xfs_mount *mp = args->dp->i_mount;
xfs_dablk_t lblkno;
@@ -633,19 +616,6 @@ xfs_attr_rmtval_remove(
XFS_BMAPI_ATTRFORK, 1, &done);
if (error)
goto out_defer_cancel;
-
- if (roll_trans) {
- error = xfs_defer_finish(&args->trans);
- if (error)
- return error;
-
- /*
- * Close out trans and start the next one in the chain.
- */
- error = xfs_trans_roll_inode(&args->trans, args->dp);
- if (error)
- return error;
- }
}
return 0;
out_defer_cancel:
diff --git a/fs/xfs/libxfs/xfs_attr_remote.h b/fs/xfs/libxfs/xfs_attr_remote.h
index c7c073d..9d20b66 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.h
+++ b/fs/xfs/libxfs/xfs_attr_remote.h
@@ -9,7 +9,7 @@
int xfs_attr3_rmt_blocks(struct xfs_mount *mp, int attrlen);
int xfs_attr_rmtval_get(struct xfs_da_args *args);
-int xfs_attr_rmtval_set(struct xfs_da_args *args, bool roll_trans);
-int xfs_attr_rmtval_remove(struct xfs_da_args *args, bool roll_trans);
+int xfs_attr_rmtval_set(struct xfs_da_args *args);
+int xfs_attr_rmtval_remove(struct xfs_da_args *args);
#endif /* __XFS_ATTR_REMOTE_H__ */
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
index db6cb6d..4d138a9 100644
--- a/fs/xfs/xfs_trans_attr.c
+++ b/fs/xfs/xfs_trans_attr.c
@@ -81,11 +81,11 @@ xfs_trans_attr(
case XFS_ATTR_OP_FLAGS_SET:
args->op_flags |= XFS_DA_OP_ADDNAME;
error = xfs_attr_set_args(args, leaf_bp,
- (xfs_attr_state_t *)state, false);
+ (xfs_attr_state_t *)state);
break;
case XFS_ATTR_OP_FLAGS_REMOVE:
ASSERT(XFS_IFORK_Q((args->dp)));
- error = xfs_attr_remove_args(args, false);
+ error = xfs_attr_remove_args(args);
break;
default:
error = -EFSCORRUPTED;
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 13/28] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names.
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (11 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 12/28] xfs: Remove roll_trans boolean Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 14/28] xfs: get directory offset when adding directory name Allison Henderson
` (16 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 16 ++++++++++------
fs/xfs/libxfs/xfs_attr.h | 10 ++++++----
fs/xfs/xfs_acl.c | 12 +++++++-----
fs/xfs/xfs_attr_item.c | 2 +-
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 ++++++----
8 files changed, 45 insertions(+), 26 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 79e7650..34f4ab0 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -70,6 +70,7 @@ xfs_attr_args_init(
struct xfs_da_args *args,
struct xfs_inode *dp,
const unsigned char *name,
+ size_t namelen,
int flags)
{
@@ -82,7 +83,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 */
@@ -128,6 +129,7 @@ int
xfs_attr_get(
struct xfs_inode *ip,
const unsigned char *name,
+ size_t namelen,
unsigned char *value,
int *valuelenp,
int flags)
@@ -141,7 +143,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;
@@ -370,6 +372,7 @@ int
xfs_attr_set(
struct xfs_inode *dp,
const unsigned char *name,
+ size_t namelen,
unsigned char *value,
int valuelen,
int flags)
@@ -386,7 +389,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;
@@ -438,7 +441,7 @@ xfs_attr_set(
xfs_trans_ijoin(args.trans, dp, 0);
- error = xfs_attr_set_deferred(dp, args.trans, name, strlen(name),
+ error = xfs_attr_set_deferred(dp, args.trans, name, namelen,
value, valuelen, flags);
if (error)
goto out;
@@ -525,6 +528,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;
@@ -575,7 +579,7 @@ xfs_attr_remove(
error = xfs_attr_remove_deferred(dp, args.trans,
- name, strlen(name), flags);
+ name, namelen, flags);
if (error)
goto out;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 3a51c84..bee449d 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -174,18 +174,20 @@ 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, struct xfs_buf **leaf_bp,
xfs_attr_state_t *state);
-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_has_attr(struct xfs_da_args *args);
int xfs_attr_remove_args(struct xfs_da_args *args);
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_trans *tp,
void *name, unsigned int name_len, void *value,
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 48166df..9b1b93e 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -143,8 +143,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
@@ -194,15 +194,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_attr_item.c b/fs/xfs/xfs_attr_item.c
index b8db2da..5cf87e7 100644
--- a/fs/xfs/xfs_attr_item.c
+++ b/fs/xfs/xfs_attr_item.c
@@ -530,7 +530,7 @@ xfs_attri_recover(
return error;
error = xfs_attr_args_init(&args, ip, attrip->name,
- attrp->alfi_attr_flags);
+ attrp->alfi_name_len, attrp->alfi_attr_flags);
if (error)
return error;
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 6cd9218..b0a4b37 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -439,6 +439,7 @@ xfs_attrmulti_attr_get(
{
unsigned char *kbuf;
int error = -EFAULT;
+ size_t namelen;
if (*len > XFS_XATTR_SIZE_MAX)
return -EINVAL;
@@ -446,7 +447,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;
@@ -468,6 +471,7 @@ xfs_attrmulti_attr_set(
{
unsigned char *kbuf;
int error;
+ size_t namelen;
if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
return -EPERM;
@@ -478,7 +482,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);
@@ -492,10 +497,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 ab605fe..f7b1e83 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -60,8 +60,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 4d138a9..7e20721 100644
--- a/fs/xfs/xfs_trans_attr.c
+++ b/fs/xfs/xfs_trans_attr.c
@@ -201,7 +201,7 @@ xfs_attr_finish_item(
/* Only need to initialize args context once */
name_value = ((char *)attr) + sizeof(struct xfs_attr_item);
error = xfs_attr_args_init(args, attr->xattri_ip, name_value,
- attr->xattri_flags);
+ attr->xattri_name_len, attr->xattri_flags);
if (error)
goto out;
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 031f720..27a3fa4 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -27,6 +27,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) {
@@ -34,7 +35,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;
@@ -70,6 +71,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)
@@ -78,9 +80,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] 38+ messages in thread
* [PATCH v8 14/28] xfs: get directory offset when adding directory name
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (12 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 13/28] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 15/28] xfs: get directory offset when removing " Allison Henderson
` (15 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 2 +-
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 | 7 ++++---
fs/xfs/xfs_symlink.c | 3 ++-
9 files changed, 22 insertions(+), 7 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_da_btree.h b/fs/xfs/libxfs/xfs_da_btree.h
index 84dd865..04a0641 100644
--- a/fs/xfs/libxfs/xfs_da_btree.h
+++ b/fs/xfs/libxfs/xfs_da_btree.h
@@ -71,6 +71,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 229152c..d334e66 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -243,7 +243,8 @@ xfs_dir_createname(
struct xfs_inode *dp,
struct xfs_name *name,
xfs_ino_t inum, /* new entry inode number */
- 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;
@@ -298,6 +299,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;
}
@@ -536,7 +541,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, 0);
+ return xfs_dir_createname(tp, dp, name, 0, 0, NULL);
}
/*
diff --git a/fs/xfs/libxfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index c3e3f6b..c164a38 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -117,7 +117,7 @@ extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_inode *pdp);
extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t inum,
- xfs_extlen_t tot);
+ 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 30ed591..a31702c 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -547,6 +547,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 1728a3e..37450ca 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -882,6 +882,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 f1bb343..654bbf4 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -2027,6 +2027,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 585dfdb..549656b 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -393,6 +393,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.
@@ -484,6 +485,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 1ef9d03..6aea30f 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1224,7 +1224,8 @@ xfs_create(
error = xfs_dir_createname(tp, dp, name, ip->i_ino,
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;
@@ -1452,7 +1453,7 @@ xfs_link(
}
error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
- resblks);
+ resblks, NULL);
if (error)
goto error_return;
xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -2983,7 +2984,7 @@ xfs_rename(
* to account for the ".." reference from the new entry.
*/
error = xfs_dir_createname(tp, target_dp, target_name,
- src_ip->i_ino, spaceres);
+ src_ip->i_ino, spaceres, NULL);
if (error)
goto out_trans_cancel;
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 07b1036..72e2915 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -328,7 +328,8 @@ xfs_symlink(
/*
* Create the directory entry for the symlink.
*/
- error = xfs_dir_createname(tp, dp, link_name, ip->i_ino, resblks);
+ error = xfs_dir_createname(tp, dp, link_name,
+ ip->i_ino, resblks, NULL);
if (error)
goto out_trans_cancel;
xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 15/28] xfs: get directory offset when removing directory name
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (13 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 14/28] xfs: get directory offset when adding directory name Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 16/28] xfs: get directory offset when replacing a " Allison Henderson
` (14 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 6 +++++-
fs/xfs/libxfs/xfs_dir2.h | 3 ++-
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 | 4 ++--
7 files changed, 19 insertions(+), 10 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index d334e66..f5475e7 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -422,7 +422,8 @@ xfs_dir_removename(
struct xfs_inode *dp,
struct xfs_name *name,
xfs_ino_t ino,
- 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;
@@ -467,6 +468,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 c164a38..2cf1d87 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -123,7 +123,8 @@ extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *ci_name);
extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
struct xfs_name *name, xfs_ino_t ino,
- xfs_extlen_t tot);
+ 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_extlen_t tot);
diff --git a/fs/xfs/libxfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index a31702c..aa84c45 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -786,9 +786,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 37450ca..5e68c39 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -1402,9 +1402,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 654bbf4..3c1698f 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -1238,9 +1238,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 549656b..e65615c 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -905,6 +905,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 6aea30f..67a5437 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2621,7 +2621,7 @@ xfs_remove(
if (error)
goto out_trans_cancel;
- error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks);
+ error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks, NULL);
if (error) {
ASSERT(error != -ENOENT);
goto out_trans_cancel;
@@ -3099,7 +3099,7 @@ xfs_rename(
spaceres);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
- spaceres);
+ spaceres, NULL);
if (error)
goto out_trans_cancel;
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 16/28] xfs: get directory offset when replacing a directory name
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (14 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 15/28] xfs: get directory offset when removing " Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 17/28] xfs: add parent pointer support to attribute code Allison Henderson
` (13 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 8 ++++++--
fs/xfs/libxfs/xfs_dir2.h | 2 +-
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 | 14 +++++++-------
7 files changed, 20 insertions(+), 12 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index f5475e7..7d8c63b 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -468,7 +468,7 @@ xfs_dir_removename(
else
rval = xfs_dir2_node_removename(args);
out_free:
- if (offset)
+ if (!rval && offset)
*offset = args->offset;
kmem_free(args);
@@ -484,7 +484,8 @@ xfs_dir_replace(
struct xfs_inode *dp,
struct xfs_name *name, /* name of entry to replace */
xfs_ino_t inum, /* new inode number */
- 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;
@@ -532,6 +533,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 2cf1d87..63de5b9 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -127,7 +127,7 @@ extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
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_extlen_t tot);
+ 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 aa84c45..a327d81 100644
--- a/fs/xfs/libxfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -860,9 +860,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 5e68c39..1ef74572 100644
--- a/fs/xfs/libxfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -1538,6 +1538,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 3c1698f..9cbe012 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -2242,6 +2242,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 e65615c..ea5b63b 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -1031,6 +1031,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 67a5437..d7e06c2 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2737,12 +2737,12 @@ 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, spaceres);
+ error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, 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, spaceres);
+ error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -2756,7 +2756,7 @@ xfs_cross_rename(
if (S_ISDIR(VFS_I(ip2)->i_mode)) {
error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
- dp1->i_ino, spaceres);
+ dp1->i_ino, spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -2782,7 +2782,7 @@ xfs_cross_rename(
if (S_ISDIR(VFS_I(ip1)->i_mode)) {
error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
- dp2->i_ino, spaceres);
+ dp2->i_ino, spaceres, NULL);
if (error)
goto out_trans_abort;
@@ -3023,7 +3023,7 @@ xfs_rename(
* name at the destination directory, remove it first.
*/
error = xfs_dir_replace(tp, target_dp, target_name,
- src_ip->i_ino, spaceres);
+ src_ip->i_ino, spaceres, NULL);
if (error)
goto out_trans_cancel;
@@ -3057,7 +3057,7 @@ xfs_rename(
* directory.
*/
error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
- target_dp->i_ino, spaceres);
+ target_dp->i_ino, spaceres, NULL);
ASSERT(error != -EEXIST);
if (error)
goto out_trans_cancel;
@@ -3096,7 +3096,7 @@ xfs_rename(
*/
if (wip) {
error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
- spaceres);
+ spaceres, NULL);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
spaceres, NULL);
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 17/28] xfs: add parent pointer support to attribute code
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (15 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 16/28] xfs: get directory offset when replacing a " Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 18/28] xfs: define parent pointer xattr format Allison Henderson
` (12 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 4 +++-
fs/xfs/libxfs/xfs_attr.h | 2 ++
fs/xfs/libxfs/xfs_da_format.h | 12 ++++++++----
3 files changed, 13 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 34f4ab0..40274c2 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -381,11 +381,13 @@ xfs_attr_set(
struct xfs_buf *leaf_bp = NULL;
struct xfs_da_args args;
struct xfs_trans_res tres;
- int rsvd = (flags & ATTR_ROOT) != 0;
+ int rsvd;
int error, local;
XFS_STATS_INC(mp, xs_attr_set);
+ rsvd = ((flags & ATTR_ROOT) | ATTR_PARENT) != 0;
+
if (XFS_FORCED_SHUTDOWN(dp->i_mount))
return -EIO;
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index bee449d..14cb7c1 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -32,6 +32,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 */
@@ -45,6 +46,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 5d5bf3b..67cb9ea 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -746,24 +746,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] 38+ messages in thread
* [PATCH v8 18/28] xfs: define parent pointer xattr format
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (16 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 17/28] xfs: add parent pointer support to attribute code Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 19/28] xfs: extent transaction reservations for parent attributes Allison Henderson
` (11 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 67cb9ea..b6405d7 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -873,4 +873,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] 38+ messages in thread
* [PATCH v8 19/28] xfs: extent transaction reservations for parent attributes
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (17 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 18/28] xfs: define parent pointer xattr format Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 20/28] xfs: parent pointer attribute creation Allison Henderson
` (10 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 059bc44..386d734 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -550,6 +550,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 f99a7ae..44274b9 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -775,29 +775,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;
@@ -819,15 +820,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;
@@ -859,6 +922,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 7241ab2..0197d9e 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.h
+++ b/fs/xfs/libxfs/xfs_trans_resv.h
@@ -93,5 +93,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] 38+ messages in thread
* [PATCH v8 20/28] xfs: parent pointer attribute creation
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (18 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 19/28] xfs: extent transaction reservations for parent attributes Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 21/28] xfs: add parent attributes to link Allison Henderson
` (9 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
From: Dave Chinner <dchinner@redhat.com>
Add parent pointer attribute during xfs_create, and
subroutines to initialize attributes
[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 | 101 +++++++++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_parent.h | 35 ++++++++++++++++
fs/xfs/xfs_inode.c | 17 +++++++-
fs/xfs/xfs_parent_utils.c | 52 +++++++++++++++++++++++
fs/xfs/xfs_parent_utils.h | 26 ++++++++++++
6 files changed, 231 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 022e0b4..45a3360 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -42,6 +42,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 \
@@ -82,6 +83,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..5045f65
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_parent.c
@@ -0,0 +1,101 @@
+/*
+ * 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_da_btree.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)
+{
+ struct xfs_parent_name_rec rec;
+ int error;
+ int flags = ATTR_PARENT;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ error = xfs_attr_set(child, (const unsigned char *)&rec, sizeof(rec),
+ (char *)child_name->name, child_name->len, flags);
+
+ return error;
+}
+
diff --git a/fs/xfs/libxfs/xfs_parent.h b/fs/xfs/libxfs/xfs_parent.h
new file mode 100644
index 0000000..60f1172
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_parent.h
@@ -0,0 +1,35 @@
+/*
+ * 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);
+#endif /* __XFS_PARENT_H__ */
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index d7e06c2..3f722e6 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -41,6 +41,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;
@@ -1151,6 +1152,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);
@@ -1219,13 +1221,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,
resblks ?
resblks - XFS_IALLOC_SPACE_RES(mp) : 0,
- NULL);
+ &diroffset);
if (error) {
ASSERT(error != -ENOSPC);
goto out_trans_cancel;
@@ -1244,6 +1246,16 @@ 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, tp, ip, name, diroffset);
+ if (error)
+ goto out_trans_cancel;
+ }
+
+ /*
* If this is a synchronous mount, make sure that the
* create transaction goes to disk before returning to
* the user.
@@ -1268,6 +1280,7 @@ xfs_create(
*ipp = ip;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
return 0;
out_trans_cancel:
diff --git a/fs/xfs/xfs_parent_utils.c b/fs/xfs/xfs_parent_utils.c
new file mode 100644
index 0000000..f84a4fd
--- /dev/null
+++ b/fs/xfs/xfs_parent_utils.c
@@ -0,0 +1,52 @@
+/*
+ * 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_da_format.h"
+#include "xfs_da_btree.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_trans *tp,
+ struct xfs_inode *child,
+ struct xfs_name *child_name,
+ uint32_t diroffset)
+{
+ struct xfs_parent_name_rec rec;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ return xfs_attr_set_deferred(child, tp, &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..82453d2
--- /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_trans *tp,
+ struct xfs_inode *child, struct xfs_name *child_name,
+ uint32_t diroffset);
+#endif /* __XFS_PARENT_UTILS_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 21/28] xfs: add parent attributes to link
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (19 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 20/28] xfs: parent pointer attribute creation Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 22/28] xfs: remove parent pointers in unlink Allison Henderson
` (8 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 37 +++++++++++++++++++++++++++++--------
1 file changed, 29 insertions(+), 8 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 3f722e6..4a32eb1 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1409,6 +1409,7 @@ xfs_link(
xfs_trans_t *tp;
int error;
int resblks;
+ xfs_dir2_dataptr_t diroffset;
trace_xfs_link(tdp, target_name);
@@ -1436,8 +1437,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
@@ -1466,15 +1467,28 @@ xfs_link(
}
error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
- resblks, NULL);
+ 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, tp, sip, target_name,
+ diroffset);
+ if (error)
+ goto out_defer_cancel;
+ }
/*
* If this is a synchronous mount, make sure that the
@@ -1484,11 +1498,18 @@ xfs_link(
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
xfs_trans_set_sync(tp);
- 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(tp);
+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] 38+ messages in thread
* [PATCH v8 22/28] xfs: remove parent pointers in unlink
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (20 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 21/28] xfs: add parent attributes to link Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 23/28] xfs: Add parent pointers to rename Allison Henderson
` (7 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 20 ++++++++++++++++----
fs/xfs/xfs_parent_utils.c | 18 ++++++++++++++++++
fs/xfs/xfs_parent_utils.h | 4 ++++
3 files changed, 38 insertions(+), 4 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 4a32eb1..300ba90 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2577,6 +2577,7 @@ xfs_remove(
int is_dir = S_ISDIR(VFS_I(ip)->i_mode);
int error = 0;
uint resblks;
+ xfs_dir2_dataptr_t dir_offset;
trace_xfs_remove(dp, name);
@@ -2614,8 +2615,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.
@@ -2655,12 +2656,18 @@ xfs_remove(
if (error)
goto out_trans_cancel;
- error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks, NULL);
+ error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks, &dir_offset);
if (error) {
ASSERT(error != -ENOENT);
goto out_trans_cancel;
}
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_remove_deferred(dp, tp, ip, dir_offset);
+ if (error)
+ goto out_trans_cancel;
+ }
+
/*
* If this is a synchronous mount, make sure that the
* remove transaction goes to disk before returning to
@@ -2671,15 +2678,20 @@ 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);
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+ xfs_iunlock(dp, XFS_ILOCK_EXCL);
return 0;
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 f84a4fd..8f35afe 100644
--- a/fs/xfs/xfs_parent_utils.c
+++ b/fs/xfs/xfs_parent_utils.c
@@ -50,3 +50,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_trans *tp,
+ struct xfs_inode *child,
+ xfs_dir2_dataptr_t diroffset)
+{
+ struct xfs_parent_name_rec rec;
+
+ xfs_init_parent_name_rec(&rec, parent, diroffset);
+
+ return xfs_attr_remove_deferred(child, tp, &rec, sizeof(rec),
+ ATTR_PARENT);
+}
+
diff --git a/fs/xfs/xfs_parent_utils.h b/fs/xfs/xfs_parent_utils.h
index 82453d2..010e517 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_trans *tp,
struct xfs_inode *child, struct xfs_name *child_name,
uint32_t diroffset);
+int xfs_parent_remove_deferred(struct xfs_inode *parent,
+ struct xfs_trans *tp,
+ struct xfs_inode *child,
+ xfs_dir2_dataptr_t diroffset);
#endif /* __XFS_PARENT_UTILS_H__ */
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 23/28] xfs: Add parent pointers to rename
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (21 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 22/28] xfs: remove parent pointers in unlink Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-09-03 3:20 ` Dave Chinner
2018-08-28 19:22 ` [PATCH v8 24/28] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
` (6 subsequent siblings)
29 siblings, 1 reply; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 | 70 +++++++++++++++++++++++++++++++++++++++++-------------
1 file changed, 54 insertions(+), 16 deletions(-)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 300ba90..043a5d6 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2931,6 +2931,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);
@@ -2985,14 +2987,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
@@ -3002,15 +3004,16 @@ 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;
}
/* 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,
spaceres);
-
+ goto out;
+ }
/*
* Set up the target.
*/
@@ -3022,7 +3025,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
@@ -3030,7 +3033,7 @@ xfs_rename(
* to account for the ".." reference from the new entry.
*/
error = xfs_dir_createname(tp, target_dp, target_name,
- src_ip->i_ino, spaceres, NULL);
+ src_ip->i_ino, spaceres, &new_diroffset);
if (error)
goto out_trans_cancel;
@@ -3055,7 +3058,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;
}
}
@@ -3069,7 +3072,7 @@ xfs_rename(
* name at the destination directory, remove it first.
*/
error = xfs_dir_replace(tp, target_dp, target_name,
- src_ip->i_ino, spaceres, NULL);
+ src_ip->i_ino, spaceres, &new_diroffset);
if (error)
goto out_trans_cancel;
@@ -3103,7 +3106,7 @@ xfs_rename(
* directory.
*/
error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
- target_dp->i_ino, spaceres, NULL);
+ target_dp->i_ino, spaceres, &new_diroffset);
ASSERT(error != -EEXIST);
if (error)
goto out_trans_cancel;
@@ -3142,10 +3145,10 @@ xfs_rename(
*/
if (wip) {
error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
- spaceres, NULL);
+ spaceres, &old_diroffset);
} else
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
- spaceres, NULL);
+ spaceres, &old_diroffset);
if (error)
goto out_trans_cancel;
@@ -3175,16 +3178,51 @@ xfs_rename(
VFS_I(wip)->i_state &= ~I_LINKABLE;
}
+out:
+ if (xfs_sb_version_hasparent(&mp->m_sb)) {
+ error = xfs_parent_add_deferred(target_dp, tp, src_ip, target_name,
+ new_diroffset);
+ if (error)
+ goto out_bmap_cancel;
+
+ error = xfs_parent_remove_deferred(src_dp, tp, src_ip,
+ old_diroffset);
+ 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);
+
if (wip)
xfs_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(tp);
+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] 38+ messages in thread
* [PATCH v8 24/28] xfs: Add the parent pointer support to the superblock version 5.
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (22 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 23/28] xfs: Add parent pointers to rename Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 25/28] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
` (5 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 386d734..d77683e 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -453,10 +453,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(
@@ -552,7 +554,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 f3aa593..9c58a78 100644
--- a/fs/xfs/libxfs/xfs_fs.h
+++ b/fs/xfs/libxfs/xfs_fs.h
@@ -210,6 +210,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 081f46e..05dd226 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -1148,6 +1148,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 41f53d7..0d6432b 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1710,6 +1710,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] 38+ messages in thread
* [PATCH v8 25/28] xfs: Add helper function xfs_attr_list_context_init
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (23 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 24/28] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 26/28] xfs: Increase XFS_DEFER_OPS_NR_INODES to 4 Allison Henderson
` (4 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 14cb7c1..913dcb7 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -188,6 +188,9 @@ int xfs_has_attr(struct xfs_da_args *args);
int xfs_attr_remove_args(struct xfs_da_args *args);
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 a580340..3c30ec4 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -592,23 +592,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.
@@ -634,20 +630,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] 38+ messages in thread
* [PATCH v8 26/28] xfs: Increase XFS_DEFER_OPS_NR_INODES to 4
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (24 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 25/28] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 27/28] xfs: Add parent pointer ioctl Allison Henderson
` (3 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 UTC (permalink / raw)
To: linux-xfs
Renames that generate parent pointer updates will
need to 2 extra defer operations. One for the rmap
update and another for the parent pointer update
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
fs/xfs/xfs_trans.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index cc38d45..7e86892 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -95,7 +95,7 @@ void xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
/*
* Deferred operation item relogging limits.
*/
-#define XFS_DEFER_OPS_NR_INODES 2 /* join up to two inodes */
+#define XFS_DEFER_OPS_NR_INODES 4 /* join up to four inodes */
#define XFS_DEFER_OPS_NR_BUFS 2 /* join up to two buffers */
/*
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* [PATCH v8 27/28] xfs: Add parent pointer ioctl
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (25 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 26/28] xfs: Increase XFS_DEFER_OPS_NR_INODES to 4 Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 28/28] xfs: Add delayed attributes error tag Allison Henderson
` (2 subsequent siblings)
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 9c58a78..47d05ef 100644
--- a/fs/xfs/libxfs/xfs_fs.h
+++ b/fs/xfs/libxfs/xfs_fs.h
@@ -547,6 +547,47 @@ struct xfs_scrub_metadata {
XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED)
#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
*/
@@ -591,6 +632,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 5045f65..74e41be 100644
--- a/fs/xfs/libxfs/xfs_parent.c
+++ b/fs/xfs/libxfs/xfs_parent.c
@@ -33,6 +33,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 60f1172..3fcbbbb 100644
--- a/fs/xfs/libxfs/xfs_parent.h
+++ b/fs/xfs/libxfs/xfs_parent.h
@@ -32,4 +32,6 @@ void xfs_init_parent_name_irec(struct xfs_parent_name_irec *irec,
int xfs_parent_add(struct xfs_inode *parent,
struct xfs_inode *child, struct xfs_name *child_name,
uint32_t diroffset);
+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 3c30ec4..f4ffc2c 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -570,6 +570,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 b0a4b37..b0791f3 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -35,6 +35,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>
@@ -1730,6 +1732,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)
@@ -1972,7 +2055,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 9397b6b..a9ff19c 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -127,6 +127,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 8f35afe..6d8b1e3 100644
--- a/fs/xfs/xfs_parent_utils.c
+++ b/fs/xfs/xfs_parent_utils.c
@@ -30,6 +30,7 @@
#include "xfs_da_btree.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.
@@ -68,3 +69,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 010e517..5f5a3e2 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_trans *tp,
struct xfs_inode *child,
xfs_dir2_dataptr_t diroffset);
+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] 38+ messages in thread
* [PATCH v8 28/28] xfs: Add delayed attributes error tag
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (26 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 27/28] xfs: Add parent pointer ioctl Allison Henderson
@ 2018-08-28 19:22 ` Allison Henderson
2018-09-03 1:20 ` [PATCH v8 00/28] Parent Pointers v8 Dave Chinner
2018-09-03 5:41 ` Dave Chinner
29 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-08-28 19:22 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 66077a1..5cd408d0 100644
--- a/fs/xfs/libxfs/xfs_errortag.h
+++ b/fs/xfs/libxfs/xfs_errortag.h
@@ -54,7 +54,8 @@
#define XFS_ERRTAG_BUF_LRU_REF 31
#define XFS_ERRTAG_FORCE_SCRUB_REPAIR 32
#define XFS_ERRTAG_FORCE_SUMMARY_RECALC 33
-#define XFS_ERRTAG_MAX 34
+#define XFS_ERRTAG_DELAYED_ATTR 34
+#define XFS_ERRTAG_MAX 35
/*
* Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -93,5 +94,6 @@
#define XFS_RANDOM_BUF_LRU_REF 2
#define XFS_RANDOM_FORCE_SCRUB_REPAIR 1
#define XFS_RANDOM_FORCE_SUMMARY_RECALC 1
+#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 9866f54..5193ba9 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -51,6 +51,7 @@ static unsigned int xfs_errortag_random_default[] = {
XFS_RANDOM_BUF_LRU_REF,
XFS_RANDOM_FORCE_SCRUB_REPAIR,
XFS_RANDOM_FORCE_SUMMARY_RECALC,
+ XFS_RANDOM_DELAYED_ATTR,
};
struct xfs_errortag_attr {
@@ -159,6 +160,7 @@ 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(force_repair, XFS_ERRTAG_FORCE_SCRUB_REPAIR);
XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);
+XFS_ERRORTAG_ATTR_RW(delayed_attr, XFS_ERRTAG_DELAYED_ATTR);
static struct attribute *xfs_errortag_attrs[] = {
XFS_ERRORTAG_ATTR_LIST(noerror),
@@ -195,6 +197,7 @@ static struct attribute *xfs_errortag_attrs[] = {
XFS_ERRORTAG_ATTR_LIST(buf_lru_ref),
XFS_ERRORTAG_ATTR_LIST(force_repair),
XFS_ERRORTAG_ATTR_LIST(bad_summary),
+ XFS_ERRORTAG_ATTR_LIST(delayed_attr),
NULL,
};
diff --git a/fs/xfs/xfs_trans_attr.c b/fs/xfs/xfs_trans_attr.c
index 7e20721..1b14830 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 "attr free done"
@@ -77,6 +79,11 @@ xfs_trans_attr(
if (error)
return error;
+ if (XFS_TEST_ERROR(false, args->dp->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;
@@ -91,6 +98,7 @@ xfs_trans_attr(
error = -EFSCORRUPTED;
}
+out:
/*
* Mark the transaction dirty, even on error. This ensures the
* transaction is aborted, which:
--
2.7.4
^ permalink raw reply related [flat|nested] 38+ messages in thread
* Re: [PATCH v8 00/28] Parent Pointers v8
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (27 preceding siblings ...)
2018-08-28 19:22 ` [PATCH v8 28/28] xfs: Add delayed attributes error tag Allison Henderson
@ 2018-09-03 1:20 ` Dave Chinner
2018-09-03 1:40 ` Dave Chinner
2018-09-03 5:41 ` Dave Chinner
29 siblings, 1 reply; 38+ messages in thread
From: Dave Chinner @ 2018-09-03 1:20 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Tue, Aug 28, 2018 at 12:22:13PM -0700, Allison Henderson wrote:
> Hi all,
>
> This is the 8th 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.
Hi Allison,
FYI, A couple of minor things I noticed on import of the patch set
to 4.19-rc1:
......
Applying: xfs: parent pointer attribute creation
.git/rebase-apply/patch:131: trailing whitespace.
error = xfs_attr_set(child, (const unsigned char *)&rec, sizeof(rec),
.git/rebase-apply/patch:136: new blank line at EOF.
+
.git/rebase-apply/patch:296: new blank line at EOF.
+
warning: 3 lines add whitespace errors.
Applying: xfs: add parent attributes to link
Applying: xfs: remove parent pointers in unlink
.git/rebase-apply/patch:97: new blank line at EOF.
+
warning: 1 line adds whitespace errors.
Applying: xfs: Add parent pointers to rename
Applying: xfs: Add the parent pointer support to the superblock version 5.
Applying: xfs: Add helper function xfs_attr_list_context_init
Applying: xfs: Increase XFS_DEFER_OPS_NR_INODES to 4
Applying: xfs: Add parent pointer ioctl
.git/rebase-apply/patch:340: new blank line at EOF.
+
warning: 1 line adds whitespace errors.
Applying: xfs: Add delayed attributes error tag
......
Also, I get a couple of compiler warnings:
fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_set¿:
fs/xfs/libxfs/xfs_attr.c:446:48: warning: passing argument 3 of ¿xfs_attr_set_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
error = xfs_attr_set_deferred(dp, args.trans, name, namelen,
^~~~
In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
fs/xfs/libxfs/xfs_attr.h:197:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
^~~~~~~~~~~~~~~~~~~~~
fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_remove¿:
fs/xfs/libxfs/xfs_attr.c:584:4: warning: passing argument 3 of ¿xfs_attr_remove_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
name, namelen, flags);
^~~~
In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
fs/xfs/libxfs/xfs_attr.h:200:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
^~~~~~~~~~~~~~~~~~~~~~~~
I haven't looked to find what patch causes them, but I thought I'd
let you know straight away.
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 00/28] Parent Pointers v8
2018-09-03 1:20 ` [PATCH v8 00/28] Parent Pointers v8 Dave Chinner
@ 2018-09-03 1:40 ` Dave Chinner
2018-09-04 18:31 ` Allison Henderson
0 siblings, 1 reply; 38+ messages in thread
From: Dave Chinner @ 2018-09-03 1:40 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Mon, Sep 03, 2018 at 11:20:06AM +1000, Dave Chinner wrote:
> On Tue, Aug 28, 2018 at 12:22:13PM -0700, Allison Henderson wrote:
> > Hi all,
> >
> > This is the 8th 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.
>
> Hi Allison,
>
> FYI, A couple of minor things I noticed on import of the patch set
> to 4.19-rc1:
>
> ......
> Applying: xfs: parent pointer attribute creation
> .git/rebase-apply/patch:131: trailing whitespace.
> error = xfs_attr_set(child, (const unsigned char *)&rec, sizeof(rec),
> .git/rebase-apply/patch:136: new blank line at EOF.
> +
> .git/rebase-apply/patch:296: new blank line at EOF.
> +
> warning: 3 lines add whitespace errors.
> Applying: xfs: add parent attributes to link
> Applying: xfs: remove parent pointers in unlink
> .git/rebase-apply/patch:97: new blank line at EOF.
> +
> warning: 1 line adds whitespace errors.
> Applying: xfs: Add parent pointers to rename
> Applying: xfs: Add the parent pointer support to the superblock version 5.
> Applying: xfs: Add helper function xfs_attr_list_context_init
> Applying: xfs: Increase XFS_DEFER_OPS_NR_INODES to 4
> Applying: xfs: Add parent pointer ioctl
> .git/rebase-apply/patch:340: new blank line at EOF.
> +
> warning: 1 line adds whitespace errors.
> Applying: xfs: Add delayed attributes error tag
> ......
>
> Also, I get a couple of compiler warnings:
>
> fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_set¿:
> fs/xfs/libxfs/xfs_attr.c:446:48: warning: passing argument 3 of ¿xfs_attr_set_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
> error = xfs_attr_set_deferred(dp, args.trans, name, namelen,
> ^~~~
> In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
> fs/xfs/libxfs/xfs_attr.h:197:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
> int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
> ^~~~~~~~~~~~~~~~~~~~~
> fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_remove¿:
> fs/xfs/libxfs/xfs_attr.c:584:4: warning: passing argument 3 of ¿xfs_attr_remove_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
> name, namelen, flags);
> ^~~~
> In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
> fs/xfs/libxfs/xfs_attr.h:200:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
> int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
> ^~~~~~~~~~~~~~~~~~~~~~~~
Another couple:
fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_leaf_has_attr¿:
fs/xfs/libxfs/xfs_attr.c:863:27: error: variable ¿dp¿ set but not used [-Werror=unused-but-set-variable]
struct xfs_inode *dp;
^~
fs/xfs/libxfs/xfs_attr_leaf.c: In function ¿xfs_shortform_has_attr¿:
fs/xfs/libxfs/xfs_attr_leaf.c:635:15: error: variable ¿mp¿ set but not used [-Werror=unused-but-set-variable]
xfs_mount_t *mp;
^~
The fixup patch I wrote to make it compile is below.
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
xfs-pp: make it compile
---
fs/xfs/libxfs/xfs_attr.c | 8 +++-----
fs/xfs/libxfs/xfs_attr.h | 4 ++--
fs/xfs/libxfs/xfs_attr_leaf.c | 19 +++++++++----------
fs/xfs/xfs_parent_utils.c | 6 +++---
4 files changed, 17 insertions(+), 20 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 40274c2904b6..147be48ce534 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -481,9 +481,9 @@ int
xfs_attr_set_deferred(
struct xfs_inode *dp,
struct xfs_trans *tp,
- void *name,
+ const char *name,
unsigned int namelen,
- void *value,
+ const char *value,
unsigned int valuelen,
int flags)
{
@@ -616,7 +616,7 @@ int
xfs_attr_remove_deferred(
struct xfs_inode *dp,
struct xfs_trans *tp,
- void *name,
+ const char *name,
unsigned int namelen,
int flags)
{
@@ -860,11 +860,9 @@ STATIC int
xfs_leaf_has_attr(
struct xfs_da_args *args)
{
- struct xfs_inode *dp;
struct xfs_buf *bp;
int error = 0;
- dp = args->dp;
args->blkno = 0;
error = xfs_attr3_leaf_read(args->trans, args->dp,
args->blkno, -1, &bp);
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 913dcb790beb..5387e6177fa6 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -195,9 +195,9 @@ 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);
int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
- void *name, unsigned int name_len, void *value,
+ const char *name, unsigned int name_len, const char *value,
unsigned int valuelen, int flags);
int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
- void *name, unsigned int namelen, int flags);
+ const char *name, unsigned int namelen, int flags);
#endif /* __XFS_ATTR_H__ */
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 09483fe97cd7..f1b3c734147e 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -627,18 +627,17 @@ xfs_attr_fork_remove(
* Return successful if attr is found, or ENOATTR if not
*/
int
-xfs_shortform_has_attr(xfs_da_args_t *args)
+xfs_shortform_has_attr(
+ struct xfs_da_args *args)
{
- xfs_attr_shortform_t *sf;
- xfs_attr_sf_entry_t *sfe;
- int base, size = 0, end, i;
- xfs_mount_t *mp;
- xfs_inode_t *dp;
+ struct xfs_attr_shortform *sf;
+ struct xfs_attr_sf_entry *sfe;
+ int base = sizeof(struct xfs_attr_sf_hdr);
+ int size = 0;
+ int end;
+ int i;
- dp = args->dp;
- mp = dp->i_mount;
- base = sizeof(xfs_attr_sf_hdr_t);
- sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
+ sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
sfe = &sf->list[0];
end = sf->hdr.count;
for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
diff --git a/fs/xfs/xfs_parent_utils.c b/fs/xfs/xfs_parent_utils.c
index 6d8b1e3130c7..1dc6aad6c628 100644
--- a/fs/xfs/xfs_parent_utils.c
+++ b/fs/xfs/xfs_parent_utils.c
@@ -47,8 +47,8 @@ xfs_parent_add_deferred(
xfs_init_parent_name_rec(&rec, parent, diroffset);
- return xfs_attr_set_deferred(child, tp, &rec, sizeof(rec),
- (void *)child_name->name, child_name->len, ATTR_PARENT);
+ return xfs_attr_set_deferred(child, tp, (const char *)&rec, sizeof(rec),
+ child_name->name, child_name->len, ATTR_PARENT);
}
/*
@@ -65,7 +65,7 @@ xfs_parent_remove_deferred(
xfs_init_parent_name_rec(&rec, parent, diroffset);
- return xfs_attr_remove_deferred(child, tp, &rec, sizeof(rec),
+ return xfs_attr_remove_deferred(child, tp, (const char *)&rec, sizeof(rec),
ATTR_PARENT);
}
^ permalink raw reply related [flat|nested] 38+ messages in thread
* Re: [PATCH v8 23/28] xfs: Add parent pointers to rename
2018-08-28 19:22 ` [PATCH v8 23/28] xfs: Add parent pointers to rename Allison Henderson
@ 2018-09-03 3:20 ` Dave Chinner
2018-09-03 5:28 ` Amir Goldstein
2018-09-04 18:31 ` Allison Henderson
0 siblings, 2 replies; 38+ messages in thread
From: Dave Chinner @ 2018-09-03 3:20 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Tue, Aug 28, 2018 at 12:22:36PM -0700, Allison Henderson 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>
renameat operations in generic/023 trigger an ASSERT failure in the
error handling path.
XFS: Assertion failed: xfs_isilocked(ip, XFS_ILOCK_EXCL), file: fs/xfs/xfs_inode_item.c, line: 576
------------[ cut here ]------------
kernel BUG at fs/xfs/xfs_message.c:102!
invalid opcode: 0000 [#1] PREEMPT SMP
CPU: 0 PID: 10568 Comm: renameat2 Not tainted 4.19.0-rc2-dgc+ #652
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.1-1 04/01/2014
RIP: 0010:assfail+0x28/0x30
Code: c3 90 0f 1f 44 00 00 48 89 f1 41 89 d0 48 c7 c6 c8 52 2e 82 48 89 fa 31 ff e8 64 f9 ff ff 80 3d 05 95 0a 01 00 75 03 0f 0b c3 <0f> 0b 66 0f 1f 44 00 00 0f 1f 44 00 00 48 63 f6 49 8a
RSP: 0018:ffffc90000b7bc18 EFLAGS: 00010202
RAX: 0000000000000000 RBX: ffff88002d20a840 RCX: 0000000000000000
RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227a7dc
RBP: ffff88002b4fb480 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000200 R11: f000000000000000 R12: ffff880034495fc8
R13: ffffffffffffffff R14: 0000000000000000 R15: ffffffff822e6858
FS: 00007f5fc4d4b740(0000) GS:ffff88003ec00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f5fc3d01170 CR3: 0000000034534000 CR4: 00000000000006f0
Call Trace:
xfs_inode_item_unlock+0x63/0x80
xfs_trans_free_items+0x71/0xf0
xfs_trans_cancel+0xaf/0x1f0
xfs_rename+0x435/0xc50
xfs_vn_rename+0xd5/0x140
vfs_rename+0x384/0x9b0
? lookup_dcache+0x17/0x60
do_renameat2+0x49b/0x550
__x64_sys_renameat2+0x20/0x30
do_syscall_64+0x5a/0x180
entry_SYSCALL_64_after_hwframe+0x49/0xbe
> @@ -2985,14 +2987,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);
So we change the locking such that failure requires use to unlock
the inodes after the transaction commit or cancel....
>
> /*
> * If we are using project inheritance, we only allow renames
> @@ -3002,15 +3004,16 @@ 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;
This smells wrong - we need to cancel the transaction, then unlock
the items, not the other way around, so we should still be jumping
to a transaction cancel action.
> }
>
> /* 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,
> spaceres);
> -
> + goto out;
> + }
This looks problematic, too. i.e. On error, xfs_cross_rename() will
have already called xfs_trans_cancel(), but it hasn't unlocked any
of the inodes. If it succeeds, it commits the transaction. Either
way, the transaction has been finished and freed. However, the
code we jump to expects that the transaction is open and still
running.
Also "out" typically means "goto end of function and return". This
is jumping to parent pointer addition, not the function return
processing. Hence the label needs to be changed to
"parent_pointer"....
[....]
> @@ -3175,16 +3178,51 @@ xfs_rename(
> VFS_I(wip)->i_state &= ~I_LINKABLE;
> }
>
> +out:
> + if (xfs_sb_version_hasparent(&mp->m_sb)) {
> + error = xfs_parent_add_deferred(target_dp, tp, src_ip, target_name,
> + new_diroffset);
And so when we try to add the a parent pointers, we haven't checked
if the cross rename failed and aborted the transaction. Or if it
succeeded, it expects to continue using the transaction which
xfs_cross_rename() committed.
> + if (error)
> + goto out_bmap_cancel;
> +
> + error = xfs_parent_remove_deferred(src_dp, tp, src_ip,
> + old_diroffset);
> + if (error)
> + goto out_bmap_cancel;
> + }
We don't have "bmaps" in these functions any more. We just need to
cancel the trasaction now, right?
> +
> 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);
> +
> if (wip)
> xfs_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);
> +
OK, so this unlocks after the final commit. That's fine, but the
rest of the error stack looks wrong.
> return error;
>
> +out_bmap_cancel:
> + xfs_defer_cancel(tp);
xfs_trans_cancel() calls xfs_defer_cancel() now, so it's not needed
anymore.
> +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);
And I think this has to happen after calling xfs_trans_cancel().
> +
> out_trans_cancel:
> xfs_trans_cancel(tp);
> out_release_wip:
So the return stacking needs work here. I think it should look
something like:
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);
out_unlock:
if (wip)
xfs_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_trans_cancel:
xfs_trans_cancel(tp);
out_release_wip:
if (wip)
xfs_irele(wip);
goto out_unlock;
}
This means almost all the error goto's remain unchanged,
"out_bmap_cancel" should be "out_trans_cancel", xfs_cross_rename()
needs to roll the transaction, not commit it, and it if fails it
needs to jump to out_trans_cancel().
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 23/28] xfs: Add parent pointers to rename
2018-09-03 3:20 ` Dave Chinner
@ 2018-09-03 5:28 ` Amir Goldstein
2018-09-04 18:31 ` Allison Henderson
2018-09-04 18:31 ` Allison Henderson
1 sibling, 1 reply; 38+ messages in thread
From: Amir Goldstein @ 2018-09-03 5:28 UTC (permalink / raw)
To: Dave Chinner; +Cc: Allison Henderson, linux-xfs
On Mon, Sep 3, 2018 at 6:26 AM Dave Chinner <david@fromorbit.com> wrote:
>
> On Tue, Aug 28, 2018 at 12:22:36PM -0700, Allison Henderson 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>
>
[...]
> > }
> >
> > /* 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,
> > spaceres);
> > -
> > + goto out;
> > + }
>
> This looks problematic, too. i.e. On error, xfs_cross_rename() will
> have already called xfs_trans_cancel(), but it hasn't unlocked any
> of the inodes. If it succeeds, it commits the transaction. Either
> way, the transaction has been finished and freed. However, the
> code we jump to expects that the transaction is open and still
> running.
>
> Also "out" typically means "goto end of function and return". This
> is jumping to parent pointer addition, not the function return
> processing. Hence the label needs to be changed to
> "parent_pointer"....
>
[...]
> > +out:
> > + if (xfs_sb_version_hasparent(&mp->m_sb)) {
> > + error = xfs_parent_add_deferred(target_dp, tp, src_ip, target_name,
> > + new_diroffset);
>
> And so when we try to add the a parent pointers, we haven't checked
> if the cross rename failed and aborted the transaction. Or if it
> succeeded, it expects to continue using the transaction which
> xfs_cross_rename() committed.
>
Allison,
Not sure if you know that xfs_cross_rename() exchanges src with target, so
the src_dp parent pointer has to be adjusted as well in case of cross rename.
Thanks,
Amir.
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 00/28] Parent Pointers v8
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
` (28 preceding siblings ...)
2018-09-03 1:20 ` [PATCH v8 00/28] Parent Pointers v8 Dave Chinner
@ 2018-09-03 5:41 ` Dave Chinner
2018-09-04 18:32 ` Allison Henderson
29 siblings, 1 reply; 38+ messages in thread
From: Dave Chinner @ 2018-09-03 5:41 UTC (permalink / raw)
To: Allison Henderson; +Cc: linux-xfs
On Tue, Aug 28, 2018 at 12:22:13PM -0700, Allison Henderson wrote:
> Hi all,
>
> This is the 8th 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.
Another assert failure on generic/026:
SECTION -- xfs
FSTYP -- xfs (debug)
PLATFORM -- Linux/x86_64 test1 4.19.0-rc2-dgc+
MKFS_OPTIONS -- -f -m rmapbt=1,reflink=1 -i sparse=1 -b size=1k /dev/sdc
MOUNT_OPTIONS -- /dev/sdc /mnt/scratch
(though it appears block size has nothing to do with the failure as
all my other test VMs also failed on this test, too)
[ 368.699416] run fstests generic/026 at 2018-09-03 13:46:29
[ 376.651705] XFS: Assertion failed: tp->t_ticket != NULL, file: fs/xfs/xfs_trans.c, line: 952
[ 376.653346] ------------[ cut here ]------------
[ 376.654174] kernel BUG at fs/xfs/xfs_message.c:102!
[ 376.655537] invalid opcode: 0000 [#1] PREEMPT SMP
[ 376.656545] CPU: 0 PID: 12468 Comm: chacl Not tainted 4.19.0-rc2-dgc+ #653
[ 376.657742] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.1-1 04/01/2014
[ 376.659193] RIP: 0010:assfail+0x28/0x30
[ 376.659861] Code: c3 90 0f 1f 44 00 00 48 89 f1 41 89 d0 48 c7 c6 98 50 2e 82 48 89 fa 31 ff e8 64 f9 ff ff 80 3d f5 9a 0a 01 00 75 03 0f 0b c3 <0f> 0b 66 0f 1f 44 00 00 0f 1f 44 00 00 48 63 f6 49 8a
[ 376.663050] RSP: 0018:ffffc90000babaa0 EFLAGS: 00010202
[ 376.663950] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000
[ 376.665167] RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227a5fc
[ 376.666397] RBP: ffffffff822e68d0 R08: 0000000000000000 R09: 0000000000000000
[ 376.667618] R10: 0000000000000008 R11: f000000000000000 R12: 0000000000000000
[ 376.668841] R13: ffff88002d236000 R14: ffffffff814d6701 R15: 0000000000000025
[ 376.670075] FS: 00007fd8e35dc740(0000) GS:ffff88003ec00000(0000) knlGS:0000000000000000
[ 376.671462] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 376.672451] CR2: 000055624ed0c000 CR3: 00000000292b5000 CR4: 00000000000006f0
[ 376.673678] Call Trace:
[ 376.674136] __xfs_trans_commit+0x35c/0x370
[ 376.674870] xfs_attr_set+0x241/0x2d0
[ 376.675510] __xfs_set_acl+0xf4/0x1a0
[ 376.676146] xfs_set_acl+0xa8/0x100
[ 376.676759] ? posix_acl_valid+0xb6/0xd0
[ 376.677444] ? set_posix_acl+0xa0/0xa0
[ 376.678108] posix_acl_xattr_set+0x3f/0x90
[ 376.678833] __vfs_setxattr+0x64/0x80
[ 376.679484] __vfs_setxattr_noperm+0x69/0x1a0
[ 376.680243] ? unlazy_walk+0x4c/0xb0
[ 376.680871] vfs_setxattr+0xa0/0xb0
[ 376.681485] setxattr+0x132/0x1a0
[ 376.682088] ? __handle_mm_fault+0x95b/0x10c0
[ 376.682850] ? __mnt_want_write+0x5e/0x90
[ 376.683547] ? preempt_count_sub+0x43/0x50
[ 376.684262] path_setxattr+0xbe/0xe0
[ 376.684884] __x64_sys_setxattr+0x27/0x30
[ 376.685584] do_syscall_64+0x5a/0x180
[ 376.686236] entry_SYSCALL_64_after_hwframe+0x49/0xbe
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 00/28] Parent Pointers v8
2018-09-03 1:40 ` Dave Chinner
@ 2018-09-04 18:31 ` Allison Henderson
0 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-09-04 18:31 UTC (permalink / raw)
To: Dave Chinner; +Cc: linux-xfs
On 09/02/2018 06:40 PM, Dave Chinner wrote:
> On Mon, Sep 03, 2018 at 11:20:06AM +1000, Dave Chinner wrote:
>> On Tue, Aug 28, 2018 at 12:22:13PM -0700, Allison Henderson wrote:
>>> Hi all,
>>>
>>> This is the 8th 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.
>>
>> Hi Allison,
>>
>> FYI, A couple of minor things I noticed on import of the patch set
>> to 4.19-rc1:
>>
>> ......
>> Applying: xfs: parent pointer attribute creation
>> .git/rebase-apply/patch:131: trailing whitespace.
>> error = xfs_attr_set(child, (const unsigned char *)&rec, sizeof(rec),
>> .git/rebase-apply/patch:136: new blank line at EOF.
>> +
>> .git/rebase-apply/patch:296: new blank line at EOF.
>> +
>> warning: 3 lines add whitespace errors.
>> Applying: xfs: add parent attributes to link
>> Applying: xfs: remove parent pointers in unlink
>> .git/rebase-apply/patch:97: new blank line at EOF.
>> +
>> warning: 1 line adds whitespace errors.
>> Applying: xfs: Add parent pointers to rename
>> Applying: xfs: Add the parent pointer support to the superblock version 5.
>> Applying: xfs: Add helper function xfs_attr_list_context_init
>> Applying: xfs: Increase XFS_DEFER_OPS_NR_INODES to 4
>> Applying: xfs: Add parent pointer ioctl
>> .git/rebase-apply/patch:340: new blank line at EOF.
>> +
>> warning: 1 line adds whitespace errors.
>> Applying: xfs: Add delayed attributes error tag
>> ......
>>
>> Also, I get a couple of compiler warnings:
>>
>> fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_set¿:
>> fs/xfs/libxfs/xfs_attr.c:446:48: warning: passing argument 3 of ¿xfs_attr_set_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
>> error = xfs_attr_set_deferred(dp, args.trans, name, namelen,
>> ^~~~
>> In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
>> fs/xfs/libxfs/xfs_attr.h:197:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
>> int xfs_attr_set_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
>> ^~~~~~~~~~~~~~~~~~~~~
>> fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_attr_remove¿:
>> fs/xfs/libxfs/xfs_attr.c:584:4: warning: passing argument 3 of ¿xfs_attr_remove_deferred¿ discards ¿const¿ qualifier from pointer target type [-Wdiscarded-qualifiers]
>> name, namelen, flags);
>> ^~~~
>> In file included from fs/xfs/libxfs/xfs_attr.c:25:0:
>> fs/xfs/libxfs/xfs_attr.h:200:5: note: expected ¿void *¿ but argument is of type ¿const unsigned char *¿
>> int xfs_attr_remove_deferred(struct xfs_inode *dp, struct xfs_trans *tp,
>> ^~~~~~~~~~~~~~~~~~~~~~~~
>
> Another couple:
>
> fs/xfs/libxfs/xfs_attr.c: In function ¿xfs_leaf_has_attr¿:
> fs/xfs/libxfs/xfs_attr.c:863:27: error: variable ¿dp¿ set but not used [-Werror=unused-but-set-variable]
> struct xfs_inode *dp;
> ^~
> fs/xfs/libxfs/xfs_attr_leaf.c: In function ¿xfs_shortform_has_attr¿:
> fs/xfs/libxfs/xfs_attr_leaf.c:635:15: error: variable ¿mp¿ set but not used [-Werror=unused-but-set-variable]
> xfs_mount_t *mp;
> ^~
>
> The fixup patch I wrote to make it compile is below.
Alrighty, thank you! I will get those added in the next version. I
think initially these pointers were char *, and then in an earlier
review we changed them to void *. I'm not really sure it makes a huge
difference? I had noticed the warnings earlier and forgot to come back
and weed them out. I will get these changes added to their
corresponding patches. Thank you!
Allison
>
> Cheers,
>
> Dave.
>
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 23/28] xfs: Add parent pointers to rename
2018-09-03 3:20 ` Dave Chinner
2018-09-03 5:28 ` Amir Goldstein
@ 2018-09-04 18:31 ` Allison Henderson
1 sibling, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-09-04 18:31 UTC (permalink / raw)
To: Dave Chinner; +Cc: linux-xfs
On 09/02/2018 08:20 PM, Dave Chinner wrote:
> On Tue, Aug 28, 2018 at 12:22:36PM -0700, Allison Henderson 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>
>
> renameat operations in generic/023 trigger an ASSERT failure in the
> error handling path.
>
> XFS: Assertion failed: xfs_isilocked(ip, XFS_ILOCK_EXCL), file: fs/xfs/xfs_inode_item.c, line: 576
> ------------[ cut here ]------------
> kernel BUG at fs/xfs/xfs_message.c:102!
> invalid opcode: 0000 [#1] PREEMPT SMP
> CPU: 0 PID: 10568 Comm: renameat2 Not tainted 4.19.0-rc2-dgc+ #652
> Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.1-1 04/01/2014
> RIP: 0010:assfail+0x28/0x30
> Code: c3 90 0f 1f 44 00 00 48 89 f1 41 89 d0 48 c7 c6 c8 52 2e 82 48 89 fa 31 ff e8 64 f9 ff ff 80 3d 05 95 0a 01 00 75 03 0f 0b c3 <0f> 0b 66 0f 1f 44 00 00 0f 1f 44 00 00 48 63 f6 49 8a
> RSP: 0018:ffffc90000b7bc18 EFLAGS: 00010202
> RAX: 0000000000000000 RBX: ffff88002d20a840 RCX: 0000000000000000
> RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227a7dc
> RBP: ffff88002b4fb480 R08: 0000000000000000 R09: 0000000000000000
> R10: 0000000000000200 R11: f000000000000000 R12: ffff880034495fc8
> R13: ffffffffffffffff R14: 0000000000000000 R15: ffffffff822e6858
> FS: 00007f5fc4d4b740(0000) GS:ffff88003ec00000(0000) knlGS:0000000000000000
> CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
> CR2: 00007f5fc3d01170 CR3: 0000000034534000 CR4: 00000000000006f0
> Call Trace:
> xfs_inode_item_unlock+0x63/0x80
> xfs_trans_free_items+0x71/0xf0
> xfs_trans_cancel+0xaf/0x1f0
> xfs_rename+0x435/0xc50
> xfs_vn_rename+0xd5/0x140
> vfs_rename+0x384/0x9b0
> ? lookup_dcache+0x17/0x60
> do_renameat2+0x49b/0x550
> __x64_sys_renameat2+0x20/0x30
> do_syscall_64+0x5a/0x180
> entry_SYSCALL_64_after_hwframe+0x49/0xbe
>
>
>> @@ -2985,14 +2987,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);
>
> So we change the locking such that failure requires use to unlock
> the inodes after the transaction commit or cancel....
>
>>
>> /*
>> * If we are using project inheritance, we only allow renames
>> @@ -3002,15 +3004,16 @@ 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;
>
> This smells wrong - we need to cancel the transaction, then unlock
> the items, not the other way around, so we should still be jumping
> to a transaction cancel action.
>
>> }
>>
>> /* 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,
>> spaceres);
>> -
>> + goto out;
>> + }
>
> This looks problematic, too. i.e. On error, xfs_cross_rename() will
> have already called xfs_trans_cancel(), but it hasn't unlocked any
> of the inodes. If it succeeds, it commits the transaction. Either
> way, the transaction has been finished and freed. However, the
> code we jump to expects that the transaction is open and still
> running.
>
> Also "out" typically means "goto end of function and return". This
> is jumping to parent pointer addition, not the function return
> processing. Hence the label needs to be changed to
> "parent_pointer"....
>
> [....]
>
>> @@ -3175,16 +3178,51 @@ xfs_rename(
>> VFS_I(wip)->i_state &= ~I_LINKABLE;
>> }
>>
>> +out:
>> + if (xfs_sb_version_hasparent(&mp->m_sb)) {
>> + error = xfs_parent_add_deferred(target_dp, tp, src_ip, target_name,
>> + new_diroffset);
>
> And so when we try to add the a parent pointers, we haven't checked
> if the cross rename failed and aborted the transaction. Or if it
> succeeded, it expects to continue using the transaction which
> xfs_cross_rename() committed.
>
>> + if (error)
>> + goto out_bmap_cancel;
>> +
>> + error = xfs_parent_remove_deferred(src_dp, tp, src_ip,
>> + old_diroffset);
>> + if (error)
>> + goto out_bmap_cancel;
>> + }
>
> We don't have "bmaps" in these functions any more. We just need to
> cancel the trasaction now, right?
>
>> +
>> 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);
>> +
>> if (wip)
>> xfs_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);
>> +
>
> OK, so this unlocks after the final commit. That's fine, but the
> rest of the error stack looks wrong.
>
>> return error;
>>
>> +out_bmap_cancel:
>> + xfs_defer_cancel(tp);
>
> xfs_trans_cancel() calls xfs_defer_cancel() now, so it's not needed
> anymore.
>
>> +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);
>
> And I think this has to happen after calling xfs_trans_cancel().
>> +
>> out_trans_cancel:
>> xfs_trans_cancel(tp);
>> out_release_wip:
>
> So the return stacking needs work here. I think it should look
> something like:
>
> 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);
>
> out_unlock:
> if (wip)
> xfs_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_trans_cancel:
> xfs_trans_cancel(tp);
> out_release_wip:
> if (wip)
> xfs_irele(wip);
> goto out_unlock;
> }
>
> This means almost all the error goto's remain unchanged,
> "out_bmap_cancel" should be "out_trans_cancel", xfs_cross_rename()
> needs to roll the transaction, not commit it, and it if fails it
> needs to jump to out_trans_cancel().
>
> Cheers,
>
> Dave.
>
Ok, that makes sense and looks cleaner too. Thank you for all the
explaining! I will try out these changes and get them updated in the
next version. Thanks again!!
Allison
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 23/28] xfs: Add parent pointers to rename
2018-09-03 5:28 ` Amir Goldstein
@ 2018-09-04 18:31 ` Allison Henderson
0 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-09-04 18:31 UTC (permalink / raw)
To: Amir Goldstein, Dave Chinner; +Cc: linux-xfs
On 09/02/2018 10:28 PM, Amir Goldstein wrote:
> On Mon, Sep 3, 2018 at 6:26 AM Dave Chinner <david@fromorbit.com> wrote:
>>
>> On Tue, Aug 28, 2018 at 12:22:36PM -0700, Allison Henderson 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>
>>
> [...]
>>> }
>>>
>>> /* 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,
>>> spaceres);
>>> -
>>> + goto out;
>>> + }
>>
>> This looks problematic, too. i.e. On error, xfs_cross_rename() will
>> have already called xfs_trans_cancel(), but it hasn't unlocked any
>> of the inodes. If it succeeds, it commits the transaction. Either
>> way, the transaction has been finished and freed. However, the
>> code we jump to expects that the transaction is open and still
>> running.
>>
>> Also "out" typically means "goto end of function and return". This
>> is jumping to parent pointer addition, not the function return
>> processing. Hence the label needs to be changed to
>> "parent_pointer"....
>>
> [...]
>>> +out:
>>> + if (xfs_sb_version_hasparent(&mp->m_sb)) {
>>> + error = xfs_parent_add_deferred(target_dp, tp, src_ip, target_name,
>>> + new_diroffset);
>>
>> And so when we try to add the a parent pointers, we haven't checked
>> if the cross rename failed and aborted the transaction. Or if it
>> succeeded, it expects to continue using the transaction which
>> xfs_cross_rename() committed.
>>
>
> Allison,
>
> Not sure if you know that xfs_cross_rename() exchanges src with target, so
> the src_dp parent pointer has to be adjusted as well in case of cross rename.
Oh I see. Ok, I will add in a snippet to handle src_dp in the case of
the cross rename. Thank you!
Allison
>
> Thanks,
> Amir.
>
^ permalink raw reply [flat|nested] 38+ messages in thread
* Re: [PATCH v8 00/28] Parent Pointers v8
2018-09-03 5:41 ` Dave Chinner
@ 2018-09-04 18:32 ` Allison Henderson
0 siblings, 0 replies; 38+ messages in thread
From: Allison Henderson @ 2018-09-04 18:32 UTC (permalink / raw)
To: Dave Chinner; +Cc: linux-xfs
On 09/02/2018 10:41 PM, Dave Chinner wrote:
> On Tue, Aug 28, 2018 at 12:22:13PM -0700, Allison Henderson wrote:
>> Hi all,
>>
>> This is the 8th 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.
>
> Another assert failure on generic/026:
>
> SECTION -- xfs
> FSTYP -- xfs (debug)
> PLATFORM -- Linux/x86_64 test1 4.19.0-rc2-dgc+
> MKFS_OPTIONS -- -f -m rmapbt=1,reflink=1 -i sparse=1 -b size=1k /dev/sdc
> MOUNT_OPTIONS -- /dev/sdc /mnt/scratch
>
> (though it appears block size has nothing to do with the failure as
> all my other test VMs also failed on this test, too)
Alrighty, good to know though. I will take a look at it. Thanks!
Allison
>
>
> [ 368.699416] run fstests generic/026 at 2018-09-03 13:46:29
> [ 376.651705] XFS: Assertion failed: tp->t_ticket != NULL, file: fs/xfs/xfs_trans.c, line: 952
> [ 376.653346] ------------[ cut here ]------------
> [ 376.654174] kernel BUG at fs/xfs/xfs_message.c:102!
> [ 376.655537] invalid opcode: 0000 [#1] PREEMPT SMP
> [ 376.656545] CPU: 0 PID: 12468 Comm: chacl Not tainted 4.19.0-rc2-dgc+ #653
> [ 376.657742] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.1-1 04/01/2014
> [ 376.659193] RIP: 0010:assfail+0x28/0x30
> [ 376.659861] Code: c3 90 0f 1f 44 00 00 48 89 f1 41 89 d0 48 c7 c6 98 50 2e 82 48 89 fa 31 ff e8 64 f9 ff ff 80 3d f5 9a 0a 01 00 75 03 0f 0b c3 <0f> 0b 66 0f 1f 44 00 00 0f 1f 44 00 00 48 63 f6 49 8a
> [ 376.663050] RSP: 0018:ffffc90000babaa0 EFLAGS: 00010202
> [ 376.663950] RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000
> [ 376.665167] RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227a5fc
> [ 376.666397] RBP: ffffffff822e68d0 R08: 0000000000000000 R09: 0000000000000000
> [ 376.667618] R10: 0000000000000008 R11: f000000000000000 R12: 0000000000000000
> [ 376.668841] R13: ffff88002d236000 R14: ffffffff814d6701 R15: 0000000000000025
> [ 376.670075] FS: 00007fd8e35dc740(0000) GS:ffff88003ec00000(0000) knlGS:0000000000000000
> [ 376.671462] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
> [ 376.672451] CR2: 000055624ed0c000 CR3: 00000000292b5000 CR4: 00000000000006f0
> [ 376.673678] Call Trace:
> [ 376.674136] __xfs_trans_commit+0x35c/0x370
> [ 376.674870] xfs_attr_set+0x241/0x2d0
> [ 376.675510] __xfs_set_acl+0xf4/0x1a0
> [ 376.676146] xfs_set_acl+0xa8/0x100
> [ 376.676759] ? posix_acl_valid+0xb6/0xd0
> [ 376.677444] ? set_posix_acl+0xa0/0xa0
> [ 376.678108] posix_acl_xattr_set+0x3f/0x90
> [ 376.678833] __vfs_setxattr+0x64/0x80
> [ 376.679484] __vfs_setxattr_noperm+0x69/0x1a0
> [ 376.680243] ? unlazy_walk+0x4c/0xb0
> [ 376.680871] vfs_setxattr+0xa0/0xb0
> [ 376.681485] setxattr+0x132/0x1a0
> [ 376.682088] ? __handle_mm_fault+0x95b/0x10c0
> [ 376.682850] ? __mnt_want_write+0x5e/0x90
> [ 376.683547] ? preempt_count_sub+0x43/0x50
> [ 376.684262] path_setxattr+0xbe/0xe0
> [ 376.684884] __x64_sys_setxattr+0x27/0x30
> [ 376.685584] do_syscall_64+0x5a/0x180
> [ 376.686236] entry_SYSCALL_64_after_hwframe+0x49/0xbe
>
> Cheers,
>
> Dave.
>
^ permalink raw reply [flat|nested] 38+ messages in thread
end of thread, other threads:[~2018-09-04 22:58 UTC | newest]
Thread overview: 38+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-08-28 19:22 [PATCH v8 00/28] Parent Pointers v8 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 01/28] xfs: Move fs/xfs/xfs_attr.h to fs/xfs/libxfs/xfs_attr.h Allison Henderson
2018-08-28 19:22 ` [PATCH v8 02/28] xfs: Add helper function xfs_attr_try_sf_addname Allison Henderson
2018-08-28 19:22 ` [PATCH v8 03/28] xfs: Add attibute set and helper functions Allison Henderson
2018-08-28 19:22 ` [PATCH v8 04/28] xfs: Add attibute remove " Allison Henderson
2018-08-28 19:22 ` [PATCH v8 05/28] xfs: Hold inode locks in xfs_ialloc Allison Henderson
2018-08-28 19:22 ` [PATCH v8 06/28] xfs: Add trans toggle to attr routines Allison Henderson
2018-08-28 19:22 ` [PATCH v8 07/28] xfs: Set up infastructure for deferred attribute operations Allison Henderson
2018-08-28 19:22 ` [PATCH v8 08/28] xfs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
2018-08-28 19:22 ` [PATCH v8 09/28] xfs: Add xfs_has_attr and subroutines Allison Henderson
2018-08-28 19:22 ` [PATCH v8 10/28] xfs: Add attr context to log item Allison Henderson
2018-08-28 19:22 ` [PATCH v8 11/28] xfs: Roll delayed attr operations by returning EAGAIN Allison Henderson
2018-08-28 19:22 ` [PATCH v8 12/28] xfs: Remove roll_trans boolean Allison Henderson
2018-08-28 19:22 ` [PATCH v8 13/28] xfs: Remove all strlen calls in all xfs_attr_* functions for attr names Allison Henderson
2018-08-28 19:22 ` [PATCH v8 14/28] xfs: get directory offset when adding directory name Allison Henderson
2018-08-28 19:22 ` [PATCH v8 15/28] xfs: get directory offset when removing " Allison Henderson
2018-08-28 19:22 ` [PATCH v8 16/28] xfs: get directory offset when replacing a " Allison Henderson
2018-08-28 19:22 ` [PATCH v8 17/28] xfs: add parent pointer support to attribute code Allison Henderson
2018-08-28 19:22 ` [PATCH v8 18/28] xfs: define parent pointer xattr format Allison Henderson
2018-08-28 19:22 ` [PATCH v8 19/28] xfs: extent transaction reservations for parent attributes Allison Henderson
2018-08-28 19:22 ` [PATCH v8 20/28] xfs: parent pointer attribute creation Allison Henderson
2018-08-28 19:22 ` [PATCH v8 21/28] xfs: add parent attributes to link Allison Henderson
2018-08-28 19:22 ` [PATCH v8 22/28] xfs: remove parent pointers in unlink Allison Henderson
2018-08-28 19:22 ` [PATCH v8 23/28] xfs: Add parent pointers to rename Allison Henderson
2018-09-03 3:20 ` Dave Chinner
2018-09-03 5:28 ` Amir Goldstein
2018-09-04 18:31 ` Allison Henderson
2018-09-04 18:31 ` Allison Henderson
2018-08-28 19:22 ` [PATCH v8 24/28] xfs: Add the parent pointer support to the superblock version 5 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 25/28] xfs: Add helper function xfs_attr_list_context_init Allison Henderson
2018-08-28 19:22 ` [PATCH v8 26/28] xfs: Increase XFS_DEFER_OPS_NR_INODES to 4 Allison Henderson
2018-08-28 19:22 ` [PATCH v8 27/28] xfs: Add parent pointer ioctl Allison Henderson
2018-08-28 19:22 ` [PATCH v8 28/28] xfs: Add delayed attributes error tag Allison Henderson
2018-09-03 1:20 ` [PATCH v8 00/28] Parent Pointers v8 Dave Chinner
2018-09-03 1:40 ` Dave Chinner
2018-09-04 18:31 ` Allison Henderson
2018-09-03 5:41 ` Dave Chinner
2018-09-04 18:32 ` 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.