Parent Pointers
v7 cover Parent Pointers
From: Allison Henderson <[email protected]>
Hi all,
This is the latest 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, shrink, nfs handles, verity, or any other feature that could make use of quickly deriving an inodes path from the mount point.
This set can be viewed on github here
https://github.com/allisonhenderson/xfs/tree/xfs_new_pptrsv7
And the corresponding xfsprogs code is here
https://github.com/allisonhenderson/xfsprogs/tree/xfsprogs_new_pptrs_v7
This set has been tested with the below parent pointers tests
https://lore.kernel.org/fstests/[email protected]/T/#t
Updates since v6:
Andry had reported intermittent hangs on unmount while running stress tests. Reviewed and corrected unlocks in the case of error conditions.
xfs: parent pointer attribute creation
Fixed dp to unlock on error
xfs: Hold inode locks in xfs_ialloc
Fixed ip to unlock on create error
xfs: add parent attributes to symlink
Hold and release dp across pptr operation
Questions comments and feedback appreciated!
Thanks all!
Allison
Allison Henderson (27):
xfs: Add new name to attri/d
xfs: Increase XFS_DEFER_OPS_NR_INODES to 5
xfs: Increase XFS_QM_TRANS_MAXDQS to 5
xfs: Hold inode locks in xfs_ialloc
xfs: Hold inode locks in xfs_trans_alloc_dir
xfs: Hold inode locks in xfs_rename
xfs: Expose init_xattrs in xfs_create_tmpfile
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
xfs: define parent pointer xattr format
xfs: Add xfs_verify_pptr
xfs: extend transaction reservations for parent attributes
xfs: parent pointer attribute creation
xfs: add parent attributes to link
xfs: add parent attributes to symlink
xfs: remove parent pointers in unlink
xfs: Indent xfs_rename
xfs: Add parent pointers to rename
xfs: Add parent pointers to xfs_cross_rename
xfs: Add the parent pointer support to the superblock version 5.
xfs: Add helper function xfs_attr_list_context_init
xfs: Filter XFS_ATTR_PARENT for getfattr
xfs: Add parent pointer ioctl
xfs: fix unit conversion error in xfs_log_calc_max_attrsetm_res
xfs: drop compatibility minimum log size computations for reflink
fs/xfs/Makefile | 2 + fs/xfs/libxfs/xfs_attr.c | 71 +++++- fs/xfs/libxfs/xfs_attr.h | 13 +- fs/xfs/libxfs/xfs_da_btree.h | 3 + fs/xfs/libxfs/xfs_da_format.h | 38 ++- fs/xfs/libxfs/xfs_defer.c | 28 ++- fs/xfs/libxfs/xfs_defer.h | 8 +- 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_format.h | 4 +- fs/xfs/libxfs/xfs_fs.h | 75 ++++++ fs/xfs/libxfs/xfs_log_format.h | 7 +- fs/xfs/libxfs/xfs_log_rlimit.c | 53 ++++ fs/xfs/libxfs/xfs_parent.c | 207 ++++++++++++++++ fs/xfs/libxfs/xfs_parent.h | 46 ++++ fs/xfs/libxfs/xfs_sb.c | 4 + fs/xfs/libxfs/xfs_trans_resv.c | 324 ++++++++++++++++++++---- fs/xfs/libxfs/xfs_trans_space.h | 8 - fs/xfs/scrub/attr.c | 2 +- fs/xfs/xfs_attr_item.c | 142 +++++++++-- fs/xfs/xfs_attr_item.h | 1 + fs/xfs/xfs_attr_list.c | 17 +- fs/xfs/xfs_dquot.c | 25 ++ fs/xfs/xfs_dquot.h | 1 + fs/xfs/xfs_file.c | 1 + fs/xfs/xfs_inode.c | 427 +++++++++++++++++++++++++------- fs/xfs/xfs_inode.h | 3 +- fs/xfs/xfs_ioctl.c | 148 +++++++++-- fs/xfs/xfs_ioctl.h | 2 + fs/xfs/xfs_iops.c | 3 +- fs/xfs/xfs_ondisk.h | 4 + fs/xfs/xfs_parent_utils.c | 125 ++++++++++ fs/xfs/xfs_parent_utils.h | 11 + fs/xfs/xfs_qm.c | 4 +- fs/xfs/xfs_qm.h | 2 +- fs/xfs/xfs_super.c | 4 + fs/xfs/xfs_symlink.c | 58 ++++- fs/xfs/xfs_trans.c | 6 +- fs/xfs/xfs_trans_dquot.c | 15 +- fs/xfs/xfs_xattr.c | 5 +- fs/xfs/xfs_xattr.h | 1 + 45 files changed, 1712 insertions(+), 245 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_parent.c create mode 100644 fs/xfs/libxfs/xfs_parent.h create mode 100644 fs/xfs/xfs_parent_utils.c create mode 100644 fs/xfs/xfs_parent_utils.h
Signature · 1 line
2.25.1
PATCH v7 1/27 xfs: Add new name to attri/d
From: Allison Henderson <[email protected]>
This patch adds two new fields to the atti/d. They are nname and nnamelen. This will be used for parent pointer updates since a rename operation may cause the parent pointer to update both the name and value. So we need to carry both the new name as well as the target name in the attri/d.
--- fs/xfs/libxfs/xfs_attr.c | 12 ++- fs/xfs/libxfs/xfs_attr.h | 4 +- fs/xfs/libxfs/xfs_da_btree.h | 2 + fs/xfs/libxfs/xfs_log_format.h | 6 +- fs/xfs/xfs_attr_item.c | 135 +++++++++++++++++++++++++++------ fs/xfs/xfs_attr_item.h | 1 + 6 files changed, 133 insertions(+), 27 deletions(-)
fs/xfs/libxfs/xfs_attr.c +11 -1
@@ -423,6 +423,12 @@ xfs_attr_complete_op( args->op_flags &= ~XFS_DA_OP_REPLACE ;if (do_replace) { args->attr_filter &= ~XFS_ATTR_INCOMPLETE ; +if (args->new_namelen >0 ) { + args->name = args->new_name; + args->namelen = args->new_namelen; + args->hashval =xfs_da_hashname (args->name, + args->namelen); + }return replace_state; }return XFS_DAS_DONE ;
@@ -922,9 +928,13 @@ xfs_attr_defer_replace( struct xfs_da_args *args) {struct xfs_attr_intent *new; +int op_flag;int error =0 ; - error =xfs_attr_intent_init (args,XFS_ATTRI_OP_FLAGS_REPLACE , &new); + op_flag = args->new_namelen ==0 ?XFS_ATTRI_OP_FLAGS_REPLACE : +XFS_ATTRI_OP_FLAGS_NVREPLACE ; + + error =xfs_attr_intent_init (args, op_flag, &new);if (error)return error;
fs/xfs/libxfs/xfs_attr.h +2 -2
@@ -510,8 +510,8 @@ struct xfs_attr_intent {struct xfs_da_args *xattri_da_args;/* -* Shared buffer containing the attr name and value so that the logging -* code can share large memory buffers between log items. +* Shared buffer containing the attr name, new name, and value so that +* the logging code can share large memory buffers between log items. */ struct xfs_attri_log_nameval *xattri_nameval;
fs/xfs/libxfs/xfs_da_btree.h +2 -0
@@ -55,7 +55,9 @@ enum xfs_dacmp { typedef struct xfs_da_args { struct xfs_da_geometry *geo; /* da block geometry */ const uint8_t *name; /* string (maybe not NULL terminated) */ + const uint8_t *new_name; /* new attr name */ int namelen; /* length of string (maybe no NULL) */ + int new_namelen; /* new attr name len */ uint8_t filetype; /* filetype of inode for directories */ void *value; /* set of bytes (maybe contain NULLs) */ int valuelen; /* length of value */
fs/xfs/libxfs/xfs_log_format.h +4 -2
@@ -117,7 +117,8 @@ struct xfs_unmount_log_format {#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 30 +#define XLOG_REG_TYPE_ATTR_NNAME 31 +#define XLOG_REG_TYPE_MAX 31/*
@@ -957,6 +958,7 @@ struct xfs_icreate_log {#define XFS_ATTRI_OP_FLAGS_SET 1/* Set the attribute */ #define XFS_ATTRI_OP_FLAGS_REMOVE 2/* Remove the attribute */ #define XFS_ATTRI_OP_FLAGS_REPLACE 3/* Replace the attribute */ +#define XFS_ATTRI_OP_FLAGS_NVREPLACE 4/* Replace attr name and val */ #define XFS_ATTRI_OP_FLAGS_TYPE_MASK 0xFF/* Flags type mask */ /*
@@ -974,7 +976,7 @@ struct xfs_icreate_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 */ +uint32_t alfi_nname_len;/* attr new name length */ uint64_t alfi_id;/* attri identifier */ uint64_t alfi_ino;/* the inode for this attr operation */ uint32_t alfi_op_flags;/* marks the op as a set or remove */
fs/xfs/xfs_attr_item.c +113 -22
265 lines not on this page · raw message
fs/xfs/xfs_attr_item.h +1 -0
@@ -13,6 +13,7 @@ struct kmem_zone;struct xfs_attri_log_nameval {struct xfs_log_iovec name; +struct xfs_log_iovec nname;struct xfs_log_iovec value;refcount_t refcount;
Signature · 1 line
2.25.1
PATCH v7 2/27 xfs: Increase XFS_DEFER_OPS_NR_INODES to 5
In reply to [email protected]From: Allison Henderson <[email protected]>
Renames that generate parent pointer updates can join up to 5 inodes locked in sorted order. So we need to increase the number of defer ops inodes and relock them in the same way.
--- fs/xfs/libxfs/xfs_defer.c | 28 ++++++++++++++++++++++++++-- fs/xfs/libxfs/xfs_defer.h | 8 +++++++- fs/xfs/xfs_inode.c | 2 +- fs/xfs/xfs_inode.h | 1 + 4 files changed, 35 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_defer.c +26 -2
@@ -820,13 +820,37 @@ xfs_defer_ops_continue(struct xfs_trans *tp, struct xfs_defer_resources *dres) { - unsigned int i; + unsigned int i, j; +struct xfs_inode *sips[XFS_DEFER_OPS_NR_INODES ]; +struct xfs_inode *temp;ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES );ASSERT (!(tp->t_flags &XFS_TRANS_DIRTY ));/* Lock the captured resources to the new transaction. */ -if (dfc->dfc_held.dr_inos ==2 ) +if (dfc->dfc_held.dr_inos >2 ) { +/* +* Renames with parent pointer updates can lock up to 5 inodes, +* sorted by their inode number. So we need to make sure they +* are relocked in the same way. +*/ +memset (sips,0 ,sizeof (sips)); +for (i =0 ; i < dfc->dfc_held.dr_inos; i++) + sips[i] = dfc->dfc_held.dr_ip[i]; + +/* Bubble sort of at most 5 inodes */ +for (i =0 ; i < dfc->dfc_held.dr_inos; i++) { +for (j =1 ; j < dfc->dfc_held.dr_inos; j++) { +if (sips[j]->i_ino < sips[j-1 ]->i_ino) { + temp = sips[j]; + sips[j] = sips[j-1 ]; + sips[j-1 ] = temp; + } + } + } + +xfs_lock_inodes (sips, dfc->dfc_held.dr_inos,XFS_ILOCK_EXCL ); + }else if (dfc->dfc_held.dr_inos ==2 )xfs_lock_two_inodes (dfc->dfc_held.dr_ip[0 ],XFS_ILOCK_EXCL , dfc->dfc_held.dr_ip[1 ],XFS_ILOCK_EXCL );else if (dfc->dfc_held.dr_inos ==1 )
fs/xfs/libxfs/xfs_defer.h +7 -1
@@ -70,7 +70,13 @@ extern const struct xfs_defer_op_type xfs_attr_defer_type;/* * Deferred operation item relogging limits. */ -#define XFS_DEFER_OPS_NR_INODES 2/* join up to two inodes */ + +/* +* Rename w/ parent pointers can require up to 5 inodes with deferred ops to +* be joined to the transaction: src_dp, target_dp, src_ip, target_ip, and wip. +* These inodes are locked in sorted order by their inode numbers +*/ +#define XFS_DEFER_OPS_NR_INODES 5#define XFS_DEFER_OPS_NR_BUFS 2/* join up to two buffers */ /* Resources that must be held across a transaction roll. */
fs/xfs/xfs_inode.c +1 -1
@@ -447,7 +447,7 @@ xfs_lock_inumorder(* lock more than one at a time, lockdep will report false positives saying we * have violated locking orders. */ -static void +void xfs_lock_inodes( struct xfs_inode **ips, int inodes,
fs/xfs/xfs_inode.h +1 -0
@@ -574,5 +574,6 @@ void xfs_end_io(struct work_struct *work);int xfs_ilock2_io_mmap (struct xfs_inode *ip1,struct xfs_inode *ip2);void xfs_iunlock2_io_mmap (struct xfs_inode *ip1,struct xfs_inode *ip2); +void xfs_lock_inodes (struct xfs_inode **ips,int inodes,uint lock_mode);#endif /* __XFS_INODE_H__ */
Signature · 1 line
2.25.1
PATCH v7 3/27 xfs: Increase XFS_QM_TRANS_MAXDQS to 5
In reply to [email protected]From: Allison Henderson <[email protected]>
With parent pointers enabled, a rename operation can update up to 5
inodes: src_dp, target_dp, src_ip, target_ip and wip. This causes their dquots to a be attached to the transaction chain, so we need to increase XFS_QM_TRANS_MAXDQS. This patch also add a helper function xfs_dqlockn to lock an arbitrary number of dquots.
--- fs/xfs/xfs_dquot.c | 25 +++++++++++++++++++++++++ fs/xfs/xfs_dquot.h | 1 + fs/xfs/xfs_qm.h | 2 +- fs/xfs/xfs_trans_dquot.c | 15 ++++++++++----- 4 files changed, 37 insertions(+), 6 deletions(-)
fs/xfs/xfs_dquot.c +25 -0
@@ -1333,6 +1333,31 @@ xfs_dqlock2( } } +void +xfs_dqlockn ( +struct xfs_dqtrx *q) +{ +struct xfs_dquot *d; +unsigned int i, j; + +for (i =0 ; i <XFS_QM_TRANS_MAXDQS ; i++) { + d = q[i].qt_dquot; + +if (d ==NULL ) +break ; + +for (j =0 ; j < i; j++) { +ASSERT (d != q[j].qt_dquot); +ASSERT (q[j].qt_dquot->q_id > d->q_id); + } + +if (i ==0 ) +mutex_lock (&d->q_qlock); +else +mutex_lock_nested (&d->q_qlock,XFS_QLOCK_NESTED ); + } +} +int __init xfs_qm_init (void ) {
fs/xfs/xfs_dquot.h +1 -0
@@ -223,6 +223,7 @@ int xfs_qm_dqget_uncached(struct xfs_mount *mp,void xfs_qm_dqput (struct xfs_dquot *dqp);void xfs_dqlock2 (struct xfs_dquot *,struct xfs_dquot *); +void xfs_dqlockn (struct xfs_dqtrx *q);void xfs_dquot_set_prealloc_limits (struct xfs_dquot *);
fs/xfs/xfs_qm.h +1 -1
@@ -120,7 +120,7 @@ enum {XFS_QM_TRANS_PRJ , XFS_QM_TRANS_DQTYPES }; -#define XFS_QM_TRANS_MAXDQS 2 +#define XFS_QM_TRANS_MAXDQS 5struct xfs_dquot_acct {struct xfs_dqtrx dqs[XFS_QM_TRANS_DQTYPES ][XFS_QM_TRANS_MAXDQS ]; };
fs/xfs/xfs_trans_dquot.c +10 -5
@@ -268,24 +268,29 @@ xfs_trans_mod_dquot(/* * Given an array of dqtrx structures, lock all the dquots associated and join -* them to the transaction, provided they have been modified. We know that the -* highest number of dquots of one type - usr, grp and prj - involved in a -* transaction is 3 so we don't need to make this very generic. +* them to the transaction, provided they have been modified. */ STATIC voidxfs_trans_dqlockedjoin (struct xfs_trans *tp,struct xfs_dqtrx *q) { +unsigned int i;ASSERT (q[0 ].qt_dquot !=NULL );if (q[1 ].qt_dquot ==NULL ) {xfs_dqlock (q[0 ].qt_dquot);xfs_trans_dqjoin (tp, q[0 ].qt_dquot); - }else { -ASSERT (XFS_QM_TRANS_MAXDQS ==2 ); + }else if (q[2 ].qt_dquot ==NULL ) {xfs_dqlock2 (q[0 ].qt_dquot, q[1 ].qt_dquot);xfs_trans_dqjoin (tp, q[0 ].qt_dquot);xfs_trans_dqjoin (tp, q[1 ].qt_dquot); + }else { +xfs_dqlockn (q); +for (i =0 ; i <XFS_QM_TRANS_MAXDQS ; i++) { +if (q[i].qt_dquot ==NULL ) +break ; +xfs_trans_dqjoin (tp, q[i].qt_dquot); + } } }
Signature · 1 line
2.25.1
PATCH v7 4/27 xfs: Hold inode locks in xfs_ialloc
In reply to [email protected]From: Allison Henderson <[email protected]>
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
--- fs/xfs/xfs_inode.c | 8 +++++++- fs/xfs/xfs_qm.c | 4 +++- fs/xfs/xfs_symlink.c | 3 +++ 3 files changed, 13 insertions(+), 2 deletions(-)
fs/xfs/xfs_inode.c +7 -1
@@ -774,6 +774,8 @@ xfs_inode_inherit_flags2(/* * Initialise a newly allocated inode and return the in-core inode to the * caller locked exclusively. +* +* Caller is responsible for unlocking the inode manually upon return */ int xfs_init_new_inode(
@@ -899,7 +901,7 @@ xfs_init_new_inode(/* * 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 */
@@ -1076,6 +1078,7 @@ xfs_create(xfs_qm_dqrele (pdqp); *ipp = ip; +xfs_iunlock (ip,XFS_ILOCK_EXCL );return 0 ; out_trans_cancel:
@@ -1089,6 +1092,7 @@ xfs_create(if (ip) {xfs_finish_inode_setup (ip);xfs_irele (ip); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); } out_release_dquots:xfs_qm_dqrele (udqp);
@@ -1172,6 +1176,7 @@ xfs_create_tmpfile(xfs_qm_dqrele (pdqp); *ipp = ip; +xfs_iunlock (ip,XFS_ILOCK_EXCL );return 0 ; out_trans_cancel:
@@ -1185,6 +1190,7 @@ xfs_create_tmpfile(if (ip) {xfs_finish_inode_setup (ip);xfs_irele (ip); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); } out_release_dquots:xfs_qm_dqrele (udqp);
fs/xfs/xfs_qm.c +3 -1
@@ -826,8 +826,10 @@ xfs_qm_qino_alloc(ASSERT (xfs_is_shutdown (mp));xfs_alert (mp,"%s failed (error %d)!" , __func__, error); } -if (need_alloc) +if (need_alloc) {xfs_finish_inode_setup (*ipp); +xfs_iunlock (*ipp,XFS_ILOCK_EXCL ); + }return error; }
fs/xfs/xfs_symlink.c +3 -0
@@ -337,6 +337,7 @@ xfs_symlink(xfs_qm_dqrele (pdqp); *ipp = ip; +xfs_iunlock (ip,XFS_ILOCK_EXCL );return 0 ; out_trans_cancel:
@@ -358,6 +359,8 @@ xfs_symlink(if (unlock_dp_on_error)xfs_iunlock (dp,XFS_ILOCK_EXCL ); +if (ip) +xfs_iunlock (ip,XFS_ILOCK_EXCL );return error; }
Signature · 1 line
2.25.1
PATCH v7 5/27 xfs: Hold inode locks in xfs_trans_alloc_dir
In reply to [email protected]From: Allison Henderson <[email protected]>
Modify xfs_trans_alloc_dir to hold locks after return. Caller will be responsible for manual unlock. We will need this later to hold locks across parent pointer operations
--- fs/xfs/xfs_inode.c | 14 ++++++++++++-- fs/xfs/xfs_trans.c | 6 ++++-- 2 files changed, 16 insertions(+), 4 deletions(-)
fs/xfs/xfs_inode.c +12 -2
@@ -1279,10 +1279,15 @@ xfs_link(if (xfs_has_wsync (mp) ||xfs_has_dirsync (mp))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:xfs_trans_cancel (tp); +xfs_iunlock (tdp,XFS_ILOCK_EXCL ); +xfs_iunlock (sip,XFS_ILOCK_EXCL ); std_return:if (error == -ENOSPC && nospace_error) error = nospace_error;
@@ -2518,15 +2523,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; }
fs/xfs/xfs_trans.c +4 -2
@@ -1356,6 +1356,8 @@ xfs_trans_alloc_ichange(* The caller must ensure that the on-disk dquots attached to this inode have * already been allocated and initialized. The ILOCKs will be dropped when the * transaction is committed or cancelled. +* +* Caller is responsible for unlocking the inodes manually upon return */ int xfs_trans_alloc_dir(
@@ -1386,8 +1388,8 @@ xfs_trans_alloc_dir(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 ); error =xfs_qm_dqattach_locked (dp, false);if (error) {
Signature · 1 line
2.25.1
PATCH v7 6/27 xfs: Hold inode locks in xfs_rename
In reply to [email protected]From: Allison Henderson <[email protected]>
Modify xfs_rename to hold all inode locks across a rename operation We will need this later when we add parent pointers
--- fs/xfs/xfs_inode.c | 42 +++++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 13 deletions(-)
fs/xfs/xfs_inode.c +29 -13
@@ -2541,6 +2541,21 @@ xfs_remove(return error; } +static inline void +xfs_iunlock_after_rename ( +struct xfs_inode **i_tab, +int num_inodes) +{ +int i; + +for (i = num_inodes -1 ; i >=0 ; i--) { +/* Skip duplicate inodes if src and target dps are the same */ +if (!i_tab[i] || (i >0 && i_tab[i] == i_tab[i -1 ])) +continue ; +xfs_iunlock (i_tab[i],XFS_ILOCK_EXCL ); + } +} +/* * Enter all inodes for a rename transaction into a sorted array. */
@@ -2839,18 +2854,16 @@ xfs_rename(xfs_lock_inodes (inodes, num_inodes,XFS_ILOCK_EXCL );/* -* Join all the inodes to the transaction. From this point on, -* we can rely on either trans_commit or trans_cancel to unlock -* them. +* Join all the inodes to the transaction. */ -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
@@ -2864,10 +2877,12 @@ xfs_rename( }/* 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_unlock; + }/* * Try to reserve quota to handle an expansion of the target directory.
@@ -3092,12 +3107,13 @@ xfs_rename(xfs_trans_log_inode (tp, target_dp,XFS_ILOG_CORE ); error =xfs_finish_rename (tp); -if (wip) -xfs_irele (wip); -return error; + + goto out_unlock; out_trans_cancel:xfs_trans_cancel (tp); +out_unlock: +xfs_iunlock_after_rename (inodes, num_inodes); out_release_wip:if (wip)xfs_irele (wip);
Signature · 1 line
2.25.1
PATCH v7 7/27 xfs: Expose init_xattrs in xfs_create_tmpfile
In reply to [email protected]From: Allison Henderson <[email protected]>
Tmp files are used as part of rename operations and will need attr forks initialized for parent pointers. Expose the init_xattrs parameter to the calling function to initialize the fork.
--- fs/xfs/xfs_inode.c | 5 +++-- fs/xfs/xfs_inode.h | 2 +- fs/xfs/xfs_iops.c | 3 ++- 3 files changed, 6 insertions(+), 4 deletions(-)
fs/xfs/xfs_inode.c +3 -2
@@ -1109,6 +1109,7 @@ xfs_create_tmpfile(struct user_namespace *mnt_userns, struct xfs_inode *dp, umode_t mode, + bool init_xattrs, struct xfs_inode **ipp) { struct xfs_mount *mp = dp->i_mount;
@@ -1149,7 +1150,7 @@ xfs_create_tmpfile( error =xfs_dialloc (&tp, dp->i_ino, mode, &ino);if (!error) error =xfs_init_new_inode (mnt_userns, tp, dp, ino, mode, -0 ,0 , prid, false, &ip); +0 ,0 , prid, init_xattrs, &ip);if (error) goto out_trans_cancel;
@@ -2750,7 +2751,7 @@ xfs_rename_alloc_whiteout(int error; error =xfs_create_tmpfile (mnt_userns, dp,S_IFCHR |WHITEOUT_MODE , - &tmpfile); + false, &tmpfile);if (error)return error;
fs/xfs/xfs_inode.h +1 -1
@@ -478,7 +478,7 @@ int xfs_create(struct user_namespace *mnt_userns, umode_t mode, dev_t rdev, bool need_xattr, struct xfs_inode **ipp);int xfs_create_tmpfile (struct user_namespace *mnt_userns, -struct xfs_inode *dp,umode_t mode, +struct xfs_inode *dp,umode_t mode,bool init_xattrs,struct xfs_inode **ipp);int xfs_remove (struct xfs_inode *dp,struct xfs_name *name,struct xfs_inode *ip);
fs/xfs/xfs_iops.c +2 -1
@@ -200,7 +200,8 @@ xfs_generic_create(xfs_create_need_xattr (dir, default_acl, acl), &ip); }else { - error =xfs_create_tmpfile (mnt_userns,XFS_I (dir), mode, &ip); + error =xfs_create_tmpfile (mnt_userns,XFS_I (dir), mode, false, + &ip); }if (unlikely (error)) goto out_free_acl;
Signature · 1 line
2.25.1
PATCH v7 8/27 xfs: get directory offset when adding directory name
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- 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 | 6 +++--- fs/xfs/xfs_symlink.c | 3 ++- 9 files changed, 21 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_da_btree.h +1 -0
@@ -81,6 +81,7 @@ typedef struct xfs_da_args {int rmtvaluelen2;/* remote attr value length in bytes */ uint32_t 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;/*
fs/xfs/libxfs/xfs_dir2.c +7 -2
@@ -257,7 +257,8 @@ xfs_dir_createname(struct xfs_inode *dp, const 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;
@@ -312,6 +313,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; }
@@ -550,7 +555,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); }/*
fs/xfs/libxfs/xfs_dir2.h +1 -1
@@ -40,7 +40,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,const 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,const struct xfs_name *name,xfs_ino_t *inum,struct xfs_name *ci_name);
fs/xfs/libxfs/xfs_dir2_block.c +1 -0
@@ -573,6 +573,7 @@ xfs_dir2_block_addname(xfs_dir2_data_put_ftype (dp->i_mount, dep, args->filetype); tagp =xfs_dir2_data_entry_tag_p (dp->i_mount, 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. */
fs/xfs/libxfs/xfs_dir2_leaf.c +2 -0
@@ -870,6 +870,8 @@ xfs_dir2_leaf_addname(xfs_dir2_data_put_ftype (dp->i_mount, dep, args->filetype); tagp =xfs_dir2_data_entry_tag_p (dp->i_mount, 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. */
fs/xfs/libxfs/xfs_dir2_node.c +2 -0
@@ -1974,6 +1974,8 @@ xfs_dir2_node_addname_int(xfs_dir2_data_put_ftype (dp->i_mount, dep, args->filetype); tagp =xfs_dir2_data_entry_tag_p (dp->i_mount, 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 freespace and log the data block if needed. */
fs/xfs/libxfs/xfs_dir2_sf.c +2 -0
@@ -485,6 +485,7 @@ xfs_dir2_sf_addname_easy(memcpy (sfep->name, args->name, sfep->namelen);xfs_dir2_sf_put_ino (mp, sfp, sfep, args->inumber);xfs_dir2_sf_put_ftype (mp, sfep, args->filetype); + args->offset =xfs_dir2_byte_to_dataptr (offset);/* * Update the header and inode.
@@ -575,6 +576,7 @@ xfs_dir2_sf_addname_hard(memcpy (sfep->name, args->name, sfep->namelen);xfs_dir2_sf_put_ino (mp, sfp, sfep, args->inumber);xfs_dir2_sf_put_ftype (mp, sfep, args->filetype); + args->offset =xfs_dir2_byte_to_dataptr (offset); sfp->count++;if (args->inumber >XFS_DIR2_MAX_SHORT_INUM && !objchange) sfp->i8count++;
fs/xfs/xfs_inode.c +3 -3
@@ -1038,7 +1038,7 @@ xfs_create( unlock_dp_on_error = false; error =xfs_dir_createname (tp, dp, name, ip->i_ino, - resblks -XFS_IALLOC_SPACE_RES (mp)); + resblks -XFS_IALLOC_SPACE_RES (mp),NULL );if (error) {ASSERT (error != -ENOSPC ); goto out_trans_cancel;
@@ -1264,7 +1264,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 );
@@ -3000,7 +3000,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;
fs/xfs/xfs_symlink.c +2 -1
@@ -314,7 +314,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 );
Signature · 1 line
2.25.1
PATCH v7 9/27 xfs: get directory offset when removing directory name
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- 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(-)
fs/xfs/libxfs/xfs_dir2.c +5 -1
@@ -436,7 +436,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;
@@ -481,6 +482,9 @@ xfs_dir_removename(else rval =xfs_dir2_node_removename (args); out_free: +if (offset) + *offset = args->offset; +kmem_free (args);return rval; }
fs/xfs/libxfs/xfs_dir2.h +2 -1
@@ -46,7 +46,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,const struct xfs_name *name,xfs_ino_t inum,xfs_extlen_t tot);
fs/xfs/libxfs/xfs_dir2_block.c +2 -2
@@ -810,9 +810,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. */
fs/xfs/libxfs/xfs_dir2_leaf.c +3 -2
@@ -1386,9 +1386,10 @@ xfs_dir2_leaf_removename(* Point to the leaf entry, use that to point to the data entry. */ lep = &leafhdr.ents[index]; - db =xfs_dir2_dataptr_to_db (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 (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 (geo, leaf);
fs/xfs/libxfs/xfs_dir2_node.c +3 -2
@@ -1296,9 +1296,10 @@ xfs_dir2_leafn_remove(/* * Extract the data block and offset from the entry. */ - db =xfs_dir2_dataptr_to_db (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 (geo,be32_to_cpu (lep->address)); + off =xfs_dir2_dataptr_to_off (args->geo, args->offset);ASSERT (dblk->index == off);/*
fs/xfs/libxfs/xfs_dir2_sf.c +2 -0
@@ -969,6 +969,8 @@ xfs_dir2_sf_removename( XFS_CMP_EXACT) {ASSERT (xfs_dir2_sf_get_ino (mp, sfp, sfep) == args->inumber); + args->offset =xfs_dir2_byte_to_dataptr ( +xfs_dir2_sf_get_offset (sfep));break ; } }
fs/xfs/xfs_inode.c +2 -2
@@ -2508,7 +2508,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;
@@ -3097,7 +3097,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;
Signature · 1 line
2.25.1
PATCH v7 10/27 xfs: get directory offset when replacing a directory name
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- 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 | 16 ++++++++-------- 7 files changed, 21 insertions(+), 13 deletions(-)
fs/xfs/libxfs/xfs_dir2.c +6 -2
@@ -482,7 +482,7 @@ xfs_dir_removename(else rval =xfs_dir2_node_removename (args); out_free: -if (offset) +if (!rval && offset) *offset = args->offset;kmem_free (args);
@@ -498,7 +498,8 @@ xfs_dir_replace(struct xfs_inode *dp, const 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;
@@ -546,6 +547,9 @@ xfs_dir_replace(else rval =xfs_dir2_node_replace (args); out_free: +if (offset) + *offset = args->offset; +kmem_free (args);return rval; }
fs/xfs/libxfs/xfs_dir2.h +1 -1
@@ -50,7 +50,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,const 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);
fs/xfs/libxfs/xfs_dir2_block.c +2 -2
@@ -885,9 +885,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.
fs/xfs/libxfs/xfs_dir2_leaf.c +1 -0
@@ -1523,6 +1523,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)));
fs/xfs/libxfs/xfs_dir2_node.c +1 -0
@@ -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 (leafhdr.ents[blk->index].address); dep = (xfs_dir2_data_entry_t *) ((char *)hdr + xfs_dir2_dataptr_to_off(args->geo,
fs/xfs/libxfs/xfs_dir2_sf.c +2 -0
@@ -1107,6 +1107,8 @@ xfs_dir2_sf_replace(xfs_dir2_sf_put_ino (mp, sfp, sfep, args->inumber);xfs_dir2_sf_put_ftype (mp, sfep, args->filetype); + args->offset =xfs_dir2_byte_to_dataptr ( +xfs_dir2_sf_get_offset (sfep));break ; } }
fs/xfs/xfs_inode.c +8 -8
@@ -2489,7 +2489,7 @@ xfs_remove(*/ if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) { error =xfs_dir_replace (tp, ip, &xfs_name_dotdot, - tp->t_mountp->m_sb.sb_rootino,0 ); + tp->t_mountp->m_sb.sb_rootino,0 ,NULL );if (error) goto out_trans_cancel; }
@@ -2644,12 +2644,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;
@@ -2663,7 +2663,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;
@@ -2687,7 +2687,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;
@@ -3021,7 +3021,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;
@@ -3055,7 +3055,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;
@@ -3094,7 +3094,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 );
Signature · 1 line
2.25.1
PATCH v7 11/27 xfs: add parent pointer support to attribute code
In reply to [email protected]From: Allison Henderson <[email protected]>
Add the new parent attribute type. XFS_ATTR_PARENT is used only for parent pointer entries; it uses reserved blocks like XFS_ATTR_ROOT.
--- fs/xfs/libxfs/xfs_attr.c | 4 +++- fs/xfs/libxfs/xfs_da_format.h | 5 ++++- fs/xfs/libxfs/xfs_log_format.h | 1 + 3 files changed, 8 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_attr.c +3 -1
@@ -976,11 +976,13 @@ xfs_attr_set(struct xfs_inode *dp = args->dp;struct xfs_mount *mp = dp->i_mount;struct xfs_trans_res tres; -bool rsvd = (args->attr_filter &XFS_ATTR_ROOT ); +bool rsvd;int error, local;int rmt_blks =0 ;unsigned int total; + rsvd = (args->attr_filter & (XFS_ATTR_ROOT |XFS_ATTR_PARENT )) !=0 ; +if (xfs_is_shutdown (dp->i_mount))return -EIO ;
fs/xfs/libxfs/xfs_da_format.h +4 -1
@@ -688,12 +688,15 @@ struct xfs_attr3_leafblock {#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 attrs */ #define XFS_ATTR_INCOMPLETE_BIT 7/* attr in middle of create/delete */ #define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT) +#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT)#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT) -#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | XFS_ATTR_SECURE) +#define XFS_ATTR_NSP_ONDISK_MASK \ + (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT)/* * Alignment for namelist and valuelist entries (since they are mixed
fs/xfs/libxfs/xfs_log_format.h +1 -0
@@ -967,6 +967,7 @@ struct xfs_icreate_log {*/ #define XFS_ATTRI_FILTER_MASK (XFS_ATTR_ROOT | \ XFS_ATTR_SECURE | \ + XFS_ATTR_PARENT | \ XFS_ATTR_INCOMPLETE)/*
Signature · 1 line
2.25.1
PATCH v7 12/27 xfs: define parent pointer xattr format
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- fs/xfs/libxfs/xfs_da_format.h | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
fs/xfs/libxfs/xfs_da_format.h +25 -0
@@ -805,4 +805,29 @@ static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)xfs_failaddr_t xfs_da3_blkinfo_verify (struct xfs_buf *bp,struct xfs_da3_blkinfo *hdr3); +/* +* 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__ */
Signature · 1 line
2.25.1
PATCH v7 13/27 xfs: Add xfs_verify_pptr
In reply to [email protected]From: Allison Henderson <[email protected]>
Attribute names of parent pointers are not strings. So we need to modify attr_namecheck to verify parent pointer records when the XFS_ATTR_PARENT flag is set.
--- fs/xfs/libxfs/xfs_attr.c | 47 ++++++++++++++++++++++++++++++++--- fs/xfs/libxfs/xfs_attr.h | 3 ++- fs/xfs/libxfs/xfs_da_format.h | 8 ++++++ fs/xfs/scrub/attr.c | 2 +- fs/xfs/xfs_attr_item.c | 11 +++++--- fs/xfs/xfs_attr_list.c | 17 +++++++++---- 6 files changed, 74 insertions(+), 14 deletions(-)
fs/xfs/libxfs/xfs_attr.c +44 -3
@@ -1577,9 +1577,33 @@ xfs_attr_node_get(return error; } -/* Returns true if the attribute entry name is valid. */ -bool -xfs_attr_namecheck ( +/* +* Verify parent pointer attribute is valid. +* Return true on success or false on failure +*/ +STATIC bool +xfs_verify_pptr ( +struct xfs_mount *mp, +const struct xfs_parent_name_rec *rec) +{ +xfs_ino_t p_ino; +xfs_dir2_dataptr_t p_diroffset; + + p_ino =be64_to_cpu (rec->p_ino); + p_diroffset =be32_to_cpu (rec->p_diroffset); + +if (!xfs_verify_ino (mp, p_ino)) +return false; + +if (p_diroffset >XFS_DIR2_MAX_DATAPTR ) +return false; + +return true; +} + +/* Returns true if the string attribute entry name is valid. */ +static bool +xfs_str_attr_namecheck (const void *name,size_t length) {
@@ -1594,6 +1618,23 @@ xfs_attr_namecheck(return !memchr (name,0 , length); } +/* Returns true if the attribute entry name is valid. */ +bool +xfs_attr_namecheck ( +struct xfs_mount *mp, +const void *name, +size_t length, +int flags) +{ +if (flags &XFS_ATTR_PARENT ) { +if (length !=sizeof (struct xfs_parent_name_rec )) +return false; +return xfs_verify_pptr (mp, (struct xfs_parent_name_rec *)name); + } + +return xfs_str_attr_namecheck (name, length); +} +int __init xfs_attr_intent_init_cache (void ) {
fs/xfs/libxfs/xfs_attr.h +2 -1
@@ -547,7 +547,8 @@ int xfs_attr_get(struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr); -bool xfs_attr_namecheck (const void *name,size_t length); +bool xfs_attr_namecheck (struct xfs_mount *mp,const void *name,size_t length, +int flags);int xfs_attr_calc_size (struct xfs_da_args *args,int *local);void xfs_init_attr_trans (struct xfs_da_args *args,struct xfs_trans_res *tres,unsigned int *total);
fs/xfs/libxfs/xfs_da_format.h +8 -0
@@ -731,6 +731,14 @@ xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)return &((char *)leafp)[be16_to_cpu (entries[idx].nameidx)]; } +static inline int +xfs_attr3_leaf_flags (xfs_attr_leafblock_t *leafp,int idx) +{ +struct xfs_attr_leaf_entry *entries =xfs_attr3_leaf_entryp (leafp); + +return entries[idx].flags; +} +static inline xfs_attr_leaf_name_remote_t *xfs_attr3_leaf_name_remote (xfs_attr_leafblock_t *leafp,int idx) {
fs/xfs/scrub/attr.c +1 -1
@@ -129,7 +129,7 @@ xchk_xattr_listent( }/* Does this name make sense? */ -if (!xfs_attr_namecheck (name, namelen)) { +if (!xfs_attr_namecheck (sx->sc->mp, name, namelen, flags)) {xchk_fblock_set_corrupt (sx->sc,XFS_ATTR_FORK , args.blkno);return ; }
fs/xfs/xfs_attr_item.c +7 -4
@@ -593,7 +593,8 @@ xfs_attri_item_recover(*/ attrp = &attrip->attri_format;if (!xfs_attri_validate (mp, attrp) || - !xfs_attr_namecheck (nv->name.i_addr, nv->name.i_len)) + !xfs_attr_namecheck (mp, nv->name.i_addr, nv->name.i_len, + attrp->alfi_attr_filter))return -EFSCORRUPTED ; error =xlog_recover_iget (mp, attrp->alfi_ino, &ip);
@@ -804,7 +805,8 @@ xlog_recover_attri_commit_pass2( } attr_name = item->ri_buf[i].i_addr; -if (!xfs_attr_namecheck (attr_name, attri_formatp->alfi_name_len)) { +if (!xfs_attr_namecheck (mp, attr_name, attri_formatp->alfi_name_len, + attri_formatp->alfi_attr_filter)) {XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , mp, item->ri_buf[i].i_addr, item->ri_buf[i].i_len);return -EFSCORRUPTED ;
@@ -822,8 +824,9 @@ xlog_recover_attri_commit_pass2( } attr_nname = item->ri_buf[i].i_addr; -if (!xfs_attr_namecheck (attr_nname, - attri_formatp->alfi_nname_len)) { +if (!xfs_attr_namecheck (mp, attr_nname, + attri_formatp->alfi_nname_len, + attri_formatp->alfi_attr_filter)) {XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , mp, item->ri_buf[i].i_addr, item->ri_buf[i].i_len);
fs/xfs/xfs_attr_list.c +12 -5
@@ -58,9 +58,13 @@ xfs_attr_shortform_list(struct xfs_attr_sf_sort *sbuf, *sbp;struct xfs_attr_shortform *sf;struct xfs_attr_sf_entry *sfe; +struct xfs_mount *mp;int sbsize, nsbuf, count, i;int error =0 ; +ASSERT (context !=NULL ); +ASSERT (dp !=NULL ); + mp = dp->i_mount; sf = (struct xfs_attr_shortform *)dp->i_af.if_u1.if_data;ASSERT (sf !=NULL );if (!sf->hdr.count)
@@ -82,8 +86,9 @@ xfs_attr_shortform_list( (dp->i_af.if_bytes + sf->hdr.count * 16) < context->bufsize)) {for (i =0 , sfe = &sf->list[0 ]; i < sf->hdr.count; i++) {if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (sfe->nameval, - sfe->namelen))) + !xfs_attr_namecheck (mp, sfe->nameval, + sfe->namelen, + sfe->flags)))return -EFSCORRUPTED ; context->put_listent(context, sfe->flags,
@@ -174,8 +179,9 @@ xfs_attr_shortform_list( cursor->offset =0 ; }if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (sbp->name, - sbp->namelen))) { + !xfs_attr_namecheck (mp, sbp->name, + sbp->namelen, + sbp->flags))) { error = -EFSCORRUPTED ; goto out; }
@@ -465,7 +471,8 @@ xfs_attr3_leaf_list_int( }if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (name, namelen))) + !xfs_attr_namecheck (mp, name, namelen, + entry->flags)))return -EFSCORRUPTED ; context->put_listent (context, entry->flags, name, namelen, valuelen);
Signature · 1 line
2.25.1
PATCH v7 14/27 xfs: extend transaction reservations for parent attributes
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- fs/xfs/libxfs/xfs_trans_resv.c | 324 +++++++++++++++++++++++++++------ 1 file changed, 272 insertions(+), 52 deletions(-)
fs/xfs/libxfs/xfs_trans_resv.c +272 -52
@@ -19,6 +19,9 @@#include "xfs_trans.h" #include "xfs_qm.h" #include "xfs_trans_space.h" +#include "xfs_attr_item.h" +#include "xfs_log.h" +#include "xfs_da_format.h" #define _ALLOC true#define _FREE false
@@ -420,29 +423,108 @@ xfs_calc_itruncate_reservation_minlogsize(return xfs_calc_itruncate_reservation (mp, true); } +static inline unsigned int xfs_calc_pptr_link_overhead (void ) +{ +return sizeof (struct xfs_attri_log_format ) + +xlog_calc_iovec_len (XATTR_NAME_MAX ) + +xlog_calc_iovec_len (sizeof (struct xfs_parent_name_rec )); +} +static inline unsigned int xfs_calc_pptr_unlink_overhead (void ) +{ +return sizeof (struct xfs_attri_log_format ) + +xlog_calc_iovec_len (sizeof (struct xfs_parent_name_rec )); +} +static inline unsigned int xfs_calc_pptr_replace_overhead (void ) +{ +return sizeof (struct xfs_attri_log_format ) + +xlog_calc_iovec_len (XATTR_NAME_MAX ) + +xlog_calc_iovec_len (XATTR_NAME_MAX ) + +xlog_calc_iovec_len (sizeof (struct xfs_parent_name_rec )); +} +/* * In renaming a files we can modify: * the five inodes involved: 5 * inode size * the two directory btrees: 2 * (max depth + v2) * dir block size * the two directory bmap btrees: 2 * max depth * block size * And the bmap_finish transaction can free dir and bmap blocks (two sets -* of bmap blocks) giving: +* of bmap blocks) giving (t2): * the agf for the ags in which the blocks live: 3 * sector size * the agfl for the ags in which the blocks live: 3 * sector size * the superblock for the free block count: sector size * the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size +* If parent pointers are enabled (t3), then each transaction in the chain +* must be capable of setting or removing the extended attribute +* containing the parent information. It must also be able to handle +* the three xattr intent items that track the progress of the parent +* pointer update. */ STATIC uintxfs_calc_rename_reservation (struct xfs_mount *mp) { -return XFS_DQUOT_LOGRES (mp) + -max ((xfs_calc_inode_res (mp,5 ) + -xfs_calc_buf_res (2 *XFS_DIROP_LOG_COUNT (mp), -XFS_FSB_TO_B (mp,1 ))), - (xfs_calc_buf_res (7 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,3 ), -XFS_FSB_TO_B (mp,1 )))); +unsigned int overhead =XFS_DQUOT_LOGRES (mp); +struct xfs_trans_resv *resp =M_RES (mp); +unsigned int t1, t2, t3 =0 ; + + t1 =xfs_calc_inode_res (mp,5 ) + +xfs_calc_buf_res (2 *XFS_DIROP_LOG_COUNT (mp), +XFS_FSB_TO_B (mp,1 )); + + t2 =xfs_calc_buf_res (7 , mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_allocfree_block_count (mp,3 ), +XFS_FSB_TO_B (mp,1 )); + +if (xfs_has_parent (mp)) { +unsigned int rename_overhead, exchange_overhead; + + t3 =max (resp->tr_attrsetm.tr_logres, + resp->tr_attrrm.tr_logres); + +/* +* For a standard rename, the three xattr intent log items +* are (1) replacing the pptr for the source file; (2) +* removing the pptr on the dest file; and (3) adding a +* pptr for the whiteout file in the src dir. +* +* For an RENAME_EXCHANGE, there are two xattr intent +* items to replace the pptr for both src and dest +* files. Link counts don't change and there is no +* whiteout. +* +* In the worst case we can end up relogging all log +* intent items to allow the log tail to move ahead, so +* they become overhead added to each transaction in a +* processing chain. +*/ + rename_overhead =xfs_calc_pptr_replace_overhead () + +xfs_calc_pptr_unlink_overhead () + +xfs_calc_pptr_link_overhead (); + exchange_overhead =2 *xfs_calc_pptr_replace_overhead (); + + overhead +=max (rename_overhead, exchange_overhead); + } + +return overhead +max3 (t1, t2, t3); +} + +static inline unsigned int +xfs_rename_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +/* One for the rename, one more for freeing blocks */ +unsigned int ret =XFS_RENAME_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to remove or add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret +=max (resp->tr_attrsetm.tr_logcount, + resp->tr_attrrm.tr_logcount); + +return ret; }/*
@@ -459,6 +541,23 @@ xfs_calc_iunlink_remove_reservation(2 *M_IGEO (mp)->inode_cluster_size; } +static inline unsigned int +xfs_link_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret =XFS_LINK_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret += resp->tr_attrsetm.tr_logcount; + +return ret; +} +/* * For creating a link to an inode: * the parent directory inode: inode size
@@ -475,14 +574,23 @@ STATIC uintxfs_calc_link_reservation ( struct xfs_mount *mp) { -return XFS_DQUOT_LOGRES (mp) + -xfs_calc_iunlink_remove_reservation (mp) + -max ((xfs_calc_inode_res (mp,2 ) + -xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp), -XFS_FSB_TO_B (mp,1 ))), - (xfs_calc_buf_res (3 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,1 ), -XFS_FSB_TO_B (mp,1 )))); +unsigned int overhead =XFS_DQUOT_LOGRES (mp); +struct xfs_trans_resv *resp =M_RES (mp); +unsigned int t1, t2, t3 =0 ; + + overhead +=xfs_calc_iunlink_remove_reservation (mp); + t1 =xfs_calc_inode_res (mp,2 ) + +xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp),XFS_FSB_TO_B (mp,1 )); + t2 =xfs_calc_buf_res (3 , mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_allocfree_block_count (mp,1 ), +XFS_FSB_TO_B (mp,1 )); + +if (xfs_has_parent (mp)) { + t3 = resp->tr_attrsetm.tr_logres; + overhead +=xfs_calc_pptr_link_overhead (); + } + +return overhead +max3 (t1, t2, t3); }/*
@@ -497,6 +605,23 @@ xfs_calc_iunlink_add_reservation(xfs_mount_t *mp)M_IGEO (mp)->inode_cluster_size; } +static inline unsigned int +xfs_remove_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret =XFS_REMOVE_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret += resp->tr_attrrm.tr_logcount; + +return ret; +} +/* * For removing a directory entry we can modify: * the parent directory inode: inode size
@@ -513,14 +638,24 @@ STATIC uintxfs_calc_remove_reservation ( struct xfs_mount *mp) { -return XFS_DQUOT_LOGRES (mp) + -xfs_calc_iunlink_add_reservation (mp) + -max ((xfs_calc_inode_res (mp,2 ) + -xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp), -XFS_FSB_TO_B (mp,1 ))), - (xfs_calc_buf_res (4 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,2 ), -XFS_FSB_TO_B (mp,1 )))); +unsigned int overhead =XFS_DQUOT_LOGRES (mp); +struct xfs_trans_resv *resp =M_RES (mp); +unsigned int t1, t2, t3 =0 ; + + overhead +=xfs_calc_iunlink_add_reservation (mp); + + t1 =xfs_calc_inode_res (mp,2 ) + +xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp),XFS_FSB_TO_B (mp,1 )); + t2 =xfs_calc_buf_res (4 , mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_allocfree_block_count (mp,2 ), +XFS_FSB_TO_B (mp,1 )); + +if (xfs_has_parent (mp)) { + t3 = resp->tr_attrrm.tr_logres; + overhead +=xfs_calc_pptr_unlink_overhead (); + } + +return overhead +max3 (t1, t2, t3); }/*
@@ -569,12 +704,40 @@ xfs_calc_icreate_resv_alloc(xfs_calc_finobt_res (mp); } +static inline unsigned int +xfs_icreate_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret =XFS_CREATE_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret += resp->tr_attrsetm.tr_logcount; + +return ret; +} + STATIC uint -xfs_calc_icreate_reservation (xfs_mount_t *mp) +xfs_calc_icreate_reservation ( +struct xfs_mount *mp) { -return XFS_DQUOT_LOGRES (mp) + -max (xfs_calc_icreate_resv_alloc (mp), -xfs_calc_create_resv_modify (mp)); +struct xfs_trans_resv *resp =M_RES (mp); +unsigned int overhead =XFS_DQUOT_LOGRES (mp); +unsigned int t1, t2, t3 =0 ; + + t1 =xfs_calc_icreate_resv_alloc (mp); + t2 =xfs_calc_create_resv_modify (mp); + +if (xfs_has_parent (mp)) { + t3 = resp->tr_attrsetm.tr_logres; + overhead +=xfs_calc_pptr_link_overhead (); + } + +return overhead +max3 (t1, t2, t3); }STATIC uint
@@ -587,6 +750,23 @@ xfs_calc_create_tmpfile_reservation(return res +xfs_calc_iunlink_add_reservation (mp); } +static inline unsigned int +xfs_mkdir_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret =XFS_MKDIR_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret += resp->tr_attrsetm.tr_logcount; + +return ret; +} +/* * Making a new directory is the same as creating a new file. */
@@ -597,6 +777,22 @@ xfs_calc_mkdir_reservation(return xfs_calc_icreate_reservation (mp); } +static inline unsigned int +xfs_symlink_log_count ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +unsigned int ret =XFS_SYMLINK_LOG_COUNT ; + +/* +* Pre-reserve enough log reservation to handle the transaction +* rolling needed to add one parent pointer. +*/ +if (xfs_has_parent (mp)) + ret += resp->tr_attrsetm.tr_logcount; + +return ret; +}/* * Making a new symplink is the same as creating a new file, but
@@ -909,54 +1105,76 @@ xfs_calc_sb_reservation(return xfs_calc_buf_res (1 , mp->m_sb.sb_sectsize); } -void -xfs_trans_resv_calc ( +/* +* 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 requires 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. +*/ +STATIC void +xfs_calc_namespace_reservations (struct xfs_mount *mp,struct xfs_trans_resv *resp) { -int logcount_adj =0 ; - -/* -* 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, false); - 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, false); - 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 ; + resp->tr_rename.tr_logcount =xfs_rename_log_count (mp, resp); resp->tr_rename.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; resp->tr_link.tr_logres =xfs_calc_link_reservation (mp); - resp->tr_link.tr_logcount =XFS_LINK_LOG_COUNT ; + resp->tr_link.tr_logcount =xfs_link_log_count (mp, resp); resp->tr_link.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; resp->tr_remove.tr_logres =xfs_calc_remove_reservation (mp); - resp->tr_remove.tr_logcount =XFS_REMOVE_LOG_COUNT ; + resp->tr_remove.tr_logcount =xfs_remove_log_count (mp, resp); resp->tr_remove.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; resp->tr_symlink.tr_logres =xfs_calc_symlink_reservation (mp); - resp->tr_symlink.tr_logcount =XFS_SYMLINK_LOG_COUNT ; + resp->tr_symlink.tr_logcount =xfs_symlink_log_count (mp, resp); resp->tr_symlink.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; resp->tr_create.tr_logres =xfs_calc_icreate_reservation (mp); - resp->tr_create.tr_logcount =XFS_CREATE_LOG_COUNT ; + resp->tr_create.tr_logcount =xfs_icreate_log_count (mp, resp); 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 (mp, resp); + resp->tr_mkdir.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; +} + +void +xfs_trans_resv_calc ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +int logcount_adj =0 ; + +/* +* 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, false); + 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, false); + 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 ;
@@ -986,6 +1204,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.
Signature · 1 line
2.25.1
PATCH v7 15/27 xfs: parent pointer attribute creation
In reply to [email protected]From: Allison Henderson <[email protected]>
Add parent pointer attribute during xfs_create, and subroutines to initialize attributes
--- fs/xfs/Makefile | 1 + fs/xfs/libxfs/xfs_attr.c | 4 +- fs/xfs/libxfs/xfs_attr.h | 4 +- fs/xfs/libxfs/xfs_parent.c | 149 +++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_parent.h | 34 +++++++++ fs/xfs/xfs_inode.c | 64 ++++++++++++++-- fs/xfs/xfs_xattr.c | 2 +- fs/xfs/xfs_xattr.h | 1 + 8 files changed, 247 insertions(+), 12 deletions(-)
fs/xfs/Makefile +1 -0
@@ -40,6 +40,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 \
fs/xfs/libxfs/xfs_attr.c +2 -2
@@ -886,7 +886,7 @@ xfs_attr_lookup(return error; } -static int +int xfs_attr_intent_init( struct xfs_da_args *args, unsigned int op_flags, /* op flag (set or remove) */
@@ -904,7 +904,7 @@ xfs_attr_intent_init( }/* Sets an attribute for an inode as a deferred operation */ -static int +int xfs_attr_defer_add (struct xfs_da_args *args) {
fs/xfs/libxfs/xfs_attr.h +3 -1
@@ -544,6 +544,7 @@ int xfs_inode_hasattr(struct xfs_inode *ip);bool xfs_attr_is_leaf (struct xfs_inode *ip);int xfs_attr_get_ilocked (struct xfs_da_args *args);int xfs_attr_get (struct xfs_da_args *args); +int xfs_attr_defer_add (struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr);
@@ -552,7 +553,8 @@ bool xfs_attr_namecheck(struct xfs_mount *mp, const void *name, size_t length,int xfs_attr_calc_size (struct xfs_da_args *args,int *local);void xfs_init_attr_trans (struct xfs_da_args *args,struct xfs_trans_res *tres,unsigned int *total); - +int xfs_attr_intent_init (struct xfs_da_args *args,unsigned int op_flags, +struct xfs_attr_intent **attr);/* * Check to see if the attr should be upgraded from non-existent or shortform to * single-leaf-block attribute list.
fs/xfs/libxfs/xfs_parent.c new file +149 -0
149 lines not on this page · raw message
fs/xfs/libxfs/xfs_parent.h new file +34 -0
@@ -0,0 +1,34 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2022 Oracle, Inc. +* All Rights Reserved. +*/ +#ifndef __XFS_PARENT_H__ +#define __XFS_PARENT_H__ + +/* +* Dynamically allocd structure used to wrap the needed data to pass around +* the defer ops machinery +*/ +struct xfs_parent_defer { +struct xfs_parent_name_rec rec; +struct xfs_da_args args; +}; + +/* +* 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_init (xfs_mount_t *mp,struct xfs_parent_defer **parentp); +int xfs_parent_defer_add (struct xfs_trans *tp,struct xfs_parent_defer *parent, +struct xfs_inode *dp,struct xfs_name *parent_name, +xfs_dir2_dataptr_t diroffset,struct xfs_inode *child); +void xfs_parent_cancel (xfs_mount_t *mp,struct xfs_parent_defer *parent); +unsigned int xfs_pptr_calc_space_res (struct xfs_mount *mp, +unsigned int namelen); + +#endif /* __XFS_PARENT_H__ */
fs/xfs/xfs_inode.c +56 -8
140 lines not on this page · raw message
fs/xfs/xfs_xattr.c +1 -1
@@ -27,7 +27,7 @@* they must release the permission by calling xlog_drop_incompat_feat * when they're done. */ -static inline int +int xfs_attr_grab_log_assist (struct xfs_mount *mp) {
fs/xfs/xfs_xattr.h +1 -0
@@ -7,6 +7,7 @@#define __XFS_XATTR_H__int xfs_attr_change (struct xfs_da_args *args); +int xfs_attr_grab_log_assist (struct xfs_mount *mp);extern const struct xattr_handler *xfs_xattr_handlers[];
Signature · 1 line
2.25.1
PATCH v7 16/27 xfs: add parent attributes to link
In reply to [email protected]From: Allison Henderson <[email protected]>
This patch modifies xfs_link to add a parent pointer to the inode.
--- fs/xfs/libxfs/xfs_trans_space.h | 2 -- fs/xfs/xfs_inode.c | 52 ++++++++++++++++++++++++++++----- 2 files changed, 45 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_trans_space.h +0 -2
@@ -84,8 +84,6 @@ (2 * (mp)->m_alloc_maxlevels)#define XFS_GROWFSRT_SPACE_RES (mp,b) \ ((b) + XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK)) -#define XFS_LINK_SPACE_RES (mp,nl) \ - XFS_DIRENTER_SPACE_RES(mp,nl)#define XFS_MKDIR_SPACE_RES (mp,nl) \ (XFS_IALLOC_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl))#define XFS_QM_DQALLOC_SPACE_RES (mp) \
fs/xfs/xfs_inode.c +45 -7
91 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v7 17/27 xfs: add parent attributes to symlink
In reply to [email protected]From: Allison Henderson <[email protected]>
This patch modifies xfs_symlink to add a parent pointer to the inode.
--- fs/xfs/libxfs/xfs_trans_space.h | 2 -- fs/xfs/xfs_symlink.c | 54 ++++++++++++++++++++++++++++----- 2 files changed, 47 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_trans_space.h +0 -2
@@ -95,8 +95,6 @@ XFS_DIRREMOVE_SPACE_RES(mp)#define XFS_RENAME_SPACE_RES (mp,nl) \ (XFS_DIRREMOVE_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl)) -#define XFS_SYMLINK_SPACE_RES (mp,nl,b) \ - (XFS_IALLOC_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl) + (b))#define XFS_IFREE_SPACE_RES (mp) \ (xfs_has_finobt(mp) ? M_IGEO(mp)->inobt_maxlevels : 0)
fs/xfs/xfs_symlink.c +47 -7
117 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v7 18/27 xfs: remove parent pointers in unlink
In reply to [email protected]From: Allison Henderson <[email protected]>
This patch removes the parent pointer attribute during unlink
--- fs/xfs/libxfs/xfs_attr.c | 2 +- fs/xfs/libxfs/xfs_attr.h | 1 + fs/xfs/libxfs/xfs_parent.c | 17 +++++++++++++ fs/xfs/libxfs/xfs_parent.h | 4 +++ fs/xfs/libxfs/xfs_trans_space.h | 2 -- fs/xfs/xfs_inode.c | 44 +++++++++++++++++++++++++++------ 6 files changed, 60 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_attr.c +1 -1
@@ -946,7 +946,7 @@ xfs_attr_defer_replace( }/* Removes an attribute for an inode as a deferred operation */ -static int +int xfs_attr_defer_remove (struct xfs_da_args *args) {
fs/xfs/libxfs/xfs_attr.h +1 -0
@@ -545,6 +545,7 @@ bool xfs_attr_is_leaf(struct xfs_inode *ip);int xfs_attr_get_ilocked (struct xfs_da_args *args);int xfs_attr_get (struct xfs_da_args *args);int xfs_attr_defer_add (struct xfs_da_args *args); +int xfs_attr_defer_remove (struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr);
fs/xfs/libxfs/xfs_parent.c +17 -0
@@ -125,6 +125,23 @@ xfs_parent_defer_add(return xfs_attr_defer_add (args); } +int +xfs_parent_defer_remove ( +struct xfs_trans *tp, +struct xfs_inode *dp, +struct xfs_parent_defer *parent, +xfs_dir2_dataptr_t diroffset, +struct xfs_inode *child) +{ +struct xfs_da_args *args = &parent->args; + +xfs_init_parent_name_rec (&parent->rec, dp, diroffset); + args->trans = tp; + args->dp = child; + args->hashval =xfs_da_hashname (args->name, args->namelen); +return xfs_attr_defer_remove (args); +} + void xfs_parent_cancel( xfs_mount_t *mp,
fs/xfs/libxfs/xfs_parent.h +4 -0
@@ -27,6 +27,10 @@ int xfs_parent_init(xfs_mount_t *mp, struct xfs_parent_defer **parentp);int xfs_parent_defer_add (struct xfs_trans *tp,struct xfs_parent_defer *parent,struct xfs_inode *dp,struct xfs_name *parent_name,xfs_dir2_dataptr_t diroffset,struct xfs_inode *child); +int xfs_parent_defer_remove (struct xfs_trans *tp,struct xfs_inode *dp, +struct xfs_parent_defer *parent, +xfs_dir2_dataptr_t diroffset, +struct xfs_inode *child);void xfs_parent_cancel (xfs_mount_t *mp,struct xfs_parent_defer *parent);unsigned int xfs_pptr_calc_space_res (struct xfs_mount *mp,unsigned int namelen);
fs/xfs/libxfs/xfs_trans_space.h +0 -2
@@ -91,8 +91,6 @@ XFS_DQUOT_CLUSTER_SIZE_FSB)#define XFS_QM_QINOCREATE_SPACE_RES (mp) \ XFS_IALLOC_SPACE_RES(mp) -#define XFS_REMOVE_SPACE_RES (mp) \ - XFS_DIRREMOVE_SPACE_RES(mp)#define XFS_RENAME_SPACE_RES (mp,nl) \ (XFS_DIRREMOVE_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl))#define XFS_IFREE_SPACE_RES (mp) \
fs/xfs/xfs_inode.c +37 -7
95 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v7 19/27 xfs: Indent xfs_rename
In reply to [email protected]From: Allison Henderson <[email protected]>
Indent variables and parameters in xfs_rename in preparation for parent pointer modifications. White space only, no functional changes. This will make reviewing new code easier on reviewers.
--- fs/xfs/xfs_inode.c | 41 +++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-)
fs/xfs/xfs_inode.c +21 -20
@@ -2898,26 +2898,27 @@ xfs_rename_alloc_whiteout(*/ int xfs_rename ( -struct user_namespace *mnt_userns, -struct xfs_inode *src_dp, -struct xfs_name *src_name, -struct xfs_inode *src_ip, -struct xfs_inode *target_dp, -struct xfs_name *target_name, -struct xfs_inode *target_ip, -unsigned int flags) -{ -struct xfs_mount *mp = src_dp->i_mount; -struct xfs_trans *tp; -struct xfs_inode *wip =NULL ;/* whiteout inode */ -struct xfs_inode *inodes[__XFS_SORT_INODES]; -int i; -int num_inodes = __XFS_SORT_INODES; -bool new_parent = (src_dp != target_dp); -bool src_is_directory =S_ISDIR (VFS_I (src_ip)->i_mode); -int spaceres; -bool retried = false; -int error, nospace_error =0 ; +struct user_namespace *mnt_userns, +struct xfs_inode *src_dp, +struct xfs_name *src_name, +struct xfs_inode *src_ip, +struct xfs_inode *target_dp, +struct xfs_name *target_name, +struct xfs_inode *target_ip, +unsigned int flags) +{ +struct xfs_mount *mp = src_dp->i_mount; +struct xfs_trans *tp; +struct xfs_inode *wip =NULL ;/* whiteout inode */ +struct xfs_inode *inodes[__XFS_SORT_INODES]; +int i; +int num_inodes = __XFS_SORT_INODES; +bool new_parent = (src_dp != target_dp); +bool src_is_directory = +S_ISDIR (VFS_I (src_ip)->i_mode); +int spaceres; +bool retried = false; +int error, nospace_error =0 ;trace_xfs_rename (src_dp, target_dp, src_name, target_name);
Signature · 1 line
2.25.1
PATCH v7 20/27 xfs: Add parent pointers to rename
In reply to [email protected]From: Allison Henderson <[email protected]>
This patch removes the old parent pointer attribute during the rename operation, and re-adds the updated parent pointer. In the case of xfs_cross_rename, we modify the routine not to roll the transaction just yet. We will do this after the parent pointer is added in the calling xfs_rename function.
--- fs/xfs/libxfs/xfs_attr.c | 2 +- fs/xfs/libxfs/xfs_attr.h | 1 + fs/xfs/libxfs/xfs_parent.c | 31 ++++++++++++ fs/xfs/libxfs/xfs_parent.h | 6 +++ fs/xfs/libxfs/xfs_trans_space.h | 2 - fs/xfs/xfs_inode.c | 89 ++++++++++++++++++++++++++++++--- 6 files changed, 122 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_attr.c +1 -1
@@ -923,7 +923,7 @@ xfs_attr_defer_add( }/* Sets an attribute for an inode as a deferred operation */ -static int +int xfs_attr_defer_replace (struct xfs_da_args *args) {
fs/xfs/libxfs/xfs_attr.h +1 -0
@@ -546,6 +546,7 @@ int xfs_attr_get_ilocked(struct xfs_da_args *args);int xfs_attr_get (struct xfs_da_args *args);int xfs_attr_defer_add (struct xfs_da_args *args);int xfs_attr_defer_remove (struct xfs_da_args *args); +int xfs_attr_defer_replace (struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr);
fs/xfs/libxfs/xfs_parent.c +31 -0
@@ -142,6 +142,37 @@ xfs_parent_defer_remove(return xfs_attr_defer_remove (args); } + +int +xfs_parent_defer_replace ( +struct xfs_trans *tp, +struct xfs_parent_defer *new_parent, +struct xfs_inode *old_dp, +xfs_dir2_dataptr_t old_diroffset, +struct xfs_name *parent_name, +struct xfs_inode *new_dp, +xfs_dir2_dataptr_t new_diroffset, +struct xfs_inode *child) +{ +struct xfs_da_args *args = &new_parent->args; + +xfs_init_parent_name_rec (&new_parent->old_rec, old_dp, old_diroffset); +xfs_init_parent_name_rec (&new_parent->rec, new_dp, new_diroffset); + new_parent->args.name = (const uint8_t *)&new_parent->old_rec; + new_parent->args.namelen =sizeof (struct xfs_parent_name_rec ); + new_parent->args.new_name = (const uint8_t *)&new_parent->rec; + new_parent->args.new_namelen =sizeof (struct xfs_parent_name_rec ); + args->trans = tp; + args->dp = child; + +ASSERT (parent_name !=NULL ); + new_parent->args.value = (void *)parent_name->name; + new_parent->args.valuelen = parent_name->len; + + args->hashval =xfs_da_hashname (args->name, args->namelen); +return xfs_attr_defer_replace (args); +} + void xfs_parent_cancel( xfs_mount_t *mp,
fs/xfs/libxfs/xfs_parent.h +6 -0
@@ -12,6 +12,7 @@*/ struct xfs_parent_defer {struct xfs_parent_name_rec rec; +struct xfs_parent_name_rec old_rec;struct xfs_da_args args; };
@@ -27,6 +28,11 @@ int xfs_parent_init(xfs_mount_t *mp, struct xfs_parent_defer **parentp);int xfs_parent_defer_add (struct xfs_trans *tp,struct xfs_parent_defer *parent,struct xfs_inode *dp,struct xfs_name *parent_name,xfs_dir2_dataptr_t diroffset,struct xfs_inode *child); +int xfs_parent_defer_replace (struct xfs_trans *tp, +struct xfs_parent_defer *new_parent,struct xfs_inode *old_dp, +xfs_dir2_dataptr_t old_diroffset,struct xfs_name *parent_name, +struct xfs_inode *new_ip,xfs_dir2_dataptr_t new_diroffset, +struct xfs_inode *child); int xfs_parent_defer_remove(struct xfs_trans *tp, struct xfs_inode *dp, struct xfs_parent_defer *parent, xfs_dir2_dataptr_t diroffset,
fs/xfs/libxfs/xfs_trans_space.h +0 -2
@@ -91,8 +91,6 @@ XFS_DQUOT_CLUSTER_SIZE_FSB)#define XFS_QM_QINOCREATE_SPACE_RES (mp) \ XFS_IALLOC_SPACE_RES(mp) -#define XFS_RENAME_SPACE_RES (mp,nl) \ - (XFS_DIRREMOVE_SPACE_RES(mp) + XFS_DIRENTER_SPACE_RES(mp,nl))#define XFS_IFREE_SPACE_RES (mp) \ (xfs_has_finobt(mp) ? M_IGEO(mp)->inobt_maxlevels : 0)
fs/xfs/xfs_inode.c +83 -6
146 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v7 21/27 xfs: Add parent pointers to xfs_cross_rename
In reply to [email protected]From: Allison Henderson <[email protected]>
Cross renames are handled separately from standard renames, and need different handling to update the parent attributes correctly.
--- fs/xfs/xfs_inode.c | 64 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 48 insertions(+), 16 deletions(-)
fs/xfs/xfs_inode.c +48 -16
@@ -2745,27 +2745,40 @@ xfs_finish_rename(*/ STATIC intxfs_cross_rename ( -struct xfs_trans *tp, -struct xfs_inode *dp1, -struct xfs_name *name1, -struct xfs_inode *ip1, -struct xfs_inode *dp2, -struct xfs_name *name2, -struct xfs_inode *ip2, -int spaceres) -{ -int error =0 ; -int ip1_flags =0 ; -int ip2_flags =0 ; -int dp2_flags =0 ; +struct xfs_trans *tp, +struct xfs_inode *dp1, +struct xfs_name *name1, +struct xfs_inode *ip1, +struct xfs_inode *dp2, +struct xfs_name *name2, +struct xfs_inode *ip2, +int spaceres) +{ +struct xfs_mount *mp = dp1->i_mount; +int error =0 ; +int ip1_flags =0 ; +int ip2_flags =0 ; +int dp2_flags =0 ; +int new_diroffset, old_diroffset; +struct xfs_parent_defer *parent_ptr =NULL ; +struct xfs_parent_defer *parent_ptr2 =NULL ; + +if (xfs_has_parent (mp)) { + error =xfs_parent_init (mp, &parent_ptr); +if (error) + goto out_trans_abort; + error =xfs_parent_init (mp, &parent_ptr2); +if (error) + goto out_trans_abort; + }/* Swap inode number for dirent in first parent */ - error =xfs_dir_replace (tp, dp1, name1, ip2->i_ino, spaceres,NULL ); + error =xfs_dir_replace (tp, dp1, name1, ip2->i_ino, spaceres, &old_diroffset);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,NULL ); + error =xfs_dir_replace (tp, dp2, name2, ip1->i_ino, spaceres, &new_diroffset);if (error) goto out_trans_abort;
@@ -2826,6 +2839,18 @@ xfs_cross_rename( } } +if (xfs_has_parent (mp)) { + error =xfs_parent_defer_replace (tp, parent_ptr, dp1, + old_diroffset, name2, dp2, new_diroffset, ip1); +if (error) + goto out_trans_abort; + + error =xfs_parent_defer_replace (tp, parent_ptr2, dp2, + new_diroffset, name1, dp1, old_diroffset, ip2); +if (error) + goto out_trans_abort; + } +if (ip1_flags) {xfs_trans_ichgtime (tp, ip1, ip1_flags);xfs_trans_log_inode (tp, ip1,XFS_ILOG_CORE );
@@ -2840,10 +2865,17 @@ xfs_cross_rename( }xfs_trans_ichgtime (tp, dp1,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG );xfs_trans_log_inode (tp, dp1,XFS_ILOG_CORE ); -return xfs_finish_rename (tp); + error =xfs_finish_rename (tp); + goto out; out_trans_abort:xfs_trans_cancel (tp); +out: +if (parent_ptr) +xfs_parent_cancel (mp, parent_ptr); +if (parent_ptr2) +xfs_parent_cancel (mp, parent_ptr2); +return error; }
Signature · 1 line
2.25.1
PATCH v7 22/27 xfs: Add the parent pointer support to the superblock version 5.
In reply to [email protected]From: Allison Henderson <[email protected]>
--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_sb.c | 4 ++++ fs/xfs/xfs_super.c | 4 ++++ 4 files changed, 12 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +3 -1
@@ -373,13 +373,15 @@ xfs_sb_has_ro_compat_feature(#define XFS_SB_FEAT_INCOMPAT_BIGTIME (1 << 3)/* large timestamps */ #define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4)/* needs xfs_repair */ #define XFS_SB_FEAT_INCOMPAT_NREXT64 (1 << 5)/* large extent counters */ +#define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 6)/* parent pointers */ #define XFS_SB_FEAT_INCOMPAT_ALL \ (XFS_SB_FEAT_INCOMPAT_FTYPE| \ XFS_SB_FEAT_INCOMPAT_SPINODES| \ XFS_SB_FEAT_INCOMPAT_META_UUID| \ XFS_SB_FEAT_INCOMPAT_BIGTIME| \ XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR| \ - XFS_SB_FEAT_INCOMPAT_NREXT64) + XFS_SB_FEAT_INCOMPAT_NREXT64| \ + XFS_SB_FEAT_INCOMPAT_PARENT)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline bool
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -237,6 +237,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_BIGTIME (1 << 21)/* 64-bit nsec timestamps */ #define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 23)/* large extent counters */ +#define XFS_FSOP_GEOM_FLAGS_PARENT (1 << 24)/* parent pointers */ /* * Minimum and maximum sizes need for growth checks.
fs/xfs/libxfs/xfs_sb.c +4 -0
@@ -173,6 +173,8 @@ xfs_sb_version_to_features( features |=XFS_FEAT_NEEDSREPAIR ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_NREXT64 ) features |=XFS_FEAT_NREXT64 ; +if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_PARENT ) + features |=XFS_FEAT_PARENT ;return features; }
@@ -1189,6 +1191,8 @@ xfs_fs_geometry( geo->flags |=XFS_FSOP_GEOM_FLAGS_BIGTIME ;if (xfs_has_inobtcounts (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_INOBTCNT ; +if (xfs_has_parent (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_PARENT ;if (xfs_has_sector (mp)) { geo->flags |=XFS_FSOP_GEOM_FLAGS_SECTOR ; geo->logsectsize = sbp->sb_logsectsize;
fs/xfs/xfs_super.c +4 -0
@@ -1663,6 +1663,10 @@ xfs_fs_fill_super(xfs_warn (mp,"EXPERIMENTAL Large extent counts feature in use. Use at your own risk!" ); +if (xfs_has_parent (mp)) +xfs_alert (mp, +"EXPERIMENTAL parent pointer feature enabled. Use at your own risk!" ); + error =xfs_mountfs (mp);if (error) goto out_filestream_unmount;
Signature · 1 line
2.25.1
PATCH v7 23/27 xfs: Add helper function xfs_attr_list_context_init
In reply to [email protected]From: Allison Henderson <[email protected]>
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.
--- fs/xfs/xfs_file.c | 1 + fs/xfs/xfs_ioctl.c | 54 ++++++++++++++++++++++++++++++++-------------- fs/xfs/xfs_ioctl.h | 2 ++ 3 files changed, 41 insertions(+), 16 deletions(-)
fs/xfs/xfs_file.c +1 -0
@@ -17,6 +17,7 @@#include "xfs_bmap_util.h" #include "xfs_dir2.h" #include "xfs_dir2_priv.h" +#include "xfs_attr.h" #include "xfs_ioctl.h" #include "xfs_trace.h" #include "xfs_log.h"
fs/xfs/xfs_ioctl.c +38 -16
72 lines not on this page · raw message
fs/xfs/xfs_ioctl.h +2 -0
@@ -35,6 +35,8 @@ int xfs_ioc_attrmulti_one(struct file *parfilp, struct inode *inode,int xfs_ioc_attr_list (struct xfs_inode *dp,void __user *ubuf,size_t bufsize,int flags,struct xfs_attrlist_cursor __user *ucursor); +int xfs_ioc_attr_list_context_init (struct xfs_inode *dp,char *buffer, +int bufsize,int flags,struct xfs_attr_list_context *context);extern struct dentry * xfs_handle_to_dentry(
Signature · 1 line
2.25.1
PATCH v7 24/27 xfs: Filter XFS_ATTR_PARENT for getfattr
In reply to [email protected]From: Allison Henderson <[email protected]>
Parent pointers returned to the get_fattr tool cause errors since the tool cannot parse parent pointers. Fix this by filtering parent parent pointers from xfs_xattr_put_listent.
--- fs/xfs/xfs_xattr.c | 3 +++ 1 file changed, 3 insertions(+)
fs/xfs/xfs_xattr.c +3 -0
@@ -234,6 +234,9 @@ xfs_xattr_put_listent(ASSERT (context->count >=0 ); +if (flags &XFS_ATTR_PARENT ) +return ; +if (flags &XFS_ATTR_ROOT ) {#ifdef CONFIG_XFS_POSIX_ACL if (namelen == SGI_ACL_FILE_SIZE &&
Signature · 1 line
2.25.1
PATCH v7 25/27 xfs: Add parent pointer ioctl
In reply to [email protected]From: Allison Henderson <[email protected]>
This patch adds a new file ioctl to retrieve the parent pointer of a given inode
--- fs/xfs/Makefile | 1 + fs/xfs/libxfs/xfs_fs.h | 74 ++++++++++++++++++++++ fs/xfs/libxfs/xfs_parent.c | 10 +++ fs/xfs/libxfs/xfs_parent.h | 2 + fs/xfs/xfs_ioctl.c | 94 +++++++++++++++++++++++++++- fs/xfs/xfs_ondisk.h | 4 ++ fs/xfs/xfs_parent_utils.c | 125 +++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_parent_utils.h | 11 ++++ 8 files changed, 320 insertions(+), 1 deletion(-)
fs/xfs/Makefile +1 -0
@@ -86,6 +86,7 @@ xfs-y += xfs_aops.o \ xfs_mount.o \ xfs_mru_cache.o \ xfs_pwork.o \ + xfs_parent_utils.o \ xfs_reflink.o \ xfs_stats.o \ xfs_super.o \
fs/xfs/libxfs/xfs_fs.h +74 -0
86 lines not on this page · raw message
fs/xfs/libxfs/xfs_parent.c +10 -0
@@ -27,6 +27,16 @@#include "xfs_parent.h" #include "xfs_trans_space.h" +/* Initializes a xfs_parent_ptr from an xfs_parent_name_rec */ +void +xfs_init_parent_ptr (struct xfs_parent_ptr *xpp, +const 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. *
fs/xfs/libxfs/xfs_parent.h +2 -0
@@ -24,6 +24,8 @@ void xfs_init_parent_name_rec(struct xfs_parent_name_rec *rec, uint32_t p_diroffset);void xfs_init_parent_name_irec (struct xfs_parent_name_irec *irec,struct xfs_parent_name_rec *rec); +void xfs_init_parent_ptr (struct xfs_parent_ptr *xpp, +const struct xfs_parent_name_rec *rec);int xfs_parent_init (xfs_mount_t *mp,struct xfs_parent_defer **parentp); int xfs_parent_defer_add(struct xfs_trans *tp, struct xfs_parent_defer *parent, struct xfs_inode *dp, struct xfs_name *parent_name,
fs/xfs/xfs_ioctl.c +93 -1
112 lines not on this page · raw message
fs/xfs/xfs_ondisk.h +4 -0
@@ -150,6 +150,10 @@ xfs_check_ondisk_structs(void) XFS_CHECK_OFFSET(struct xfs_efi_log_format_32, efi_extents, 16); XFS_CHECK_OFFSET(struct xfs_efi_log_format_64, efi_extents, 16); +/* parent pointer ioctls */ + XFS_CHECK_STRUCT_SIZE(struct xfs_parent_ptr, 280); + XFS_CHECK_STRUCT_SIZE(struct xfs_pptr_info, 104); +/* * The v5 superblock format extended several v4 header structures with * additional data. While new fields are only accessible on v5
fs/xfs/xfs_parent_utils.c new file +125 -0
125 lines not on this page · raw message
fs/xfs/xfs_parent_utils.h new file +11 -0
@@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2022 Oracle, Inc. +* All rights reserved. +*/ +#ifndef __XFS_PARENT_UTILS_H__ +#define __XFS_PARENT_UTILS_H__ + +int xfs_attr_get_parent_pointer (struct xfs_inode *ip, +struct xfs_pptr_info *ppi); +#endif /* __XFS_PARENT_UTILS_H__ */
Signature · 1 line
2.25.1
PATCH v7 26/27 xfs: fix unit conversion error in xfs_log_calc_max_attrsetm_res
In reply to [email protected]From: Allison Henderson <[email protected]>
Dave and I were discussing some recent test regressions as a result of me turning on nrext64=1 on realtime filesystems, when we noticed that the minimum log size of a 32M filesystem jumped from 954 blocks to 4287 blocks.
Digging through xfs_log_calc_max_attrsetm_res, Dave noticed that @size contains the maximum estimated amount of space needed for a local format xattr, in bytes, but we feed this quantity to XFS_NEXTENTADD_SPACE_RES, which requires units of blocks. This has resulted in an overestimation of the minimum log size over the years.
We should nominally correct this, but there's a backwards compatibility problem -- if we enable it now, the minimum log size will decrease. If a corrected mkfs formats a filesystem with this new smaller log size, a user will encounter mount failures on an uncorrected kernel due to the larger minimum log size computations there.
However, the large extent counters feature is still EXPERIMENTAL, so we can gate the correction on that feature (or any features that get added after that) being enabled. Any filesystem with nrext64 or any of the as-yet-undefined feature bits turned on will be rejected by old uncorrected kernels, so this should be safe even in the upgrade case.
--- fs/xfs/libxfs/xfs_log_rlimit.c | 43 ++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
fs/xfs/libxfs/xfs_log_rlimit.c +43 -0
@@ -16,6 +16,39 @@#include "xfs_bmap_btree.h" #include "xfs_trace.h" +/* +* Decide if the filesystem has the parent pointer feature or any feature +* added after that. +*/ +static inline bool +xfs_has_parent_or_newer_feature ( +struct xfs_mount *mp) +{ +if (!xfs_sb_is_v5 (&mp->m_sb)) +return false; + +if (xfs_sb_has_compat_feature (&mp->m_sb, ~0 )) +return true; + +if (xfs_sb_has_ro_compat_feature (&mp->m_sb, + ~(XFS_SB_FEAT_RO_COMPAT_FINOBT | +XFS_SB_FEAT_RO_COMPAT_RMAPBT | +XFS_SB_FEAT_RO_COMPAT_REFLINK | +XFS_SB_FEAT_RO_COMPAT_INOBTCNT ))) +return true; + +if (xfs_sb_has_incompat_feature (&mp->m_sb, + ~(XFS_SB_FEAT_INCOMPAT_FTYPE | +XFS_SB_FEAT_INCOMPAT_SPINODES | +XFS_SB_FEAT_INCOMPAT_META_UUID | +XFS_SB_FEAT_INCOMPAT_BIGTIME | +XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR | +XFS_SB_FEAT_INCOMPAT_NREXT64 ))) +return true; + +return false; +} +/* * Calculate the maximum length in bytes that would be required for a local * attribute value as large attributes out of line are not logged.
@@ -31,6 +64,16 @@ xfs_log_calc_max_attrsetm_res(MAXNAMELEN -1 ; nblks =XFS_DAENTER_SPACE_RES (mp,XFS_ATTR_FORK ); nblks +=XFS_B_TO_FSB (mp, size); + +/* +* Starting with the parent pointer feature, every new fs feature +* corrects a unit conversion error in the xattr transaction +* reservation code that resulted in oversized minimum log size +* computations. +*/ +if (xfs_has_parent_or_newer_feature (mp)) + size =XFS_B_TO_FSB (mp, size); + nblks +=XFS_NEXTENTADD_SPACE_RES (mp, size,XFS_ATTR_FORK ); return M_RES(mp)->tr_attrsetm.tr_logres +
Signature · 1 line
2.25.1
PATCH v7 27/27 xfs: drop compatibility minimum log size computations for reflink
In reply to [email protected]From: Allison Henderson <[email protected]>
Having established that we can reduce the minimum log size computation for filesystems with parent pointers or any newer feature, we should also drop the compat minlogsize code that we added when we reduced the transaction reservation size for rmap and reflink.
--- fs/xfs/libxfs/xfs_log_rlimit.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
fs/xfs/libxfs/xfs_log_rlimit.c +10 -0
@@ -91,6 +91,16 @@ xfs_log_calc_trans_resv_for_minlogblocks( {unsigned int rmap_maxlevels = mp->m_rmap_maxlevels; +/* +* Starting with the parent pointer feature, every new fs feature +* drops the oversized minimum log size computation introduced by the +* original reflink code. +*/ +if (xfs_has_parent_or_newer_feature (mp)) { +xfs_trans_resv_calc (mp, resv); +return ; + } +/* * In the early days of rmap+reflink, we always set the rmap maxlevels * to 9 even if the AG was small enough that it would never grow to
Signature · 1 line
2.25.1
Quoted 12 lines · On Sun, Dec 18, 2022 at 03:02:39AM -0700, [email protected] wrote:
From: Allison Henderson <[email protected]>
Hi all,
This is the latest 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, shrink, nfs handles, verity, or any other feature that could make use of quickly deriving an inodes path from the mount point.
Quoted 8 lines
This set can be viewed on github here
https://github.com/allisonhenderson/xfs/tree/xfs_new_pptrsv7And the corresponding xfsprogs code is here
https://github.com/allisonhenderson/xfsprogs/tree/xfsprogs_new_pptrs_v7This set has been tested with the below parent pointers tests
https://lore.kernel.org/fstests/[email protected]/T/#t
I pulled v7 and rebased your patches atop 6.2-rc3. generic/476 failed with quotas enabled:
XFS: Assertion failed: q[j].qt_dquot->q_id > d->q_id, file: fs/xfs/xfs_dquot.c, line: 1351 <repeat>
I suspect this is becuase xfs_dqlockn needs to sort the dqtrx structures by quotaid?
So I turned off quotas and the kernel quieted down. Good. :)
Next up was xfs_scrub, which complained about *something* in the xattr structures. I'm guessing that it probably doesn't know how to deal with the new pptr namespace or the zeroes that can be present in the pptr attr name?
Other than that, looks promising. I'll fix up the scrub and quota problems and start prototyping fsck code from there.
--D
Quoted 102 lines
Updates since v6:
Andry had reported intermittent hangs on unmount while running stress tests. Reviewed and corrected unlocks in the case of error conditions.xfs: parent pointer attribute creation
Fixed dp to unlock on errorxfs: Hold inode locks in
xfs_ialloc
Fixed ip to unlock on create errorxfs: add parent attributes to symlink
Hold and release dp across pptr operationQuestions comments and feedback appreciated!
Thanks all!
AllisonAllison Henderson (27):
xfs: Add new name to attri/d
xfs: IncreaseXFS_DEFER_OPS_NR_INODESto 5
xfs: IncreaseXFS_QM_TRANS_MAXDQSto 5
xfs: Hold inode locks inxfs_ialloc
xfs: Hold inode locks inxfs_trans_alloc_dir
xfs: Hold inode locks inxfs_rename
xfs: Exposeinit_xattrsinxfs_create_tmpfile
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
xfs: define parent pointer xattr format
xfs: Addxfs_verify_pptr
xfs: extend transaction reservations for parent attributes
xfs: parent pointer attribute creation
xfs: add parent attributes to link
xfs: add parent attributes to symlink
xfs: remove parent pointers in unlink
xfs: Indentxfs_rename
xfs: Add parent pointers to rename
xfs: Add parent pointers toxfs_cross_rename
xfs: Add the parent pointer support to the superblock version 5.
xfs: Add helper functionxfs_attr_list_context_init
xfs: FilterXFS_ATTR_PARENTfor getfattr
xfs: Add parent pointer ioctl
xfs: fix unit conversion error inxfs_log_calc_max_attrsetm_res
xfs: drop compatibility minimum log size computations for reflinkfs/xfs/Makefile | 2 + fs/xfs/libxfs/xfs_attr.c | 71 +++++- fs/xfs/libxfs/xfs_attr.h | 13 +- fs/xfs/libxfs/xfs_da_btree.h | 3 + fs/xfs/libxfs/xfs_da_format.h | 38 ++- fs/xfs/libxfs/xfs_defer.c | 28 ++- fs/xfs/libxfs/xfs_defer.h | 8 +- 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_format.h | 4 +- fs/xfs/libxfs/xfs_fs.h | 75 ++++++ fs/xfs/libxfs/xfs_log_format.h | 7 +- fs/xfs/libxfs/xfs_log_rlimit.c | 53 ++++ fs/xfs/libxfs/xfs_parent.c | 207 ++++++++++++++++ fs/xfs/libxfs/xfs_parent.h | 46 ++++ fs/xfs/libxfs/xfs_sb.c | 4 + fs/xfs/libxfs/xfs_trans_resv.c | 324 ++++++++++++++++++++---- fs/xfs/libxfs/xfs_trans_space.h | 8 - fs/xfs/scrub/attr.c | 2 +- fs/xfs/xfs_attr_item.c | 142 +++++++++-- fs/xfs/xfs_attr_item.h | 1 + fs/xfs/xfs_attr_list.c | 17 +- fs/xfs/xfs_dquot.c | 25 ++ fs/xfs/xfs_dquot.h | 1 + fs/xfs/xfs_file.c | 1 + fs/xfs/xfs_inode.c | 427 +++++++++++++++++++++++++------- fs/xfs/xfs_inode.h | 3 +- fs/xfs/xfs_ioctl.c | 148 +++++++++-- fs/xfs/xfs_ioctl.h | 2 + fs/xfs/xfs_iops.c | 3 +- fs/xfs/xfs_ondisk.h | 4 + fs/xfs/xfs_parent_utils.c | 125 ++++++++++ fs/xfs/xfs_parent_utils.h | 11 + fs/xfs/xfs_qm.c | 4 +- fs/xfs/xfs_qm.h | 2 +- fs/xfs/xfs_super.c | 4 + fs/xfs/xfs_symlink.c | 58 ++++- fs/xfs/xfs_trans.c | 6 +- fs/xfs/xfs_trans_dquot.c | 15 +- fs/xfs/xfs_xattr.c | 5 +- fs/xfs/xfs_xattr.h | 1 + 45 files changed, 1712 insertions(+), 245 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_parent.c create mode 100644 fs/xfs/libxfs/xfs_parent.h create mode 100644 fs/xfs/xfs_parent_utils.c create mode 100644 fs/xfs/xfs_parent_utils.hSignature · 1 line
2.25.1
Quoted 33 lines · Darrick J. Wong
Quoted 12 lines · On Sun, Dec 18, 2022 at 03:02:39AM -0700, [email protected] wrote:
From: Allison Henderson <[email protected]>
Hi all,
This is the latest 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, shrink, nfs handles, verity, or any other feature that could make use of quickly deriving an inodes path from the mount point.Quoted 8 lines
This set can be viewed on github here
https://github.com/allisonhenderson/xfs/tree/xfs_new_pptrsv7And the corresponding xfsprogs code is here
https://github.com/allisonhenderson/xfsprogs/tree/xfsprogs_new_pptrs_v7This set has been tested with the below parent pointers tests
https://lore.kernel.org/fstests/[email protected]/T/#tI pulled v7 and rebased your patches atop 6.2-rc3. generic/476 failed with quotas enabled:
XFS: Assertion failed: q[j].qt_dquot->q_id >
d->q_id, file:fs/xfs/xfs_dquot.c, line: 1351 <repeat>I suspect this is becuase
xfs_dqlocknneeds to sort the dqtrx structures by quotaid?So I turned off quotas and the kernel quieted down. Good. :)
Quoted 7 lines
Next up was
xfs_scrub, which complained about *something* in the xattr structures. I'm guessing that it probably doesn't know how to deal with the new pptr namespace or the zeroes that can be present in the pptr attr name?Other than that, looks promising. I'll fix up the scrub and quota problems and start prototyping fsck code from there.
Second followup: two of the fstest vms are stuck spinning in unmount on xfs/113; and the other two are stuck trying to grab ilocks in generic/681 and generic/682.
--D
Quoted 104 lines
--D
Quoted 102 lines
Updates since v6:
Andry had reported intermittent hangs on unmount while running stress tests. Reviewed and corrected unlocks in the case of error conditions.xfs: parent pointer attribute creation
Fixed dp to unlock on errorxfs: Hold inode locks in
xfs_ialloc
Fixed ip to unlock on create errorxfs: add parent attributes to symlink
Hold and release dp across pptr operationQuestions comments and feedback appreciated!
Thanks all!
AllisonAllison Henderson (27):
xfs: Add new name to attri/d
xfs: IncreaseXFS_DEFER_OPS_NR_INODESto 5
xfs: IncreaseXFS_QM_TRANS_MAXDQSto 5
xfs: Hold inode locks inxfs_ialloc
xfs: Hold inode locks inxfs_trans_alloc_dir
xfs: Hold inode locks inxfs_rename
xfs: Exposeinit_xattrsinxfs_create_tmpfile
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
xfs: define parent pointer xattr format
xfs: Addxfs_verify_pptr
xfs: extend transaction reservations for parent attributes
xfs: parent pointer attribute creation
xfs: add parent attributes to link
xfs: add parent attributes to symlink
xfs: remove parent pointers in unlink
xfs: Indentxfs_rename
xfs: Add parent pointers to rename
xfs: Add parent pointers toxfs_cross_rename
xfs: Add the parent pointer support to the superblock version 5.
xfs: Add helper functionxfs_attr_list_context_init
xfs: FilterXFS_ATTR_PARENTfor getfattr
xfs: Add parent pointer ioctl
xfs: fix unit conversion error inxfs_log_calc_max_attrsetm_res
xfs: drop compatibility minimum log size computations for reflinkfs/xfs/Makefile | 2 + fs/xfs/libxfs/xfs_attr.c | 71 +++++- fs/xfs/libxfs/xfs_attr.h | 13 +- fs/xfs/libxfs/xfs_da_btree.h | 3 + fs/xfs/libxfs/xfs_da_format.h | 38 ++- fs/xfs/libxfs/xfs_defer.c | 28 ++- fs/xfs/libxfs/xfs_defer.h | 8 +- 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_format.h | 4 +- fs/xfs/libxfs/xfs_fs.h | 75 ++++++ fs/xfs/libxfs/xfs_log_format.h | 7 +- fs/xfs/libxfs/xfs_log_rlimit.c | 53 ++++ fs/xfs/libxfs/xfs_parent.c | 207 ++++++++++++++++ fs/xfs/libxfs/xfs_parent.h | 46 ++++ fs/xfs/libxfs/xfs_sb.c | 4 + fs/xfs/libxfs/xfs_trans_resv.c | 324 ++++++++++++++++++++---- fs/xfs/libxfs/xfs_trans_space.h | 8 - fs/xfs/scrub/attr.c | 2 +- fs/xfs/xfs_attr_item.c | 142 +++++++++-- fs/xfs/xfs_attr_item.h | 1 + fs/xfs/xfs_attr_list.c | 17 +- fs/xfs/xfs_dquot.c | 25 ++ fs/xfs/xfs_dquot.h | 1 + fs/xfs/xfs_file.c | 1 + fs/xfs/xfs_inode.c | 427 +++++++++++++++++++++++++------- fs/xfs/xfs_inode.h | 3 +- fs/xfs/xfs_ioctl.c | 148 +++++++++-- fs/xfs/xfs_ioctl.h | 2 + fs/xfs/xfs_iops.c | 3 +- fs/xfs/xfs_ondisk.h | 4 + fs/xfs/xfs_parent_utils.c | 125 ++++++++++ fs/xfs/xfs_parent_utils.h | 11 + fs/xfs/xfs_qm.c | 4 +- fs/xfs/xfs_qm.h | 2 +- fs/xfs/xfs_super.c | 4 + fs/xfs/xfs_symlink.c | 58 ++++- fs/xfs/xfs_trans.c | 6 +- fs/xfs/xfs_trans_dquot.c | 15 +- fs/xfs/xfs_xattr.c | 5 +- fs/xfs/xfs_xattr.h | 1 + 45 files changed, 1712 insertions(+), 245 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_parent.c create mode 100644 fs/xfs/libxfs/xfs_parent.h create mode 100644 fs/xfs/xfs_parent_utils.c create mode 100644 fs/xfs/xfs_parent_utils.hSignature · 1 line
2.25.1