xfs: the rest of online repair part 1
Subsystems (3)
PATCH 4/4 xfs: hook live rmap operations during a repair operation
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Hook the regular rmap code when an rmapbt repair operation is running so that we can unlock the AGF buffer to scan the filesystem and keep the in-memory btree up to date during the scan.
--- fs/xfs/libxfs/xfs_ag.c | 1 fs/xfs/libxfs/xfs_ag.h | 3 + fs/xfs/libxfs/xfs_rmap.c | 145 ++++++++++++++++++++++++++++++++---------- fs/xfs/libxfs/xfs_rmap.h | 28 ++++++++ fs/xfs/scrub/common.c | 3 + fs/xfs/scrub/repair.c | 36 ++++++++++ fs/xfs/scrub/repair.h | 4 + fs/xfs/scrub/rmap_repair.c | 153 ++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/scrub/scrub.c | 4 + fs/xfs/scrub/scrub.h | 4 + fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 47 ++++++++++++++ 12 files changed, 389 insertions(+), 40 deletions(-)
fs/xfs/libxfs/xfs_ag.c +1 -0
@@ -392,6 +392,7 @@ xfs_initialize_perag(init_waitqueue_head (&pag->pag_active_wq); pag->pagb_count =0 ; pag->pagb_tree =RB_ROOT ; +xfs_hooks_init (&pag->pag_rmap_update_hooks);#endif /* __KERNEL__ */ error =xfs_buf_cache_init (&pag->pag_bcache);
fs/xfs/libxfs/xfs_ag.h +3 -0
@@ -117,6 +117,9 @@ struct xfs_perag {* inconsistencies. */ struct xfs_defer_drain pag_intents_drain; + +/* Hook to feed rmapbt updates to an active online repair. */ +struct xfs_hooks pag_rmap_update_hooks;#endif /* __KERNEL__ */ };
fs/xfs/libxfs/xfs_rmap.c +112 -33
176 lines not on this page · raw message
fs/xfs/libxfs/xfs_rmap.h +28 -0
@@ -186,6 +186,10 @@ void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp, struct xfs_btree_cur *rcur, int error);int xfs_rmap_finish_one (struct xfs_trans *tp,struct xfs_rmap_intent *ri,struct xfs_btree_cur **pcur); +int __xfs_rmap_finish_intent (struct xfs_btree_cur *rcur, +enum xfs_rmap_intent_type op,xfs_agblock_t bno, +xfs_extlen_t len,const struct xfs_owner_info *oinfo, +bool unwritten); int xfs_rmap_lookup_le_range(struct xfs_btree_cur *cur, xfs_agblock_t bno, uint64_t owner, uint64_t offset, unsigned int flags,
@@ -235,4 +239,28 @@ extern struct kmem_cache *xfs_rmap_intent_cache;int __init xfs_rmap_intent_init_cache (void );void xfs_rmap_intent_destroy_cache (void ); +/* +* Parameters for tracking reverse mapping changes. The hook function arg +* parameter is enum xfs_rmap_intent_type, and the rest is below. +*/ +struct xfs_rmap_update_params { +xfs_agblock_t startblock; +xfs_extlen_t blockcount; +struct xfs_owner_info oinfo; +bool unwritten; +}; + +#ifdef CONFIG_XFS_LIVE_HOOKS + +struct xfs_rmap_hook { +struct xfs_hook update_hook; +}; + +void xfs_rmap_hook_disable (void ); +void xfs_rmap_hook_enable (void ); + +int xfs_rmap_hook_add (struct xfs_perag *pag,struct xfs_rmap_hook *hook); +void xfs_rmap_hook_del (struct xfs_perag *pag,struct xfs_rmap_hook *hook); +#endif +#endif /* __XFS_RMAP_H__ */
fs/xfs/scrub/common.c +3 -0
@@ -1305,6 +1305,9 @@ xchk_fsgates_enable(if (scrub_fsgates &XCHK_FSGATES_DIRENTS )xfs_dir_hook_enable (); +if (scrub_fsgates &XCHK_FSGATES_RMAP ) +xfs_rmap_hook_enable (); + sc->flags |= scrub_fsgates; }
fs/xfs/scrub/repair.c +36 -0
@@ -1165,3 +1165,39 @@ xrep_setup_buftarg(return xfile_alloc_buftarg (sc->mp, descr, &sc->xfile_buftarg); } + +/* +* Create a dummy transaction for use in a live update hook function. This +* function MUST NOT be called from regular repair code because the current +* process' transaction is saved via the cookie. +*/ +int +xrep_trans_alloc_hook_dummy ( +struct xfs_mount *mp, +void **cookiep, +struct xfs_trans **tpp) +{ +int error; + + *cookiep = current->journal_info; + current->journal_info =NULL ; + + error =xfs_trans_alloc_empty (mp, tpp); +if (!error) +return 0 ; + + current->journal_info = *cookiep; + *cookiep =NULL ; +return error; +} + +/* Cancel a dummy transaction used by a live update hook function. */ +void +xrep_trans_cancel_hook_dummy ( +void **cookiep, +struct xfs_trans *tp) +{ +xfs_trans_cancel (tp); + current->journal_info = *cookiep; + *cookiep =NULL ; +}
fs/xfs/scrub/repair.h +4 -0
@@ -140,6 +140,10 @@ int xrep_quotacheck(struct xfs_scrub *sc);int xrep_reinit_pagf (struct xfs_scrub *sc);int xrep_reinit_pagi (struct xfs_scrub *sc); +int xrep_trans_alloc_hook_dummy (struct xfs_mount *mp,void **cookiep, +struct xfs_trans **tpp); +void xrep_trans_cancel_hook_dummy (void **cookiep,struct xfs_trans *tp); +#else #define xrep_ino_dqattach (sc) (0)
fs/xfs/scrub/rmap_repair.c +147 -6
230 lines not on this page · raw message
fs/xfs/scrub/scrub.c +4 -0
@@ -16,6 +16,7 @@#include "xfs_qm.h" #include "xfs_scrub.h" #include "xfs_buf_xfile.h" +#include "xfs_rmap.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -164,6 +165,9 @@ xchk_fsgates_disable(if (sc->flags &XCHK_FSGATES_DIRENTS )xfs_dir_hook_disable (); +if (sc->flags &XCHK_FSGATES_RMAP ) +xfs_rmap_hook_disable (); + sc->flags &= ~XCHK_FSGATES_ALL ; }
fs/xfs/scrub/scrub.h +3 -1
@@ -126,6 +126,7 @@ struct xfs_scrub {#define XCHK_NEED_DRAIN (1U << 3)/* scrub needs to drain defer ops */ #define XCHK_FSGATES_QUOTA (1U << 4)/* quota live update enabled */ #define XCHK_FSGATES_DIRENTS (1U << 5)/* directory live update enabled */ +#define XCHK_FSGATES_RMAP (1U << 6)/* rmapbt live update enabled */ #define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */
@@ -137,7 +138,8 @@ struct xfs_scrub {*/ #define XCHK_FSGATES_ALL (XCHK_FSGATES_DRAIN | \ XCHK_FSGATES_QUOTA | \ - XCHK_FSGATES_DIRENTS) + XCHK_FSGATES_DIRENTS | \ + XCHK_FSGATES_RMAP)/* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);
fs/xfs/scrub/trace.c +1 -0
@@ -19,6 +19,7 @@#include "xfs_quota_defs.h" #include "xfs_da_format.h" #include "xfs_dir2.h" +#include "xfs_rmap.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h"
fs/xfs/scrub/trace.h +47 -0
65 lines not on this page · raw message
PATCH 10/28 xfs: move btree geometry to ops struct
In reply to Darrick J. WongHi all,
This patchset prepares the generic btree code to allow for the creation of new btree types outside of libxfs. The end goal here is for online fsck to be able to create its own in-memory btrees that will be used to improve the performance (and reduce the memory requirements of) the refcount btree.
To enable this, I decided that the btree ops structure is the ideal place to encode all of the geometry information about a btree. The btree ops struture already contains the buffer ops (and hence the btree block magic numbers) as well as the key and record sizes, so it doesn't seem all that farfetched to encode the XFS_BTREE_ flags that determine the geometry (ROOT_IN_INODE, LONG_PTRS, etc).
The rest of the patchset cleans up the btree functions that initialize btree blocks and btree buffers. The bulk of this work is to replace btree geometry related function call arguments with a single pointer to the ops structure, and then clean up everything else around that. As a side effect, we rename the functions.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=btree-geometry-in-ops
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=btree-geometry-in-ops
--- fs/xfs/libxfs/xfs_ag.c | 33 +++++++---------- fs/xfs/libxfs/xfs_ag.h | 2 + fs/xfs/libxfs/xfs_alloc_btree.c | 21 ++++------- fs/xfs/libxfs/xfs_bmap.c | 9 +---- fs/xfs/libxfs/xfs_bmap_btree.c | 14 ++----- fs/xfs/libxfs/xfs_btree.c | 70 +++++++++++++++++++----------------- fs/xfs/libxfs/xfs_btree.h | 36 ++++++++----------- fs/xfs/libxfs/xfs_btree_mem.h | 9 ----- fs/xfs/libxfs/xfs_btree_staging.c | 6 +-- fs/xfs/libxfs/xfs_ialloc_btree.c | 17 ++++----- fs/xfs/libxfs/xfs_refcount_btree.c | 8 ++-- fs/xfs/libxfs/xfs_rmap_btree.c | 16 ++++---- fs/xfs/libxfs/xfs_shared.h | 9 +++++ fs/xfs/scrub/trace.h | 10 ++--- fs/xfs/scrub/xfbtree.c | 16 +++----- 15 files changed, 118 insertions(+), 158 deletions(-)
PATCH 1/9 xfs: set the btree cursor bc_ops in xfs_btree_alloc_cursor
From: Darrick J. Wong <[email protected]>
This is a precursor to putting more static data in the btree ops structure.
--- fs/xfs/libxfs/xfs_alloc_btree.c | 11 +++++------ fs/xfs/libxfs/xfs_bmap_btree.c | 3 +-- fs/xfs/libxfs/xfs_btree.h | 2 ++ fs/xfs/libxfs/xfs_ialloc_btree.c | 10 ++++++---- fs/xfs/libxfs/xfs_refcount_btree.c | 4 ++-- fs/xfs/libxfs/xfs_rmap_btree.c | 7 +++---- fs/xfs/scrub/xfbtree.c | 4 ++-- 7 files changed, 21 insertions(+), 20 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +5 -6
@@ -512,18 +512,17 @@ xfs_allocbt_init_common(ASSERT (btnum ==XFS_BTNUM_BNO || btnum ==XFS_BTNUM_CNT ); - cur =xfs_btree_alloc_cursor (mp, tp, btnum, mp->m_alloc_maxlevels, - xfs_allocbt_cur_cache); - cur->bc_ag.abt.active = false; -if (btnum ==XFS_BTNUM_CNT ) { - cur->bc_ops = &xfs_cntbt_ops; + cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_cntbt_ops, + mp->m_alloc_maxlevels, xfs_allocbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); cur->bc_flags =XFS_BTREE_LASTREC_UPDATE ; }else { - cur->bc_ops = &xfs_bnobt_ops; + cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_bnobt_ops, + mp->m_alloc_maxlevels, xfs_allocbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); } + cur->bc_ag.abt.active = false; cur->bc_ag.pag =xfs_perag_hold (pag);
fs/xfs/libxfs/xfs_bmap_btree.c +1 -2
@@ -549,11 +549,10 @@ xfs_bmbt_init_common(ASSERT (whichfork !=XFS_COW_FORK ); - cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_BMAP , + cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_BMAP , &xfs_bmbt_ops, mp->m_bm_maxlevels[whichfork], xfs_bmbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_bmbt_2); - cur->bc_ops = &xfs_bmbt_ops; cur->bc_flags =XFS_BTREE_LONG_PTRS |XFS_BTREE_ROOT_IN_INODE ;if (xfs_has_crc (mp)) cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ;
fs/xfs/libxfs/xfs_btree.h +2 -0
@@ -737,12 +737,14 @@ xfs_btree_alloc_cursor(struct xfs_mount *mp, struct xfs_trans *tp, xfs_btnum_t btnum, + const struct xfs_btree_ops *ops, uint8_t maxlevels, struct kmem_cache *cache) { struct xfs_btree_cur *cur; cur =kmem_cache_zalloc (cache,GFP_NOFS | __GFP_NOFAIL); + cur->bc_ops = ops; cur->bc_tp = tp; cur->bc_mp = mp; cur->bc_btnum = btnum;
fs/xfs/libxfs/xfs_ialloc_btree.c +6 -4
@@ -454,14 +454,16 @@ xfs_inobt_init_common(struct xfs_mount *mp = pag->pag_mount;struct xfs_btree_cur *cur; - cur =xfs_btree_alloc_cursor (mp, tp, btnum, -M_IGEO (mp)->inobt_maxlevels, xfs_inobt_cur_cache);if (btnum ==XFS_BTNUM_INO ) { + cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_inobt_ops, +M_IGEO (mp)->inobt_maxlevels, + xfs_inobt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_ibt_2); - cur->bc_ops = &xfs_inobt_ops; }else { + cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_finobt_ops, +M_IGEO (mp)->inobt_maxlevels, + xfs_inobt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_fibt_2); - cur->bc_ops = &xfs_finobt_ops; }if (xfs_has_crc (mp))
fs/xfs/libxfs/xfs_refcount_btree.c +2 -2
@@ -353,7 +353,8 @@ xfs_refcountbt_init_common(ASSERT (pag->pag_agno < mp->m_sb.sb_agcount); cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_REFC , - mp->m_refc_maxlevels, xfs_refcountbt_cur_cache); + &xfs_refcountbt_ops, mp->m_refc_maxlevels, + xfs_refcountbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_refcbt_2); cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ;
@@ -361,7 +362,6 @@ xfs_refcountbt_init_common( cur->bc_ag.pag =xfs_perag_hold (pag); cur->bc_ag.refc.nr_ops =0 ; cur->bc_ag.refc.shape_changes =0 ; - cur->bc_ops = &xfs_refcountbt_ops;return cur; }
fs/xfs/libxfs/xfs_rmap_btree.c +3 -4
@@ -517,11 +517,10 @@ xfs_rmapbt_init_common(struct xfs_btree_cur *cur;/* Overlapping btree; 2 keys per pointer. */ - cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_RMAP , + cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_RMAP , &xfs_rmapbt_ops, mp->m_rmap_maxlevels, xfs_rmapbt_cur_cache); cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING ; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); - cur->bc_ops = &xfs_rmapbt_ops; cur->bc_ag.pag =xfs_perag_hold (pag);return cur;
@@ -646,11 +645,11 @@ xfs_rmapbt_mem_cursor(/* Overlapping btree; 2 keys per pointer. */ cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_RMAP , - mp->m_rmap_maxlevels, xfs_rmapbt_cur_cache); + &xfs_rmapbt_mem_ops, mp->m_rmap_maxlevels, + xfs_rmapbt_cur_cache); cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING |XFS_BTREE_IN_XFILE ; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); - cur->bc_ops = &xfs_rmapbt_mem_ops; cur->bc_mem.xfbtree = xfbtree; cur->bc_mem.head_bp = head_bp; cur->bc_nlevels =xfs_btree_mem_head_nlevels (head_bp);
fs/xfs/scrub/xfbtree.c +2 -2
@@ -289,11 +289,11 @@ xfbtree_dup_cursor(ASSERT (cur->bc_flags &XFS_BTREE_IN_XFILE ); ncur =xfs_btree_alloc_cursor (cur->bc_mp, cur->bc_tp, cur->bc_btnum, - cur->bc_maxlevels, cur->bc_cache); + cur->bc_ops, cur->bc_maxlevels, cur->bc_cache); ncur->bc_flags = cur->bc_flags; ncur->bc_nlevels = cur->bc_nlevels; ncur->bc_statoff = cur->bc_statoff; - ncur->bc_ops = cur->bc_ops; +memcpy (&ncur->bc_mem, &cur->bc_mem,sizeof (cur->bc_mem));if (cur->bc_mem.pag)
Re: [PATCH 1/9] xfs: set the btree cursor bc_ops in xfs_btree_alloc_cursor
Looks good:
PATCH 2/9 xfs: encode the default bc_flags in the btree ops structure
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Certain btree flags never change for the life of a btree cursor because they describe the geometry of the btree itself. Encode these in the btree ops structure and reduce the amount of code required in each btree type's init_cursor functions.
--- fs/xfs/libxfs/xfs_alloc_btree.c | 8 ++------ fs/xfs/libxfs/xfs_bmap_btree.c | 5 +---- fs/xfs/libxfs/xfs_btree.h | 6 ++++++ fs/xfs/libxfs/xfs_ialloc_btree.c | 3 --- fs/xfs/libxfs/xfs_refcount_btree.c | 2 -- fs/xfs/libxfs/xfs_rmap_btree.c | 6 +++--- 6 files changed, 12 insertions(+), 18 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +2 -6
@@ -480,6 +480,7 @@ static const struct xfs_btree_ops xfs_bnobt_ops = {static const struct xfs_btree_ops xfs_cntbt_ops = { .rec_len =sizeof (xfs_alloc_rec_t), .key_len =sizeof (xfs_alloc_key_t), + .geom_flags =XFS_BTREE_LASTREC_UPDATE , .dup_cursor = xfs_allocbt_dup_cursor, .set_root = xfs_allocbt_set_root,
@@ -516,19 +517,14 @@ xfs_allocbt_init_common( cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_cntbt_ops, mp->m_alloc_maxlevels, xfs_allocbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); - cur->bc_flags =XFS_BTREE_LASTREC_UPDATE ; }else { cur =xfs_btree_alloc_cursor (mp, tp, btnum, &xfs_bnobt_ops, mp->m_alloc_maxlevels, xfs_allocbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); } - cur->bc_ag.abt.active = false; cur->bc_ag.pag =xfs_perag_hold (pag); - -if (xfs_has_crc (mp)) - cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - + cur->bc_ag.abt.active = false;return cur; }
fs/xfs/libxfs/xfs_bmap_btree.c +1 -4
@@ -518,6 +518,7 @@ xfs_bmbt_keys_contiguous(static const struct xfs_btree_ops xfs_bmbt_ops = { .rec_len =sizeof (xfs_bmbt_rec_t), .key_len =sizeof (xfs_bmbt_key_t), + .geom_flags =XFS_BTREE_LONG_PTRS |XFS_BTREE_ROOT_IN_INODE , .dup_cursor = xfs_bmbt_dup_cursor, .update_cursor = xfs_bmbt_update_cursor,
@@ -553,10 +554,6 @@ xfs_bmbt_init_common( mp->m_bm_maxlevels[whichfork], xfs_bmbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_bmbt_2); - cur->bc_flags =XFS_BTREE_LONG_PTRS |XFS_BTREE_ROOT_IN_INODE ; -if (xfs_has_crc (mp)) - cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - cur->bc_ino.ip = ip; cur->bc_ino.allocated =0 ; cur->bc_ino.flags =0 ;
fs/xfs/libxfs/xfs_btree.h +6 -0
@@ -116,6 +116,9 @@ struct xfs_btree_ops {size_t key_len;size_t rec_len; +/* XFS_BTREE_* flags that determine the geometry of the btree */ +unsigned int geom_flags; +/* cursor operations */ struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *); void (*update_cursor)(struct xfs_btree_cur *src,
@@ -750,6 +753,9 @@ xfs_btree_alloc_cursor( cur->bc_btnum = btnum; cur->bc_maxlevels = maxlevels; cur->bc_cache = cache; + cur->bc_flags = ops->geom_flags; +if (xfs_has_crc (mp)) + cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ;return cur; }
fs/xfs/libxfs/xfs_ialloc_btree.c +0 -3
@@ -466,9 +466,6 @@ xfs_inobt_init_common( cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_fibt_2); } -if (xfs_has_crc (mp)) - cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - cur->bc_ag.pag =xfs_perag_hold (pag);return cur; }
fs/xfs/libxfs/xfs_refcount_btree.c +0 -2
@@ -357,8 +357,6 @@ xfs_refcountbt_init_common( xfs_refcountbt_cur_cache); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_refcbt_2); - cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - cur->bc_ag.pag =xfs_perag_hold (pag); cur->bc_ag.refc.nr_ops =0 ; cur->bc_ag.refc.shape_changes =0 ;
fs/xfs/libxfs/xfs_rmap_btree.c +3 -3
@@ -489,6 +489,7 @@ xfs_rmapbt_keys_contiguous(static const struct xfs_btree_ops xfs_rmapbt_ops = { .rec_len =sizeof (struct xfs_rmap_rec ), .key_len =2 *sizeof (struct xfs_rmap_key ), + .geom_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING , .dup_cursor = xfs_rmapbt_dup_cursor, .set_root = xfs_rmapbt_set_root,
@@ -519,7 +520,6 @@ xfs_rmapbt_init_common(/* Overlapping btree; 2 keys per pointer. */ cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_RMAP , &xfs_rmapbt_ops, mp->m_rmap_maxlevels, xfs_rmapbt_cur_cache); - cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING ; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); cur->bc_ag.pag =xfs_perag_hold (pag);
@@ -613,6 +613,8 @@ static const struct xfs_buf_ops xfs_rmapbt_mem_buf_ops = {static const struct xfs_btree_ops xfs_rmapbt_mem_ops = { .rec_len =sizeof (struct xfs_rmap_rec ), .key_len =2 *sizeof (struct xfs_rmap_key ), + .geom_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING | +XFS_BTREE_IN_XFILE , .dup_cursor = xfbtree_dup_cursor, .set_root = xfbtree_set_root,
@@ -647,8 +649,6 @@ xfs_rmapbt_mem_cursor( cur =xfs_btree_alloc_cursor (mp, tp,XFS_BTNUM_RMAP , &xfs_rmapbt_mem_ops, mp->m_rmap_maxlevels, xfs_rmapbt_cur_cache); - cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING | -XFS_BTREE_IN_XFILE ; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); cur->bc_mem.xfbtree = xfbtree; cur->bc_mem.head_bp = head_bp;
Re: [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Certain btree flags never change for the life of a btree cursor because they describe the geometry of the btree itself. Encode these in the btree ops structure and reduce the amount of code required in each btree type's
init_cursorfunctions.
I like the idea, but why are the geom_flags mirrored into bc_flags instead of beeing kept entirely separate and accessed as cur->bc_ops->geom_flags which would be a lot easier to follow?
Re: [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure
Quoted 11 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Certain btree flags never change for the life of a btree cursor because they describe the geometry of the btree itself. Encode these in the btree ops structure and reduce the amount of code required in each btree type's
init_cursorfunctions.I like the idea, but why are the
geom_flagsmirrored intobc_flagsinstead of beeing kept entirely separate and accessed ascur->bc_ops->geom_flagswhich would be a lot easier to follow?
Oh! That hadn't occurred to me. Let me take a look at that.
--D
Re: [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure
Quoted 9 lines · Darrick J. Wong
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Certain btree flags never change for the life of a btree cursor because they describe the geometry of the btree itself. Encode these in the btree ops structure and reduce the amount of code required in each btree type's
init_cursorfunctions.
Quoted 5 lines
Quoted 3 lines
I like the idea, but why are the
geom_flagsmirrored intobc_flagsinstead of beeing kept entirely separate and accessed ascur->bc_ops->geom_flagswhich would be a lot easier to follow?Oh! That hadn't occurred to me. Let me take a look at that.
Eeeeyugh, this became kind of a mess. These XFS_BTREE_ flags describe btree geometry, are set in the bc_ops->geom_flags, and never change:
1. XFS_BTREE_LONG_PTRS
2. XFS_BTREE_ROOT_IN_INODE
3. XFS_BTREE_IROOT_RECORDS /* rt rmap patchset */
4. XFS_BTREE_IN_XFILE
5. XFS_BTREE_OVERLAPPING
This one flag describes geometry but is set dynamically by xfs_btree_alloc_cursor. Some of the geom_flags (rmap, refcount) can set it directly too, since they don't exist in V4 filesystems:
6. XFS_BTREE_CRC_BLOCKS
This one flag doesn't describe btree geometry but never changes and could be set in bc_ops->geom_flags:
7. XFS_BTREE_LASTREC_UPDATE
The remaining flag actually describes per-cursor state:
8. XFS_BTREE_STAGING
Flags 1-5 can be referenced directly from geom_flags.
Flag 6 could be replaced by an xfs_has_crc call, though I'd bet it's cheaper to test a cursor variable than to walk to the xfs_mount and test_bit. But this feels weird.
Flag 7 is set in geom_flags as it should be.
Flag 8 is really a runtime flag, so it can stay in bc_flags.
*or* I could rename geom_flags to default_bcflags and make it clearer that it's used to seed cur->bc_flags?
--D
Re: [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure
Quoted 46 lines · Darrick J. Wong
Quoted 9 lines · Darrick J. Wong
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Certain btree flags never change for the life of a btree cursor because they describe the geometry of the btree itself. Encode these in the btree ops structure and reduce the amount of code required in each btree type's
init_cursorfunctions.Quoted 5 lines
Quoted 3 lines
I like the idea, but why are the
geom_flagsmirrored intobc_flagsinstead of beeing kept entirely separate and accessed ascur->bc_ops->geom_flagswhich would be a lot easier to follow?Oh! That hadn't occurred to me. Let me take a look at that.
Eeeeyugh, this became kind of a mess. These
XFS_BTREE_flags describe btree geometry, are set in thebc_ops->geom_flags, and never change:1.
XFS_BTREE_LONG_PTRS
2.XFS_BTREE_ROOT_IN_INODE
3.XFS_BTREE_IROOT_RECORDS/* rt rmap patchset */
4.XFS_BTREE_IN_XFILE
5.XFS_BTREE_OVERLAPPINGThis one flag describes geometry but is set dynamically by
xfs_btree_alloc_cursor. Some of thegeom_flags(rmap, refcount) can set it directly too, since they don't exist in V4 filesystems:6.
XFS_BTREE_CRC_BLOCKSThis one flag doesn't describe btree geometry but never changes and could be set in
bc_ops->geom_flags:7.
XFS_BTREE_LASTREC_UPDATEThe remaining flag actually describes per-cursor state:
8.
XFS_BTREE_STAGINGFlags 1-5 can be referenced directly from
geom_flags.Flag 6 could be replaced by an
xfs_has_crccall, though I'd bet it's cheaper to test a cursor variable than to walk to thexfs_mountandtest_bit. But this feels weird.
Quoted 6 lines
Flag 7 is set in
geom_flagsas it should be.Flag 8 is really a runtime flag, so it can stay in
bc_flags.*or* I could rename
geom_flagstodefault_bcflagsand make it clearer that it's used to seedcur->bc_flags?
*or* I could define a separate struct xfs_btree_ops for the bnobt/cntbt/inobt/bmbt for V4 filesystems.
--D
Quoted 3 lines
--D
Re: [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure
Quoted 2 lines · Darrick J. Wong
*or* I could define a separate struct
xfs_btree_opsfor the bnobt/cntbt/inobt/bmbt for V4 filesystems.
That actually sounds nice, and might allow for some pre-calculation of maxrec/minxrec eventually.
PATCH 3/9 xfs: export some of the btree ops structures
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Export these btree ops structures so that we can reference them in the AG initialization code in the next patch.
--- fs/xfs/libxfs/xfs_alloc_btree.c | 4 ++-- fs/xfs/libxfs/xfs_bmap_btree.c | 2 +- fs/xfs/libxfs/xfs_ialloc_btree.c | 4 ++-- fs/xfs/libxfs/xfs_refcount_btree.c | 2 +- fs/xfs/libxfs/xfs_rmap_btree.c | 2 +- fs/xfs/libxfs/xfs_shared.h | 9 +++++++++ 6 files changed, 16 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +2 -2
@@ -454,7 +454,7 @@ xfs_allocbt_keys_contiguous( be32_to_cpu(key2->alloc.ar_startblock)); } -static const struct xfs_btree_ops xfs_bnobt_ops = { +const struct xfs_btree_ops xfs_bnobt_ops = { .rec_len =sizeof (xfs_alloc_rec_t), .key_len =sizeof (xfs_alloc_key_t),
@@ -477,7 +477,7 @@ static const struct xfs_btree_ops xfs_bnobt_ops = { .keys_contiguous = xfs_allocbt_keys_contiguous, }; -static const struct xfs_btree_ops xfs_cntbt_ops = { +const struct xfs_btree_ops xfs_cntbt_ops = { .rec_len =sizeof (xfs_alloc_rec_t), .key_len =sizeof (xfs_alloc_key_t), .geom_flags =XFS_BTREE_LASTREC_UPDATE ,
fs/xfs/libxfs/xfs_bmap_btree.c +1 -1
@@ -515,7 +515,7 @@ xfs_bmbt_keys_contiguous( be64_to_cpu(key2->bmbt.br_startoff)); } -static const struct xfs_btree_ops xfs_bmbt_ops = { +const struct xfs_btree_ops xfs_bmbt_ops = { .rec_len =sizeof (xfs_bmbt_rec_t), .key_len =sizeof (xfs_bmbt_key_t), .geom_flags =XFS_BTREE_LONG_PTRS |XFS_BTREE_ROOT_IN_INODE ,
fs/xfs/libxfs/xfs_ialloc_btree.c +2 -2
@@ -398,7 +398,7 @@ xfs_inobt_keys_contiguous( be32_to_cpu(key2->inobt.ir_startino)); } -static const struct xfs_btree_ops xfs_inobt_ops = { +const struct xfs_btree_ops xfs_inobt_ops = { .rec_len =sizeof (xfs_inobt_rec_t), .key_len =sizeof (xfs_inobt_key_t),
@@ -420,7 +420,7 @@ static const struct xfs_btree_ops xfs_inobt_ops = { .keys_contiguous = xfs_inobt_keys_contiguous, }; -static const struct xfs_btree_ops xfs_finobt_ops = { +const struct xfs_btree_ops xfs_finobt_ops = { .rec_len =sizeof (xfs_inobt_rec_t), .key_len =sizeof (xfs_inobt_key_t),
fs/xfs/libxfs/xfs_refcount_btree.c +1 -1
@@ -317,7 +317,7 @@ xfs_refcountbt_keys_contiguous( be32_to_cpu(key2->refc.rc_startblock)); } -static const struct xfs_btree_ops xfs_refcountbt_ops = { +const struct xfs_btree_ops xfs_refcountbt_ops = { .rec_len =sizeof (struct xfs_refcount_rec ), .key_len =sizeof (struct xfs_refcount_key ),
fs/xfs/libxfs/xfs_rmap_btree.c +1 -1
@@ -486,7 +486,7 @@ xfs_rmapbt_keys_contiguous( be32_to_cpu(key2->rmap.rm_startblock)); } -static const struct xfs_btree_ops xfs_rmapbt_ops = { +const struct xfs_btree_ops xfs_rmapbt_ops = { .rec_len =sizeof (struct xfs_rmap_rec ), .key_len =2 *sizeof (struct xfs_rmap_key ), .geom_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING ,
fs/xfs/libxfs/xfs_shared.h +9 -0
@@ -43,6 +43,15 @@ extern const struct xfs_buf_ops xfs_sb_buf_ops;extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;extern const struct xfs_buf_ops xfs_symlink_buf_ops; +/* btree ops */ +extern const struct xfs_btree_ops xfs_bnobt_ops; +extern const struct xfs_btree_ops xfs_cntbt_ops; +extern const struct xfs_btree_ops xfs_inobt_ops; +extern const struct xfs_btree_ops xfs_finobt_ops; +extern const struct xfs_btree_ops xfs_bmbt_ops; +extern const struct xfs_btree_ops xfs_refcountbt_ops; +extern const struct xfs_btree_ops xfs_rmapbt_ops; +/* log size calculation functions */ int xfs_log_calc_unit_res (struct xfs_mount *mp,int unit_bytes);int xfs_log_calc_minimum_size (struct xfs_mount *);
Re: [PATCH 3/9] xfs: export some of the btree ops structures
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Export these btree ops structures so that we can reference them in the AG initialization code in the next patch.
Fortunately not export, just not marked static :) The being said this would be easier to follow if simple squashed into the next patch.
Otherwise:
PATCH 4/9 xfs: initialize btree blocks using btree_ops structure
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Notice now that the btree ops structure encodes btree geometry flags and the magic number through the buffer ops. Refactor the btree block initialization functions to use the btree ops so that we no longer have to open code all that.
--- fs/xfs/libxfs/xfs_ag.c | 33 +++++++++-------------- fs/xfs/libxfs/xfs_ag.h | 2 + fs/xfs/libxfs/xfs_bmap.c | 10 +++---- fs/xfs/libxfs/xfs_bmap_btree.c | 5 +-- fs/xfs/libxfs/xfs_btree.c | 53 +++++++++++++++---------------------- fs/xfs/libxfs/xfs_btree.h | 28 ++++++-------------- fs/xfs/libxfs/xfs_btree_staging.c | 5 +-- fs/xfs/scrub/xfbtree.c | 8 +----- 8 files changed, 53 insertions(+), 91 deletions(-)
fs/xfs/libxfs/xfs_ag.c +13 -20
@@ -473,7 +473,7 @@ xfs_btroot_init(struct xfs_buf *bp, struct aghdr_init_data *id) { - xfs_btree_init_block(mp, bp, id->type, 0, 0, id->agno); + xfs_btree_init_block(mp, bp, id->bc_ops, 0, 0, id->agno); }/* Finish initializing a free space btree. */
@@ -531,7 +531,7 @@ xfs_freesp_init_recs( }/* -* Alloc btree root block init functions +* bnobt/cntbt btree root block init functions */ static void xfs_bnoroot_init(
@@ -539,17 +539,7 @@ xfs_bnoroot_init(struct xfs_buf *bp, struct aghdr_init_data *id) { - xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 0, id->agno); -xfs_freesp_init_recs (mp, bp, id); -} - -static void -xfs_cntroot_init ( -struct xfs_mount *mp, -struct xfs_buf *bp, -struct aghdr_init_data *id) -{ -xfs_btree_init_block (mp, bp,XFS_BTNUM_CNT ,0 ,0 , id->agno); + xfs_btree_init_block(mp, bp, id->bc_ops, 0, 0, id->agno);xfs_freesp_init_recs (mp, bp, id); }
@@ -565,7 +555,7 @@ xfs_rmaproot_init(struct xfs_btree_block *block =XFS_BUF_TO_BLOCK (bp);struct xfs_rmap_rec *rrec; -xfs_btree_init_block (mp, bp,XFS_BTNUM_RMAP ,0 ,4 , id->agno); +xfs_btree_init_block (mp, bp, id->bc_ops,0 ,4 , id->agno);/* * mark the AG header regions as static metadata The BNO
@@ -778,7 +768,7 @@ struct xfs_aghdr_grow_data {size_t numblks;const struct xfs_buf_ops *ops;aghdr_init_work_f work; -xfs_btnum_t type; +const struct xfs_btree_ops *bc_ops;bool need_init; };
@@ -832,13 +822,15 @@ xfs_ag_init_headers( .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_bnobt_buf_ops, .work = &xfs_bnoroot_init, + .bc_ops = &xfs_bnobt_ops, .need_init = true }, {/* CNT root block */ .daddr = XFS_AGB_TO_DADDR(mp, id->agno, XFS_CNT_BLOCK(mp)), .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_cntbt_buf_ops, - .work = &xfs_cntroot_init, + .work = &xfs_bnoroot_init, + .bc_ops = &xfs_cntbt_ops, .need_init = true }, {/* INO root block */
@@ -846,7 +838,7 @@ xfs_ag_init_headers( .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_inobt_buf_ops, .work = &xfs_btroot_init, - .type = XFS_BTNUM_INO, + .bc_ops = &xfs_inobt_ops, .need_init = true }, {/* FINO root block */
@@ -854,7 +846,7 @@ xfs_ag_init_headers( .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_finobt_buf_ops, .work = &xfs_btroot_init, - .type = XFS_BTNUM_FINO, + .bc_ops = &xfs_finobt_ops, .need_init = xfs_has_finobt(mp) }, {/* RMAP root block */
@@ -862,6 +854,7 @@ xfs_ag_init_headers( .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_rmapbt_buf_ops, .work = &xfs_rmaproot_init, + .bc_ops = &xfs_rmapbt_ops, .need_init = xfs_has_rmapbt(mp) }, {/* REFC root block */
@@ -869,7 +862,7 @@ xfs_ag_init_headers( .numblks = BTOBB(mp->m_sb.sb_blocksize), .ops = &xfs_refcountbt_buf_ops, .work = &xfs_btroot_init, - .type = XFS_BTNUM_REFC, + .bc_ops = &xfs_refcountbt_ops, .need_init = xfs_has_reflink(mp) }, {/* NULL terminating block */
@@ -887,7 +880,7 @@ xfs_ag_init_headers( id->daddr = dp->daddr; id->numblks = dp->numblks; - id->type = dp->type; + id->bc_ops = dp->bc_ops; error =xfs_ag_init_hdr (mp, id, dp->work, dp->ops);if (error)break ;
fs/xfs/libxfs/xfs_ag.h +1 -1
@@ -330,7 +330,7 @@ struct aghdr_init_data {/* per header data */ xfs_daddr_t daddr;/* header location */ size_t numblks;/* size of header */ -xfs_btnum_t type;/* type of btree root block */ +const struct xfs_btree_ops *bc_ops;/* btree ops */ };int xfs_ag_init_headers (struct xfs_mount *mp,struct aghdr_init_data *id);
fs/xfs/libxfs/xfs_bmap.c +4 -6
@@ -644,9 +644,8 @@ xfs_bmap_extents_to_btree(* Fill in the root. */ block = ifp->if_broot; -xfs_btree_init_block_int (mp, block,XFS_BUF_DADDR_NULL , -XFS_BTNUM_BMAP ,1 ,1 , ip->i_ino, -XFS_BTREE_LONG_PTRS ); +xfs_btree_init_block_int (mp, block, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL , +1 ,1 , ip->i_ino);/* * Need a cursor. Can't allocate until bb_level is filled in. */
@@ -691,9 +690,8 @@ xfs_bmap_extents_to_btree(*/ abp->b_ops = &xfs_bmbt_buf_ops; ablock =XFS_BUF_TO_BLOCK (abp); -xfs_btree_init_block_int (mp, ablock,xfs_buf_daddr (abp), -XFS_BTNUM_BMAP ,0 ,0 , ip->i_ino, -XFS_BTREE_LONG_PTRS ); +xfs_btree_init_block_int (mp, ablock, &xfs_bmbt_ops,xfs_buf_daddr (abp), +0 ,0 , ip->i_ino);for_each_xfs_iext (ifp, &icur, &rec) {if (isnullstartblock (rec.br_startblock))
fs/xfs/libxfs/xfs_bmap_btree.c +2 -3
@@ -44,9 +44,8 @@ xfs_bmdr_to_bmbt(xfs_bmbt_key_t *tkp;__be64 *tpp; -xfs_btree_init_block_int (mp, rblock,XFS_BUF_DADDR_NULL , -XFS_BTNUM_BMAP ,0 ,0 , ip->i_ino, -XFS_BTREE_LONG_PTRS ); +xfs_btree_init_block_int (mp, rblock, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL , +0 ,0 , ip->i_ino); rblock->bb_level = dblock->bb_level;ASSERT (be16_to_cpu (rblock->bb_level) >0 ); rblock->bb_numrecs = dblock->bb_numrecs;
fs/xfs/libxfs/xfs_btree.c +21 -32
118 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree.h +8 -20
@@ -63,7 +63,8 @@ union xfs_btree_rec {#define XFS_BTNUM_RMAP ((xfs_btnum_t)XFS_BTNUM_RMAPi)#define XFS_BTNUM_REFC ((xfs_btnum_t)XFS_BTNUM_REFCi) -uint32_t xfs_btree_magic (int crc,xfs_btnum_t btnum); +struct xfs_btree_ops ; +uint32_t xfs_btree_magic (struct xfs_mount *mp,const struct xfs_btree_ops *ops);/* * For logging record fields.
@@ -450,25 +451,12 @@ xfs_btree_reada_bufs(/* * Initialise a new btree block header */ -void -xfs_btree_init_block ( -struct xfs_mount *mp, -struct xfs_buf *bp, -xfs_btnum_t btnum, -__u16 level, -__u16 numrecs, -__u64 owner); - -void -xfs_btree_init_block_int ( -struct xfs_mount *mp, -struct xfs_btree_block *buf, -xfs_daddr_t blkno, -xfs_btnum_t btnum, -__u16 level, -__u16 numrecs, -__u64 owner, -unsigned int flags); +void xfs_btree_init_block (struct xfs_mount *mp,struct xfs_buf *bp, +const struct xfs_btree_ops *ops,__u16 level,__u16 numrecs, +__u64 owner); +void xfs_btree_init_block_int (struct xfs_mount *mp, +struct xfs_btree_block *buf,const struct xfs_btree_ops *ops, +xfs_daddr_t blkno,__u16 level,__u16 numrecs,__u64 owner);/* * Common btree core entry points.
fs/xfs/libxfs/xfs_btree_staging.c +2 -3
@@ -411,9 +411,8 @@ xfs_btree_bload_prep_block(/* Initialize it and send it out. */ xfs_btree_init_block_int (cur->bc_mp, ifp->if_broot, -XFS_BUF_DADDR_NULL , cur->bc_btnum, level, - nr_this_block, cur->bc_ino.ip->i_ino, - cur->bc_flags); + cur->bc_ops,XFS_BUF_DADDR_NULL , level, + nr_this_block, cur->bc_ino.ip->i_ino); *bpp =NULL ; *blockp = ifp->if_broot;
fs/xfs/scrub/xfbtree.c +2 -6
@@ -437,10 +437,6 @@ xfbtree_init_leaf_block(struct xfs_buf *bp;xfs_daddr_t daddr;int error; -unsigned int bc_flags =0 ; - -if (cfg->flags &XFBTREE_CREATE_LONG_PTRS ) - bc_flags |=XFS_BTREE_LONG_PTRS ; daddr =xfo_to_daddr (XFBTREE_INIT_LEAF_BLOCK ); error =xfs_buf_get (xfbt->target, daddr,xfbtree_bbsize (), &bp);
@@ -450,8 +446,8 @@ xfbtree_init_leaf_block(trace_xfbtree_create_root_buf (xfbt, bp); bp->b_ops = cfg->btree_ops->buf_ops; -xfs_btree_init_block_int (mp, bp->b_addr, daddr, cfg->btnum,0 ,0 , - cfg->owner, bc_flags); +xfs_btree_init_block_int (mp, bp->b_addr, cfg->btree_ops, daddr,0 ,0 , + cfg->owner); error =xfs_bwrite (bp);xfs_buf_relse (bp);if (error)
Re: [PATCH 4/9] xfs: initialize btree blocks using btree_ops structure
Looks good:
PATCH 5/9 xfs: rename btree block/buffer init functions
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Rename xfs_btree_init_block_int to xfs_btree_init_block, and xfs_btree_init_block to xfs_btree_init_buf so that the name suggests the type that caller are supposed to pass in.
--- fs/xfs/libxfs/xfs_ag.c | 6 +++--- fs/xfs/libxfs/xfs_bmap.c | 6 +++--- fs/xfs/libxfs/xfs_bmap_btree.c | 2 +- fs/xfs/libxfs/xfs_btree.c | 8 ++++---- fs/xfs/libxfs/xfs_btree.h | 4 ++-- fs/xfs/libxfs/xfs_btree_staging.c | 2 +- fs/xfs/scrub/xfbtree.c | 2 +- 7 files changed, 15 insertions(+), 15 deletions(-)
fs/xfs/libxfs/xfs_ag.c +3 -3
@@ -473,7 +473,7 @@ xfs_btroot_init(struct xfs_buf *bp, struct aghdr_init_data *id) { - xfs_btree_init_block(mp, bp, id->bc_ops, 0, 0, id->agno); + xfs_btree_init_buf(mp, bp, id->bc_ops, 0, 0, id->agno); }/* Finish initializing a free space btree. */
@@ -539,7 +539,7 @@ xfs_bnoroot_init(struct xfs_buf *bp, struct aghdr_init_data *id) { - xfs_btree_init_block(mp, bp, id->bc_ops, 0, 0, id->agno); + xfs_btree_init_buf(mp, bp, id->bc_ops, 0, 0, id->agno);xfs_freesp_init_recs (mp, bp, id); }
@@ -555,7 +555,7 @@ xfs_rmaproot_init(struct xfs_btree_block *block =XFS_BUF_TO_BLOCK (bp);struct xfs_rmap_rec *rrec; -xfs_btree_init_block (mp, bp, id->bc_ops,0 ,4 , id->agno); +xfs_btree_init_buf (mp, bp, id->bc_ops,0 ,4 , id->agno);/* * mark the AG header regions as static metadata The BNO
fs/xfs/libxfs/xfs_bmap.c +3 -3
@@ -644,8 +644,8 @@ xfs_bmap_extents_to_btree(* Fill in the root. */ block = ifp->if_broot; -xfs_btree_init_block_int (mp, block, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL , -1 ,1 , ip->i_ino); +xfs_btree_init_block (mp, block, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL ,1 , +1 , ip->i_ino);/* * Need a cursor. Can't allocate until bb_level is filled in. */
@@ -690,7 +690,7 @@ xfs_bmap_extents_to_btree(*/ abp->b_ops = &xfs_bmbt_buf_ops; ablock =XFS_BUF_TO_BLOCK (abp); -xfs_btree_init_block_int (mp, ablock, &xfs_bmbt_ops,xfs_buf_daddr (abp), +xfs_btree_init_block (mp, ablock, &xfs_bmbt_ops,xfs_buf_daddr (abp),0 ,0 , ip->i_ino);for_each_xfs_iext (ifp, &icur, &rec) {
fs/xfs/libxfs/xfs_bmap_btree.c +1 -1
@@ -44,7 +44,7 @@ xfs_bmdr_to_bmbt(xfs_bmbt_key_t *tkp;__be64 *tpp; -xfs_btree_init_block_int (mp, rblock, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL , +xfs_btree_init_block (mp, rblock, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL ,0 ,0 , ip->i_ino); rblock->bb_level = dblock->bb_level;ASSERT (be16_to_cpu (rblock->bb_level) >0 );
fs/xfs/libxfs/xfs_btree.c +4 -4
@@ -1213,7 +1213,7 @@ xfs_btree_set_sibling( } void -xfs_btree_init_block_int( +xfs_btree_init_block( struct xfs_mount *mp, struct xfs_btree_block *buf, const struct xfs_btree_ops *ops,
@@ -1255,7 +1255,7 @@ xfs_btree_init_block_int( } void -xfs_btree_init_block( +xfs_btree_init_buf( struct xfs_mount *mp, struct xfs_buf *bp, const struct xfs_btree_ops *ops,
@@ -1263,7 +1263,7 @@ xfs_btree_init_block(__u16 numrecs, __u64 owner) { -xfs_btree_init_block_int (mp ,XFS_BUF_TO_BLOCK (bp ),ops , +xfs_btree_init_block (mp ,XFS_BUF_TO_BLOCK (bp ),ops ,xfs_buf_daddr (bp ),level ,numrecs ,owner ); }
@@ -1289,7 +1289,7 @@ xfs_btree_init_block_cur(else owner = cur->bc_ag.pag->pag_agno; -xfs_btree_init_block_int (cur->bc_mp,XFS_BUF_TO_BLOCK (bp), cur->bc_ops, +xfs_btree_init_block (cur->bc_mp,XFS_BUF_TO_BLOCK (bp), cur->bc_ops,xfs_buf_daddr (bp), level, numrecs, owner); }
fs/xfs/libxfs/xfs_btree.h +2 -2
@@ -451,10 +451,10 @@ xfs_btree_reada_bufs(/* * Initialise a new btree block header */ -void xfs_btree_init_block (struct xfs_mount *mp,struct xfs_buf *bp, +void xfs_btree_init_buf (struct xfs_mount *mp,struct xfs_buf *bp,const struct xfs_btree_ops *ops,__u16 level,__u16 numrecs,__u64 owner); -void xfs_btree_init_block_int (struct xfs_mount *mp, +void xfs_btree_init_block (struct xfs_mount *mp,struct xfs_btree_block *buf,const struct xfs_btree_ops *ops,xfs_daddr_t blkno,__u16 level,__u16 numrecs,__u64 owner);
fs/xfs/libxfs/xfs_btree_staging.c +1 -1
@@ -410,7 +410,7 @@ xfs_btree_bload_prep_block( ifp->if_broot_bytes = (int )new_size;/* Initialize it and send it out. */ -xfs_btree_init_block_int (cur->bc_mp, ifp->if_broot, +xfs_btree_init_block (cur->bc_mp, ifp->if_broot, cur->bc_ops,XFS_BUF_DADDR_NULL , level, nr_this_block, cur->bc_ino.ip->i_ino);
fs/xfs/scrub/xfbtree.c +1 -1
@@ -446,7 +446,7 @@ xfbtree_init_leaf_block(trace_xfbtree_create_root_buf (xfbt, bp); bp->b_ops = cfg->btree_ops->buf_ops; -xfs_btree_init_block_int (mp, bp->b_addr, cfg->btree_ops, daddr,0 ,0 , +xfs_btree_init_block (mp, bp->b_addr, cfg->btree_ops, daddr,0 ,0 , cfg->owner); error =xfs_bwrite (bp);xfs_buf_relse (bp);
Re: [PATCH 5/9] xfs: rename btree block/buffer init functions
Looks good:
PATCH 6/9 xfs: btree convert xfs_btree_init_block to xfs_btree_init_buf calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert any place we call xfs_btree_init_block with a buffer to use the _init_buf function.
--- fs/xfs/libxfs/xfs_bmap.c | 3 +-- fs/xfs/libxfs/xfs_btree.c | 3 +-- fs/xfs/scrub/xfbtree.c | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +1 -2
@@ -690,8 +690,7 @@ xfs_bmap_extents_to_btree(*/ abp->b_ops = &xfs_bmbt_buf_ops; ablock =XFS_BUF_TO_BLOCK (abp); -xfs_btree_init_block (mp, ablock, &xfs_bmbt_ops,xfs_buf_daddr (abp), -0 ,0 , ip->i_ino); +xfs_btree_init_buf (mp, abp, &xfs_bmbt_ops,0 ,0 , ip->i_ino);for_each_xfs_iext (ifp, &icur, &rec) {if (isnullstartblock (rec.br_startblock))
fs/xfs/libxfs/xfs_btree.c +1 -2
@@ -1289,8 +1289,7 @@ xfs_btree_init_block_cur(else owner = cur->bc_ag.pag->pag_agno; -xfs_btree_init_block (cur->bc_mp,XFS_BUF_TO_BLOCK (bp), cur->bc_ops, -xfs_buf_daddr (bp), level, numrecs, owner); +xfs_btree_init_buf (cur->bc_mp, bp, cur->bc_ops, level, numrecs, owner); }/*
fs/xfs/scrub/xfbtree.c +1 -2
@@ -446,8 +446,7 @@ xfbtree_init_leaf_block(trace_xfbtree_create_root_buf (xfbt, bp); bp->b_ops = cfg->btree_ops->buf_ops; -xfs_btree_init_block (mp, bp->b_addr, cfg->btree_ops, daddr,0 ,0 , - cfg->owner); +xfs_btree_init_buf (mp, bp, cfg->btree_ops,0 ,0 , cfg->owner); error =xfs_bwrite (bp);xfs_buf_relse (bp);if (error)
Re: [PATCH 6/9] xfs: btree convert xfs_btree_init_block to xfs_btree_init_buf calls
Looks good:
PATCH 7/9 xfs: remove the unnecessary daddr paramter to _init_block
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that all of the callers pass XFS_BUF_DADDR_NULL as the daddr parameter, we can elide that too.
--- fs/xfs/libxfs/xfs_bmap.c | 3 +-- fs/xfs/libxfs/xfs_bmap_btree.c | 3 +-- fs/xfs/libxfs/xfs_btree.c | 19 ++++++++++++++++--- fs/xfs/libxfs/xfs_btree.h | 2 +- fs/xfs/libxfs/xfs_btree_staging.c | 5 ++--- 5 files changed, 21 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +1 -2
@@ -644,8 +644,7 @@ xfs_bmap_extents_to_btree(* Fill in the root. */ block = ifp->if_broot; -xfs_btree_init_block (mp, block, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL ,1 , -1 , ip->i_ino); +xfs_btree_init_block (mp, block, &xfs_bmbt_ops,1 ,1 , ip->i_ino);/* * Need a cursor. Can't allocate until bb_level is filled in. */
fs/xfs/libxfs/xfs_bmap_btree.c +1 -2
@@ -44,8 +44,7 @@ xfs_bmdr_to_bmbt(xfs_bmbt_key_t *tkp;__be64 *tpp; -xfs_btree_init_block (mp, rblock, &xfs_bmbt_ops,XFS_BUF_DADDR_NULL , -0 ,0 , ip->i_ino); +xfs_btree_init_block (mp, rblock, &xfs_bmbt_ops,0 ,0 , ip->i_ino); rblock->bb_level = dblock->bb_level;ASSERT (be16_to_cpu (rblock->bb_level) >0 ); rblock->bb_numrecs = dblock->bb_numrecs;
fs/xfs/libxfs/xfs_btree.c +16 -3
@@ -1212,8 +1212,8 @@ xfs_btree_set_sibling( } } -void -xfs_btree_init_block( +static void +__xfs_btree_init_block( struct xfs_mount *mp, struct xfs_btree_block *buf, const struct xfs_btree_ops *ops,
@@ -1254,6 +1254,19 @@ xfs_btree_init_block( } } +void +xfs_btree_init_block ( +struct xfs_mount *mp, +struct xfs_btree_block *block, +const struct xfs_btree_ops *ops, +__u16 level, +__u16 numrecs, +__u64 owner) +{ +__xfs_btree_init_block (mp, block, ops,XFS_BUF_DADDR_NULL , level, + numrecs, owner); +} + void xfs_btree_init_buf( struct xfs_mount *mp,
@@ -1263,7 +1276,7 @@ xfs_btree_init_buf(__u16 numrecs, __u64 owner) { -xfs_btree_init_block (mp ,XFS_BUF_TO_BLOCK (bp ),ops , +__xfs_btree_init_block (mp ,XFS_BUF_TO_BLOCK (bp ),ops ,xfs_buf_daddr (bp ),level ,numrecs ,owner ); }
fs/xfs/libxfs/xfs_btree.h +1 -1
@@ -456,7 +456,7 @@ void xfs_btree_init_buf(struct xfs_mount *mp, struct xfs_buf *bp, __u64 owner);void xfs_btree_init_block (struct xfs_mount *mp,struct xfs_btree_block *buf,const struct xfs_btree_ops *ops, -xfs_daddr_t blkno,__u16 level,__u16 numrecs,__u64 owner); +__u16 level,__u16 numrecs,__u64 owner);/* * Common btree core entry points.
fs/xfs/libxfs/xfs_btree_staging.c +2 -3
@@ -410,9 +410,8 @@ xfs_btree_bload_prep_block( ifp->if_broot_bytes = (int )new_size;/* Initialize it and send it out. */ -xfs_btree_init_block (cur->bc_mp, ifp->if_broot, - cur->bc_ops,XFS_BUF_DADDR_NULL , level, - nr_this_block, cur->bc_ino.ip->i_ino); +xfs_btree_init_block (cur->bc_mp, ifp->if_broot, cur->bc_ops, + level, nr_this_block, cur->bc_ino.ip->i_ino); *bpp =NULL ; *blockp = ifp->if_broot;
Re: [PATCH 7/9] xfs: remove the unnecessary daddr paramter to _init_block
Looks good:
PATCH 8/9 xfs: set btree block buffer ops in _init_buf
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Set the btree block buffer ops in xfs_btree_init_buf since we already have access to that information through the btree ops.
--- fs/xfs/libxfs/xfs_bmap.c | 1 - fs/xfs/libxfs/xfs_btree.c | 1 + fs/xfs/scrub/xfbtree.c | 1 - 3 files changed, 1 insertion(+), 2 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +0 -1
@@ -687,7 +687,6 @@ xfs_bmap_extents_to_btree(/* * Fill in the child block. */ - abp->b_ops = &xfs_bmbt_buf_ops; ablock =XFS_BUF_TO_BLOCK (abp);xfs_btree_init_buf (mp, abp, &xfs_bmbt_ops,0 ,0 , ip->i_ino);
fs/xfs/libxfs/xfs_btree.c +1 -0
@@ -1278,6 +1278,7 @@ xfs_btree_init_buf( {__xfs_btree_init_block (mp,XFS_BUF_TO_BLOCK (bp), ops,xfs_buf_daddr (bp), level, numrecs, owner); + bp->b_ops = ops->buf_ops; }void
fs/xfs/scrub/xfbtree.c +0 -1
@@ -445,7 +445,6 @@ xfbtree_init_leaf_block(trace_xfbtree_create_root_buf (xfbt, bp); - bp->b_ops = cfg->btree_ops->buf_ops;xfs_btree_init_buf (mp, bp, cfg->btree_ops,0 ,0 , cfg->owner); error =xfs_bwrite (bp);xfs_buf_relse (bp);
Re: [PATCH 8/9] xfs: set btree block buffer ops in _init_buf
Looks good:
PATCH 9/9 xfs: remove unnecessary fields in xfbtree_config
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Remove these fields now that we get all the info we need from the btree ops.
--- fs/xfs/libxfs/xfs_btree_mem.h | 9 --------- fs/xfs/libxfs/xfs_rmap_btree.c | 1 - fs/xfs/scrub/trace.h | 10 ++++------ fs/xfs/scrub/xfbtree.c | 4 ++-- 4 files changed, 6 insertions(+), 18 deletions(-)
fs/xfs/libxfs/xfs_btree_mem.h +0 -9
@@ -17,17 +17,8 @@ struct xfbtree_config {/* Owner of this btree. */ unsigned long long owner; - -/* Btree type number */ -xfs_btnum_t btnum; - -/* XFBTREE_CREATE_* flags */ -unsigned int flags; }; -/* btree has long pointers */ -#define XFBTREE_CREATE_LONG_PTRS (1U << 0) -#ifdef CONFIG_XFS_BTREE_IN_XFILE unsigned int xfs_btree_mem_head_nlevels (struct xfs_buf *head_bp);
fs/xfs/libxfs/xfs_rmap_btree.c +0 -1
@@ -669,7 +669,6 @@ xfs_rmapbt_mem_create(struct xfbtree_config cfg = { .btree_ops = &xfs_rmapbt_mem_ops, .target = target, - .btnum =XFS_BTNUM_RMAP , .owner = agno, };
fs/xfs/scrub/trace.h +4 -6
@@ -2218,8 +2218,7 @@ TRACE_EVENT(xfbtree_create, struct xfbtree *xfbt),TP_ARGS (mp ,cfg ,xfbt ),TP_STRUCT__entry ( - __field(xfs_btnum_t, btnum) -__field (unsigned int ,xfbtree_flags ) + __field(const void *, btree_ops)__field (unsigned long ,xfino ) __field(unsigned int, leaf_mxr) __field(unsigned int, leaf_mnr)
@@ -2228,8 +2227,7 @@ TRACE_EVENT(xfbtree_create, __field(unsigned long long, owner) ),TP_fast_assign ( - __entry->btnum = cfg->btnum; - __entry->xfbtree_flags = cfg->flags; + __entry->btree_ops = cfg->btree_ops; __entry->xfino =xfbtree_ino (xfbt); __entry->leaf_mxr = xfbt->maxrecs[0 ]; __entry->node_mxr = xfbt->maxrecs[1 ];
@@ -2237,9 +2235,9 @@ TRACE_EVENT(xfbtree_create, __entry->node_mnr = xfbt->minrecs[1 ]; __entry->owner = cfg->owner; ), - TP_printk("xfino 0x%lx btnum %s owner 0x%llx leaf_mxr %u leaf_mnr %u node_mxr %u node_mnr %u", + TP_printk("xfino 0x%lx btree_ops %pS owner 0x%llx leaf_mxr %u leaf_mnr %u node_mxr %u node_mnr %u", __entry->xfino, - __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), + __entry->btree_ops, __entry->owner, __entry->leaf_mxr, __entry->leaf_mnr,
fs/xfs/scrub/xfbtree.c +2 -2
@@ -414,7 +414,7 @@ xfbtree_rec_bytes( {unsigned int blocklen =xfo_to_b (1 ); -if (cfg->flags &XFBTREE_CREATE_LONG_PTRS ) { +if (cfg->btree_ops->geom_flags &XFS_BTREE_LONG_PTRS ) {if (xfs_has_crc (mp))return blocklen -XFS_BTREE_LBLOCK_CRC_LEN ;
@@ -504,7 +504,7 @@ xfbtree_create(xfboff_bitmap_init (&xfbt->freespace);/* Set up min/maxrecs for this btree. */ -if (cfg->flags &XFBTREE_CREATE_LONG_PTRS ) +if (cfg->btree_ops->geom_flags &XFS_BTREE_LONG_PTRS ) keyptr_len +=sizeof (__be64);else keyptr_len +=sizeof (__be32);
Re: [PATCH 9/9] xfs: remove unnecessary fields in xfbtree_config
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Remove these fields now that we get all the info we need from the btree ops.
It would be great if this series could just be moved forwared to before adding xfbtree_config so that it wouldn't need adding in the first place?
Otherwise looks good:
Re: [PATCH 9/9] xfs: remove unnecessary fields in xfbtree_config
Quoted 9 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Remove these fields now that we get all the info we need from the btree ops.
It would be great if this series could just be moved forwared to before adding
xfbtree_configso that it wouldn't need adding in the first place?
I can look into that, but jumping this series ahead by 15 patches might be a lot of work.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
Re: [PATCH 9/9] xfs: remove unnecessary fields in xfbtree_config
Quoted 2 lines · Darrick J. Wong
I can look into that, but jumping this series ahead by 15 patches might be a lot of work.
Skip it if it's too much work.
PATCH 11/28 xfs: reduce refcount repair memory usage
In reply to Darrick J. WongHi all,
The refcountbt repair code has serious memory usage problems when the block sharing factor of the filesystem is very high. This can happen if a deduplication tool has been run against the filesystem, or if the fs stores reflinked VM images that have been aging for a long time.
Recall that the original reference counting algorithm walks the reverse mapping records of the filesystem to generate reference counts. For any given block in the AG, the rmap bag structure contains the all rmap records that cover that block; the refcount is the size of that bag.
For online repair, the bag doesn't need the owner, offset, or state flag information, so it discards those. This halves the record size, but the bag structure still stores one excerpted record for each reverse mapping. If the sharing count is high, this will use a LOT of memory storing redundant records. In the extreme case, 100k mappings to the same piece of space will consume 100k*16 bytes = 1.6M of memory.
For offline repair, the bag stores the owner values so that we know which inodes need to be marked as being reflink inodes. If a deduplication tool has been run and there are many blocks within a file pointing to the same physical space, this will stll use a lot of memory to store redundant records.
The solution to this problem is to deduplicate the bag records when possible by adding a reference count to the bag record, and changing the bag add function to detect an existing record to bump the refcount. In the above example, the 100k mappings will now use 24 bytes of memory. These lookups can be done efficiently with a btree, so we create a new refcount bag btree type (inside of online repair). This is why we refactored the btree code in the previous patchset.
The btree conversion also dramatically reduces the runtime of the refcount generation algorithm, because the code to delete all bag records that end at a given agblock now only has to delete one record instead of (using the example above) 100k records. As an added benefit, record deletion now gives back the unused xfile space, which it did not do previously.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-refcount-scalability
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-refcount-scalability
--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_alloc_btree.c | 2 fs/xfs/libxfs/xfs_bmap_btree.c | 1 fs/xfs/libxfs/xfs_btree.c | 24 -- fs/xfs/libxfs/xfs_btree.h | 4 fs/xfs/libxfs/xfs_ialloc_btree.c | 2 fs/xfs/libxfs/xfs_refcount_btree.c | 1 fs/xfs/libxfs/xfs_rmap_btree.c | 2 fs/xfs/libxfs/xfs_types.h | 6 - fs/xfs/scrub/rcbag.c | 331 ++++++++++++++++++++++++++++++++ fs/xfs/scrub/rcbag.h | 28 +++ fs/xfs/scrub/rcbag_btree.c | 372 ++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/rcbag_btree.h | 83 ++++++++ fs/xfs/scrub/refcount.c | 12 + fs/xfs/scrub/refcount_repair.c | 164 ++++++---------- fs/xfs/scrub/repair.h | 2 fs/xfs/scrub/trace.h | 1 fs/xfs/xfs_super.c | 10 + fs/xfs/xfs_trace.h | 1 19 files changed, 917 insertions(+), 131 deletions(-) create mode 100644 fs/xfs/scrub/rcbag.c create mode 100644 fs/xfs/scrub/rcbag.h create mode 100644 fs/xfs/scrub/rcbag_btree.c create mode 100644 fs/xfs/scrub/rcbag_btree.h
PATCH 1/4 xfs: move lru refs to the btree ops structure
From: Darrick J. Wong <[email protected]>
Move the btree buffer LRU refcount to the btree ops structure so that we can eliminate the last bc_btnum switch in the generic btree code. We're about to create repair-specific btree types, and we don't want that stuff cluttering up libxfs.
--- fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/libxfs/xfs_bmap_btree.c | 1 + fs/xfs/libxfs/xfs_btree.c | 24 ++---------------------- fs/xfs/libxfs/xfs_btree.h | 3 +++ fs/xfs/libxfs/xfs_ialloc_btree.c | 2 ++ fs/xfs/libxfs/xfs_refcount_btree.c | 1 + fs/xfs/libxfs/xfs_rmap_btree.c | 2 ++ 7 files changed, 13 insertions(+), 22 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +2 -0
@@ -457,6 +457,7 @@ xfs_allocbt_keys_contiguous(const struct xfs_btree_ops xfs_bnobt_ops = { .rec_len =sizeof (xfs_alloc_rec_t), .key_len =sizeof (xfs_alloc_key_t), + .lru_refs =XFS_ALLOC_BTREE_REF , .dup_cursor = xfs_allocbt_dup_cursor, .set_root = xfs_allocbt_set_root,
@@ -480,6 +481,7 @@ const struct xfs_btree_ops xfs_bnobt_ops = {const struct xfs_btree_ops xfs_cntbt_ops = { .rec_len =sizeof (xfs_alloc_rec_t), .key_len =sizeof (xfs_alloc_key_t), + .lru_refs =XFS_ALLOC_BTREE_REF , .geom_flags =XFS_BTREE_LASTREC_UPDATE , .dup_cursor = xfs_allocbt_dup_cursor,
fs/xfs/libxfs/xfs_bmap_btree.c +1 -0
@@ -516,6 +516,7 @@ xfs_bmbt_keys_contiguous(const struct xfs_btree_ops xfs_bmbt_ops = { .rec_len =sizeof (xfs_bmbt_rec_t), .key_len =sizeof (xfs_bmbt_key_t), + .lru_refs =XFS_BMAP_BTREE_REF , .geom_flags =XFS_BTREE_LONG_PTRS |XFS_BTREE_ROOT_IN_INODE , .dup_cursor = xfs_bmbt_dup_cursor,
fs/xfs/libxfs/xfs_btree.c +2 -22
@@ -1350,32 +1350,12 @@ xfs_btree_buf_to_ptr( } } -STATIC void +static inline void xfs_btree_set_refs (struct xfs_btree_cur *cur,struct xfs_buf *bp) { -switch (cur->bc_btnum) { -case XFS_BTNUM_BNO : -case XFS_BTNUM_CNT : -xfs_buf_set_ref (bp,XFS_ALLOC_BTREE_REF ); -break ; -case XFS_BTNUM_INO : -case XFS_BTNUM_FINO : -xfs_buf_set_ref (bp,XFS_INO_BTREE_REF ); -break ; -case XFS_BTNUM_BMAP : -xfs_buf_set_ref (bp,XFS_BMAP_BTREE_REF ); -break ; -case XFS_BTNUM_RMAP : -xfs_buf_set_ref (bp,XFS_RMAP_BTREE_REF ); -break ; -case XFS_BTNUM_REFC : -xfs_buf_set_ref (bp,XFS_REFC_BTREE_REF ); -break ; -default : -ASSERT (0 ); - } +xfs_buf_set_ref (bp, cur->bc_ops->lru_refs); }int
fs/xfs/libxfs/xfs_btree.h +3 -0
@@ -120,6 +120,9 @@ struct xfs_btree_ops {/* XFS_BTREE_* flags that determine the geometry of the btree */ unsigned int geom_flags; +/* LRU refcount to set on each btree buffer created */ +int lru_refs; +/* cursor operations */ struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *); void (*update_cursor)(struct xfs_btree_cur *src,
fs/xfs/libxfs/xfs_ialloc_btree.c +2 -0
@@ -401,6 +401,7 @@ xfs_inobt_keys_contiguous(const struct xfs_btree_ops xfs_inobt_ops = { .rec_len =sizeof (xfs_inobt_rec_t), .key_len =sizeof (xfs_inobt_key_t), + .lru_refs =XFS_INO_BTREE_REF , .dup_cursor = xfs_inobt_dup_cursor, .set_root = xfs_inobt_set_root,
@@ -423,6 +424,7 @@ const struct xfs_btree_ops xfs_inobt_ops = {const struct xfs_btree_ops xfs_finobt_ops = { .rec_len =sizeof (xfs_inobt_rec_t), .key_len =sizeof (xfs_inobt_key_t), + .lru_refs =XFS_INO_BTREE_REF , .dup_cursor = xfs_inobt_dup_cursor, .set_root = xfs_finobt_set_root,
fs/xfs/libxfs/xfs_refcount_btree.c +1 -0
@@ -320,6 +320,7 @@ xfs_refcountbt_keys_contiguous(const struct xfs_btree_ops xfs_refcountbt_ops = { .rec_len =sizeof (struct xfs_refcount_rec ), .key_len =sizeof (struct xfs_refcount_key ), + .lru_refs =XFS_REFC_BTREE_REF , .dup_cursor = xfs_refcountbt_dup_cursor, .set_root = xfs_refcountbt_set_root,
fs/xfs/libxfs/xfs_rmap_btree.c +2 -0
@@ -489,6 +489,7 @@ xfs_rmapbt_keys_contiguous(const struct xfs_btree_ops xfs_rmapbt_ops = { .rec_len =sizeof (struct xfs_rmap_rec ), .key_len =2 *sizeof (struct xfs_rmap_key ), + .lru_refs =XFS_RMAP_BTREE_REF , .geom_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING , .dup_cursor = xfs_rmapbt_dup_cursor,
@@ -613,6 +614,7 @@ static const struct xfs_buf_ops xfs_rmapbt_mem_buf_ops = {static const struct xfs_btree_ops xfs_rmapbt_mem_ops = { .rec_len =sizeof (struct xfs_rmap_rec ), .key_len =2 *sizeof (struct xfs_rmap_key ), + .lru_refs =XFS_RMAP_BTREE_REF , .geom_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING |XFS_BTREE_IN_XFILE ,
Re: [PATCH 1/4] xfs: move lru refs to the btree ops structure
Quoted 5 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Move the btree buffer LRU refcount to the btree ops structure so that we can eliminate the last
bc_btnumswitch in the generic btree code. We're about to create repair-specific btree types, and we don't want that
Looks good:
PATCH 2/4 xfs: define an in-memory btree for storing refcount bag info during repairs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new in-memory btree type so that we can store refcount bag info in a much more memory-efficient format.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree.h | 1 fs/xfs/libxfs/xfs_types.h | 6 + fs/xfs/scrub/rcbag_btree.c | 314 ++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/rcbag_btree.h | 76 +++++++++++ fs/xfs/scrub/trace.h | 1 fs/xfs/xfs_trace.h | 1 7 files changed, 398 insertions(+), 2 deletions(-) create mode 100644 fs/xfs/scrub/rcbag_btree.c create mode 100644 fs/xfs/scrub/rcbag_btree.h
fs/xfs/Makefile +1 -0
@@ -198,6 +198,7 @@ xfs-y += $(addprefix scrub/, \ inode_repair.o \ newbt.o \ nlinks_repair.o \ + rcbag_btree.o \ reap.o \ refcount_repair.o \ repair.o \
fs/xfs/libxfs/xfs_btree.h +1 -0
@@ -62,6 +62,7 @@ union xfs_btree_rec {#define XFS_BTNUM_FINO ((xfs_btnum_t)XFS_BTNUM_FINOi)#define XFS_BTNUM_RMAP ((xfs_btnum_t)XFS_BTNUM_RMAPi)#define XFS_BTNUM_REFC ((xfs_btnum_t)XFS_BTNUM_REFCi) +#define XFS_BTNUM_RCBAG ((xfs_btnum_t)XFS_BTNUM_RCBAGi)struct xfs_btree_ops ;uint32_t xfs_btree_magic (struct xfs_mount *mp,const struct xfs_btree_ops *ops);
fs/xfs/libxfs/xfs_types.h +4 -2
@@ -121,7 +121,8 @@ typedef enum {*/ typedef enum { XFS_BTNUM_BNOi, XFS_BTNUM_CNTi, XFS_BTNUM_RMAPi, XFS_BTNUM_BMAPi, - XFS_BTNUM_INOi, XFS_BTNUM_FINOi, XFS_BTNUM_REFCi,XFS_BTNUM_MAX + XFS_BTNUM_INOi, XFS_BTNUM_FINOi, XFS_BTNUM_REFCi, XFS_BTNUM_RCBAGi, +XFS_BTNUM_MAX }xfs_btnum_t ;#define XFS_BTNUM_STRINGS \
@@ -131,7 +132,8 @@ typedef enum { { XFS_BTNUM_BMAPi, "bmbt" }, \ { XFS_BTNUM_INOi, "inobt" }, \ { XFS_BTNUM_FINOi, "finobt" }, \ - { XFS_BTNUM_REFCi, "refcbt" } + { XFS_BTNUM_REFCi, "refcbt" }, \ + { XFS_BTNUM_RCBAGi, "rcbagbt" } struct xfs_name {const unsigned char *name;
fs/xfs/scrub/rcbag_btree.c new file +314 -0
314 lines not on this page · raw message
fs/xfs/scrub/rcbag_btree.h new file +76 -0
76 lines not on this page · raw message
fs/xfs/scrub/trace.h +1 -0
@@ -42,6 +42,7 @@ TRACE_DEFINE_ENUM(XFS_BTNUM_INOi);TRACE_DEFINE_ENUM (XFS_BTNUM_FINOi);TRACE_DEFINE_ENUM (XFS_BTNUM_RMAPi);TRACE_DEFINE_ENUM (XFS_BTNUM_REFCi); +TRACE_DEFINE_ENUM (XFS_BTNUM_RCBAGi);TRACE_DEFINE_ENUM (XFS_REFC_DOMAIN_SHARED );TRACE_DEFINE_ENUM (XFS_REFC_DOMAIN_COW );
fs/xfs/xfs_trace.h +1 -0
@@ -2458,6 +2458,7 @@ TRACE_DEFINE_ENUM(XFS_BTNUM_INOi);TRACE_DEFINE_ENUM (XFS_BTNUM_FINOi);TRACE_DEFINE_ENUM (XFS_BTNUM_RMAPi);TRACE_DEFINE_ENUM (XFS_BTNUM_REFCi); +TRACE_DEFINE_ENUM (XFS_BTNUM_RCBAGi); DECLARE_EVENT_CLASS(xfs_btree_cur_class, TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp),
Re: [PATCH 2/4] xfs: define an in-memory btree for storing refcount bag info during repairs
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new in-memory btree type so that we can store refcount bag info in a much more memory-efficient format.
Can you add a cursory explanation of what 'bag info' is? It took me quite a while to figure this out by looking at the refcount_repair.c file, and future readers or the commit log might be a lot less savy in finding that information. The source file could also really use a comment explaining the bag term and what is actually stored in it.
Re: [PATCH 2/4] xfs: define an in-memory btree for storing refcount bag info during repairs
Quoted 11 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new in-memory btree type so that we can store refcount bag info in a much more memory-efficient format.
Can you add a cursory explanation of what 'bag info' is? It took me quite a while to figure this out by looking at the
refcount_repair.cfile, and future readers or the commit log might be a lot less savy in finding that information. The source file could also really use a comment explaining the bag term and what is actually stored in it.
In the original refcount recordset regenerator in xfs_repair, refcount records are generated from rmap records. Let's say that the rmap records are:
{agbno: 10, length: 40...}
{agbno: 11, length: 3...}
{agbno: 12, length: 20...}
{agbno: 15, length: 1...}
It would be convenient to have a data structure that could quickly tell us the refcount for an arbitrary agbno without wasting memory. An array or a list could do that pretty easily. List suck because of the pointer overhead. xfarrays are a lot more compact, but we want to minimize sparse holes in the xfarray to constrain memory usage. Maintaining order isn't critical for correctness, so I created the "rcbag", which is shorthand for an unordered list of (excerpted) reverse mappings.
So we add the first rmap to the rcbag, and it looks like:
0: {agbno: 10, length: 40}
The refcount for agbno 10 is 1. Then we move on to block 11, so we add the second rmap:
0: {agbno: 10, length: 40}
1: {agbno: 11, length: 3}
The refcount for agbno 11 is 2. We move on to block 12, so we add the third:
0: {agbno: 10, length: 40}
1: {agbno: 11, length: 3}
2: {agbno: 12, length: 20}
The refcount for agbno 12 and 13 is 3. We move on to block 14, and remove the second rmap:
0: {agbno: 10, length: 40}
1: NULL
2: {agbno: 12, length: 20}
The refcount for agbno 14 is 2. We move on to block 15, and add the last rmap. But we don't care where it is and we don't want to expand the array so we put it in slot 1:
0: {agbno: 10, length: 40}
1: {agbno: 15, length: 1}
2: {agbno: 12, length: 20}
The refcount for block 15 is 3. Notice how order doesn't matter in this list? That's why repair uses an unordered list, or "bag".
That said, adding and removing specific items is now an O(n) operation because we have no idea where that item might be in the list. Overall, the runtime is O(n^2) which is bad.
I realized that I could easily refactor the btree code and reimplement the refcount bag with an xfbtree. Adding and removing is now O(log2 n), so the runtime is at least O(n log2 n), which is much faster. In the end, the rcbag becomes a sorted list, but that's merely a detail of the implementation. The repair code doesn't care.
(Note: That horrible xfs_db bmap_inflate command can be used to exercise this sort of rcbag insanity by cranking up refcounts quickly.)
--D
PATCH 3/4 xfs: create refcount bag structure for btree repairs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a bag structure for refcount information that uses the refcount bag btree defined in the previous patch.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/rcbag.c | 331 ++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/rcbag.h | 28 ++++ fs/xfs/scrub/rcbag_btree.c | 58 ++++++++ fs/xfs/scrub/rcbag_btree.h | 7 + 5 files changed, 425 insertions(+) create mode 100644 fs/xfs/scrub/rcbag.c create mode 100644 fs/xfs/scrub/rcbag.h
fs/xfs/Makefile +1 -0
@@ -199,6 +199,7 @@ xfs-y += $(addprefix scrub/, \ newbt.o \ nlinks_repair.o \ rcbag_btree.o \ + rcbag.o \ reap.o \ refcount_repair.o \ repair.o \
fs/xfs/scrub/rcbag.c new file +331 -0
331 lines not on this page · raw message
fs/xfs/scrub/rcbag.h new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2022-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_RCBAG_H__ +#define __XFS_SCRUB_RCBAG_H__ + +struct xfs_mount ; +struct rcbag ; +struct xfs_buftarg ; + +int rcbag_init (struct xfs_mount *mp,struct xfs_buftarg *target, +struct rcbag **bagp); +void rcbag_free (struct rcbag **bagp); +int rcbag_add (struct rcbag *bag,struct xfs_trans *tp, +const struct xfs_rmap_irec *rmap); +uint64_t rcbag_count (const struct rcbag *bag); + +int rcbag_next_edge (struct rcbag *bag,struct xfs_trans *tp, +const struct xfs_rmap_irec *next_rmap,bool next_valid, +uint32_t *next_bnop); +int rcbag_remove_ending_at (struct rcbag *bag,struct xfs_trans *tp, +uint32_t next_bno); + +void rcbag_dump (struct rcbag *bag,struct xfs_trans *tp); + +#endif /* __XFS_SCRUB_RCBAG_H__ */
fs/xfs/scrub/rcbag_btree.c +58 -0
61 lines not on this page · raw message
fs/xfs/scrub/rcbag_btree.h +7 -0
@@ -68,6 +68,13 @@ struct xfs_btree_cur *rcbagbt_mem_cursor(struct xfs_mount *mp,int rcbagbt_mem_create (struct xfs_mount *mp,struct xfs_buftarg *target,struct xfbtree **xfbtreep); +int rcbagbt_lookup_eq (struct xfs_btree_cur *cur, +const struct xfs_rmap_irec *rmap,int *success); +int rcbagbt_get_rec (struct xfs_btree_cur *cur,struct rcbag_rec *rec,int *has); +int rcbagbt_update (struct xfs_btree_cur *cur,const struct rcbag_rec *rec); +int rcbagbt_insert (struct xfs_btree_cur *cur,const struct rcbag_rec *rec, +int *success); +#else # define rcbagbt_init_cur_cache () 0# define rcbagbt_destroy_cur_cache () ((void)0)
Re: [PATCH 3/4] xfs: create refcount bag structure for btree repairs
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a bag structure for refcount information that uses the refcount bag btree defined in the previous patch.
Same commit log information comment as for the previous patch here.
PATCH 4/4 xfs: port refcount repair to the new refcount bag structure
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port the refcount record generating code to use the new refcount bag data structure.
--- fs/xfs/scrub/refcount.c | 12 +++ fs/xfs/scrub/refcount_repair.c | 164 ++++++++++++++-------------------------- fs/xfs/scrub/repair.h | 2 fs/xfs/xfs_super.c | 10 ++ 4 files changed, 81 insertions(+), 107 deletions(-)
fs/xfs/scrub/refcount.c +12 -0
@@ -7,8 +7,10 @@#include "xfs_fs.h" #include "xfs_shared.h" #include "xfs_format.h" +#include "xfs_log_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h" +#include "xfs_trans.h" #include "xfs_ag.h" #include "xfs_btree.h" #include "xfs_rmap.h"
@@ -17,6 +19,7 @@#include "scrub/common.h" #include "scrub/btree.h" #include "scrub/trace.h" +#include "scrub/repair.h" /* * Set us up to scrub reference count btrees.
@@ -27,6 +30,15 @@ xchk_setup_ag_refcountbt( {if (xchk_need_intent_drain (sc))xchk_fsgates_enable (sc,XCHK_FSGATES_DRAIN ); + +if (xchk_could_repair (sc)) { +int error; + + error =xrep_setup_ag_refcountbt (sc); +if (error) +return error; + } +return xchk_setup_ag_btree (sc, false); }
fs/xfs/scrub/refcount_repair.c +58 -106
304 lines not on this page · raw message
fs/xfs/scrub/repair.h +2 -0
@@ -89,6 +89,7 @@ int xrep_reset_perag_resv(struct xfs_scrub *sc);int xrep_bmap (struct xfs_scrub *sc,int whichfork,bool allow_unwritten);int xrep_metadata_inode_forks (struct xfs_scrub *sc);int xrep_setup_ag_rmapbt (struct xfs_scrub *sc); +int xrep_setup_ag_refcountbt (struct xfs_scrub *sc);/* Repair setup functions */ int xrep_setup_ag_allocbt (struct xfs_scrub *sc);
@@ -186,6 +187,7 @@ xrep_setup_nothing( }#define xrep_setup_ag_allocbt xrep_setup_nothing#define xrep_setup_ag_rmapbt xrep_setup_nothing +#define xrep_setup_ag_refcountbt xrep_setup_nothing#define xrep_setup_inode (sc, imap) ((void)0)
fs/xfs/xfs_super.c +9 -1
@@ -44,6 +44,7 @@#include "xfs_dahash_test.h" #include "xfs_rtbitmap.h" #include "scrub/stats.h" +#include "scrub/rcbag_btree.h" #include <linux/magic.h> #include <linux/fs_context.h>
@@ -2069,10 +2070,14 @@ xfs_init_caches(void)if (error) goto out_destroy_log_ticket_cache; - error =xfs_defer_init_item_caches (); + error =rcbagbt_init_cur_cache ();if (error) goto out_destroy_btree_cur_cache; + error =xfs_defer_init_item_caches (); +if (error) + goto out_destroy_rcbagbt_cur_cache; + xfs_da_state_cache =kmem_cache_create ("xfs_da_state" ,sizeof (struct xfs_da_state ),0 ,0 ,NULL );
@@ -2229,6 +2234,8 @@ xfs_init_caches(void)kmem_cache_destroy (xfs_da_state_cache); out_destroy_defer_item_cache:xfs_defer_destroy_item_caches (); + out_destroy_rcbagbt_cur_cache: +rcbagbt_destroy_cur_cache (); out_destroy_btree_cur_cache:xfs_btree_destroy_cur_caches (); out_destroy_log_ticket_cache:
@@ -2266,6 +2273,7 @@ xfs_destroy_caches(void)kmem_cache_destroy (xfs_ifork_cache);kmem_cache_destroy (xfs_da_state_cache);xfs_defer_destroy_item_caches (); +rcbagbt_destroy_cur_cache ();xfs_btree_destroy_cur_caches ();kmem_cache_destroy (xfs_log_ticket_cache);kmem_cache_destroy (xfs_buf_cache);
Re: [PATCH 4/4] xfs: port refcount repair to the new refcount bag structure
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Port the refcount record generating code to use the new refcount bag data structure.
This could again use some comments on why you're doing that. My strong suspicion is that it will be a lot faster and/or memory efficient, but please document this for future readers of the commit logs.
Re: [PATCH 4/4] xfs: port refcount repair to the new refcount bag structure
Quoted 9 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Port the refcount record generating code to use the new refcount bag data structure.
This could again use some comments on why you're doing that. My strong suspicion is that it will be a lot faster and/or memory efficient, but please document this for future readers of the commit logs.
The new implementation is less memory efficient (because now we have btree headers and internal nodes) but makes it a lot faster. If I turn my reply to patch #2 into the commit message, will that work?
--D
PATCH 12/28 xfs: bmap log intent cleanups
In reply to Darrick J. WongHi all,
The next major target of online repair are metadata that are persisted in blocks mapped by a file fork. In other words, we want to repair directories, extended attributes, symbolic links, and the realtime free space information. For file-based metadata, we assume that the space metadata is correct, which enables repair to construct new versions of the metadata in a temporary file. We then need to swap the file fork mappings of the two files atomically. With this patchset, we begin constructing such a facility based on the existing bmap log items and a new extent swap log item.
This series cleans up a few parts of the file block mapping log intent code before we start adding support for realtime bmap intents. Most of it involves cleaning up tracepoints so that more of the data extraction logic ends up in the tracepoint code and not the tracepoint call site, which should reduce overhead further when tracepoints are disabled. There is also a change to pass bmap intents all the way back to the bmap code instead of unboxing the intent values and re-boxing them after the _finish_one function completes.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=bmap-intent-cleanups
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=bmap-intent-cleanups
--- fs/xfs/libxfs/xfs_bmap.c | 21 +--- fs/xfs/libxfs/xfs_bmap.h | 7 + fs/xfs/xfs_attr_item.c | 11 +- fs/xfs/xfs_bmap_item.c | 95 ++++++++-------- fs/xfs/xfs_bmap_item.h | 4 + fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 267 +++++++++++++++++++++++++++++----------------- 7 files changed, 237 insertions(+), 169 deletions(-)
PATCH 1/7 xfs: split tracepoint classes for deferred items
From: Darrick J. Wong <[email protected]>
We're about to start adding support for deferred log intent items for realtime extents, so split these four types into separate classes so that we can customize them as the transition happens.
--- fs/xfs/xfs_trace.h | 273 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 177 insertions(+), 96 deletions(-)
fs/xfs/xfs_trace.h +177 -96
@@ -2658,94 +2658,6 @@ DEFINE_EVENT(xfs_defer_pending_class, name, \ TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \ TP_ARGS(mp, dfp)) -DECLARE_EVENT_CLASS(xfs_phys_extent_deferred_class, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, - int type, xfs_agblock_t agbno, xfs_extlen_t len), - TP_ARGS(mp, agno, type, agbno, len), - TP_STRUCT__entry( - __field(dev_t, dev) - __field(xfs_agnumber_t, agno) - __field(int, type) - __field(xfs_agblock_t, agbno) - __field(xfs_extlen_t, len) - ), - TP_fast_assign( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->type = type; - __entry->agbno = agbno; - __entry->len = len; - ), - TP_printk("dev %d:%d op %d agno 0x%x agbno 0x%x fsbcount 0x%x", -MAJOR (__entry->dev),MINOR (__entry->dev), - __entry->type, - __entry->agno, - __entry->agbno, - __entry->len) -); -#define DEFINE_PHYS_EXTENT_DEFERRED_EVENT (name) \ -DEFINE_EVENT(xfs_phys_extent_deferred_class, name, \ - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ - int type, \ - xfs_agblock_t bno, \ - xfs_extlen_t len), \ - TP_ARGS(mp, agno, type, bno, len)) - -DECLARE_EVENT_CLASS (xfs_map_extent_deferred_class, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, - int op, - xfs_agblock_t agbno, - xfs_ino_t ino, - int whichfork, - xfs_fileoff_t offset, - xfs_filblks_t len, - xfs_exntst_t state), -TP_ARGS (mp, agno, op, agbno, ino, whichfork, offset, len, state), -TP_STRUCT__entry ( - __field(dev_t, dev) - __field(xfs_agnumber_t, agno) - __field(xfs_ino_t, ino) - __field(xfs_agblock_t, agbno) - __field(int, whichfork) - __field(xfs_fileoff_t, l_loff) - __field(xfs_filblks_t, l_len) - __field(xfs_exntst_t, l_state) -__field (int, op) - ), -TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->ino = ino; - __entry->agbno = agbno; - __entry->whichfork = whichfork; - __entry->l_loff = offset; - __entry->l_len = len; - __entry->l_state = state; - __entry->op = op; - ), -TP_printk ("dev %d:%d op %d agno 0x%x agbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d" , -MAJOR (__entry->dev),MINOR (__entry->dev), - __entry->op, - __entry->agno, - __entry->agbno, - __entry->ino, -__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), - __entry->l_loff, - __entry->l_len, - __entry->l_state) -); -#define DEFINE_MAP_EXTENT_DEFERRED_EVENT (name) \ -DEFINE_EVENT(xfs_map_extent_deferred_class, name, \ - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ - int op, \ - xfs_agblock_t agbno, \ - xfs_ino_t ino, \ - int whichfork, \ - xfs_fileoff_t offset, \ - xfs_filblks_t len, \ - xfs_exntst_t state), \ - TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state)) - DEFINE_DEFER_EVENT(xfs_defer_cancel);DEFINE_DEFER_EVENT (xfs_defer_trans_roll);DEFINE_DEFER_EVENT (xfs_defer_trans_abort);
@@ -2764,11 +2676,42 @@ DEFINE_DEFER_PENDING_EVENT(xfs_defer_isolate_paused);DEFINE_DEFER_PENDING_EVENT (xfs_defer_item_pause);DEFINE_DEFER_PENDING_EVENT (xfs_defer_item_unpause); -#define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT -DEFINE_BMAP_FREE_DEFERRED_EVENT (xfs_bmap_free_defer); -DEFINE_BMAP_FREE_DEFERRED_EVENT (xfs_bmap_free_deferred); -DEFINE_BMAP_FREE_DEFERRED_EVENT (xfs_agfl_free_defer); -DEFINE_BMAP_FREE_DEFERRED_EVENT (xfs_agfl_free_deferred); +DECLARE_EVENT_CLASS (xfs_free_extent_deferred_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + int type, xfs_agblock_t agbno, xfs_extlen_t len), +TP_ARGS (mp, agno, type, agbno, len), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(int, type) + __field(xfs_agblock_t, agbno) +__field (xfs_extlen_t, len) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->type = type; + __entry->agbno = agbno; + __entry->len = len; + ), +TP_printk ("dev %d:%d op %d agno 0x%x agbno 0x%x fsbcount 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->type, + __entry->agno, + __entry->agbno, + __entry->len) +); +#define DEFINE_FREE_EXTENT_DEFERRED_EVENT (name) \ +DEFINE_EVENT(xfs_free_extent_deferred_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + int type, \ + xfs_agblock_t bno, \ + xfs_extlen_t len), \ + TP_ARGS(mp, agno, type, bno, len)) +DEFINE_FREE_EXTENT_DEFERRED_EVENT (xfs_bmap_free_defer); +DEFINE_FREE_EXTENT_DEFERRED_EVENT (xfs_bmap_free_deferred); +DEFINE_FREE_EXTENT_DEFERRED_EVENT (xfs_agfl_free_defer); +DEFINE_FREE_EXTENT_DEFERRED_EVENT (xfs_agfl_free_deferred); DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp,
@@ -2933,7 +2876,60 @@ DEFINE_EVENT(xfs_rmapbt_class, name, \ uint64_t owner, uint64_t offset, unsigned int flags), \ TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) -#define DEFINE_RMAP_DEFERRED_EVENT DEFINE_MAP_EXTENT_DEFERRED_EVENT +DECLARE_EVENT_CLASS(xfs_rmap_deferred_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + int op, + xfs_agblock_t agbno, + xfs_ino_t ino, + int whichfork, + xfs_fileoff_t offset, + xfs_filblks_t len, + xfs_exntst_t state), + TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state), + TP_STRUCT__entry( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_ino_t, ino) + __field(xfs_agblock_t, agbno) + __field(int, whichfork) + __field(xfs_fileoff_t, l_loff) + __field(xfs_filblks_t, l_len) + __field(xfs_exntst_t, l_state) + __field(int, op) + ), + TP_fast_assign( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->ino = ino; + __entry->agbno = agbno; + __entry->whichfork = whichfork; + __entry->l_loff = offset; + __entry->l_len = len; + __entry->l_state = state; + __entry->op = op; + ), + TP_printk("dev %d:%d op %d agno 0x%x agbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->op, + __entry->agno, + __entry->agbno, + __entry->ino, +__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), + __entry->l_loff, + __entry->l_len, + __entry->l_state) +); +#define DEFINE_RMAP_DEFERRED_EVENT (name) \ +DEFINE_EVENT(xfs_rmap_deferred_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + int op, \ + xfs_agblock_t agbno, \ + xfs_ino_t ino, \ + int whichfork, \ + xfs_fileoff_t offset, \ + xfs_filblks_t len, \ + xfs_exntst_t state), \ + TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state))DEFINE_RMAP_DEFERRED_EVENT (xfs_rmap_defer);DEFINE_RMAP_DEFERRED_EVENT (xfs_rmap_deferred);
@@ -2953,7 +2949,60 @@ DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result);DEFINE_RMAPBT_EVENT (xfs_rmap_find_left_neighbor_result);/* deferred bmbt updates */ -#define DEFINE_BMAP_DEFERRED_EVENT DEFINE_RMAP_DEFERRED_EVENT +DECLARE_EVENT_CLASS (xfs_bmap_deferred_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + int op, + xfs_agblock_t agbno, + xfs_ino_t ino, + int whichfork, + xfs_fileoff_t offset, + xfs_filblks_t len, + xfs_exntst_t state), +TP_ARGS (mp, agno, op, agbno, ino, whichfork, offset, len, state), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(xfs_ino_t, ino) + __field(xfs_agblock_t, agbno) + __field(int, whichfork) + __field(xfs_fileoff_t, l_loff) + __field(xfs_filblks_t, l_len) + __field(xfs_exntst_t, l_state) +__field (int, op) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->ino = ino; + __entry->agbno = agbno; + __entry->whichfork = whichfork; + __entry->l_loff = offset; + __entry->l_len = len; + __entry->l_state = state; + __entry->op = op; + ), +TP_printk ("dev %d:%d op %d agno 0x%x agbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->op, + __entry->agno, + __entry->agbno, + __entry->ino, +__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), + __entry->l_loff, + __entry->l_len, + __entry->l_state) +); +#define DEFINE_BMAP_DEFERRED_EVENT (name) \ +DEFINE_EVENT(xfs_bmap_deferred_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + int op, \ + xfs_agblock_t agbno, \ + xfs_ino_t ino, \ + int whichfork, \ + xfs_fileoff_t offset, \ + xfs_filblks_t len, \ + xfs_exntst_t state), \ + TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state))DEFINE_BMAP_DEFERRED_EVENT (xfs_bmap_defer);DEFINE_BMAP_DEFERRED_EVENT (xfs_bmap_deferred);
@@ -3330,7 +3379,39 @@ DEFINE_AG_ERROR_EVENT(xfs_refcount_find_right_extent_error);DEFINE_AG_EXTENT_EVENT (xfs_refcount_find_shared);DEFINE_AG_EXTENT_EVENT (xfs_refcount_find_shared_result);DEFINE_AG_ERROR_EVENT (xfs_refcount_find_shared_error); -#define DEFINE_REFCOUNT_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT + +DECLARE_EVENT_CLASS (xfs_refcount_deferred_class, + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, + int type, xfs_agblock_t agbno, xfs_extlen_t len), +TP_ARGS (mp, agno, type, agbno, len), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_agnumber_t, agno) + __field(int, type) + __field(xfs_agblock_t, agbno) +__field (xfs_extlen_t, len) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->agno = agno; + __entry->type = type; + __entry->agbno = agbno; + __entry->len = len; + ), +TP_printk ("dev %d:%d op %d agno 0x%x agbno 0x%x fsbcount 0x%x" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->type, + __entry->agno, + __entry->agbno, + __entry->len) +); +#define DEFINE_REFCOUNT_DEFERRED_EVENT (name) \ +DEFINE_EVENT(xfs_refcount_deferred_class, name, \ + TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ + int type, \ + xfs_agblock_t bno, \ + xfs_extlen_t len), \ + TP_ARGS(mp, agno, type, bno, len))DEFINE_REFCOUNT_DEFERRED_EVENT (xfs_refcount_defer);DEFINE_REFCOUNT_DEFERRED_EVENT (xfs_refcount_deferred);
Re: [PATCH 1/7] xfs: split tracepoint classes for deferred items
Looks good:
PATCH 2/7 xfs: clean up bmap log intent item tracepoint callsites
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Pass the incore bmap structure to the tracepoints instead of open-coding the argument passing.
--- fs/xfs/libxfs/xfs_bmap.c | 19 +++------------- fs/xfs/libxfs/xfs_bmap.h | 4 +++ fs/xfs/xfs_trace.c | 1 + fs/xfs/xfs_trace.h | 54 ++++++++++++++++++++-------------------------- 4 files changed, 32 insertions(+), 46 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +3 -16
@@ -6169,15 +6169,6 @@ __xfs_bmap_add( {struct xfs_bmap_intent *bi; -trace_xfs_bmap_defer (tp->t_mountp, -XFS_FSB_TO_AGNO (tp->t_mountp, bmap->br_startblock), - type, -XFS_FSB_TO_AGBNO (tp->t_mountp, bmap->br_startblock), - ip->i_ino, whichfork, - bmap->br_startoff, - bmap->br_blockcount, - bmap->br_state); - bi =kmem_cache_alloc (xfs_bmap_intent_cache,GFP_NOFS | __GFP_NOFAIL);INIT_LIST_HEAD (&bi->bi_list); bi->bi_type = type;
@@ -6185,6 +6176,8 @@ __xfs_bmap_add( bi->bi_whichfork = whichfork; bi->bi_bmap = *bmap; +trace_xfs_bmap_defer (bi); +xfs_bmap_update_get_group (tp->t_mountp, bi);xfs_defer_add (tp, &bi->bi_list, &xfs_bmap_update_defer_type);return 0 ;
@@ -6230,13 +6223,7 @@ xfs_bmap_finish_one(ASSERT (tp->t_highest_agno ==NULLAGNUMBER ); -trace_xfs_bmap_deferred (tp->t_mountp, -XFS_FSB_TO_AGNO (tp->t_mountp, bmap->br_startblock), - bi->bi_type, -XFS_FSB_TO_AGBNO (tp->t_mountp, bmap->br_startblock), - bi->bi_owner->i_ino, bi->bi_whichfork, - bmap->br_startoff, bmap->br_blockcount, - bmap->br_state); +trace_xfs_bmap_deferred (bi);if (WARN_ON_ONCE (bi->bi_whichfork !=XFS_DATA_FORK )) {xfs_bmap_mark_sick (bi->bi_owner, bi->bi_whichfork);
fs/xfs/libxfs/xfs_bmap.h +4 -0
@@ -230,6 +230,10 @@ enum xfs_bmap_intent_type { XFS_BMAP_UNMAP, }; +#define XFS_BMAP_INTENT_STRINGS \ + { XFS_BMAP_MAP, "map" }, \ + { XFS_BMAP_UNMAP, "unmap" } +struct xfs_bmap_intent {struct list_head bi_list;enum xfs_bmap_intent_type bi_type;
fs/xfs/xfs_trace.c +1 -0
@@ -39,6 +39,7 @@#include "scrub/xfile.h" #include "scrub/xfbtree.h" #include "xfs_btree_mem.h" +#include "xfs_bmap.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +24 -30
83 lines not on this page · raw message
Re: [PATCH 2/7] xfs: clean up bmap log intent item tracepoint callsites
Looks good:
PATCH 3/7 xfs: remove xfs_trans_set_bmap_flags
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Remove this single-use helper.
--- fs/xfs/xfs_bmap_item.c | 38 +++++++++++++------------------------- 1 file changed, 13 insertions(+), 25 deletions(-)
fs/xfs/xfs_bmap_item.c +13 -25
@@ -236,29 +236,6 @@ xfs_bmap_update_diff_items(return ba->bi_owner->i_ino - bb->bi_owner->i_ino; } -/* Set the map extent flags for this mapping. */ -static void -xfs_trans_set_bmap_flags ( -struct xfs_map_extent *map, -enum xfs_bmap_intent_type type, -int whichfork, -xfs_exntst_t state) -{ - map->me_flags =0 ; -switch (type) { -case XFS_BMAP_MAP : -case XFS_BMAP_UNMAP : - map->me_flags = type; -break ; -default : -ASSERT (0 ); - } -if (state ==XFS_EXT_UNWRITTEN ) - map->me_flags |=XFS_BMAP_EXTENT_UNWRITTEN ; -if (whichfork ==XFS_ATTR_FORK ) - map->me_flags |=XFS_BMAP_EXTENT_ATTR_FORK ; -} -/* Log bmap updates in the intent item. */ STATIC void xfs_bmap_update_log_item(
@@ -281,8 +258,19 @@ xfs_bmap_update_log_item( map->me_startblock = bi->bi_bmap.br_startblock; map->me_startoff = bi->bi_bmap.br_startoff; map->me_len = bi->bi_bmap.br_blockcount; -xfs_trans_set_bmap_flags (map, bi->bi_type, bi->bi_whichfork, - bi->bi_bmap.br_state); + +switch (bi->bi_type) { +case XFS_BMAP_MAP : +case XFS_BMAP_UNMAP : + map->me_flags = bi->bi_type; +break ; +default : +ASSERT (0 ); + } +if (bi->bi_bmap.br_state ==XFS_EXT_UNWRITTEN ) + map->me_flags |=XFS_BMAP_EXTENT_UNWRITTEN ; +if (bi->bi_whichfork ==XFS_ATTR_FORK ) + map->me_flags |=XFS_BMAP_EXTENT_ATTR_FORK ; } static struct xfs_log_item *
Re: [PATCH 3/7] xfs: remove xfs_trans_set_bmap_flags
Looks good:
PATCH 4/7 xfs: add a bi_entry helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a helper to translate from the item list head to the bmap_intent structure and use it so shorten assignments and avoid the need for extra local variables.
--- fs/xfs/xfs_bmap_item.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)
fs/xfs/xfs_bmap_item.c +9 -10
@@ -221,6 +221,11 @@ static const struct xfs_item_ops xfs_bud_item_ops = { .iop_intent = xfs_bud_item_intent, }; +static inline struct xfs_bmap_intent *bi_entry (const struct list_head *e) +{ + return list_entry(e, struct xfs_bmap_intent, bi_list); +} +/* Sort bmap intents by inode. */ static int xfs_bmap_update_diff_items(
@@ -228,11 +233,9 @@ xfs_bmap_update_diff_items(const struct list_head *a, const struct list_head *b) { - struct xfs_bmap_intent *ba; -struct xfs_bmap_intent *bb; + struct xfs_bmap_intent *ba = bi_entry(a); +struct xfs_bmap_intent *bb =bi_entry (b); - ba = container_of(a, struct xfs_bmap_intent, bi_list); - bb = container_of(b, struct xfs_bmap_intent, bi_list);return ba->bi_owner->i_ino - bb->bi_owner->i_ino; }
@@ -348,11 +351,9 @@ xfs_bmap_update_finish_item(struct list_head *item, struct xfs_btree_cur **state) { - struct xfs_bmap_intent *bi; + struct xfs_bmap_intent *bi = bi_entry(item);int error; - bi = container_of(item, struct xfs_bmap_intent, bi_list); - error =xfs_bmap_finish_one (tp, bi);if (!error && bi->bi_bmap.br_blockcount >0 ) {ASSERT (bi->bi_type ==XFS_BMAP_UNMAP );
@@ -377,9 +378,7 @@ STATIC voidxfs_bmap_update_cancel_item ( struct list_head *item) { -struct xfs_bmap_intent *bi; - - bi = container_of(item, struct xfs_bmap_intent, bi_list); +struct xfs_bmap_intent *bi =bi_entry (item);xfs_bmap_update_put_group (bi);kmem_cache_free (xfs_bmap_intent_cache, bi);
Re: [PATCH 4/7] xfs: add a bi_entry helper
Looks good:
PATCH 5/7 xfs: reuse xfs_bmap_update_cancel_item
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Reuse xfs_bmap_update_cancel_item to put the AG/RTG and free the item in a few places that currently open code the logic.
--- fs/xfs/xfs_bmap_item.c | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-)
fs/xfs/xfs_bmap_item.c +12 -13
@@ -343,6 +343,17 @@ xfs_bmap_update_put_group(xfs_perag_intent_put (bi->bi_pag); } +/* Cancel a deferred bmap update. */ +STATIC void +xfs_bmap_update_cancel_item ( +struct list_head *item) +{ +struct xfs_bmap_intent *bi =bi_entry (item); + +xfs_bmap_update_put_group (bi); +kmem_cache_free (xfs_bmap_intent_cache, bi); +} +/* Process a deferred bmap update. */ STATIC int xfs_bmap_update_finish_item(
@@ -360,8 +371,7 @@ xfs_bmap_update_finish_item(return -EAGAIN ; } -xfs_bmap_update_put_group (bi); -kmem_cache_free (xfs_bmap_intent_cache, bi); +xfs_bmap_update_cancel_item (item);return error; }
@@ -373,17 +383,6 @@ xfs_bmap_update_abort_intent(xfs_bui_release (BUI_ITEM (intent)); } -/* Cancel a deferred bmap update. */ -STATIC void -xfs_bmap_update_cancel_item ( -struct list_head *item) -{ -struct xfs_bmap_intent *bi =bi_entry (item); - -xfs_bmap_update_put_group (bi); -kmem_cache_free (xfs_bmap_intent_cache, bi); -} -/* Is this recovered BUI ok? */ static inline bool xfs_bui_validate(
Re: [PATCH 5/7] xfs: reuse xfs_bmap_update_cancel_item
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Reuse
xfs_bmap_update_cancel_itemto put the AG/RTG and free the item in a few places that currently open code the logic.Inspired-by Christoph Hellwig <[email protected]>Signed-off-by Darrick J. Wong <[email protected]>
Isn't this actually pretty much exactly my patch?
Either way this looks (obviously :)) good:
Re: [PATCH 5/7] xfs: reuse xfs_bmap_update_cancel_item
Quoted 10 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Reuse
xfs_bmap_update_cancel_itemto put the AG/RTG and free the item in a few places that currently open code the logic.Inspired-by Christoph Hellwig <[email protected]>Signed-off-by Darrick J. Wong <[email protected]>Isn't this actually pretty much exactly my patch?
Yeah, but with some non-trivial alterations, so that's why I went with the tagset presented here.
Quoted 3 lines
Either way this looks (obviously :)) good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 6/7 xfs: move xfs_bmap_defer_add to xfs_bmap_item.c
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the code that adds the incore xfs_bmap_item deferred work data to a transaction live with the BUI log item code. This means that the file mapping code no longer has to know about the inner workings of the BUI log items.
As a consequence, we can hide the _get_group helper.
--- fs/xfs/libxfs/xfs_bmap.c | 6 ++---- fs/xfs/libxfs/xfs_bmap.h | 3 --- fs/xfs/xfs_bmap_item.c | 15 ++++++++++++++- fs/xfs/xfs_bmap_item.h | 4 ++++ 4 files changed, 20 insertions(+), 8 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +2 -4
@@ -37,6 +37,7 @@#include "xfs_icache.h" #include "xfs_iomap.h" #include "xfs_health.h" +#include "xfs_bmap_item.h" struct kmem_cache *xfs_bmap_intent_cache;
@@ -6176,10 +6177,7 @@ __xfs_bmap_add( bi->bi_whichfork = whichfork; bi->bi_bmap = *bmap; -trace_xfs_bmap_defer (bi); - -xfs_bmap_update_get_group (tp->t_mountp, bi); -xfs_defer_add (tp, &bi->bi_list, &xfs_bmap_update_defer_type); +xfs_bmap_defer_add (tp, bi);return 0 ; }
fs/xfs/libxfs/xfs_bmap.h +0 -3
@@ -243,9 +243,6 @@ struct xfs_bmap_intent {struct xfs_bmbt_irec bi_bmap; }; -void xfs_bmap_update_get_group (struct xfs_mount *mp, -struct xfs_bmap_intent *bi); -int xfs_bmap_finish_one (struct xfs_trans *tp,struct xfs_bmap_intent *bi);void xfs_bmap_map_extent (struct xfs_trans *tp,struct xfs_inode *ip,struct xfs_bmbt_irec *imap);
fs/xfs/xfs_bmap_item.c +14 -1
@@ -25,6 +25,7 @@#include "xfs_log_priv.h" #include "xfs_log_recover.h" #include "xfs_ag.h" +#include "xfs_trace.h" struct kmem_cache *xfs_bui_cache;struct kmem_cache *xfs_bud_cache;
@@ -316,7 +317,7 @@ xfs_bmap_update_create_done( }/* Take a passive ref to the AG containing the space we're mapping. */ -void +static inline void xfs_bmap_update_get_group (struct xfs_mount *mp,struct xfs_bmap_intent *bi)
@@ -335,6 +336,18 @@ xfs_bmap_update_get_group( bi->bi_pag =xfs_perag_intent_get (mp, agno); } +/* Add this deferred BUI to the transaction. */ +void +xfs_bmap_defer_add ( +struct xfs_trans *tp, +struct xfs_bmap_intent *bi) +{ +trace_xfs_bmap_defer (bi); + +xfs_bmap_update_get_group (tp->t_mountp, bi); +xfs_defer_add (tp, &bi->bi_list, &xfs_bmap_update_defer_type); +} +/* Release a passive AG ref after finishing mapping work. */ static inline void xfs_bmap_update_put_group(
fs/xfs/xfs_bmap_item.h +4 -0
@@ -68,4 +68,8 @@ struct xfs_bud_log_item {extern struct kmem_cache *xfs_bui_cache;extern struct kmem_cache *xfs_bud_cache; +struct xfs_bmap_intent ; + +void xfs_bmap_defer_add (struct xfs_trans *tp,struct xfs_bmap_intent *bi); +#endif /* __XFS_BMAP_ITEM_H__ */
Re: [PATCH 6/7] xfs: move xfs_bmap_defer_add to xfs_bmap_item.c
Looks good:
PATCH 7/7 xfs: add a xattr_entry helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a helper to translate from the item list head to the attr_intent item structure and use it so shorten assignments and avoid the need for extra local variables.
--- fs/xfs/xfs_attr_item.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
fs/xfs/xfs_attr_item.c +7 -4
@@ -391,6 +391,11 @@ xfs_attr_free_item(kmem_cache_free (xfs_attr_intent_cache, attr); } +static inline struct xfs_attr_intent *attri_entry (const struct list_head *e) +{ + return list_entry(e, struct xfs_attr_intent, xattri_list); +} +/* Process an attr. */ STATIC int xfs_attr_finish_item(
@@ -399,11 +404,10 @@ xfs_attr_finish_item(struct list_head *item, struct xfs_btree_cur **state) { - struct xfs_attr_intent *attr; + struct xfs_attr_intent *attr = attri_entry(item);struct xfs_da_args *args;int error; - attr = container_of(item, struct xfs_attr_intent, xattri_list); args = attr->xattri_da_args;/* Reset trans after EAGAIN cycle since the transaction is new */
@@ -443,9 +447,8 @@ STATIC voidxfs_attr_cancel_item ( struct list_head *item) { -struct xfs_attr_intent *attr; +struct xfs_attr_intent *attr =attri_entry (item); - attr = container_of(item, struct xfs_attr_intent, xattri_list);xfs_attr_free_item (attr); }
Re: [PATCH 7/7] xfs: add a xattr_entry helper
Looks good:
PATCH 13/28 xfs: widen BUI formats to support realtime
In reply to Darrick J. WongHi all,
Atomic extent swapping (and later, reverse mapping and reflink) on the realtime device needs to be able to defer file mapping and extent freeing work in much the same manner as is required on the data volume. Make the BUI log items operate on rt extents in preparation for atomic swapping and realtime rmap.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=realtime-bmap-intents
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=realtime-bmap-intents
--- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- fs/xfs/libxfs/xfs_log_format.h | 4 +++- fs/xfs/xfs_bmap_item.c | 17 +++++++++++++++++ fs/xfs/xfs_trace.h | 23 ++++++++++++++++++----- 4 files changed, 40 insertions(+), 8 deletions(-)
PATCH 1/3 xfs: fix xfs_bunmapi to allow unmapping of partial rt extents
From: Darrick J. Wong <[email protected]>
When XFS_BMAPI_REMAP is passed to bunmapi, that means that we want to remove part of a block mapping without touching the allocator. For realtime files with rtextsize > 1, that also means that we should skip all the code that changes a partial remove request into an unwritten extent conversion. IOWs, bunmapi in this mode should handle removing the mapping from the rt file and nothing else.
Note that XFS_BMAPI_REMAP callers are required to decrement the reference count and/or free the space manually.
--- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +2 -2
@@ -5431,7 +5431,7 @@ __xfs_bunmapi(if (del.br_startoff + del.br_blockcount > end +1 ) del.br_blockcount = end +1 - del.br_startoff; -if (!isrt) +if (!isrt || (flags &XFS_BMAPI_REMAP )) goto delete; mod = xfs_rtb_to_rtxoff(mp,
@@ -5449,7 +5449,7 @@ __xfs_bunmapi(* This piece is unwritten, or we're not * using unwritten extents. Skip over it. */ -ASSERT (end >= mod); +ASSERT ((flags &XFS_BMAPI_REMAP ) || end >= mod); end -= mod > del.br_blockcount ? del.br_blockcount : mod; if (end < got.br_startoff &&
Re: [PATCH 1/3] xfs: fix xfs_bunmapi to allow unmapping of partial rt extents
Looks good:
PATCH 2/3 xfs: add a realtime flag to the bmap update log redo items
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Extend the bmap update (BUI) log items with a new realtime flag that indicates that the updates apply against a realtime file's data fork. We'll wire up the actual code later.
--- fs/xfs/libxfs/xfs_log_format.h | 4 +++- fs/xfs/xfs_bmap_item.c | 8 ++++++++ fs/xfs/xfs_trace.h | 23 ++++++++++++++++++----- 3 files changed, 29 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_log_format.h +3 -1
@@ -838,10 +838,12 @@ struct xfs_cud_log_format {#define XFS_BMAP_EXTENT_ATTR_FORK (1U << 31)#define XFS_BMAP_EXTENT_UNWRITTEN (1U << 30) +#define XFS_BMAP_EXTENT_REALTIME (1U << 29)#define XFS_BMAP_EXTENT_FLAGS (XFS_BMAP_EXTENT_TYPE_MASK | \ XFS_BMAP_EXTENT_ATTR_FORK | \ - XFS_BMAP_EXTENT_UNWRITTEN) + XFS_BMAP_EXTENT_UNWRITTEN | \ + XFS_BMAP_EXTENT_REALTIME)/* * This is the structure used to lay out an bui log item in the
fs/xfs/xfs_bmap_item.c +8 -0
@@ -275,6 +275,8 @@ xfs_bmap_update_log_item( map->me_flags |=XFS_BMAP_EXTENT_UNWRITTEN ;if (bi->bi_whichfork ==XFS_ATTR_FORK ) map->me_flags |=XFS_BMAP_EXTENT_ATTR_FORK ; +if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) + map->me_flags |=XFS_BMAP_EXTENT_REALTIME ; } static struct xfs_log_item *
@@ -324,6 +326,9 @@ xfs_bmap_update_get_group( {xfs_agnumber_t agno; +if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) +return ; + agno =XFS_FSB_TO_AGNO (mp, bi->bi_bmap.br_startblock);/*
@@ -353,6 +358,9 @@ static inline voidxfs_bmap_update_put_group ( struct xfs_bmap_intent *bi) { +if (xfs_ifork_is_realtime (bi->bi_owner, bi->bi_whichfork)) +return ; +xfs_perag_intent_put (bi->bi_pag); }
fs/xfs/xfs_trace.h +18 -5
@@ -2958,9 +2958,11 @@ DECLARE_EVENT_CLASS(xfs_bmap_deferred_class,TP_ARGS (bi),TP_STRUCT__entry ( __field(dev_t, dev) + __field(dev_t, opdev) __field(xfs_agnumber_t, agno) __field(xfs_ino_t, ino) __field(xfs_agblock_t, agbno) + __field(xfs_fsblock_t, rtbno) __field(int, whichfork) __field(xfs_fileoff_t, l_loff) __field(xfs_filblks_t, l_len)
@@ -2971,23 +2973,34 @@ DECLARE_EVENT_CLASS(xfs_bmap_deferred_class,struct xfs_inode *ip = bi->bi_owner; __entry->dev = ip->i_mount->m_super->s_dev; - __entry->agno =XFS_FSB_TO_AGNO (ip->i_mount, - bi->bi_bmap.br_startblock); +if (xfs_ifork_is_realtime (ip, bi->bi_whichfork)) { + __entry->agno =0 ; + __entry->agbno =0 ; + __entry->rtbno = bi->bi_bmap.br_startblock; + __entry->opdev = ip->i_mount->m_rtdev_targp->bt_dev; + }else { + __entry->agno =XFS_FSB_TO_AGNO (ip->i_mount, + bi->bi_bmap.br_startblock); + __entry->agbno =XFS_FSB_TO_AGBNO (ip->i_mount, + bi->bi_bmap.br_startblock); + __entry->rtbno =0 ; + __entry->opdev = __entry->dev; + } __entry->ino = ip->i_ino; - __entry->agbno =XFS_FSB_TO_AGBNO (ip->i_mount, - bi->bi_bmap.br_startblock); __entry->whichfork = bi->bi_whichfork; __entry->l_loff = bi->bi_bmap.br_startoff; __entry->l_len = bi->bi_bmap.br_blockcount; __entry->l_state = bi->bi_bmap.br_state; __entry->op = bi->bi_type; ), - TP_printk("dev %d:%d op %s ino 0x%llx agno 0x%x agbno 0x%x %s fileoff 0x%llx fsbcount 0x%llx state %d", + TP_printk("dev %d:%d op %s opdev %d:%d ino 0x%llx agno 0x%x agbno 0x%x rtbno 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", MAJOR(__entry->dev), MINOR(__entry->dev), __print_symbolic(__entry->op, XFS_BMAP_INTENT_STRINGS), + MAJOR(__entry->opdev), MINOR(__entry->opdev), __entry->ino, __entry->agno, __entry->agbno, + __entry->rtbno, __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), __entry->l_loff, __entry->l_len,
Re: [PATCH 2/3] xfs: add a realtime flag to the bmap update log redo items
Looks good:
PATCH 3/3 xfs: support recovering bmap intent items targetting realtime extents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we have reflink on the realtime device, bmap intent items have to support remapping extents on the realtime volume.
--- fs/xfs/xfs_bmap_item.c | 9 +++++++++ 1 file changed, 9 insertions(+)
fs/xfs/xfs_bmap_item.c +9 -0
@@ -435,6 +435,9 @@ xfs_bui_validate(if (!xfs_verify_fileext (mp, map->me_startoff, map->me_len))return false; +if (map->me_flags &XFS_BMAP_EXTENT_REALTIME ) +return xfs_verify_rtbext (mp, map->me_startblock, map->me_len); +return xfs_verify_fsbext (mp, map->me_startblock, map->me_len); }
@@ -509,6 +512,12 @@ xfs_bmap_recover_work(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); +if (!!(map->me_flags &XFS_BMAP_EXTENT_REALTIME ) != +xfs_ifork_is_realtime (ip, work->bi_whichfork)) { + error = -EFSCORRUPTED ; + goto err_cancel; + } +if (work->bi_type ==XFS_BMAP_MAP ) iext_delta =XFS_IEXT_ADD_NOSPLIT_CNT ;else
Re: [PATCH 3/3] xfs: support recovering bmap intent items targetting realtime extents
Looks good:
PATCH 14/28 xfs: support attrfork and unwritten BUIs
In reply to Darrick J. WongHi all,
In preparation for atomic extent swapping and the online repair functionality that wants atomic extent swaps, enhance the BUI code so that we can support deferred work on the extended attribute fork and on unwritten extents.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=expand-bmap-intent-usage
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=expand-bmap-intent-usage
--- fs/xfs/libxfs/xfs_bmap.c | 49 ++++++++++++++++++++-------------------------- fs/xfs/libxfs/xfs_bmap.h | 4 ++-- fs/xfs/xfs_bmap_util.c | 8 ++++---- fs/xfs/xfs_reflink.c | 8 ++++---- 4 files changed, 31 insertions(+), 38 deletions(-)
PATCH 1/2 xfs: support deferred bmap updates on the attr fork
From: Darrick J. Wong <[email protected]>
The deferred bmap update log item has always supported the attr fork, so plumb this in so that higher layers can access this.
--- fs/xfs/libxfs/xfs_bmap.c | 47 +++++++++++++++++++--------------------------- fs/xfs/libxfs/xfs_bmap.h | 4 ++-- fs/xfs/xfs_bmap_util.c | 8 ++++---- fs/xfs/xfs_reflink.c | 8 ++++---- 4 files changed, 29 insertions(+), 38 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +19 -28
@@ -6150,17 +6150,8 @@ xfs_bmap_split_extent(return error; } -/* Deferred mapping is only for real extents in the data fork. */ -static bool -xfs_bmap_is_update_needed ( -struct xfs_bmbt_irec *bmap) -{ -return bmap->br_startblock !=HOLESTARTBLOCK && - bmap->br_startblock !=DELAYSTARTBLOCK ; -} -/* Record a bmap intent. */ -static int +static inline void __xfs_bmap_add( struct xfs_trans *tp, enum xfs_bmap_intent_type type,
@@ -6170,6 +6161,11 @@ __xfs_bmap_add( {struct xfs_bmap_intent *bi; +if ((whichfork !=XFS_DATA_FORK && whichfork !=XFS_ATTR_FORK ) || + bmap->br_startblock ==HOLESTARTBLOCK || + bmap->br_startblock ==DELAYSTARTBLOCK ) +return ; + bi =kmem_cache_alloc (xfs_bmap_intent_cache,GFP_NOFS | __GFP_NOFAIL);INIT_LIST_HEAD (&bi->bi_list); bi->bi_type = type;
@@ -6178,7 +6174,6 @@ __xfs_bmap_add( bi->bi_bmap = *bmap;xfs_bmap_defer_add (tp, bi); -return 0 ; }/* Map an extent into a file. */
@@ -6186,12 +6181,10 @@ voidxfs_bmap_map_extent ( struct xfs_trans *tp, struct xfs_inode *ip, + int whichfork, struct xfs_bmbt_irec *PREV) { - if (!xfs_bmap_is_update_needed(PREV)) - return; - -__xfs_bmap_add (tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV); +__xfs_bmap_add (tp, XFS_BMAP_MAP, ip, whichfork, PREV); }/* Unmap an extent out of a file. */
@@ -6199,12 +6192,10 @@ voidxfs_bmap_unmap_extent ( struct xfs_trans *tp, struct xfs_inode *ip, + int whichfork, struct xfs_bmbt_irec *PREV) { - if (!xfs_bmap_is_update_needed(PREV)) - return; - -__xfs_bmap_add (tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV); +__xfs_bmap_add (tp, XFS_BMAP_UNMAP, ip, whichfork, PREV); }/*
@@ -6218,29 +6209,29 @@ xfs_bmap_finish_one( {struct xfs_bmbt_irec *bmap = &bi->bi_bmap;int error =0 ; +int flags =0 ; + +if (bi->bi_whichfork ==XFS_ATTR_FORK ) + flags |=XFS_BMAPI_ATTRFORK ;ASSERT (tp->t_highest_agno ==NULLAGNUMBER );trace_xfs_bmap_deferred (bi); -if (WARN_ON_ONCE (bi->bi_whichfork !=XFS_DATA_FORK )) { -xfs_bmap_mark_sick (bi->bi_owner, bi->bi_whichfork); -return -EFSCORRUPTED ; - } - -if (XFS_TEST_ERROR (false, tp->t_mountp, -XFS_ERRTAG_BMAP_FINISH_ONE )) +if (XFS_TEST_ERROR (false, tp->t_mountp,XFS_ERRTAG_BMAP_FINISH_ONE ))return -EIO ;switch (bi->bi_type) {case XFS_BMAP_MAP : error =xfs_bmapi_remap (tp, bi->bi_owner, bmap->br_startoff, - bmap->br_blockcount, bmap->br_startblock,0 ); + bmap->br_blockcount, bmap->br_startblock, + flags); bmap->br_blockcount =0 ;break ;case XFS_BMAP_UNMAP : error =__xfs_bunmapi (tp, bi->bi_owner, bmap->br_startoff, - &bmap->br_blockcount,XFS_BMAPI_REMAP ,1 ); + &bmap->br_blockcount, flags |XFS_BMAPI_REMAP , +1 );break ;default :ASSERT (0 );
fs/xfs/libxfs/xfs_bmap.h +2 -2
@@ -245,9 +245,9 @@ struct xfs_bmap_intent {int xfs_bmap_finish_one (struct xfs_trans *tp,struct xfs_bmap_intent *bi);void xfs_bmap_map_extent (struct xfs_trans *tp,struct xfs_inode *ip, -struct xfs_bmbt_irec *imap); +int whichfork,struct xfs_bmbt_irec *imap);void xfs_bmap_unmap_extent (struct xfs_trans *tp,struct xfs_inode *ip, -struct xfs_bmbt_irec *imap); +int whichfork,struct xfs_bmbt_irec *imap);static inline uint32_t xfs_bmap_fork_to_state (int whichfork) {
fs/xfs/xfs_bmap_util.c +4 -4
@@ -1448,16 +1448,16 @@ xfs_swap_extent_rmap( }/* Remove the mapping from the donor file. */ -xfs_bmap_unmap_extent (tp, tip, &uirec); +xfs_bmap_unmap_extent (tp, tip,XFS_DATA_FORK , &uirec);/* Remove the mapping from the source file. */ -xfs_bmap_unmap_extent (tp, ip, &irec); +xfs_bmap_unmap_extent (tp, ip,XFS_DATA_FORK , &irec);/* Map the donor file's blocks into the source file. */ -xfs_bmap_map_extent (tp, ip, &uirec); +xfs_bmap_map_extent (tp, ip,XFS_DATA_FORK , &uirec);/* Map the source file's blocks into the donor file. */ -xfs_bmap_map_extent (tp, tip, &irec); +xfs_bmap_map_extent (tp, tip,XFS_DATA_FORK , &irec); error =xfs_defer_finish (tpp); tp = *tpp;
fs/xfs/xfs_reflink.c +4 -4
@@ -806,7 +806,7 @@ xfs_reflink_end_cow_extent(* If the extent we're remapping is backed by storage (written * or not), unmap the extent and drop its refcount. */ -xfs_bmap_unmap_extent (tp, ip, &data); +xfs_bmap_unmap_extent (tp, ip,XFS_DATA_FORK , &data);xfs_refcount_decrease_extent (tp, &data);xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_BCOUNT , -data.br_blockcount);
@@ -830,7 +830,7 @@ xfs_reflink_end_cow_extent(xfs_refcount_free_cow_extent (tp, del.br_startblock, del.br_blockcount);/* Map the new blocks into the data fork. */ -xfs_bmap_map_extent (tp, ip, &del); +xfs_bmap_map_extent (tp, ip,XFS_DATA_FORK , &del);/* Charge this new data fork mapping to the on-disk quota. */ xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_DELBCOUNT,
@@ -1294,7 +1294,7 @@ xfs_reflink_remap_extent(* If the extent we're unmapping is backed by storage (written * or not), unmap the extent and drop its refcount. */ -xfs_bmap_unmap_extent (tp, ip, &smap); +xfs_bmap_unmap_extent (tp, ip,XFS_DATA_FORK , &smap);xfs_refcount_decrease_extent (tp, &smap); qdelta -= smap.br_blockcount; }else if (smap.br_startblock ==DELAYSTARTBLOCK ) {
@@ -1319,7 +1319,7 @@ xfs_reflink_remap_extent(*/ if (dmap_written) {xfs_refcount_increase_extent (tp, dmap); -xfs_bmap_map_extent (tp, ip, dmap); +xfs_bmap_map_extent (tp, ip,XFS_DATA_FORK , dmap); qdelta += dmap->br_blockcount; }
Re: [PATCH 1/2] xfs: support deferred bmap updates on the attr fork
Looks good:
PATCH 2/2 xfs: xfs_bmap_finish_one should map unwritten extents properly
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The deferred bmap work state and the log item can transmit unwritten state, so the XFS_BMAP_MAP handler must map in extents with that unwritten state.
--- fs/xfs/libxfs/xfs_bmap.c | 2 ++ 1 file changed, 2 insertions(+)
fs/xfs/libxfs/xfs_bmap.c +2 -0
@@ -6223,6 +6223,8 @@ xfs_bmap_finish_one(switch (bi->bi_type) {case XFS_BMAP_MAP : +if (bi->bi_bmap.br_state ==XFS_EXT_UNWRITTEN ) + flags |=XFS_BMAPI_PREALLOC ; error =xfs_bmapi_remap (tp, bi->bi_owner, bmap->br_startoff, bmap->br_blockcount, bmap->br_startblock, flags);
Re: [PATCH 2/2] xfs: xfs_bmap_finish_one should map unwritten extents properly
Looks good:
PATCH 15/28 xfs: clean up symbolic link code
In reply to Darrick J. WongHi all,
This series cleans up a few bits of the symbolic link code as needed for future projects. Online repair requires the ability to commit fixed fork-based filesystem metadata such as directories, xattrs, and symbolic links atomically, so we need to rearrange the symlink code before we land the atomic extent swapping.
Accomplish this by moving the remote symlink target block code and declarations to xfs_symlink_remote.[ch].
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=symlink-cleanups
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=symlink-cleanups
--- fs/xfs/libxfs/xfs_bmap.c | 1 fs/xfs/libxfs/xfs_inode_fork.c | 1 fs/xfs/libxfs/xfs_shared.h | 13 --- fs/xfs/libxfs/xfs_symlink_remote.c | 155 ++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_symlink_remote.h | 26 ++++++ fs/xfs/scrub/inode_repair.c | 1 fs/xfs/scrub/symlink.c | 3 - fs/xfs/xfs_symlink.c | 145 ++-------------------------------- fs/xfs/xfs_symlink.h | 1 9 files changed, 192 insertions(+), 154 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_symlink_remote.h
PATCH 1/3 xfs: move xfs_symlink_remote.c declarations to xfs_symlink_remote.h
From: Darrick J. Wong <[email protected]>
Move declarations for libxfs symlink functions into a separate header file like we do for most everything else.
--- fs/xfs/libxfs/xfs_bmap.c | 1 + fs/xfs/libxfs/xfs_inode_fork.c | 1 + fs/xfs/libxfs/xfs_shared.h | 13 ------------- fs/xfs/libxfs/xfs_symlink_remote.c | 2 +- fs/xfs/libxfs/xfs_symlink_remote.h | 22 ++++++++++++++++++++++ fs/xfs/scrub/inode_repair.c | 1 + fs/xfs/scrub/symlink.c | 1 + fs/xfs/xfs_symlink.c | 1 + 8 files changed, 28 insertions(+), 14 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_symlink_remote.h
fs/xfs/libxfs/xfs_bmap.c +1 -0
@@ -38,6 +38,7 @@#include "xfs_iomap.h" #include "xfs_health.h" #include "xfs_bmap_item.h" +#include "xfs_symlink_remote.h" struct kmem_cache *xfs_bmap_intent_cache;
fs/xfs/libxfs/xfs_inode_fork.c +1 -0
@@ -26,6 +26,7 @@#include "xfs_types.h" #include "xfs_errortag.h" #include "xfs_health.h" +#include "xfs_symlink_remote.h" struct kmem_cache *xfs_ifork_cache;
fs/xfs/libxfs/xfs_shared.h +0 -13
@@ -137,19 +137,6 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,#define XFS_ICHGTIME_CHG 0x2/* inode field change timestamp */ #define XFS_ICHGTIME_CREATE 0x4/* inode create timestamp */ - -/* -* Symlink decoding/encoding functions -*/ -int xfs_symlink_blocks (struct xfs_mount *mp,int pathlen); -int xfs_symlink_hdr_set (struct xfs_mount *mp,xfs_ino_t ino,uint32_t offset, -uint32_t size,struct xfs_buf *bp); -bool xfs_symlink_hdr_ok (xfs_ino_t ino,uint32_t offset, -uint32_t size,struct xfs_buf *bp); -void xfs_symlink_local_to_remote (struct xfs_trans *tp,struct xfs_buf *bp, -struct xfs_inode *ip,struct xfs_ifork *ifp); -xfs_failaddr_t xfs_symlink_shortform_verify (void *sfp,int64_t size); -/* Computed inode geometry for the filesystem. */ struct xfs_ino_geometry {/* Maximum inode count in this filesystem. */
fs/xfs/libxfs/xfs_symlink_remote.c +1 -1
@@ -16,7 +16,7 @@#include "xfs_trans.h" #include "xfs_buf_item.h" #include "xfs_log.h" - +#include "xfs_symlink_remote.h" /* * Each contiguous block has a header, so it is not just a simple pathlen
fs/xfs/libxfs/xfs_symlink_remote.h new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2000-2005 Silicon Graphics, Inc. +* Copyright (c) 2013 Red Hat, Inc. +* All Rights Reserved. +*/ +#ifndef __XFS_SYMLINK_REMOTE_H +#define __XFS_SYMLINK_REMOTE_H + +/* +* Symlink decoding/encoding functions +*/ +int xfs_symlink_blocks (struct xfs_mount *mp,int pathlen); +int xfs_symlink_hdr_set (struct xfs_mount *mp,xfs_ino_t ino,uint32_t offset, +uint32_t size,struct xfs_buf *bp); +bool xfs_symlink_hdr_ok (xfs_ino_t ino,uint32_t offset, +uint32_t size,struct xfs_buf *bp); +void xfs_symlink_local_to_remote (struct xfs_trans *tp,struct xfs_buf *bp, +struct xfs_inode *ip,struct xfs_ifork *ifp); +xfs_failaddr_t xfs_symlink_shortform_verify (void *sfp,int64_t size); + +#endif /* __XFS_SYMLINK_REMOTE_H */
fs/xfs/scrub/inode_repair.c +1 -0
@@ -37,6 +37,7 @@#include "xfs_attr_leaf.h" #include "xfs_log_priv.h" #include "xfs_health.h" +#include "xfs_symlink_remote.h" #include "scrub/xfs_scrub.h" #include "scrub/scrub.h" #include "scrub/common.h"
fs/xfs/scrub/symlink.c +1 -0
@@ -13,6 +13,7 @@#include "xfs_inode.h" #include "xfs_symlink.h" #include "xfs_health.h" +#include "xfs_symlink_remote.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/health.h"
fs/xfs/xfs_symlink.c +1 -0
@@ -24,6 +24,7 @@#include "xfs_ialloc.h" #include "xfs_error.h" #include "xfs_health.h" +#include "xfs_symlink_remote.h" /* ----- Kernel only functions below ----- */ int
Re: [PATCH 1/3] xfs: move xfs_symlink_remote.c declarations to xfs_symlink_remote.h
Looks good:
PATCH 2/3 xfs: move remote symlink target read function to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move xfs_readlink_bmap_ilocked to xfs_symlink_remote.c so that the swapext code can use it to convert a remote format symlink back to shortform format after a metadata repair. While we're at it, fix a broken printf prefix.
--- fs/xfs/libxfs/xfs_symlink_remote.c | 77 ++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_symlink_remote.h | 1 fs/xfs/scrub/symlink.c | 2 - fs/xfs/xfs_symlink.c | 75 ----------------------------------- fs/xfs/xfs_symlink.h | 1 5 files changed, 80 insertions(+), 76 deletions(-)
fs/xfs/libxfs/xfs_symlink_remote.c +77 -0
@@ -17,6 +17,9 @@#include "xfs_buf_item.h" #include "xfs_log.h" #include "xfs_symlink_remote.h" +#include "xfs_bit.h" +#include "xfs_bmap.h" +#include "xfs_health.h" /* * Each contiguous block has a header, so it is not just a simple pathlen
@@ -227,3 +230,77 @@ xfs_symlink_shortform_verify(return __this_address;return NULL ; } + +/* Read a remote symlink target into the buffer. */ +int +xfs_symlink_remote_read ( +struct xfs_inode *ip, +char *link) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS ]; +struct xfs_buf *bp; +xfs_daddr_t d; +char *cur_chunk; +int pathlen = ip->i_disk_size; +int nmaps =XFS_SYMLINK_MAPS ; +int byte_cnt; +int n; +int error =0 ; +int fsblocks =0 ; +int offset; + +ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL )); + + fsblocks =xfs_symlink_blocks (mp, pathlen); + error =xfs_bmapi_read (ip,0 , fsblocks, mval, &nmaps,0 ); +if (error) + goto out; + + offset =0 ; +for (n =0 ; n < nmaps; n++) { + d =XFS_FSB_TO_DADDR (mp, mval[n].br_startblock); + byte_cnt =XFS_FSB_TO_B (mp, mval[n].br_blockcount); + + error =xfs_buf_read (mp->m_ddev_targp, d,BTOBB (byte_cnt),0 , + &bp, &xfs_symlink_buf_ops); +if (xfs_metadata_is_sick (error)) +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK ); +if (error) +return error; + byte_cnt =XFS_SYMLINK_BUF_SPACE (mp, byte_cnt); +if (pathlen < byte_cnt) + byte_cnt = pathlen; + + cur_chunk = bp->b_addr; +if (xfs_has_crc (mp)) { +if (!xfs_symlink_hdr_ok (ip->i_ino, offset, + byte_cnt, bp)) { +xfs_inode_mark_sick (ip,XFS_SICK_INO_SYMLINK ); + error = -EFSCORRUPTED ; +xfs_alert (mp, +"symlink header does not match required off/len/owner (0x%x/0x%x,0x%llx)" , + offset, byte_cnt, ip->i_ino); +xfs_buf_relse (bp); + goto out; + + } + + cur_chunk +=sizeof (struct xfs_dsymlink_hdr ); + } + +memcpy (link + offset, cur_chunk, byte_cnt); + + pathlen -= byte_cnt; + offset += byte_cnt; + +xfs_buf_relse (bp); + } +ASSERT (pathlen ==0 ); + + link[ip->i_disk_size] ='\0' ; + error =0 ; + + out: +return error; +}
fs/xfs/libxfs/xfs_symlink_remote.h +1 -0
@@ -18,5 +18,6 @@ bool xfs_symlink_hdr_ok(xfs_ino_t ino, uint32_t offset,void xfs_symlink_local_to_remote (struct xfs_trans *tp,struct xfs_buf *bp,struct xfs_inode *ip,struct xfs_ifork *ifp);xfs_failaddr_t xfs_symlink_shortform_verify (void *sfp,int64_t size); +int xfs_symlink_remote_read (struct xfs_inode *ip,char *link);#endif /* __XFS_SYMLINK_REMOTE_H */
fs/xfs/scrub/symlink.c +1 -1
@@ -68,7 +68,7 @@ xchk_symlink( }/* Remote symlink; must read the contents. */ - error =xfs_readlink_bmap_ilocked (sc->ip, sc->buf); + error =xfs_symlink_remote_read (sc->ip, sc->buf);if (!xchk_fblock_process_error (sc,XFS_DATA_FORK ,0 , &error))return error;if (strnlen (sc->buf,XFS_SYMLINK_MAXLEN ) < len)
fs/xfs/xfs_symlink.c +1 -74
87 lines not on this page · raw message
fs/xfs/xfs_symlink.h +0 -1
@@ -10,7 +10,6 @@int xfs_symlink (struct mnt_idmap *idmap,struct xfs_inode *dp,struct xfs_name *link_name,const char *target_path,umode_t mode,struct xfs_inode **ipp); -int xfs_readlink_bmap_ilocked (struct xfs_inode *ip,char *link);int xfs_readlink (struct xfs_inode *ip,char *link);int xfs_inactive_symlink (struct xfs_inode *ip);
Re: [PATCH 2/3] xfs: move remote symlink target read function to libxfs
Looks good:
PATCH 3/3 xfs: move symlink target write function to libxfs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move xfs_symlink_write_target to xfs_symlink_remote.c so that kernel and mkfs can share the same function.
--- fs/xfs/libxfs/xfs_symlink_remote.c | 76 ++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_symlink_remote.h | 3 + fs/xfs/xfs_symlink.c | 69 ++------------------------------- 3 files changed, 84 insertions(+), 64 deletions(-)
fs/xfs/libxfs/xfs_symlink_remote.c +76 -0
@@ -304,3 +304,79 @@ xfs_symlink_remote_read( out:return error; } + +/* Write the symlink target into the inode. */ +int +xfs_symlink_write_target ( +struct xfs_trans *tp, +struct xfs_inode *ip, +const char *target_path, +int pathlen, +xfs_fsblock_t fs_blocks, +uint resblks) +{ +struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS ]; +struct xfs_mount *mp = tp->t_mountp; +const char *cur_chunk; +struct xfs_buf *bp; +xfs_daddr_t d; +int byte_cnt; +int nmaps; +int offset =0 ; +int n; +int error; + +/* +* If the symlink will fit into the inode, write it inline. +*/ +if (pathlen <=xfs_inode_data_fork_size (ip)) { +xfs_init_local_fork (ip,XFS_DATA_FORK , target_path, pathlen); + + ip->i_disk_size = pathlen; + ip->i_df.if_format =XFS_DINODE_FMT_LOCAL ; +xfs_trans_log_inode (tp, ip,XFS_ILOG_DDATA |XFS_ILOG_CORE ); +return 0 ; + } + + nmaps =XFS_SYMLINK_MAPS ; + error =xfs_bmapi_write (tp, ip,0 , fs_blocks,XFS_BMAPI_METADATA , + resblks, mval, &nmaps); +if (error) +return error; + + ip->i_disk_size = pathlen; +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); + + cur_chunk = target_path; + offset =0 ; +for (n =0 ; n < nmaps; n++) { +char *buf; + + d =XFS_FSB_TO_DADDR (mp, mval[n].br_startblock); + byte_cnt =XFS_FSB_TO_B (mp, mval[n].br_blockcount); + error =xfs_trans_get_buf (tp, mp->m_ddev_targp, d, +BTOBB (byte_cnt),0 , &bp); +if (error) +return error; + bp->b_ops = &xfs_symlink_buf_ops; + + byte_cnt =XFS_SYMLINK_BUF_SPACE (mp, byte_cnt); + byte_cnt =min (byte_cnt, pathlen); + + buf = bp->b_addr; + buf +=xfs_symlink_hdr_set (mp, ip->i_ino, offset, byte_cnt, + bp); + +memcpy (buf, cur_chunk, byte_cnt); + + cur_chunk += byte_cnt; + pathlen -= byte_cnt; + offset += byte_cnt; + +xfs_trans_buf_set_type (tp, bp,XFS_BLFT_SYMLINK_BUF ); +xfs_trans_log_buf (tp, bp,0 , (buf + byte_cnt -1 ) - + (char *)bp->b_addr); + } +ASSERT (pathlen ==0 ); +return 0 ; +}
fs/xfs/libxfs/xfs_symlink_remote.h +3 -0
@@ -19,5 +19,8 @@ void xfs_symlink_local_to_remote(struct xfs_trans *tp, struct xfs_buf *bp, struct xfs_inode *ip, struct xfs_ifork *ifp);xfs_failaddr_t xfs_symlink_shortform_verify (void *sfp,int64_t size);int xfs_symlink_remote_read (struct xfs_inode *ip,char *link); +int xfs_symlink_write_target (struct xfs_trans *tp,struct xfs_inode *ip, +const char *target_path,int pathlen,xfs_fsblock_t fs_blocks, +uint resblks);#endif /* __XFS_SYMLINK_REMOTE_H */
fs/xfs/xfs_symlink.c +5 -64
82 lines not on this page · raw message
Re: [PATCH 3/3] xfs: move symlink target write function to libxfs
Looks good:
PATCH 16/28 xfs: atomic file updates
In reply to Darrick J. WongHi all,
This series creates a new FIEXCHANGE_RANGE system call to exchange ranges of bytes between two files atomically. This new functionality enables data storage programs to stage and commit file updates such that reader programs will see either the old contents or the new contents in their entirety, with no chance of torn writes. A successful call completion guarantees that the new contents will be seen even if the system fails.
The ability to swap extent mappings between files in this manner is critical to supporting online filesystem repair, which is built upon the strategy of constructing a clean copy of a damaged structure and committing the new structure into the metadata file atomically.
User programs will be able to update files atomically by opening an O_TMPFILE, reflinking the source file to it, making whatever updates they want to make, and exchange the relevant ranges of the temp file with the original file. If the updates are aligned with the file block size, a new (since v2) flag provides for exchanging only the written areas. Callers can arrange for the update to be rejected if the original file has been changed.
The intent behind this new userspace functionality is to enable atomic rewrites of arbitrary parts of individual files. For years, application programmers wanting to ensure the atomicity of a file update had to write the changes to a new file in the same directory, fsync the new file, rename the new file on top of the old filename, and then fsync the directory. People get it wrong all the time, and $fs hacks abound. Here is the proposed manual page:
IOCTL-XFS-EXCHANGE-RANGE(2System Calls ManuIOCTL-XFS-EXCHANGE-RANGE(2)
NAME
ioctl_xfs_exchange_range - exchange the contents of parts of two files
SYNOPSIS
#include <sys/ioctl.h>
#include <xfs/xfs_fs_staging.h>
int ioctl(int file2_fd, XFS_IOC_EXCHANGE_RANGE, struct
xfs_exch_range *arg);DESCRIPTION
Given a range of bytes in a first file file1_fd and a second range of bytes in a second file file2_fd, this ioctl(2) ex‐ changes the contents of the two ranges.
Exchanges are atomic with regards to concurrent file opera‐ tions, so no userspace-level locks need to be taken to obtain consistent results. Implementations must guarantee that read‐ ers see either the old contents or the new contents in their entirety, even if the system fails.
The exchange parameters are conveyed in a structure of the fol‐ lowing form:
struct xfs_exch_range {
__s64 file1_fd;
__s64 file1_offset;
__s64 file2_offset;
__s64 length;
__u64 flags;
__s64 file2_ino;
__s64 file2_mtime;
__s64 file2_ctime;
__s32 file2_mtime_nsec;
__s32 file2_ctime_nsec;
__u64 pad[6];
};
The field pad must be zero.
The fields file1_fd, file1_offset, and length define the first range of bytes to be exchanged.
The fields file2_fd, file2_offset, and length define the second range of bytes to be exchanged.
Both files must be from the same filesystem mount. If the two file descriptors represent the same file, the byte ranges must not overlap. Most disk-based filesystems require that the starts of both ranges must be aligned to the file block size. If this is the case, the ends of the ranges must also be so aligned unless the XFS_EXCH_RANGE_TO_EOF flag is set.
The field flags control the behavior of the exchange operation.
XFS_EXCH_RANGE_FILE2_FRESH
Check the freshness of file2_fd after locking the
file but before exchanging the contents. The sup‐
plied file2_ino field must match file2's inode num‐ ber, and the supplied file2_mtime, file2_mtime_nsec, file2_ctime, and file2_ctime_nsec fields must match
the modification time and change time of file2. If
they do not match, EBUSY will be returned.
XFS_EXCH_RANGE_TO_EOF
Ignore the length parameter. All bytes in file1_fd from file1_offset to EOF are moved to file2_fd, and file2's size is set to (file2_offset+(file1_length- file1_offset)). Meanwhile, all bytes in file2 from file2_offset to EOF are moved to file1 and file1's
size is set to (file1_offset+(file2_length-
file2_offset)). This option is not compatible with
XFS_EXCH_RANGE_FULL_FILES.
XFS_EXCH_RANGE_FSYNC
Ensure that all modified in-core data in both file ranges and all metadata updates pertaining to the exchange operation are flushed to persistent storage before the call returns. Opening either file de‐ scriptor with O_SYNC or O_DSYNC will have the same effect.
XFS_EXCH_RANGE_FILE1_WRITTEN
Only exchange sub-ranges of file1_fd that are known to contain data written by application software. Each sub-range may be expanded (both upwards and downwards) to align with the file allocation unit. For files on the data device, this is one filesystem block. For files on the realtime device, this is the realtime extent size. This facility can be used to implement fast atomic scatter-gather writes of any complexity for software-defined storage targets if all writes are aligned to the file allocation unit.
XFS_EXCH_RANGE_DRY_RUN
Check the parameters and the feasibility of the op‐ eration, but do not change anything.
XFS_EXCH_RANGE_COMMIT
This flag is a combination of
XFS_EXCH_RANGE_FILE2_FRESH | XFS_EXCH_RANGE_FSYNC
and can be used to commit changes to file2_fd to persistent storage if and only if file2 has not changed.
XFS_EXCH_RANGE_FULL_FILES
Require that file1_offset and file2_offset are zero, and that the length field matches the lengths of
both files. If not, EDOM will be returned. This
option is not compatible with XFS_EXCH_RANGE_TO_EOF.
XFS_EXCH_RANGE_NONATOMIC
This flag relaxes the requirement that readers see only the old contents or the new contents in their
entirety. If the system fails before all modified
in-core data and metadata updates are persisted to disk, the contents of both file ranges after recov‐ ery are not defined and may be a mix of both.
Do not use this flag unless the contents of both ranges are known to be identical and there are no other writers.
RETURN VALUE
On error, -1 is returned, and errno is set to indicate the er‐ ror.
ERRORS
Error codes can be one of, but are not limited to, the follow‐ ing:
EBADF file1_fd is not open for reading and writing or is open
for append-only writes; or file2_fd is not open for reading and writing or is open for append-only writes.
EBUSY The inode number and timestamps supplied do not match
file2_fd and XFS_EXCH_RANGE_FILE2_FRESH was set in
flags.
EDOM The ranges do not cover the entirety of both files, and
XFS_EXCH_RANGE_FULL_FILES was set in flags.
EINVAL The parameters are not correct for these files. This
error can also appear if either file descriptor repre‐ sents a device, FIFO, or socket. Disk filesystems gen‐ erally require the offset and length arguments to be aligned to the fundamental block sizes of both files.
EIO An I/O error occurred.
EISDIR One of the files is a directory.
ENOMEM The kernel was unable to allocate sufficient memory to
perform the operation.
ENOSPC There is not enough free space in the filesystem ex‐
change the contents safely.
EOPNOTSUPP
The filesystem does not support exchanging bytes between the two files.
EPERM file1_fd or file2_fd are immutable.
ETXTBSY
One of the files is a swap file.
EUCLEAN
The filesystem is corrupt.
EXDEV file1_fd and file2_fd are not on the same mounted
filesystem.
CONFORMING TO
This API is XFS-specific.
USE CASES
Three use cases are imagined for this system call.
The first is a filesystem defragmenter, which copies the con‐ tents of a file into another file and wishes to exchange the space mappings of the two files, provided that the original file has not changed. The flags NONATOMIC and FILE2_FRESH are recommended for this application.
The second is a data storage program that wants to commit non- contiguous updates to a file atomically. This can be done by creating a temporary file, calling FICLONE(2) to share the con‐ tents, and staging the updates into the temporary file. Either of the FULL_FILES or TO_EOF flags are recommended, along with FSYNC. Depending on the application's locking design, the flags FILE2_FRESH or COMMIT may be applicable here. The tempo‐ rary file can be deleted or punched out afterwards.
The third is a software-defined storage host (e.g. a disk juke‐ box) which implements an atomic scatter-gather write command. Provided the exported disk's logical block size matches the file's allocation unit size, this can be done by creating a temporary file and writing the data at the appropriate offsets. It is recommended that the temporary file be truncated to the size of the regular file before any writes are staged to the temporary file to avoid issues with zeroing during EOF exten‐ sion. Use this call with the FILE1_WRITTEN flag to exchange only the file allocation units involved in the emulated de‐ vice's write command. The use of the FSYNC flag is recommended here. The temporary file should be deleted or punched out com‐ pletely before being reused to stage another write.
NOTES
Some filesystems may limit the amount of data or the number of extents that can be exchanged in a single call.
SEE ALSO
ioctl(2)
The reference implementation in XFS creates a new log incompat feature and log intent items to track high level progress of swapping ranges of two files and finish interrupted work if the system goes down. Sample code can be found in the corresponding changes to xfs_io to exercise the use case mentioned above.
Note that this function is /not/ the O_DIRECT atomic file writes concept that has also been floating around for years. It is also not the RWF_ATOMIC patchset that has been shared. This RFC is constructed entirely in software, which means that there are no limitations other than the general filesystem limits.
As a side note, the original motivation behind the kernel functionality is online repair of file-based metadata. The atomic file swap is implemented as an atomic inode fork swap, which means that we can implement online reconstruction of extended attributes and directories by building a new one in another inode and atomically swap the contents.
Subsequent patchsets adapt the online filesystem repair code to use atomic extent swapping. This enables repair functions to construct a clean copy of a directory, xattr information, symbolic links, realtime bitmaps, and realtime summary information in a temporary inode. If this completes successfully, the new contents can be swapped atomically into the inode being repaired. This is essential to avoid making corruption problems worse if the system goes down in the middle of running repair.
This patchset also ports the old XFS extent swap ioctl interface to use the new extent swap code.
For userspace, this series also includes the userspace pieces needed to test the new functionality, and a sample implementation of atomic file updates.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=atomic-file-updates
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=atomic-file-updates
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=atomic-file-updates
xfsdocs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-documentation.git/log/?h=atomic-file-updates
--- fs/read_write.c | 2 fs/remap_range.c | 4 fs/xfs/Makefile | 3 fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_defer.c | 6 fs/xfs/libxfs/xfs_defer.h | 2 fs/xfs/libxfs/xfs_errortag.h | 4 fs/xfs/libxfs/xfs_format.h | 20 - fs/xfs/libxfs/xfs_fs.h | 4 fs/xfs/libxfs/xfs_fs_staging.h | 107 +++ fs/xfs/libxfs/xfs_log_format.h | 83 ++ fs/xfs/libxfs/xfs_log_recover.h | 2 fs/xfs/libxfs/xfs_sb.c | 3 fs/xfs/libxfs/xfs_swapext.c | 1318 ++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_swapext.h | 223 ++++++ fs/xfs/libxfs/xfs_symlink_remote.c | 47 + fs/xfs/libxfs/xfs_symlink_remote.h | 1 fs/xfs/libxfs/xfs_trans_space.h | 4 fs/xfs/xfs_bmap_util.c | 732 ++++--------------- fs/xfs/xfs_bmap_util.h | 10 fs/xfs/xfs_error.c | 3 fs/xfs/xfs_file.c | 88 -- fs/xfs/xfs_file.h | 15 fs/xfs/xfs_inode.c | 75 ++ fs/xfs/xfs_inode.h | 12 fs/xfs/xfs_ioctl.c | 133 ++- fs/xfs/xfs_ioctl.h | 4 fs/xfs/xfs_ioctl32.c | 11 fs/xfs/xfs_iops.c | 1 fs/xfs/xfs_iops.h | 7 fs/xfs/xfs_linux.h | 6 fs/xfs/xfs_log.c | 47 + fs/xfs/xfs_log.h | 10 fs/xfs/xfs_log_priv.h | 3 fs/xfs/xfs_log_recover.c | 5 fs/xfs/xfs_mount.c | 11 fs/xfs/xfs_mount.h | 7 fs/xfs/xfs_super.c | 19 fs/xfs/xfs_swapext_item.c | 616 ++++++++++++++++ fs/xfs/xfs_swapext_item.h | 60 ++ fs/xfs/xfs_symlink.c | 49 - fs/xfs/xfs_trace.c | 2 fs/xfs/xfs_trace.h | 359 +++++++++ fs/xfs/xfs_xattr.c | 6 fs/xfs/xfs_xchgrange.c | 1393 ++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_xchgrange.h | 56 + include/linux/fs.h | 1 47 files changed, 4727 insertions(+), 849 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_fs_staging.h create mode 100644 fs/xfs/libxfs/xfs_swapext.c create mode 100644 fs/xfs/libxfs/xfs_swapext.h create mode 100644 fs/xfs/xfs_file.h create mode 100644 fs/xfs/xfs_swapext_item.c create mode 100644 fs/xfs/xfs_swapext_item.h create mode 100644 fs/xfs/xfs_xchgrange.c create mode 100644 fs/xfs/xfs_xchgrange.h
PATCH 1/25 xfs: add a libxfs header file for staging new ioctls
From: Darrick J. Wong <[email protected]>
Create a new xfs_fs_staging.h header where we can land experimental ioctls without committing them to any stable interfaces anywhere.
--- fs/xfs/libxfs/xfs_fs_staging.h | 18 ++++++++++++++++++ fs/xfs/xfs_linux.h | 1 + 2 files changed, 19 insertions(+) create mode 100644 fs/xfs/libxfs/xfs_fs_staging.h
fs/xfs/libxfs/xfs_fs_staging.h new file +18 -0
@@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: LGPL-2.1 */ +/* +* Copyright (c) 2020-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_FS_STAGING_H__ +#define __XFS_FS_STAGING_H__ + +/* +* Experimental system calls, ioctls and data structures supporting them. +* Nothing in here should be considered part of a stable interface of any kind. +* +* If you add an ioctl here, please leave a comment in xfs_fs.h marking it +* reserved. If you promote anything out of this file, please leave a comment +* explaining where it went. +*/ + +#endif /* __XFS_FS_STAGING_H__ */
fs/xfs/xfs_linux.h +1 -0
@@ -73,6 +73,7 @@ typedef __u32 xfs_nlink_t;#include <asm/unaligned.h> #include "xfs_fs.h" +#include "xfs_fs_staging.h" #include "xfs_stats.h" #include "xfs_sysctl.h" #include "xfs_iops.h"
PATCH 2/25 xfs: introduce new file range exchange ioctl
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Introduce a new ioctl to handle swapping ranges of bytes between files.
--- fs/read_write.c | 2 fs/remap_range.c | 4 fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_fs.h | 1 fs/xfs/libxfs/xfs_fs_staging.h | 89 ++++++++++ fs/xfs/xfs_ioctl.c | 30 +++ fs/xfs/xfs_xchgrange.c | 346 ++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_xchgrange.h | 18 ++ include/linux/fs.h | 1 9 files changed, 490 insertions(+), 2 deletions(-) create mode 100644 fs/xfs/xfs_xchgrange.c create mode 100644 fs/xfs/xfs_xchgrange.h
fs/read_write.c +2 -0
@@ -1650,6 +1650,7 @@ int generic_write_check_limits(struct file *file, loff_t pos, loff_t *count)return 0 ; } +EXPORT_SYMBOL (generic_write_check_limits);/* Like generic_write_checks(), but takes size of write instead of iter. */ int generic_write_checks_count (struct kiocb *iocb,loff_t *count)
@@ -1718,3 +1719,4 @@ int generic_file_rw_checks(struct file *file_in, struct file *file_out)return 0 ; } +EXPORT_SYMBOL (generic_file_rw_checks);
fs/remap_range.c +2 -2
@@ -99,8 +99,7 @@ static int generic_remap_checks(struct file *file_in, loff_t pos_in,return 0 ; } -static int remap_verify_area (struct file *file,loff_t pos,loff_t len, -bool write) +int remap_verify_area (struct file *file,loff_t pos,loff_t len,bool write) {loff_t tmp;
@@ -112,6 +111,7 @@ static int remap_verify_area(struct file *file, loff_t pos, loff_t len,return security_file_permission (file, write ?MAY_WRITE :MAY_READ ); } +EXPORT_SYMBOL (remap_verify_area);/* * Ensure that we don't remap a partial EOF block in the middle of something
fs/xfs/Makefile +1 -0
@@ -93,6 +93,7 @@ xfs-y += xfs_aops.o \ xfs_sysfs.o \ xfs_trans.o \ xfs_xattr.o \ + xfs_xchgrange.o \ kmem.o # low-level transaction/log code
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -843,6 +843,7 @@ struct xfs_scrub_metadata {#define XFS_IOC_FSGEOMETRY _IOR ('X', 126, struct xfs_fsop_geom)#define XFS_IOC_BULKSTAT _IOR ('X', 127, struct xfs_bulkstat_req)#define XFS_IOC_INUMBERS _IOR ('X', 128, struct xfs_inumbers_req) +/* XFS_IOC_EXCHANGE_RANGE -------- staging 129 */ /* XFS_IOC_GETFSUUID ---------- deprecated 140 */
fs/xfs/libxfs/xfs_fs_staging.h +89 -0
93 lines not on this page · raw message
fs/xfs/xfs_ioctl.c +30 -0
@@ -39,6 +39,7 @@#include "xfs_ioctl.h" #include "xfs_xattr.h" #include "xfs_rtbitmap.h" +#include "xfs_xchgrange.h" #include <linux/mount.h> #include <linux/namei.h>
@@ -1873,6 +1874,32 @@ xfs_fs_eofblocks_from_user(return 0 ; } +static long +xfs_ioc_exchange_range ( +struct file *file2, +struct xfs_exch_range __user *argp) +{ +struct xfs_exch_range args; +struct fd file1; +int error; + +if (copy_from_user (&args, argp,sizeof (args))) +return -EFAULT ; + + file1 =fdget (args.file1_fd); +if (!file1.file) +return -EBADF ; + + error = -EXDEV ; +if (file1.file->f_path.mnt != file2->f_path.mnt) + goto fdput; + + error =xfs_exch_range (file1.file, file2, &args); +fdput: +fdput (file1); +return error; +} +/* * These long-unused ioctls were removed from the official ioctl API in 5.17, * but retain these definitions so that we can log warnings about them.
@@ -2161,6 +2188,9 @@ xfs_file_ioctl(return error; } +case XFS_IOC_EXCHANGE_RANGE : +return xfs_ioc_exchange_range (filp, arg); +default :return -ENOTTY ; }
fs/xfs/xfs_xchgrange.c new file +346 -0
346 lines not on this page · raw message
fs/xfs/xfs_xchgrange.h new file +18 -0
@@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* Copyright (c) 2020-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_XCHGRANGE_H__ +#define __XFS_XCHGRANGE_H__ + +/* Prepare generic VFS data structures for file exchanges */ + +int xfs_exch_range_prep (struct file *file1,struct file *file2, +struct xfs_exch_range *fxr,unsigned int blocksize); +int xfs_exch_range_finish (struct file *file1,struct file *file2); + +int xfs_exch_range (struct file *file1,struct file *file2, +struct xfs_exch_range *fxr); + +#endif /* __XFS_XCHGRANGE_H__ */
include/linux/fs.h +1 -0
@@ -2032,6 +2032,7 @@ extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,extern ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in,struct file *file_out,loff_t pos_out,size_t len,unsigned int flags); +int remap_verify_area (struct file *file,loff_t pos,loff_t len,bool write); int __generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, loff_t *len, unsigned int remap_flags,
PATCH 3/25 xfs: move inode lease breaking functions to xfs_inode.c
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The lease breaking functions operate at the scope of the entire VFS inode, not subranges of a file. Move them to xfs_inode.c since they're already declared in xfs_inode.h. This cleanup moves us closer to having xfs_FOO.h declare only the symbols in xfs_FOO.c.
--- fs/xfs/xfs_file.c | 61 --------------------------------------------------- fs/xfs/xfs_inode.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_inode.h | 1 - 3 files changed, 62 insertions(+), 62 deletions(-)
fs/xfs/xfs_file.c +0 -61
@@ -861,67 +861,6 @@ xfs_file_write_iter(return xfs_file_buffered_write (iocb, from); } -static void -xfs_wait_dax_page ( -struct inode *inode) -{ -struct xfs_inode *ip =XFS_I (inode); - -xfs_iunlock (ip,XFS_MMAPLOCK_EXCL ); -schedule (); -xfs_ilock (ip,XFS_MMAPLOCK_EXCL ); -} - -int -xfs_break_dax_layouts ( -struct inode *inode, -bool *retry) -{ -struct page *page; - -ASSERT (xfs_isilocked (XFS_I (inode),XFS_MMAPLOCK_EXCL )); - - page =dax_layout_busy_page (inode->i_mapping); -if (!page) -return 0 ; - - *retry = true; -return ___wait_var_event (&page->_refcount, -atomic_read (&page->_refcount) ==1 ,TASK_INTERRUPTIBLE , -0 ,0 ,xfs_wait_dax_page (inode)); -} - -int -xfs_break_layouts ( -struct inode *inode, -uint *iolock, -enum layout_break_reason reason) -{ -bool retry; -int error; - -ASSERT (xfs_isilocked (XFS_I (inode),XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )); - -do { - retry = false; -switch (reason) { -case BREAK_UNMAP : - error =xfs_break_dax_layouts (inode, &retry); -if (error || retry) -break ; - fallthrough; -case BREAK_WRITE : - error =xfs_break_leased_layouts (inode, iolock, &retry); -break ; -default : -WARN_ON_ONCE (1 ); - error = -EINVAL ; - } - }while (error ==0 && retry); - -return error; -} -/* Does this file, inode, or mount want synchronous writes? */ static inline bool xfs_file_sync_writes (struct file *filp) {
fs/xfs/xfs_inode.c +62 -0
71 lines not on this page · raw message
fs/xfs/xfs_inode.h +0 -1
@@ -565,7 +565,6 @@ xfs_itruncate_extents(return xfs_itruncate_extents_flags (tpp, ip, whichfork, new_size,0 ); } -/* from xfs_file.c */ int xfs_break_dax_layouts (struct inode *inode,bool *retry);int xfs_break_layouts (struct inode *inode,uint *iolock,enum layout_break_reason reason);
PATCH 4/25 xfs: move xfs_iops.c declarations out of xfs_inode.h
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Similarly, move declarations of public symbols of xfs_iops.c from xfs_inode.h to xfs_iops.h.
--- fs/xfs/xfs_inode.h | 5 ----- fs/xfs/xfs_iops.h | 4 ++++ 2 files changed, 4 insertions(+), 5 deletions(-)
fs/xfs/xfs_inode.h +0 -5
@@ -569,11 +569,6 @@ int xfs_break_dax_layouts(struct inode *inode, bool *retry);int xfs_break_layouts (struct inode *inode,uint *iolock,enum layout_break_reason reason); -/* from xfs_iops.c */ -extern void xfs_setup_inode (struct xfs_inode *ip); -extern void xfs_setup_iops (struct xfs_inode *ip); -extern void xfs_diflags_to_iflags (struct xfs_inode *ip,bool init); -static inline void xfs_update_stable_writes (struct xfs_inode *ip) {if (bdev_stable_writes (xfs_inode_buftarg (ip)->bt_bdev))
fs/xfs/xfs_iops.h +4 -0
@@ -19,4 +19,8 @@ int xfs_vn_setattr_size(struct mnt_idmap *idmap,int xfs_inode_init_security (struct inode *inode,struct inode *dir,const struct qstr *qstr); +extern void xfs_setup_inode (struct xfs_inode *ip); +extern void xfs_setup_iops (struct xfs_inode *ip); +extern void xfs_diflags_to_iflags (struct xfs_inode *ip,bool init); +#endif /* __XFS_IOPS_H__ */
PATCH 5/25 xfs: declare xfs_file.c symbols in xfs_file.h
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move the two public symbols in xfs_file.c to xfs_file.h. We're about to add more public symbols in that source file, so let's finally create the header file.
--- fs/xfs/xfs_file.c | 1 + fs/xfs/xfs_file.h | 12 ++++++++++++ fs/xfs/xfs_ioctl.c | 1 + fs/xfs/xfs_iops.c | 1 + fs/xfs/xfs_iops.h | 3 --- 5 files changed, 15 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/xfs_file.h
fs/xfs/xfs_file.c +1 -0
@@ -24,6 +24,7 @@#include "xfs_pnfs.h" #include "xfs_iomap.h" #include "xfs_reflink.h" +#include "xfs_file.h" #include <linux/dax.h> #include <linux/falloc.h>
fs/xfs/xfs_file.h new file +12 -0
@@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2000-2005 Silicon Graphics, Inc. +* All Rights Reserved. +*/ +#ifndef __XFS_FILE_H__ +#define __XFS_FILE_H__ + +extern const struct file_operations xfs_file_operations; +extern const struct file_operations xfs_dir_file_operations; + +#endif /* __XFS_FILE_H__ */
fs/xfs/xfs_ioctl.c +1 -0
@@ -40,6 +40,7 @@#include "xfs_xattr.h" #include "xfs_rtbitmap.h" #include "xfs_xchgrange.h" +#include "xfs_file.h" #include <linux/mount.h> #include <linux/namei.h>
fs/xfs/xfs_iops.c +1 -0
@@ -25,6 +25,7 @@#include "xfs_error.h" #include "xfs_ioctl.h" #include "xfs_xattr.h" +#include "xfs_file.h" #include <linux/posix_acl.h> #include <linux/security.h>
fs/xfs/xfs_iops.h +0 -3
@@ -8,9 +8,6 @@struct xfs_inode ; -extern const struct file_operations xfs_file_operations; -extern const struct file_operations xfs_dir_file_operations; -extern ssize_t xfs_vn_listxattr (struct dentry *,char *data,size_t size); int xfs_vn_setattr_size(struct mnt_idmap *idmap,
PATCH 6/25 xfs: create a new helper to return a file's allocation unit
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new helper function to calculate the fundamental allocation unit (i.e. the smallest unit of space we can allocate) of a file. Things are going to get hairy with range-exchange on the realtime device, so prepare for this now.
While we're at it, export xfs_is_falloc_aligned since the next patch will need it.
--- fs/xfs/xfs_file.c | 28 ++++++++++------------------ fs/xfs/xfs_file.h | 3 +++ fs/xfs/xfs_inode.c | 13 +++++++++++++ fs/xfs/xfs_inode.h | 1 + 4 files changed, 27 insertions(+), 18 deletions(-)
fs/xfs/xfs_file.c +10 -18
@@ -39,33 +39,25 @@ static const struct vm_operations_struct xfs_file_vm_ops;* Decide if the given file range is aligned to the size of the fundamental * allocation unit for the file. */ -static bool +bool xfs_is_falloc_aligned (struct xfs_inode *ip,loff_t pos,long long int len) { -struct xfs_mount *mp = ip->i_mount; -uint64_t mask; +unsigned int alloc_unit =xfs_inode_alloc_unitsize (ip); -if (XFS_IS_REALTIME_INODE (ip)) { -if (!is_power_of_2 (mp->m_sb.sb_rextsize)) { -u64 rextbytes; -u32 mod; +if (!is_power_of_2 (alloc_unit)) { +u32 mod; - rextbytes =XFS_FSB_TO_B (mp, mp->m_sb.sb_rextsize); -div_u64_rem (pos, rextbytes, &mod); -if (mod) -return false; -div_u64_rem (len, rextbytes, &mod); -return mod ==0 ; - } - mask =XFS_FSB_TO_B (mp, mp->m_sb.sb_rextsize) -1 ; - }else { - mask = mp->m_sb.sb_blocksize -1 ; +div_u64_rem (pos, alloc_unit, &mod); +if (mod) +return false; +div_u64_rem (len, alloc_unit, &mod); +return mod ==0 ; } -return !((pos | len) & mask); +return !((pos | len) & (alloc_unit -1 )); }/*
fs/xfs/xfs_file.h +3 -0
@@ -9,4 +9,7 @@extern const struct file_operations xfs_file_operations;extern const struct file_operations xfs_dir_file_operations; +bool xfs_is_falloc_aligned (struct xfs_inode *ip,loff_t pos, +long long int len); +#endif /* __XFS_FILE_H__ */
fs/xfs/xfs_inode.c +13 -0
@@ -4015,3 +4015,16 @@ xfs_break_layouts(return error; } + +/* Returns the size of fundamental allocation unit for a file, in bytes. */ +unsigned int +xfs_inode_alloc_unitsize ( +struct xfs_inode *ip) +{ +unsigned int blocks =1 ; + +if (XFS_IS_REALTIME_INODE (ip)) + blocks = ip->i_mount->m_sb.sb_rextsize; + +return XFS_FSB_TO_B (ip->i_mount, blocks); +}
fs/xfs/xfs_inode.h +1 -0
@@ -625,6 +625,7 @@ int xfs_inode_reload_unlinked(struct xfs_inode *ip);bool xfs_ifork_zapped (const struct xfs_inode *ip,int whichfork);void xfs_inode_count_blocks (struct xfs_trans *tp,struct xfs_inode *ip,xfs_filblks_t *dblocks,xfs_filblks_t *rblocks); +unsigned int xfs_inode_alloc_unitsize (struct xfs_inode *ip);struct xfs_dir_update_params {const struct xfs_inode *dp;
PATCH 7/25 xfs: refactor non-power-of-two alignment checks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a helper function that can compute if a 64-bit number is an integer multiple of a 32-bit number, where the 32-bit number is not required to be an even power of two. This is needed for some new code for the realtime device, where we can set 37k allocation units and then have to remap them.
--- fs/xfs/xfs_file.c | 12 +++--------- fs/xfs/xfs_linux.h | 5 +++++ 2 files changed, 8 insertions(+), 9 deletions(-)
fs/xfs/xfs_file.c +3 -9
@@ -47,15 +47,9 @@ xfs_is_falloc_aligned( {unsigned int alloc_unit =xfs_inode_alloc_unitsize (ip); -if (!is_power_of_2 (alloc_unit)) { -u32 mod; - -div_u64_rem (pos, alloc_unit, &mod); -if (mod) -return false; -div_u64_rem (len, alloc_unit, &mod); -return mod ==0 ; - } +if (!is_power_of_2 (alloc_unit)) +return isaligned_64 (pos, alloc_unit) && +isaligned_64 (len, alloc_unit);return !((pos | len) & (alloc_unit -1 )); }
fs/xfs/xfs_linux.h +5 -0
@@ -200,6 +200,11 @@ static inline uint64_t howmany_64(uint64_t x, uint32_t y)return x; } +static inline bool isaligned_64 (uint64_t x,uint32_t y) +{ +return do_div (x, y) ==0 ; +} +/* If @b is a power of 2, return log2(b). Else return -1. */ static inline int8_t log2_if_power2 (unsigned long b) {
PATCH 8/25 xfs: parameterize all the incompat log feature helpers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
We're about to define a new XFS_SB_FEAT_INCOMPAT_LOG_ bit, which means that callers will soon require the ability to toggle on and off different log incompat feature bits. Parameterize the xlog_{use,drop}_incompat_feat and xfs_sb_remove_incompat_log_features functions so that callers can specify which feature they're trying to use and so that we can clear individual log incompat bits as needed.
--- fs/xfs/libxfs/xfs_format.h | 5 +++-- fs/xfs/xfs_log.c | 34 +++++++++++++++++++++++++--------- fs/xfs/xfs_log.h | 9 ++++++--- fs/xfs/xfs_log_priv.h | 2 +- fs/xfs/xfs_log_recover.c | 3 ++- fs/xfs/xfs_mount.c | 11 +++++------ fs/xfs/xfs_mount.h | 2 +- fs/xfs/xfs_xattr.c | 6 +++--- 8 files changed, 46 insertions(+), 26 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -2
@@ -404,9 +404,10 @@ xfs_sb_has_incompat_log_feature(static inline void xfs_sb_remove_incompat_log_features ( -struct xfs_sb *sbp) +struct xfs_sb *sbp, +uint32_t feature) { - sbp->sb_features_log_incompat &= ~XFS_SB_FEAT_INCOMPAT_LOG_ALL ; + sbp->sb_features_log_incompat &= ~feature; } static inline void
fs/xfs/xfs_log.c +25 -9
@@ -1048,7 +1048,7 @@ xfs_log_quiesce(* failures, though it's not fatal to have a higher log feature * protection level than the log contents actually require. */ -if (xfs_clear_incompat_log_features (mp)) { +if (xfs_clear_incompat_log_features (mp,XFS_SB_FEAT_INCOMPAT_LOG_ALL )) {int error; error =xfs_sync_sb (mp, false);
@@ -1455,6 +1455,7 @@ xlog_clear_incompat( struct xlog *log) {struct xfs_mount *mp = log->l_mp; +uint32_t incompat_mask =0 ;if (!xfs_sb_has_incompat_log_feature (&mp->m_sb,XFS_SB_FEAT_INCOMPAT_LOG_ALL ))
@@ -1463,11 +1464,16 @@ xlog_clear_incompat(if (log->l_covered_state !=XLOG_STATE_COVER_DONE2 )return ; -if (!down_write_trylock (&log->l_incompat_users)) +if (down_write_trylock (&log->l_incompat_xattrs)) + incompat_mask |=XFS_SB_FEAT_INCOMPAT_LOG_XATTRS ; + +if (!incompat_mask)return ; -xfs_clear_incompat_log_features (mp); -up_write (&log->l_incompat_users); +xfs_clear_incompat_log_features (mp, incompat_mask); + +if (incompat_mask &XFS_SB_FEAT_INCOMPAT_LOG_XATTRS ) +up_write (&log->l_incompat_xattrs); }/*
@@ -1585,7 +1591,7 @@ xlog_alloc_log( } log->l_sectBBsize =1 << log2_size; -init_rwsem (&log->l_incompat_users); +init_rwsem (&log->l_incompat_xattrs);xlog_get_iclog_buffer_size (mp, log);
@@ -3877,15 +3883,25 @@ xfs_log_check_lsn(*/ void xlog_use_incompat_feat ( -struct xlog *log) +struct xlog *log, +enum xlog_incompat_feat what) { -down_read (&log->l_incompat_users); +switch (what) { +case XLOG_INCOMPAT_FEAT_XATTRS : +down_read (&log->l_incompat_xattrs); +break ; + } }/* Notify the log that we've finished using log incompat features. */ void xlog_drop_incompat_feat ( -struct xlog *log) +struct xlog *log, +enum xlog_incompat_feat what) { -up_read (&log->l_incompat_users); +switch (what) { +case XLOG_INCOMPAT_FEAT_XATTRS : +up_read (&log->l_incompat_xattrs); +break ; + } }
fs/xfs/xfs_log.h +6 -3
@@ -159,8 +159,11 @@ bool xfs_log_check_lsn(struct xfs_mount *, xfs_lsn_t);xfs_lsn_t xlog_grant_push_threshold (struct xlog *log,int need_bytes);bool xlog_force_shutdown (struct xlog *log,uint32_t shutdown_flags); -void xlog_use_incompat_feat (struct xlog *log); -void xlog_drop_incompat_feat (struct xlog *log); -int xfs_attr_use_log_assist (struct xfs_mount *mp); +enum xlog_incompat_feat { +XLOG_INCOMPAT_FEAT_XATTRS =XFS_SB_FEAT_INCOMPAT_LOG_XATTRS , +}; + +void xlog_use_incompat_feat (struct xlog *log,enum xlog_incompat_feat what); +void xlog_drop_incompat_feat (struct xlog *log,enum xlog_incompat_feat what);#endif /* __XFS_LOG_H__ */
fs/xfs/xfs_log_priv.h +1 -1
@@ -452,7 +452,7 @@ struct xlog {uint32_t l_iclog_roundoff;/* padding roundoff */ /* Users of log incompat features should take a read lock. */ -struct rw_semaphore l_incompat_users; +struct rw_semaphore l_incompat_xattrs; };/*
fs/xfs/xfs_log_recover.c +2 -1
@@ -3479,7 +3479,8 @@ xlog_recover_finish(* longer anything to protect. We rely on the AIL push to write out the * updated superblock after everything else. */ -if (xfs_clear_incompat_log_features (log->l_mp)) { +if (xfs_clear_incompat_log_features (log->l_mp, +XFS_SB_FEAT_INCOMPAT_LOG_ALL )) { error =xfs_sync_sb (log->l_mp, false);if (error <0 ) { xfs_alert(log->l_mp,
fs/xfs/xfs_mount.c +5 -6
@@ -1362,13 +1362,13 @@ xfs_add_incompat_log_feature(*/ bool xfs_clear_incompat_log_features ( -struct xfs_mount *mp) +struct xfs_mount *mp, +uint32_t features) {bool ret = false;if (!xfs_has_crc (mp) || - !xfs_sb_has_incompat_log_feature (&mp->m_sb, -XFS_SB_FEAT_INCOMPAT_LOG_ALL ) || + !xfs_sb_has_incompat_log_feature (&mp->m_sb, features) ||xfs_is_shutdown (mp))return false;
@@ -1380,9 +1380,8 @@ xfs_clear_incompat_log_features(xfs_buf_lock (mp->m_sb_bp);xfs_buf_hold (mp->m_sb_bp); -if (xfs_sb_has_incompat_log_feature (&mp->m_sb, -XFS_SB_FEAT_INCOMPAT_LOG_ALL )) { -xfs_sb_remove_incompat_log_features (&mp->m_sb); +if (xfs_sb_has_incompat_log_feature (&mp->m_sb, features)) { +xfs_sb_remove_incompat_log_features (&mp->m_sb, features); ret = true; }
fs/xfs/xfs_mount.h +1 -1
@@ -565,7 +565,7 @@ struct xfs_error_cfg * xfs_error_get_cfg(struct xfs_mount *mp, int error_class, int error);void xfs_force_summary_recalc (struct xfs_mount *mp);int xfs_add_incompat_log_feature (struct xfs_mount *mp,uint32_t feature); -bool xfs_clear_incompat_log_features (struct xfs_mount *mp); +bool xfs_clear_incompat_log_features (struct xfs_mount *mp,uint32_t feature);void xfs_mod_delalloc (struct xfs_mount *mp,int64_t delta);#endif /* __XFS_MOUNT_H__ */
fs/xfs/xfs_xattr.c +3 -3
@@ -37,7 +37,7 @@ xfs_attr_grab_log_assist(* Protect ourselves from an idle log clearing the logged xattrs log * incompat feature bit. */ -xlog_use_incompat_feat (mp->m_log); +xlog_use_incompat_feat (mp->m_log,XLOG_INCOMPAT_FEAT_XATTRS );/* * If log-assisted xattrs are already enabled, the caller can use the
@@ -68,7 +68,7 @@ xfs_attr_grab_log_assist(return 0 ; drop_incompat: -xlog_drop_incompat_feat (mp->m_log); +xlog_drop_incompat_feat (mp->m_log,XLOG_INCOMPAT_FEAT_XATTRS );return error; }
@@ -76,7 +76,7 @@ static inline voidxfs_attr_rele_log_assist ( struct xfs_mount *mp) { -xlog_drop_incompat_feat (mp->m_log); +xlog_drop_incompat_feat (mp->m_log,XLOG_INCOMPAT_FEAT_XATTRS ); } static inline bool
PATCH 9/25 xfs: create a log incompat flag for atomic extent swapping
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a log incompat flag so that we only attempt to process swap extent log items if the filesystem supports it, and a geometry flag to advertise support if it's present.
--- fs/xfs/libxfs/xfs_format.h | 6 +++ fs/xfs/libxfs/xfs_fs.h | 3 ++ fs/xfs/libxfs/xfs_sb.c | 3 ++ fs/xfs/libxfs/xfs_swapext.h | 75 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 87 insertions(+) create mode 100644 fs/xfs/libxfs/xfs_swapext.h
fs/xfs/libxfs/xfs_format.h +6 -0
@@ -391,6 +391,12 @@ xfs_sb_has_incompat_feature( }#define XFS_SB_FEAT_INCOMPAT_LOG_XATTRS (1 << 0)/* Delayed Attributes */ + +/* +* Log contains SXI log intent items which are not otherwise protected by +* an INCOMPAT/RO_COMPAT feature flag. +*/ +#define XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT (1U << 31)#define XFS_SB_FEAT_INCOMPAT_LOG_ALL \ (XFS_SB_FEAT_INCOMPAT_LOG_XATTRS)#define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_LOG_ALL
fs/xfs/libxfs/xfs_fs.h +3 -0
@@ -240,6 +240,9 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 23)/* large extent counters */ +/* atomic file extent swap available to userspace */ +#define XFS_FSOP_GEOM_FLAGS_ATOMIC_SWAP (1U << 31) +/* * Minimum and maximum sizes need for growth checks. *
fs/xfs/libxfs/xfs_sb.c +3 -0
@@ -26,6 +26,7 @@#include "xfs_health.h" #include "xfs_ag.h" #include "xfs_rtbitmap.h" +#include "xfs_swapext.h" /* * Physical superblock buffer manipulations. Shared with libxfs in userspace.
@@ -1258,6 +1259,8 @@ xfs_fs_geometry( }if (xfs_has_large_extent_counts (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_NREXT64 ; +if (xfs_atomic_swap_supported (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_ATOMIC_SWAP ; geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
fs/xfs/libxfs/xfs_swapext.h new file +75 -0
75 lines not on this page · raw message
PATCH 10/25 xfs: introduce a swap-extent log intent item
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Introduce a new intent log item to handle swapping extents.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_log_format.h | 51 ++++++++ fs/xfs/libxfs/xfs_log_recover.h | 2 fs/xfs/xfs_log_recover.c | 2 fs/xfs/xfs_super.c | 19 +++ fs/xfs/xfs_swapext_item.c | 236 +++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_swapext_item.h | 56 +++++++++ 7 files changed, 364 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/xfs_swapext_item.c create mode 100644 fs/xfs/xfs_swapext_item.h
fs/xfs/Makefile +1 -0
@@ -111,6 +111,7 @@ xfs-y += xfs_log.o \ xfs_iunlink_item.o \ xfs_refcount_item.o \ xfs_rmap_item.o \ + xfs_swapext_item.o \ xfs_log_recover.o \ xfs_trans_ail.o \ xfs_trans_buf.o
fs/xfs/libxfs/xfs_log_format.h +48 -3
75 lines not on this page · raw message
fs/xfs/libxfs/xfs_log_recover.h +2 -0
@@ -75,6 +75,8 @@ extern const struct xlog_recover_item_ops xlog_cui_item_ops;extern const struct xlog_recover_item_ops xlog_cud_item_ops;extern const struct xlog_recover_item_ops xlog_attri_item_ops;extern const struct xlog_recover_item_ops xlog_attrd_item_ops; +extern const struct xlog_recover_item_ops xlog_sxi_item_ops; +extern const struct xlog_recover_item_ops xlog_sxd_item_ops;/* * Macros, structures, prototypes for internal log manager use.
fs/xfs/xfs_log_recover.c +2 -0
@@ -1790,6 +1790,8 @@ static const struct xlog_recover_item_ops *xlog_recover_item_ops[] = { &xlog_bud_item_ops, &xlog_attri_item_ops, &xlog_attrd_item_ops, + &xlog_sxi_item_ops, + &xlog_sxd_item_ops, }; static const struct xlog_recover_item_ops *
fs/xfs/xfs_super.c +19 -0
@@ -43,6 +43,7 @@#include "xfs_iunlink_item.h" #include "xfs_dahash_test.h" #include "xfs_rtbitmap.h" +#include "xfs_swapext_item.h" #include "scrub/stats.h" #include "scrub/rcbag_btree.h"
@@ -2196,8 +2197,24 @@ xfs_init_caches(void)if (!xfs_iunlink_cache) goto out_destroy_attri_cache; + xfs_sxd_cache =kmem_cache_create ("xfs_sxd_item" , +sizeof (struct xfs_sxd_log_item ), +0 ,0 ,NULL ); +if (!xfs_sxd_cache) + goto out_destroy_iul_cache; + + xfs_sxi_cache =kmem_cache_create ("xfs_sxi_item" , +sizeof (struct xfs_sxi_log_item ), +0 ,0 ,NULL ); +if (!xfs_sxi_cache) + goto out_destroy_sxd_cache; +return 0 ; + out_destroy_sxd_cache: +kmem_cache_destroy (xfs_sxd_cache); + out_destroy_iul_cache: +kmem_cache_destroy (xfs_iunlink_cache); out_destroy_attri_cache:kmem_cache_destroy (xfs_attri_cache); out_destroy_attrd_cache:
@@ -2254,6 +2271,8 @@ xfs_destroy_caches(void)* destroy caches. */ rcu_barrier (); +kmem_cache_destroy (xfs_sxd_cache); +kmem_cache_destroy (xfs_sxi_cache);kmem_cache_destroy (xfs_iunlink_cache);kmem_cache_destroy (xfs_attri_cache);kmem_cache_destroy (xfs_attrd_cache);
fs/xfs/xfs_swapext_item.c new file +236 -0
236 lines not on this page · raw message
fs/xfs/xfs_swapext_item.h new file +56 -0
56 lines not on this page · raw message
PATCH 11/25 xfs: create deferred log items for extent swapping
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we've created the skeleton of a log intent item to track and restart extent swap operations, add the upper level logic to commit intent items and turn them into concrete work recorded in the log. We use the deferred item "multihop" feature that was introduced a few patches ago to constrain the number of active swap operations to one per thread.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_bmap.h | 2 fs/xfs/libxfs/xfs_defer.c | 6 fs/xfs/libxfs/xfs_defer.h | 2 fs/xfs/libxfs/xfs_format.h | 6 fs/xfs/libxfs/xfs_log_format.h | 31 + fs/xfs/libxfs/xfs_swapext.c | 1031 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_swapext.h | 143 +++++ fs/xfs/libxfs/xfs_trans_space.h | 4 fs/xfs/xfs_swapext_item.c | 394 +++++++++++++++ fs/xfs/xfs_swapext_item.h | 4 fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 216 ++++++++ fs/xfs/xfs_xchgrange.c | 50 ++ fs/xfs/xfs_xchgrange.h | 10 15 files changed, 1888 insertions(+), 13 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_swapext.c
fs/xfs/Makefile +1 -0
@@ -46,6 +46,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_refcount.o \ xfs_refcount_btree.o \ xfs_sb.o \ + xfs_swapext.o \ xfs_symlink_remote.o \ xfs_trans_inode.o \ xfs_trans_resv.o \
fs/xfs/libxfs/xfs_bmap.h +1 -1
@@ -156,7 +156,7 @@ static inline bool xfs_bmap_is_real_extent(const struct xfs_bmbt_irec *irec)* Return true if the extent is a real, allocated extent, or false if it is a * delayed allocation, and unwritten extent or a hole. */ -static inline bool xfs_bmap_is_written_extent (struct xfs_bmbt_irec *irec) +static inline bool xfs_bmap_is_written_extent (const struct xfs_bmbt_irec *irec) {return xfs_bmap_is_real_extent (irec) && irec->br_state !=XFS_EXT_UNWRITTEN ;
fs/xfs/libxfs/xfs_defer.c +6 -0
@@ -27,6 +27,7 @@#include "xfs_da_btree.h" #include "xfs_attr.h" #include "xfs_trans_priv.h" +#include "xfs_swapext.h" static struct kmem_cache *xfs_defer_pending_cache;
@@ -1180,6 +1181,10 @@ xfs_defer_init_item_caches(void) error =xfs_attr_intent_init_cache ();if (error) goto err; + error =xfs_swapext_intent_init_cache (); +if (error) + goto err; +return 0 ; err:xfs_defer_destroy_item_caches ();
@@ -1190,6 +1195,7 @@ xfs_defer_init_item_caches(void)void xfs_defer_destroy_item_caches (void ) { +xfs_swapext_intent_destroy_cache ();xfs_attr_intent_destroy_cache ();xfs_extfree_intent_destroy_cache ();xfs_bmap_intent_destroy_cache ();
fs/xfs/libxfs/xfs_defer.h +1 -1
@@ -72,7 +72,7 @@ extern const struct xfs_defer_op_type xfs_rmap_update_defer_type;extern const struct xfs_defer_op_type xfs_extent_free_defer_type;extern const struct xfs_defer_op_type xfs_agfl_free_defer_type;extern const struct xfs_defer_op_type xfs_attr_defer_type; - +extern const struct xfs_defer_op_type xfs_swapext_defer_type;/* * Deferred operation item relogging limits.
fs/xfs/libxfs/xfs_format.h +6 -0
@@ -430,6 +430,12 @@ static inline bool xfs_sb_version_haslogxattrs(struct xfs_sb *sbp) XFS_SB_FEAT_INCOMPAT_LOG_XATTRS); } +static inline bool xfs_sb_version_haslogswapext (struct xfs_sb *sbp) +{ +return xfs_sb_is_v5 (sbp) && (sbp->sb_features_log_incompat & +XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT ); +} +static inline bool xfs_is_quota_inode (struct xfs_sb *sbp,xfs_ino_t ino) {
fs/xfs/libxfs/xfs_log_format.h +29 -2
@@ -898,9 +898,36 @@ struct xfs_swap_extent {int64_t sx_isize2; }; -#define XFS_SWAP_EXT_FLAGS (0) +/* Swap extents between extended attribute forks. */ +#define XFS_SWAP_EXT_ATTR_FORK (1ULL << 0) -#define XFS_SWAP_EXT_STRINGS +/* Set the file sizes when finished. */ +#define XFS_SWAP_EXT_SET_SIZES (1ULL << 1) + +/* +* Swap only the extents of the two files where the file allocation units +* mapped to file1's range have been written to. +*/ +#define XFS_SWAP_EXT_INO1_WRITTEN (1ULL << 2) + +/* Clear the reflink flag from inode1 after the operation. */ +#define XFS_SWAP_EXT_CLEAR_INO1_REFLINK (1ULL << 3) + +/* Clear the reflink flag from inode2 after the operation. */ +#define XFS_SWAP_EXT_CLEAR_INO2_REFLINK (1ULL << 4) + +#define XFS_SWAP_EXT_FLAGS (XFS_SWAP_EXT_ATTR_FORK | \ + XFS_SWAP_EXT_SET_SIZES | \ + XFS_SWAP_EXT_INO1_WRITTEN | \ + XFS_SWAP_EXT_CLEAR_INO1_REFLINK | \ + XFS_SWAP_EXT_CLEAR_INO2_REFLINK) + +#define XFS_SWAP_EXT_STRINGS \ + { XFS_SWAP_EXT_ATTR_FORK, "ATTRFORK" }, \ + { XFS_SWAP_EXT_SET_SIZES, "SETSIZES" }, \ + { XFS_SWAP_EXT_INO1_WRITTEN, "INO1_WRITTEN" }, \ + { XFS_SWAP_EXT_CLEAR_INO1_REFLINK, "CLEAR_INO1_REFLINK" }, \ + { XFS_SWAP_EXT_CLEAR_INO2_REFLINK, "CLEAR_INO2_REFLINK" }/* This is the structure used to lay out an sxi log item in the log. */ struct xfs_sxi_log_format {
fs/xfs/libxfs/xfs_swapext.c new file +1031 -0
1,031 lines not on this page · raw message
fs/xfs/libxfs/xfs_swapext.h +143 -0
147 lines not on this page · raw message
fs/xfs/libxfs/xfs_trans_space.h +4 -0
@@ -10,6 +10,10 @@* Components of space reservations. */ +/* Worst case number of bmaps that can be held in a block. */ +#define XFS_MAX_CONTIG_BMAPS_PER_BLOCK (mp) \ + (((mp)->m_bmap_dmxr[0]) - ((mp)->m_bmap_dmnr[0])) +/* Worst case number of rmaps that can be held in a block. */ #define XFS_MAX_CONTIG_RMAPS_PER_BLOCK (mp) \ (((mp)->m_rmap_mxr[0]) - ((mp)->m_rmap_mnr[0]))
fs/xfs/xfs_swapext_item.c +387 -7
428 lines not on this page · raw message
fs/xfs/xfs_swapext_item.h +4 -0
@@ -53,4 +53,8 @@ struct xfs_sxd_log_item {extern struct kmem_cache *xfs_sxi_cache;extern struct kmem_cache *xfs_sxd_cache; +struct xfs_swapext_intent ; + +void xfs_swapext_defer_add (struct xfs_trans *tp,struct xfs_swapext_intent *sxi); +#endif /* __XFS_SWAPEXT_ITEM_H__ */
fs/xfs/xfs_trace.c +1 -0
@@ -40,6 +40,7 @@#include "scrub/xfbtree.h" #include "xfs_btree_mem.h" #include "xfs_bmap.h" +#include "xfs_swapext.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +214 -2
246 lines not on this page · raw message
fs/xfs/xfs_xchgrange.c +50 -0
62 lines not on this page · raw message
fs/xfs/xfs_xchgrange.h +10 -0
@@ -15,4 +15,14 @@ int xfs_exch_range_finish(struct file *file1, struct file *file2);int xfs_exch_range (struct file *file1,struct file *file2,struct xfs_exch_range *fxr); +/* XFS-specific parts of file exchanges */ + +struct xfs_swapext_req ; + +void xfs_xchg_range_ilock (struct xfs_trans *tp,struct xfs_inode *ip1, +struct xfs_inode *ip2); +void xfs_xchg_range_iunlock (struct xfs_inode *ip1,struct xfs_inode *ip2); + +int xfs_xchg_range_estimate (struct xfs_swapext_req *req); +#endif /* __XFS_XCHGRANGE_H__ */
PATCH 12/25 xfs: enable xlog users to toggle atomic extent swapping
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Plumb the necessary bits into the xlog code so that higher level callers can enable the atomic extent swapping feature and have it clear automatically when possible.
--- fs/xfs/xfs_log.c | 13 +++++++++++++ fs/xfs/xfs_log.h | 1 + fs/xfs/xfs_log_priv.h | 1 + 3 files changed, 15 insertions(+)
fs/xfs/xfs_log.c +13 -0
@@ -1467,11 +1467,17 @@ xlog_clear_incompat(if (down_write_trylock (&log->l_incompat_xattrs)) incompat_mask |=XFS_SB_FEAT_INCOMPAT_LOG_XATTRS ; +if (down_write_trylock (&log->l_incompat_swapext)) + incompat_mask |=XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT ; +if (!incompat_mask)return ;xfs_clear_incompat_log_features (mp, incompat_mask); +if (incompat_mask &XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT ) +up_write (&log->l_incompat_swapext); +if (incompat_mask &XFS_SB_FEAT_INCOMPAT_LOG_XATTRS )up_write (&log->l_incompat_xattrs); }
@@ -1592,6 +1598,7 @@ xlog_alloc_log( log->l_sectBBsize =1 << log2_size;init_rwsem (&log->l_incompat_xattrs); +init_rwsem (&log->l_incompat_swapext);xlog_get_iclog_buffer_size (mp, log);
@@ -3890,6 +3897,9 @@ xlog_use_incompat_feat(case XLOG_INCOMPAT_FEAT_XATTRS :down_read (&log->l_incompat_xattrs);break ; +case XLOG_INCOMPAT_FEAT_SWAPEXT : +down_read (&log->l_incompat_swapext); +break ; } }
@@ -3903,5 +3913,8 @@ xlog_drop_incompat_feat(case XLOG_INCOMPAT_FEAT_XATTRS :up_read (&log->l_incompat_xattrs);break ; +case XLOG_INCOMPAT_FEAT_SWAPEXT : +up_read (&log->l_incompat_swapext); +break ; } }
fs/xfs/xfs_log.h +1 -0
@@ -161,6 +161,7 @@ bool xlog_force_shutdown(struct xlog *log, uint32_t shutdown_flags);enum xlog_incompat_feat {XLOG_INCOMPAT_FEAT_XATTRS =XFS_SB_FEAT_INCOMPAT_LOG_XATTRS , +XLOG_INCOMPAT_FEAT_SWAPEXT =XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT };void xlog_use_incompat_feat (struct xlog *log,enum xlog_incompat_feat what);
fs/xfs/xfs_log_priv.h +1 -0
@@ -453,6 +453,7 @@ struct xlog {/* Users of log incompat features should take a read lock. */ struct rw_semaphore l_incompat_xattrs; +struct rw_semaphore l_incompat_swapext; };/*
PATCH 13/25 xfs: bind the xfs-specific extent swap code to the vfs-generic file exchange code
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
So far we've constructed the top half of file range exchange which deals with VFS-level objects; and the bottom half of extent swapping, which deals with file mappings in XFS data structures. We still need to glue the two pieces together so do that now.
--- fs/xfs/xfs_bmap_util.c | 1 fs/xfs/xfs_mount.h | 5 - fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 127 +++++++++++++ fs/xfs/xfs_xchgrange.c | 462 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_xchgrange.h | 28 +++ 6 files changed, 622 insertions(+), 2 deletions(-)
fs/xfs/xfs_bmap_util.c +1 -0
@@ -29,6 +29,7 @@#include "xfs_iomap.h" #include "xfs_reflink.h" #include "xfs_rtbitmap.h" +#include "xfs_swapext.h" /* Kernel only BMAP related definitions and functions */
fs/xfs/xfs_mount.h +4 -1
@@ -412,6 +412,8 @@ __XFS_HAS_FEAT(nouuid, NOUUID)#define XFS_OPSTATE_WARNED_LARP 9/* Mount time quotacheck is running */ #define XFS_OPSTATE_QUOTACHECK_RUNNING 10 +/* Kernel has logged a warning about extent swapping being used on this fs. */ +#define XFS_OPSTATE_WARNED_SWAPEXT 11#define __XFS_IS_OPSTATE (name,NAME ) \ static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
@@ -457,7 +459,8 @@ xfs_should_warn(struct xfs_mount *mp, long nr) { (1UL << XFS_OPSTATE_WARNED_SCRUB), "wscrub" }, \ { (1UL << XFS_OPSTATE_WARNED_SHRINK), "wshrink" }, \ { (1UL << XFS_OPSTATE_WARNED_LARP), "wlarp" }, \ - { (1UL << XFS_OPSTATE_QUOTACHECK_RUNNING), "quotacheck" } + { (1UL << XFS_OPSTATE_QUOTACHECK_RUNNING), "quotacheck" }, \ + { (1UL << XFS_OPSTATE_WARNED_SWAPEXT), "wswapext" }/* * Max and min values for mount-option defined I/O
fs/xfs/xfs_trace.c +1 -0
@@ -41,6 +41,7 @@#include "xfs_btree_mem.h" #include "xfs_bmap.h" #include "xfs_swapext.h" +#include "xfs_xchgrange.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +127 -0
138 lines not on this page · raw message
fs/xfs/xfs_xchgrange.c +461 -1
485 lines not on this page · raw message
fs/xfs/xfs_xchgrange.h +28 -0
@@ -15,6 +15,11 @@ int xfs_exch_range_finish(struct file *file1, struct file *file2);int xfs_exch_range (struct file *file1,struct file *file2,struct xfs_exch_range *fxr); +/* Binding between the generic VFS and the XFS-specific file exchange */ + +int xfs_file_xchg_range (struct file *file1,struct file *file2, +struct xfs_exch_range *fxr); +/* XFS-specific parts of file exchanges */ struct xfs_swapext_req ;
@@ -25,4 +30,27 @@ void xfs_xchg_range_iunlock(struct xfs_inode *ip1, struct xfs_inode *ip2);int xfs_xchg_range_estimate (struct xfs_swapext_req *req); +int xfs_xchg_range_grab_log_assist (struct xfs_mount *mp,bool force, +bool *use_logging); +void xfs_xchg_range_rele_log_assist (struct xfs_mount *mp); + +/* Caller has permission to use log intent items for the exchange operation. */ +#define XFS_XCHG_RANGE_LOGGED (1U << 0) + +/* Update ip1's change and mod time. */ +#define XFS_XCHG_RANGE_UPD_CMTIME1 (1U << 1) + +/* Update ip2's change and mod time. */ +#define XFS_XCHG_RANGE_UPD_CMTIME2 (1U << 2) + +#define XCHG_RANGE_FLAGS_STRS \ + { XFS_XCHG_RANGE_LOGGED, "LOGGED" }, \ + { XFS_XCHG_RANGE_UPD_CMTIME1, "UPD_CMTIME1" }, \ + { XFS_XCHG_RANGE_UPD_CMTIME2, "UPD_CMTIME2" } + +int xfs_xchg_range (struct xfs_inode *ip1,struct xfs_inode *ip2, +const struct xfs_exch_range *fxr,unsigned int xchg_flags); +int xfs_xchg_range_prep (struct file *file1,struct file *file2, +struct xfs_exch_range *fxr); +#endif /* __XFS_XCHGRANGE_H__ */
PATCH 14/25 xfs: add error injection to test swapext recovery
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add an errortag so that we can test recovery of swapext log items.
--- fs/xfs/libxfs/xfs_errortag.h | 4 +++- fs/xfs/libxfs/xfs_swapext.c | 3 +++ fs/xfs/xfs_error.c | 3 +++ 3 files changed, 9 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_errortag.h +3 -1
@@ -63,7 +63,8 @@#define XFS_ERRTAG_ATTR_LEAF_TO_NODE 41#define XFS_ERRTAG_WB_DELAY_MS 42#define XFS_ERRTAG_WRITE_DELAY_MS 43 -#define XFS_ERRTAG_MAX 44 +#define XFS_ERRTAG_SWAPEXT_FINISH_ONE 44 +#define XFS_ERRTAG_MAX 45/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -111,5 +112,6 @@#define XFS_RANDOM_ATTR_LEAF_TO_NODE 1#define XFS_RANDOM_WB_DELAY_MS 3000#define XFS_RANDOM_WRITE_DELAY_MS 3000 +#define XFS_RANDOM_SWAPEXT_FINISH_ONE 1#endif /* __XFS_ERRORTAG_H_ */
fs/xfs/libxfs/xfs_swapext.c +3 -0
@@ -436,6 +436,9 @@ xfs_swapext_finish_one(return error; } +if (XFS_TEST_ERROR (false, tp->t_mountp,XFS_ERRTAG_SWAPEXT_FINISH_ONE )) +return -EIO ; +/* If we still have work to do, ask for a new transaction. */ if (sxi_has_more_swap_work (sxi) ||sxi_has_postop_work (sxi)) {trace_xfs_swapext_defer (tp->t_mountp, sxi);
fs/xfs/xfs_error.c +3 -0
@@ -62,6 +62,7 @@ static unsigned int xfs_errortag_random_default[] = {XFS_RANDOM_ATTR_LEAF_TO_NODE ,XFS_RANDOM_WB_DELAY_MS ,XFS_RANDOM_WRITE_DELAY_MS , + XFS_RANDOM_SWAPEXT_FINISH_ONE, }; struct xfs_errortag_attr {
@@ -179,6 +180,7 @@ XFS_ERRORTAG_ATTR_RW(da_leaf_split, XFS_ERRTAG_DA_LEAF_SPLIT);XFS_ERRORTAG_ATTR_RW (attr_leaf_to_node,XFS_ERRTAG_ATTR_LEAF_TO_NODE );XFS_ERRORTAG_ATTR_RW (wb_delay_ms,XFS_ERRTAG_WB_DELAY_MS );XFS_ERRORTAG_ATTR_RW (write_delay_ms,XFS_ERRTAG_WRITE_DELAY_MS ); +XFS_ERRORTAG_ATTR_RW (swapext_finish_one,XFS_ERRTAG_SWAPEXT_FINISH_ONE );static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (noerror),
@@ -224,6 +226,7 @@ static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (attr_leaf_to_node),XFS_ERRORTAG_ATTR_LIST (wb_delay_ms),XFS_ERRORTAG_ATTR_LIST (write_delay_ms), +XFS_ERRORTAG_ATTR_LIST (swapext_finish_one),NULL , };ATTRIBUTE_GROUPS (xfs_errortag);
PATCH 15/25 xfs: port xfs_swap_extents_rmap to our new code
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The inner loop of xfs_swap_extents_rmap does the same work as xfs_swapext_finish_one, so adapt it to use that. Doing so has the side benefit that the older code path no longer wastes its time remapping shared extents.
This forms the basis of the non-atomic swaprange implementation.
--- fs/xfs/xfs_bmap_util.c | 151 +++++------------------------------------------- fs/xfs/xfs_trace.h | 5 -- 2 files changed, 16 insertions(+), 140 deletions(-)
fs/xfs/xfs_bmap_util.c +15 -136
@@ -1354,138 +1354,6 @@ xfs_swap_extent_flush(return 0 ; } -/* -* Move extents from one file to another, when rmap is enabled. -*/ -STATIC int -xfs_swap_extent_rmap ( -struct xfs_trans **tpp, -struct xfs_inode *ip, -struct xfs_inode *tip) -{ -struct xfs_trans *tp = *tpp; -struct xfs_bmbt_irec irec; -struct xfs_bmbt_irec uirec; -struct xfs_bmbt_irec tirec; -xfs_fileoff_t offset_fsb; -xfs_fileoff_t end_fsb; -xfs_filblks_t count_fsb; -int error; -xfs_filblks_t ilen; -xfs_filblks_t rlen; -int nimaps; -uint64_t tip_flags2; - -/* -* If the source file has shared blocks, we must flag the donor -* file as having shared blocks so that we get the shared-block -* rmap functions when we go to fix up the rmaps. The flags -* will be switch for reals later. -*/ - tip_flags2 = tip->i_diflags2; -if (ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) - tip->i_diflags2 |=XFS_DIFLAG2_REFLINK ; - - offset_fsb =0 ; - end_fsb =XFS_B_TO_FSB (ip->i_mount,i_size_read (VFS_I (ip))); - count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb); - -while (count_fsb) { -/* Read extent from the donor file */ - nimaps =1 ; - error =xfs_bmapi_read (tip, offset_fsb, count_fsb, &tirec, - &nimaps,0 ); -if (error) - goto out; -ASSERT (nimaps ==1 ); -ASSERT (tirec.br_startblock !=DELAYSTARTBLOCK ); - -trace_xfs_swap_extent_rmap_remap (tip, &tirec); - ilen = tirec.br_blockcount; - -/* Unmap the old blocks in the source file. */ -while (tirec.br_blockcount) { -ASSERT (tp->t_highest_agno ==NULLAGNUMBER ); -trace_xfs_swap_extent_rmap_remap_piece (tip, &tirec); - -/* Read extent from the source file */ - nimaps =1 ; - error =xfs_bmapi_read (ip, tirec.br_startoff, - tirec.br_blockcount, &irec, - &nimaps,0 ); -if (error) - goto out; -ASSERT (nimaps ==1 ); -ASSERT (tirec.br_startoff == irec.br_startoff); -trace_xfs_swap_extent_rmap_remap_piece (ip, &irec); - -/* Trim the extent. */ - uirec = tirec; - uirec.br_blockcount = rlen =min_t (xfs_filblks_t, - tirec.br_blockcount, - irec.br_blockcount); -trace_xfs_swap_extent_rmap_remap_piece (tip, &uirec); - -if (xfs_bmap_is_real_extent (&uirec)) { - error =xfs_iext_count_may_overflow (ip, -XFS_DATA_FORK , -XFS_IEXT_SWAP_RMAP_CNT ); -if (error == -EFBIG ) - error =xfs_iext_count_upgrade (tp, ip, -XFS_IEXT_SWAP_RMAP_CNT ); -if (error) - goto out; - } - -if (xfs_bmap_is_real_extent (&irec)) { - error =xfs_iext_count_may_overflow (tip, -XFS_DATA_FORK , -XFS_IEXT_SWAP_RMAP_CNT ); -if (error == -EFBIG ) - error =xfs_iext_count_upgrade (tp, ip, -XFS_IEXT_SWAP_RMAP_CNT ); -if (error) - goto out; - } - -/* Remove the mapping from the donor file. */ -xfs_bmap_unmap_extent (tp, tip,XFS_DATA_FORK , &uirec); - -/* Remove the mapping from the source file. */ -xfs_bmap_unmap_extent (tp, ip,XFS_DATA_FORK , &irec); - -/* Map the donor file's blocks into the source file. */ -xfs_bmap_map_extent (tp, ip,XFS_DATA_FORK , &uirec); - -/* Map the source file's blocks into the donor file. */ -xfs_bmap_map_extent (tp, tip,XFS_DATA_FORK , &irec); - - error =xfs_defer_finish (tpp); - tp = *tpp; -if (error) - goto out; - - tirec.br_startoff += rlen; -if (tirec.br_startblock !=HOLESTARTBLOCK && - tirec.br_startblock !=DELAYSTARTBLOCK ) - tirec.br_startblock += rlen; - tirec.br_blockcount -= rlen; - } - -/* Roll on... */ - count_fsb -= ilen; - offset_fsb += ilen; - } - - tip->i_diflags2 = tip_flags2; -return 0 ; - -out: -trace_xfs_swap_extent_rmap_error (ip, error, _RET_IP_); - tip->i_diflags2 = tip_flags2; -return error; -} -/* Swap the extents of two files by swapping data forks. */ STATIC int xfs_swap_extent_forks(
@@ -1772,13 +1640,24 @@ xfs_swap_extents( src_log_flags =XFS_ILOG_CORE ; target_log_flags =XFS_ILOG_CORE ; -if (xfs_has_rmapbt (mp)) - error =xfs_swap_extent_rmap (&tp, ip, tip); -else +if (xfs_has_rmapbt (mp)) { +struct xfs_swapext_req req = { + .ip1 = tip, + .ip2 = ip, + .whichfork =XFS_DATA_FORK , + .blockcount =XFS_B_TO_FSB (ip->i_mount, +i_size_read (VFS_I (ip))), + }; + +xfs_swapext (tp, &req); + error =xfs_defer_finish (&tp); + }else error =xfs_swap_extent_forks (tp, ip, tip, &src_log_flags, &target_log_flags); -if (error) +if (error) { +trace_xfs_swap_extent_error (ip, error, _THIS_IP_); goto out_trans_cancel; + }/* Do we have to swap reflink flags? */ if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
fs/xfs/xfs_trace.h +1 -4
@@ -3746,13 +3746,10 @@ DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error);DEFINE_INODE_IREC_EVENT (xfs_reflink_cancel_cow); -/* rmap swapext tracepoints */ -DEFINE_INODE_IREC_EVENT (xfs_swap_extent_rmap_remap); -DEFINE_INODE_IREC_EVENT (xfs_swap_extent_rmap_remap_piece); -DEFINE_INODE_ERROR_EVENT (xfs_swap_extent_rmap_error);/* swapext tracepoints */ DEFINE_INODE_ERROR_EVENT (xfs_file_xchg_range_error); +DEFINE_INODE_ERROR_EVENT (xfs_swap_extent_error);DEFINE_INODE_IREC_EVENT (xfs_swapext_extent1_skip);DEFINE_INODE_IREC_EVENT (xfs_swapext_extent1);DEFINE_INODE_IREC_EVENT (xfs_swapext_extent2);
PATCH 16/25 xfs: consolidate all of the xfs_swap_extent_forks code
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we've moved the old swapext code to use the new log-assisted extent swap code for rmap filesystems, let's start porting the old implementation to the new ioctl interface so that later we can port the old interface to the new interface.
Consolidate the reflink flag swap code and the the bmbt owner change scan code in xfs_swap_extent_forks, since both interfaces are going to need that.
--- fs/xfs/xfs_bmap_util.c | 220 ++++++++++++++++++++++++------------------------ 1 file changed, 108 insertions(+), 112 deletions(-)
fs/xfs/xfs_bmap_util.c +108 -112
@@ -1354,19 +1354,61 @@ xfs_swap_extent_flush(return 0 ; } +/* +* Fix up the owners of the bmbt blocks to refer to the current inode. The +* change owner scan attempts to order all modified buffers in the current +* transaction. In the event of ordered buffer failure, the offending buffer is +* physically logged as a fallback and the scan returns -EAGAIN. We must roll +* the transaction in this case to replenish the fallback log reservation and +* restart the scan. This process repeats until the scan completes. +*/ +static int +xfs_swap_change_owner ( +struct xfs_trans **tpp, +struct xfs_inode *ip, +struct xfs_inode *tmpip) +{ +int error; +struct xfs_trans *tp = *tpp; + +do { + error =xfs_bmbt_change_owner (tp, ip,XFS_DATA_FORK , ip->i_ino, +NULL ); +/* success or fatal error */ +if (error != -EAGAIN ) +break ; + + error =xfs_trans_roll (tpp); +if (error) +break ; + tp = *tpp; + +/* +* Redirty both inodes so they can relog and keep the log tail +* moving forward. +*/ +xfs_trans_ijoin (tp, ip,0 ); +xfs_trans_ijoin (tp, tmpip,0 ); +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +xfs_trans_log_inode (tp, tmpip,XFS_ILOG_CORE ); + }while (true); + +return error; +} +/* Swap the extents of two files by swapping data forks. */ STATIC intxfs_swap_extent_forks ( -struct xfs_trans *tp, +struct xfs_trans **tpp,struct xfs_inode *ip, -struct xfs_inode *tip, -int *src_log_flags, -int *target_log_flags) +struct xfs_inode *tip) {xfs_filblks_t aforkblks =0 ;xfs_filblks_t taforkblks =0 ;xfs_extnum_t junk;uint64_t tmp; +int src_log_flags =XFS_ILOG_CORE ; +int target_log_flags =XFS_ILOG_CORE ;int error;/*
@@ -1374,14 +1416,14 @@ xfs_swap_extent_forks(*/ if (xfs_inode_has_attr_fork (ip) && ip->i_af.if_nextents >0 && ip->i_af.if_format !=XFS_DINODE_FMT_LOCAL ) { - error =xfs_bmap_count_blocks (tp, ip,XFS_ATTR_FORK , &junk, + error =xfs_bmap_count_blocks (*tpp, ip,XFS_ATTR_FORK , &junk, &aforkblks);if (error)return error; }if (xfs_inode_has_attr_fork (tip) && tip->i_af.if_nextents >0 && tip->i_af.if_format !=XFS_DINODE_FMT_LOCAL ) { - error =xfs_bmap_count_blocks (tp, tip,XFS_ATTR_FORK , &junk, + error =xfs_bmap_count_blocks (*tpp, tip,XFS_ATTR_FORK , &junk, &taforkblks);if (error)return error;
@@ -1396,9 +1438,9 @@ xfs_swap_extent_forks(*/ if (xfs_has_v3inodes (ip->i_mount)) {if (ip->i_df.if_format ==XFS_DINODE_FMT_BTREE ) - (*target_log_flags) |=XFS_ILOG_DOWNER ; + target_log_flags |=XFS_ILOG_DOWNER ;if (tip->i_df.if_format ==XFS_DINODE_FMT_BTREE ) - (*src_log_flags) |=XFS_ILOG_DOWNER ; + src_log_flags |=XFS_ILOG_DOWNER ; }/*
@@ -1428,71 +1470,80 @@ xfs_swap_extent_forks(switch (ip->i_df.if_format) {case XFS_DINODE_FMT_EXTENTS : - (*src_log_flags) |=XFS_ILOG_DEXT ; + src_log_flags |=XFS_ILOG_DEXT ;break ;case XFS_DINODE_FMT_BTREE :ASSERT (!xfs_has_v3inodes (ip->i_mount) || - (*src_log_flags &XFS_ILOG_DOWNER )); - (*src_log_flags) |=XFS_ILOG_DBROOT ; + (src_log_flags &XFS_ILOG_DOWNER )); + src_log_flags |=XFS_ILOG_DBROOT ;break ; }switch (tip->i_df.if_format) {case XFS_DINODE_FMT_EXTENTS : - (*target_log_flags) |=XFS_ILOG_DEXT ; + target_log_flags |=XFS_ILOG_DEXT ;break ;case XFS_DINODE_FMT_BTREE : - (*target_log_flags) |=XFS_ILOG_DBROOT ; + target_log_flags |=XFS_ILOG_DBROOT ;ASSERT (!xfs_has_v3inodes (ip->i_mount) || - (*target_log_flags &XFS_ILOG_DOWNER )); + (target_log_flags &XFS_ILOG_DOWNER ));break ; } +/* Do we have to swap reflink flags? */ +if ((ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) ^ + (tip->i_diflags2 &XFS_DIFLAG2_REFLINK )) { +uint64_t f; + + f = ip->i_diflags2 &XFS_DIFLAG2_REFLINK ; + ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; + ip->i_diflags2 |= tip->i_diflags2 &XFS_DIFLAG2_REFLINK ; + tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; + tip->i_diflags2 |= f &XFS_DIFLAG2_REFLINK ; + } + +/* Swap the cow forks. */ +if (xfs_has_reflink (ip->i_mount)) { +ASSERT (!ip->i_cowfp || + ip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); +ASSERT (!tip->i_cowfp || + tip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); + +swap (ip->i_cowfp, tip->i_cowfp); + +if (ip->i_cowfp && ip->i_cowfp->if_bytes) +xfs_inode_set_cowblocks_tag (ip); +else +xfs_inode_clear_cowblocks_tag (ip); +if (tip->i_cowfp && tip->i_cowfp->if_bytes) +xfs_inode_set_cowblocks_tag (tip); +else +xfs_inode_clear_cowblocks_tag (tip); + } + +xfs_trans_log_inode (*tpp, ip, src_log_flags); +xfs_trans_log_inode (*tpp, tip, target_log_flags); + +/* +* The extent forks have been swapped, but crc=1,rmapbt=0 filesystems +* have inode number owner values in the bmbt blocks that still refer to +* the old inode. Scan each bmbt to fix up the owner values with the +* inode number of the current inode. +*/ +if (src_log_flags &XFS_ILOG_DOWNER ) { + error =xfs_swap_change_owner (tpp, ip, tip); +if (error) +return error; + } +if (target_log_flags &XFS_ILOG_DOWNER ) { + error =xfs_swap_change_owner (tpp, tip, ip); +if (error) +return error; + } +return 0 ; } -/* -* Fix up the owners of the bmbt blocks to refer to the current inode. The -* change owner scan attempts to order all modified buffers in the current -* transaction. In the event of ordered buffer failure, the offending buffer is -* physically logged as a fallback and the scan returns -EAGAIN. We must roll -* the transaction in this case to replenish the fallback log reservation and -* restart the scan. This process repeats until the scan completes. -*/ -static int -xfs_swap_change_owner ( -struct xfs_trans **tpp, -struct xfs_inode *ip, -struct xfs_inode *tmpip) -{ -int error; -struct xfs_trans *tp = *tpp; - -do { - error =xfs_bmbt_change_owner (tp, ip,XFS_DATA_FORK , ip->i_ino, -NULL ); -/* success or fatal error */ -if (error != -EAGAIN ) -break ; - - error =xfs_trans_roll (tpp); -if (error) -break ; - tp = *tpp; - -/* -* Redirty both inodes so they can relog and keep the log tail -* moving forward. -*/ -xfs_trans_ijoin (tp, ip,0 ); -xfs_trans_ijoin (tp, tmpip,0 ); -xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); -xfs_trans_log_inode (tp, tmpip,XFS_ILOG_CORE ); - }while (true); - -return error; -} - int xfs_swap_extents( struct xfs_inode *ip, /* target inode */
@@ -1502,9 +1553,7 @@ xfs_swap_extents(struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;struct xfs_bstat *sbp = &sxp->sx_stat; -int src_log_flags, target_log_flags;int error =0 ; -uint64_t f;int resblks =0 ;unsigned int flags =0 ;struct timespec64 ctime, mtime;
@@ -1637,9 +1686,6 @@ xfs_swap_extents(* recovery is going to see the fork as owned by the swapped inode, * not the pre-swapped inodes. */ - src_log_flags =XFS_ILOG_CORE ; - target_log_flags =XFS_ILOG_CORE ; -if (xfs_has_rmapbt (mp)) {struct xfs_swapext_req req = { .ip1 = tip,
@@ -1652,62 +1698,12 @@ xfs_swap_extents(xfs_swapext (tp, &req); error =xfs_defer_finish (&tp); }else - error =xfs_swap_extent_forks (tp, ip, tip, &src_log_flags, - &target_log_flags); + error =xfs_swap_extent_forks (&tp, ip, tip);if (error) {trace_xfs_swap_extent_error (ip, error, _THIS_IP_); goto out_trans_cancel; } -/* Do we have to swap reflink flags? */ -if ((ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) ^ - (tip->i_diflags2 &XFS_DIFLAG2_REFLINK )) { - f = ip->i_diflags2 &XFS_DIFLAG2_REFLINK ; - ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; - ip->i_diflags2 |= tip->i_diflags2 &XFS_DIFLAG2_REFLINK ; - tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; - tip->i_diflags2 |= f &XFS_DIFLAG2_REFLINK ; - } - -/* Swap the cow forks. */ -if (xfs_has_reflink (mp)) { -ASSERT (!ip->i_cowfp || - ip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); -ASSERT (!tip->i_cowfp || - tip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); - -swap (ip->i_cowfp, tip->i_cowfp); - -if (ip->i_cowfp && ip->i_cowfp->if_bytes) -xfs_inode_set_cowblocks_tag (ip); -else -xfs_inode_clear_cowblocks_tag (ip); -if (tip->i_cowfp && tip->i_cowfp->if_bytes) -xfs_inode_set_cowblocks_tag (tip); -else -xfs_inode_clear_cowblocks_tag (tip); - } - -xfs_trans_log_inode (tp, ip, src_log_flags); -xfs_trans_log_inode (tp, tip, target_log_flags); - -/* -* The extent forks have been swapped, but crc=1,rmapbt=0 filesystems -* have inode number owner values in the bmbt blocks that still refer to -* the old inode. Scan each bmbt to fix up the owner values with the -* inode number of the current inode. -*/ -if (src_log_flags &XFS_ILOG_DOWNER ) { - error =xfs_swap_change_owner (&tp, ip, tip); -if (error) - goto out_trans_cancel; - } -if (target_log_flags &XFS_ILOG_DOWNER ) { - error =xfs_swap_change_owner (&tp, tip, ip); -if (error) - goto out_trans_cancel; - } -/* * If this is a synchronous mount, make sure that the * transaction goes to disk before returning to the user.
PATCH 17/25 xfs: port xfs_swap_extent_forks to use xfs_swapext_req
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port the old extent fork swapping function to take a xfs_swapext_req as input, which aligns it with the new fiexchange interface.
--- fs/xfs/xfs_bmap_util.c | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-)
fs/xfs/xfs_bmap_util.c +10 -11
@@ -1400,9 +1400,10 @@ xfs_swap_change_owner( STATIC intxfs_swap_extent_forks (struct xfs_trans **tpp, -struct xfs_inode *ip, -struct xfs_inode *tip) +struct xfs_swapext_req *req) { +struct xfs_inode *ip = req->ip2; +struct xfs_inode *tip = req->ip1;xfs_filblks_t aforkblks =0 ;xfs_filblks_t taforkblks =0 ;xfs_extnum_t junk;
@@ -1550,6 +1551,11 @@ xfs_swap_extents(struct xfs_inode *tip,/* tmp inode */ struct xfs_swapext *sxp) { + struct xfs_swapext_req req = { + .ip1 = tip, + .ip2 = ip, + .whichfork =XFS_DATA_FORK , + };struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;struct xfs_bstat *sbp = &sxp->sx_stat;
@@ -1686,19 +1692,12 @@ xfs_swap_extents(* recovery is going to see the fork as owned by the swapped inode, * not the pre-swapped inodes. */ + req.blockcount =XFS_B_TO_FSB (ip->i_mount,i_size_read (VFS_I (ip)));if (xfs_has_rmapbt (mp)) { -struct xfs_swapext_req req = { - .ip1 = tip, - .ip2 = ip, - .whichfork =XFS_DATA_FORK , - .blockcount =XFS_B_TO_FSB (ip->i_mount, -i_size_read (VFS_I (ip))), - }; -xfs_swapext (tp, &req); error =xfs_defer_finish (&tp); }else - error =xfs_swap_extent_forks (&tp, ip, tip); + error =xfs_swap_extent_forks (&tp, &req);if (error) {trace_xfs_swap_extent_error (ip, error, _THIS_IP_); goto out_trans_cancel;
PATCH 18/25 xfs: allow xfs_swap_range to use older extent swap algorithms
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If userspace permits non-atomic swap operations, use the older code paths to implement the same functionality.
--- fs/xfs/xfs_bmap_util.c | 4 +- fs/xfs/xfs_bmap_util.h | 4 ++ fs/xfs/xfs_xchgrange.c | 123 ++++++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 118 insertions(+), 13 deletions(-)
fs/xfs/xfs_bmap_util.c +2 -2
@@ -1255,7 +1255,7 @@ xfs_insert_file_space(* reject and log the attempt. basically we are putting the responsibility on * userspace to get this right. */ -static int +int xfs_swap_extents_check_format (struct xfs_inode *ip,/* target inode */ struct xfs_inode *tip)/* tmp inode */
@@ -1397,7 +1397,7 @@ xfs_swap_change_owner( }/* Swap the extents of two files by swapping data forks. */ -STATIC int +int xfs_swap_extent_forks (struct xfs_trans **tpp,struct xfs_swapext_req *req)
fs/xfs/xfs_bmap_util.h +4 -0
@@ -69,6 +69,10 @@ int xfs_free_eofblocks(struct xfs_inode *ip);int xfs_swap_extents (struct xfs_inode *ip,struct xfs_inode *tip,struct xfs_swapext *sx); +struct xfs_swapext_req ; +int xfs_swap_extent_forks (struct xfs_trans **tpp,struct xfs_swapext_req *req); +int xfs_swap_extents_check_format (struct xfs_inode *ip,struct xfs_inode *tip); +xfs_daddr_t xfs_fsb_to_db (struct xfs_inode *ip,xfs_fsblock_t fsb);xfs_extnum_t xfs_bmap_count_leaves (struct xfs_ifork *ifp,xfs_filblks_t *count);
fs/xfs/xfs_xchgrange.c +112 -11
161 lines not on this page · raw message
PATCH 19/25 xfs: remove old swap extents implementation
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Migrate the old XFS_IOC_SWAPEXT implementation to use our shiny new one.
--- fs/xfs/xfs_bmap_util.c | 494 ------------------------------------------------ fs/xfs/xfs_bmap_util.h | 7 - fs/xfs/xfs_ioctl.c | 102 +++------- fs/xfs/xfs_ioctl.h | 4 fs/xfs/xfs_ioctl32.c | 11 - fs/xfs/xfs_xchgrange.c | 299 +++++++++++++++++++++++++++++ 6 files changed, 334 insertions(+), 583 deletions(-)
fs/xfs/xfs_bmap_util.c +0 -494
@@ -1234,497 +1234,3 @@ xfs_insert_file_space(xfs_iunlock (ip,XFS_ILOCK_EXCL );return error; } - -/* -* We need to check that the format of the data fork in the temporary inode is -* valid for the target inode before doing the swap. This is not a problem with -* attr1 because of the fixed fork offset, but attr2 has a dynamically sized -* data fork depending on the space the attribute fork is taking so we can get -* invalid formats on the target inode. -* -* E.g. target has space for 7 extents in extent format, temp inode only has -* space for 6. If we defragment down to 7 extents, then the tmp format is a -* btree, but when swapped it needs to be in extent format. Hence we can't just -* blindly swap data forks on attr2 filesystems. -* -* Note that we check the swap in both directions so that we don't end up with -* a corrupt temporary inode, either. -* -* Note that fixing the way xfs_fsr sets up the attribute fork in the source -* inode will prevent this situation from occurring, so all we do here is -* reject and log the attempt. basically we are putting the responsibility on -* userspace to get this right. -*/ -int -xfs_swap_extents_check_format ( -struct xfs_inode *ip,/* target inode */ -struct xfs_inode *tip)/* tmp inode */ -{ -struct xfs_ifork *ifp = &ip->i_df; -struct xfs_ifork *tifp = &tip->i_df; - -/* User/group/project quota ids must match if quotas are enforced. */ -if (XFS_IS_QUOTA_ON (ip->i_mount) && - (!uid_eq (VFS_I (ip)->i_uid,VFS_I (tip)->i_uid) || - !gid_eq (VFS_I (ip)->i_gid,VFS_I (tip)->i_gid) || - ip->i_projid != tip->i_projid)) -return -EINVAL ; - -/* Should never get a local format */ -if (ifp->if_format ==XFS_DINODE_FMT_LOCAL || - tifp->if_format ==XFS_DINODE_FMT_LOCAL ) -return -EINVAL ; - -/* -* if the target inode has less extents that then temporary inode then -* why did userspace call us? -*/ -if (ifp->if_nextents < tifp->if_nextents) -return -EINVAL ; - -/* -* If we have to use the (expensive) rmap swap method, we can -* handle any number of extents and any format. -*/ -if (xfs_has_rmapbt (ip->i_mount)) -return 0 ; - -/* -* if the target inode is in extent form and the temp inode is in btree -* form then we will end up with the target inode in the wrong format -* as we already know there are less extents in the temp inode. -*/ -if (ifp->if_format ==XFS_DINODE_FMT_EXTENTS && - tifp->if_format ==XFS_DINODE_FMT_BTREE ) -return -EINVAL ; - -/* Check temp in extent form to max in target */ -if (tifp->if_format ==XFS_DINODE_FMT_EXTENTS && - tifp->if_nextents >XFS_IFORK_MAXEXT (ip,XFS_DATA_FORK )) -return -EINVAL ; - -/* Check target in extent form to max in temp */ -if (ifp->if_format ==XFS_DINODE_FMT_EXTENTS && - ifp->if_nextents >XFS_IFORK_MAXEXT (tip,XFS_DATA_FORK )) -return -EINVAL ; - -/* -* If we are in a btree format, check that the temp root block will fit -* in the target and that it has enough extents to be in btree format -* in the target. -* -* Note that we have to be careful to allow btree->extent conversions -* (a common defrag case) which will occur when the temp inode is in -* extent format... -*/ -if (tifp->if_format ==XFS_DINODE_FMT_BTREE ) { -if (xfs_inode_has_attr_fork (ip) && -XFS_BMAP_BMDR_SPACE (tifp->if_broot) >xfs_inode_fork_boff (ip)) -return -EINVAL ; -if (tifp->if_nextents <=XFS_IFORK_MAXEXT (ip,XFS_DATA_FORK )) -return -EINVAL ; - } - -/* Reciprocal target->temp btree format checks */ -if (ifp->if_format ==XFS_DINODE_FMT_BTREE ) { -if (xfs_inode_has_attr_fork (tip) && -XFS_BMAP_BMDR_SPACE (ip->i_df.if_broot) >xfs_inode_fork_boff (tip)) -return -EINVAL ; -if (ifp->if_nextents <=XFS_IFORK_MAXEXT (tip,XFS_DATA_FORK )) -return -EINVAL ; - } - -return 0 ; -} - -static int -xfs_swap_extent_flush ( -struct xfs_inode *ip) -{ -int error; - - error =filemap_write_and_wait (VFS_I (ip)->i_mapping); -if (error) -return error; -truncate_pagecache_range (VFS_I (ip),0 ,-1 ); - -/* Verify O_DIRECT for ftmp */ -if (VFS_I (ip)->i_mapping->nrpages) -return -EINVAL ; -return 0 ; -} - -/* -* Fix up the owners of the bmbt blocks to refer to the current inode. The -* change owner scan attempts to order all modified buffers in the current -* transaction. In the event of ordered buffer failure, the offending buffer is -* physically logged as a fallback and the scan returns -EAGAIN. We must roll -* the transaction in this case to replenish the fallback log reservation and -* restart the scan. This process repeats until the scan completes. -*/ -static int -xfs_swap_change_owner ( -struct xfs_trans **tpp, -struct xfs_inode *ip, -struct xfs_inode *tmpip) -{ -int error; -struct xfs_trans *tp = *tpp; - -do { - error =xfs_bmbt_change_owner (tp, ip,XFS_DATA_FORK , ip->i_ino, -NULL ); -/* success or fatal error */ -if (error != -EAGAIN ) -break ; - - error =xfs_trans_roll (tpp); -if (error) -break ; - tp = *tpp; - -/* -* Redirty both inodes so they can relog and keep the log tail -* moving forward. -*/ -xfs_trans_ijoin (tp, ip,0 ); -xfs_trans_ijoin (tp, tmpip,0 ); -xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); -xfs_trans_log_inode (tp, tmpip,XFS_ILOG_CORE ); - }while (true); - -return error; -} - -/* Swap the extents of two files by swapping data forks. */ -int -xfs_swap_extent_forks ( -struct xfs_trans **tpp, -struct xfs_swapext_req *req) -{ -struct xfs_inode *ip = req->ip2; -struct xfs_inode *tip = req->ip1; -xfs_filblks_t aforkblks =0 ; -xfs_filblks_t taforkblks =0 ; -xfs_extnum_t junk; -uint64_t tmp; -int src_log_flags =XFS_ILOG_CORE ; -int target_log_flags =XFS_ILOG_CORE ; -int error; - -/* -* Count the number of extended attribute blocks -*/ -if (xfs_inode_has_attr_fork (ip) && ip->i_af.if_nextents >0 && - ip->i_af.if_format !=XFS_DINODE_FMT_LOCAL ) { - error =xfs_bmap_count_blocks (*tpp, ip,XFS_ATTR_FORK , &junk, - &aforkblks); -if (error) -return error; - } -if (xfs_inode_has_attr_fork (tip) && tip->i_af.if_nextents >0 && - tip->i_af.if_format !=XFS_DINODE_FMT_LOCAL ) { - error =xfs_bmap_count_blocks (*tpp, tip,XFS_ATTR_FORK , &junk, - &taforkblks); -if (error) -return error; - } - -/* -* Btree format (v3) inodes have the inode number stamped in the bmbt -* block headers. We can't start changing the bmbt blocks until the -* inode owner change is logged so recovery does the right thing in the -* event of a crash. Set the owner change log flags now and leave the -* bmbt scan as the last step. -*/ -if (xfs_has_v3inodes (ip->i_mount)) { -if (ip->i_df.if_format ==XFS_DINODE_FMT_BTREE ) - target_log_flags |=XFS_ILOG_DOWNER ; -if (tip->i_df.if_format ==XFS_DINODE_FMT_BTREE ) - src_log_flags |=XFS_ILOG_DOWNER ; - } - -/* -* Swap the data forks of the inodes -*/ -swap (ip->i_df, tip->i_df); - -/* -* Fix the on-disk inode values -*/ - tmp = (uint64_t )ip->i_nblocks; - ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks; - tip->i_nblocks = tmp + taforkblks - aforkblks; - -/* -* The extents in the source inode could still contain speculative -* preallocation beyond EOF (e.g. the file is open but not modified -* while defrag is in progress). In that case, we need to copy over the -* number of delalloc blocks the data fork in the source inode is -* tracking beyond EOF so that when the fork is truncated away when the -* temporary inode is unlinked we don't underrun the i_delayed_blks -* counter on that inode. -*/ -ASSERT (tip->i_delayed_blks ==0 ); - tip->i_delayed_blks = ip->i_delayed_blks; - ip->i_delayed_blks =0 ; - -switch (ip->i_df.if_format) { -case XFS_DINODE_FMT_EXTENTS : - src_log_flags |=XFS_ILOG_DEXT ; -break ; -case XFS_DINODE_FMT_BTREE : -ASSERT (!xfs_has_v3inodes (ip->i_mount) || - (src_log_flags &XFS_ILOG_DOWNER )); - src_log_flags |=XFS_ILOG_DBROOT ; -break ; - } - -switch (tip->i_df.if_format) { -case XFS_DINODE_FMT_EXTENTS : - target_log_flags |=XFS_ILOG_DEXT ; -break ; -case XFS_DINODE_FMT_BTREE : - target_log_flags |=XFS_ILOG_DBROOT ; -ASSERT (!xfs_has_v3inodes (ip->i_mount) || - (target_log_flags &XFS_ILOG_DOWNER )); -break ; - } - -/* Do we have to swap reflink flags? */ -if ((ip->i_diflags2 &XFS_DIFLAG2_REFLINK ) ^ - (tip->i_diflags2 &XFS_DIFLAG2_REFLINK )) { -uint64_t f; - - f = ip->i_diflags2 &XFS_DIFLAG2_REFLINK ; - ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; - ip->i_diflags2 |= tip->i_diflags2 &XFS_DIFLAG2_REFLINK ; - tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK ; - tip->i_diflags2 |= f &XFS_DIFLAG2_REFLINK ; - } - -/* Swap the cow forks. */ -if (xfs_has_reflink (ip->i_mount)) { -ASSERT (!ip->i_cowfp || - ip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); -ASSERT (!tip->i_cowfp || - tip->i_cowfp->if_format ==XFS_DINODE_FMT_EXTENTS ); - -swap (ip->i_cowfp, tip->i_cowfp); - -if (ip->i_cowfp && ip->i_cowfp->if_bytes) -xfs_inode_set_cowblocks_tag (ip); -else -xfs_inode_clear_cowblocks_tag (ip); -if (tip->i_cowfp && tip->i_cowfp->if_bytes) -xfs_inode_set_cowblocks_tag (tip); -else -xfs_inode_clear_cowblocks_tag (tip); - } - -xfs_trans_log_inode (*tpp, ip, src_log_flags); -xfs_trans_log_inode (*tpp, tip, target_log_flags); - -/* -* The extent forks have been swapped, but crc=1,rmapbt=0 filesystems -* have inode number owner values in the bmbt blocks that still refer to -* the old inode. Scan each bmbt to fix up the owner values with the -* inode number of the current inode. -*/ -if (src_log_flags &XFS_ILOG_DOWNER ) { - error =xfs_swap_change_owner (tpp, ip, tip); -if (error) -return error; - } -if (target_log_flags &XFS_ILOG_DOWNER ) { - error =xfs_swap_change_owner (tpp, tip, ip); -if (error) -return error; - } - -return 0 ; -} - -int -xfs_swap_extents ( -struct xfs_inode *ip,/* target inode */ -struct xfs_inode *tip,/* tmp inode */ -struct xfs_swapext *sxp) -{ -struct xfs_swapext_req req = { - .ip1 = tip, - .ip2 = ip, - .whichfork =XFS_DATA_FORK , - }; -struct xfs_mount *mp = ip->i_mount; -struct xfs_trans *tp; -struct xfs_bstat *sbp = &sxp->sx_stat; -int error =0 ; -int resblks =0 ; -unsigned int flags =0 ; -struct timespec64 ctime, mtime; - -/* -* Lock the inodes against other IO, page faults and truncate to -* begin with. Then we can ensure the inodes are flushed and have no -* page cache safely. Once we have done this we can take the ilocks and -* do the rest of the checks. -*/ -lock_two_nondirectories (VFS_I (ip),VFS_I (tip)); -filemap_invalidate_lock_two (VFS_I (ip)->i_mapping, -VFS_I (tip)->i_mapping); - -/* Verify that both files have the same format */ -if ((VFS_I (ip)->i_mode &S_IFMT ) != (VFS_I (tip)->i_mode &S_IFMT )) { - error = -EINVAL ; - goto out_unlock; - } - -/* Verify both files are either real-time or non-realtime */ -if (XFS_IS_REALTIME_INODE (ip) !=XFS_IS_REALTIME_INODE (tip)) { - error = -EINVAL ; - goto out_unlock; - } - - error =xfs_qm_dqattach (ip); -if (error) - goto out_unlock; - - error =xfs_qm_dqattach (tip); -if (error) - goto out_unlock; - - error =xfs_swap_extent_flush (ip); -if (error) - goto out_unlock; - error =xfs_swap_extent_flush (tip); -if (error) - goto out_unlock; - -if (xfs_inode_has_cow_data (tip)) { - error =xfs_reflink_cancel_cow_range (tip,0 ,NULLFILEOFF , true); -if (error) - goto out_unlock; - } - -/* -* Extent "swapping" with rmap requires a permanent reservation and -* a block reservation because it's really just a remap operation -* performed with log redo items! -*/ -if (xfs_has_rmapbt (mp)) { -int w =XFS_DATA_FORK ; -uint32_t ipnext = ip->i_df.if_nextents; -uint32_t tipnext = tip->i_df.if_nextents; - -/* -* Conceptually this shouldn't affect the shape of either bmbt, -* but since we atomically move extents one by one, we reserve -* enough space to rebuild both trees. -*/ - resblks =XFS_SWAP_RMAP_SPACE_RES (mp, ipnext, w); - resblks +=XFS_SWAP_RMAP_SPACE_RES (mp, tipnext, w); - -/* -* If either inode straddles a bmapbt block allocation boundary, -* the rmapbt algorithm triggers repeated allocs and frees as -* extents are remapped. This can exhaust the block reservation -* prematurely and cause shutdown. Return freed blocks to the -* transaction reservation to counter this behavior. -*/ - flags |=XFS_TRANS_RES_FDBLKS ; - } - error =xfs_trans_alloc (mp, &M_RES (mp)->tr_write, resblks,0 , flags, - &tp); -if (error) - goto out_unlock; - -/* -* Lock and join the inodes to the tansaction so that transaction commit -* or cancel will unlock the inodes from this point onwards. -*/ -xfs_lock_two_inodes (ip,XFS_ILOCK_EXCL , tip,XFS_ILOCK_EXCL ); -xfs_trans_ijoin (tp, ip,0 ); -xfs_trans_ijoin (tp, tip,0 ); - - -/* Verify all data are being swapped */ -if (sxp->sx_offset !=0 || - sxp->sx_length != ip->i_disk_size || - sxp->sx_length != tip->i_disk_size) { - error = -EFAULT ; - goto out_trans_cancel; - } - -trace_xfs_swap_extent_before (ip,0 ); -trace_xfs_swap_extent_before (tip,1 ); - -/* check inode formats now that data is flushed */ - error =xfs_swap_extents_check_format (ip, tip); -if (error) { -xfs_notice (mp, -"%s: inode 0x%llx format is incompatible for exchanging." , - __func__, ip->i_ino); - goto out_trans_cancel; - } - -/* -* Compare the current change & modify times with that -* passed in. If they differ, we abort this swap. -* This is the mechanism used to ensure the calling -* process that the file was not changed out from -* under it. -*/ - ctime =inode_get_ctime (VFS_I (ip)); - mtime =inode_get_mtime (VFS_I (ip)); -if ((sbp->bs_ctime.tv_sec != ctime.tv_sec) || - (sbp->bs_ctime.tv_nsec != ctime.tv_nsec) || - (sbp->bs_mtime.tv_sec != mtime.tv_sec) || - (sbp->bs_mtime.tv_nsec != mtime.tv_nsec)) { - error = -EBUSY ; - goto out_trans_cancel; - } - -/* -* Note the trickiness in setting the log flags - we set the owner log -* flag on the opposite inode (i.e. the inode we are setting the new -* owner to be) because once we swap the forks and log that, log -* recovery is going to see the fork as owned by the swapped inode, -* not the pre-swapped inodes. -*/ - req.blockcount =XFS_B_TO_FSB (ip->i_mount,i_size_read (VFS_I (ip))); -if (xfs_has_rmapbt (mp)) { -xfs_swapext (tp, &req); - error =xfs_defer_finish (&tp); - }else - error =xfs_swap_extent_forks (&tp, &req); -if (error) { -trace_xfs_swap_extent_error (ip, error, _THIS_IP_); - goto out_trans_cancel; - } - -/* -* If this is a synchronous mount, make sure that the -* transaction goes to disk before returning to the user. -*/ -if (xfs_has_wsync (mp)) -xfs_trans_set_sync (tp); - - error =xfs_trans_commit (tp); - -trace_xfs_swap_extent_after (ip,0 ); -trace_xfs_swap_extent_after (tip,1 ); - -out_unlock_ilock: -xfs_iunlock (ip,XFS_ILOCK_EXCL ); -xfs_iunlock (tip,XFS_ILOCK_EXCL ); -out_unlock: -filemap_invalidate_unlock_two (VFS_I (ip)->i_mapping, -VFS_I (tip)->i_mapping); -unlock_two_nondirectories (VFS_I (ip),VFS_I (tip)); -return error; - -out_trans_cancel: -xfs_trans_cancel (tp); - goto out_unlock_ilock; -}
fs/xfs/xfs_bmap_util.h +0 -7
@@ -66,13 +66,6 @@ int xfs_insert_file_space(struct xfs_inode *, xfs_off_t offset,bool xfs_can_free_eofblocks (struct xfs_inode *ip,bool force);int xfs_free_eofblocks (struct xfs_inode *ip); -int xfs_swap_extents (struct xfs_inode *ip,struct xfs_inode *tip, -struct xfs_swapext *sx); - -struct xfs_swapext_req ; -int xfs_swap_extent_forks (struct xfs_trans **tpp,struct xfs_swapext_req *req); -int xfs_swap_extents_check_format (struct xfs_inode *ip,struct xfs_inode *tip); -xfs_daddr_t xfs_fsb_to_db (struct xfs_inode *ip,xfs_fsblock_t fsb);xfs_extnum_t xfs_bmap_count_leaves (struct xfs_ifork *ifp,xfs_filblks_t *count);
fs/xfs/xfs_ioctl.c +30 -72
125 lines not on this page · raw message
fs/xfs/xfs_ioctl.h +1 -3
@@ -10,9 +10,7 @@ struct xfs_bstat;struct xfs_ibulk ;struct xfs_inogrp ; -int -xfs_ioc_swapext ( -xfs_swapext_t *sxp); +int xfs_ioc_swapext (struct xfs_swapext *sxp);extern int xfs_find_handle(
fs/xfs/xfs_ioctl32.c +4 -7
@@ -425,7 +425,6 @@ xfs_file_compat_ioctl(struct inode *inode =file_inode (filp);struct xfs_inode *ip =XFS_I (inode);void __user *arg =compat_ptr (p); -int error;trace_xfs_file_compat_ioctl (ip);
@@ -435,6 +434,7 @@ xfs_file_compat_ioctl(return xfs_compat_ioc_fsgeometry_v1 (ip->i_mount, arg);case XFS_IOC_FSGROWFSDATA_32 : {struct xfs_growfs_data in; +int error;if (xfs_compat_growfs_data_copyin (&in, arg))return -EFAULT ;
@@ -447,6 +447,7 @@ xfs_file_compat_ioctl( }case XFS_IOC_FSGROWFSRT_32 : {struct xfs_growfs_rt in; +int error;if (xfs_compat_growfs_rt_copyin (&in, arg))return -EFAULT ;
@@ -471,12 +472,8 @@ xfs_file_compat_ioctl( offsetof(struct xfs_swapext, sx_stat)) || xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat)) return -EFAULT; - error =mnt_want_write_file (filp); -if (error) -return error; - error =xfs_ioc_swapext (&sxp); -mnt_drop_write_file (filp); -return error; + +return xfs_ioc_swapext (&sxp); }case XFS_IOC_FSBULKSTAT_32 :case XFS_IOC_FSBULKSTAT_SINGLE_32 :
fs/xfs/xfs_xchgrange.c +299 -0
317 lines not on this page · raw message
PATCH 20/25 xfs: condense extended attributes after an atomic swap
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new swapext flag that enables us to perform post-swap processing on file2 once we're done swapping the extent maps. If we were swapping the extended attributes, we want to be able to convert file2's attr fork from block to inline format.
This isn't used anywhere right now, but we need to have the basic ondisk flags in place so that a future online xattr repair feature can create salvaged attrs in a temporary file and swap the attr forks when ready. If one file is in extents format and the other is inline, we will have to promote both to extents format to perform the swap. After the swap, we can try to condense the fixed file's attr fork back down to inline format if possible.
--- fs/xfs/libxfs/xfs_log_format.h | 9 +++++-- fs/xfs/libxfs/xfs_swapext.c | 51 +++++++++++++++++++++++++++++++++++++++- fs/xfs/libxfs/xfs_swapext.h | 9 +++++-- 3 files changed, 64 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_log_format.h +7 -2
@@ -916,18 +916,23 @@ struct xfs_swap_extent {/* Clear the reflink flag from inode2 after the operation. */ #define XFS_SWAP_EXT_CLEAR_INO2_REFLINK (1ULL << 4) +/* Try to convert inode2 from block to short format at the end, if possible. */ +#define XFS_SWAP_EXT_CVT_INO2_SF (1ULL << 5) +#define XFS_SWAP_EXT_FLAGS (XFS_SWAP_EXT_ATTR_FORK | \ XFS_SWAP_EXT_SET_SIZES | \ XFS_SWAP_EXT_INO1_WRITTEN | \ XFS_SWAP_EXT_CLEAR_INO1_REFLINK | \ - XFS_SWAP_EXT_CLEAR_INO2_REFLINK) + XFS_SWAP_EXT_CLEAR_INO2_REFLINK | \ + XFS_SWAP_EXT_CVT_INO2_SF)#define XFS_SWAP_EXT_STRINGS \ { XFS_SWAP_EXT_ATTR_FORK, "ATTRFORK" }, \ { XFS_SWAP_EXT_SET_SIZES, "SETSIZES" }, \ { XFS_SWAP_EXT_INO1_WRITTEN, "INO1_WRITTEN" }, \ { XFS_SWAP_EXT_CLEAR_INO1_REFLINK, "CLEAR_INO1_REFLINK" }, \ - { XFS_SWAP_EXT_CLEAR_INO2_REFLINK, "CLEAR_INO2_REFLINK" } + { XFS_SWAP_EXT_CLEAR_INO2_REFLINK, "CLEAR_INO2_REFLINK" }, \ + { XFS_SWAP_EXT_CVT_INO2_SF, "CVT_INO2_SF" }/* This is the structure used to lay out an sxi log item in the log. */ struct xfs_sxi_log_format {
fs/xfs/libxfs/xfs_swapext.c +50 -1
87 lines not on this page · raw message
fs/xfs/libxfs/xfs_swapext.h +7 -2
@@ -180,16 +180,21 @@ struct xfs_swapext_req {/* Files need to be upgraded to have large extent counts. */ #define XFS_SWAP_REQ_NREXT64 (1U << 3) +/* Try to convert inode2's fork to local format, if possible. */ +#define XFS_SWAP_REQ_CVT_INO2_SF (1U << 4) +#define XFS_SWAP_REQ_FLAGS (XFS_SWAP_REQ_LOGGED | \ XFS_SWAP_REQ_SET_SIZES | \ XFS_SWAP_REQ_INO1_WRITTEN | \ - XFS_SWAP_REQ_NREXT64) + XFS_SWAP_REQ_NREXT64 | \ + XFS_SWAP_REQ_CVT_INO2_SF)#define XFS_SWAP_REQ_STRINGS \ { XFS_SWAP_REQ_LOGGED, "LOGGED" }, \ { XFS_SWAP_REQ_SET_SIZES, "SETSIZES" }, \ { XFS_SWAP_REQ_INO1_WRITTEN, "INO1_WRITTEN" }, \ - { XFS_SWAP_REQ_NREXT64, "NREXT64" } + { XFS_SWAP_REQ_NREXT64, "NREXT64" }, \ + { XFS_SWAP_REQ_CVT_INO2_SF, "CVT_INO2_SF" }unsigned int xfs_swapext_reflink_prep (const struct xfs_swapext_req *req); void xfs_swapext_reflink_finish(struct xfs_trans *tp,
PATCH 21/25 xfs: condense directories after an atomic swap
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The previous commit added a new swapext flag that enables us to perform post-swap processing on file2 once we're done swapping the extent maps. Now add this ability for directories.
This isn't used anywhere right now, but we need to have the basic ondisk flags in place so that a future online directory repair feature can create salvaged dirents in a temporary directory and swap the data forks when ready. If one file is in extents format and the other is inline, we will have to promote both to extents format to perform the swap. After the swap, we can try to condense the fixed directory down to inline format if possible.
--- fs/xfs/libxfs/xfs_swapext.c | 44 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 43 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_swapext.c +43 -1
@@ -28,6 +28,8 @@#include "xfs_da_btree.h" #include "xfs_attr_leaf.h" #include "xfs_attr.h" +#include "xfs_dir2_priv.h" +#include "xfs_dir2.h" struct kmem_cache *xfs_swapext_intent_cache;
@@ -395,6 +397,42 @@ xfs_swapext_attr_to_sf(return xfs_attr3_leaf_to_shortform (bp, &args, forkoff); } +/* Convert inode2's block dir fork back to shortform, if possible.. */ +STATIC int +xfs_swapext_dir_to_sf ( +struct xfs_trans *tp, +struct xfs_swapext_intent *sxi) +{ +struct xfs_da_args args = { + .dp = sxi->sxi_ip2, + .geo = tp->t_mountp->m_dir_geo, + .whichfork =XFS_DATA_FORK , + .trans = tp, + }; +struct xfs_dir2_sf_hdr sfh; +struct xfs_buf *bp; +bool isblock; +int size; +int error; + + error =xfs_dir2_isblock (&args, &isblock); +if (error) +return error; + +if (!isblock) +return 0 ; + + error =xfs_dir3_block_read (tp, sxi->sxi_ip2, &bp); +if (error) +return error; + + size =xfs_dir2_block_sfsize (sxi->sxi_ip2, bp->b_addr, &sfh); +if (size >xfs_inode_data_fork_size (sxi->sxi_ip2)) +return 0 ; + +return xfs_dir2_block_to_sf (&args, bp, size, &sfh); +} + static inline void xfs_swapext_clear_reflink( struct xfs_trans *tp,
@@ -417,6 +455,8 @@ xfs_swapext_do_postop_work(if (sxi->sxi_flags &XFS_SWAP_EXT_ATTR_FORK ) error =xfs_swapext_attr_to_sf (tp, sxi); +else if (S_ISDIR (VFS_I (sxi->sxi_ip2)->i_mode)) + error =xfs_swapext_dir_to_sf (tp, sxi); sxi->sxi_flags &= ~XFS_SWAP_EXT_CVT_INO2_SF ;if (error)return error;
@@ -1071,7 +1111,9 @@ xfs_swapext(if (req->req_flags &XFS_SWAP_REQ_SET_SIZES )ASSERT (req->whichfork ==XFS_DATA_FORK );if (req->req_flags &XFS_SWAP_REQ_CVT_INO2_SF ) -ASSERT (req->whichfork ==XFS_ATTR_FORK ); +ASSERT (req->whichfork ==XFS_ATTR_FORK || + (req->whichfork ==XFS_DATA_FORK && +S_ISDIR (VFS_I (req->ip2)->i_mode)));if (req->blockcount ==0 )return ;
PATCH 22/25 xfs: condense symbolic links after an atomic swap
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The previous commit added a new swapext flag that enables us to perform post-swap processing on file2 once we're done swapping the extent maps. Now add this ability for symlinks.
This isn't used anywhere right now, but we need to have the basic ondisk flags in place so that a future online symlink repair feature can salvage the remote target in a temporary link and swap the data forks when ready. If one file is in extents format and the other is inline, we will have to promote both to extents format to perform the swap. After the swap, we can try to condense the fixed symlink down to inline format if possible.
--- fs/xfs/libxfs/xfs_swapext.c | 48 +++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_symlink_remote.c | 47 +++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_symlink_remote.h | 1 + fs/xfs/xfs_symlink.c | 49 ++++-------------------------------- 4 files changed, 101 insertions(+), 44 deletions(-)
fs/xfs/libxfs/xfs_swapext.c +47 -1
@@ -30,6 +30,7 @@#include "xfs_attr.h" #include "xfs_dir2_priv.h" #include "xfs_dir2.h" +#include "xfs_symlink_remote.h" struct kmem_cache *xfs_swapext_intent_cache;
@@ -433,6 +434,48 @@ xfs_swapext_dir_to_sf(return xfs_dir2_block_to_sf (&args, bp, size, &sfh); } +/* Convert inode2's remote symlink target back to shortform, if possible. */ +STATIC int +xfs_swapext_link_to_sf ( +struct xfs_trans *tp, +struct xfs_swapext_intent *sxi) +{ +struct xfs_inode *ip = sxi->sxi_ip2; +struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_DATA_FORK ); +char *buf; +int error; + +if (ifp->if_format ==XFS_DINODE_FMT_LOCAL || + ip->i_disk_size >xfs_inode_data_fork_size (ip)) +return 0 ; + +/* Read the current symlink target into a buffer. */ + buf =kmem_alloc (ip->i_disk_size +1 ,KM_NOFS ); +if (!buf) { +ASSERT (0 ); +return -ENOMEM ; + } + + error =xfs_symlink_remote_read (ip, buf); +if (error) + goto free; + +/* Remove the blocks. */ + error =xfs_symlink_remote_truncate (tp, ip); +if (error) + goto free; + +/* Convert fork to local format and log our changes. */ +xfs_idestroy_fork (ifp); + ifp->if_bytes =0 ; + ifp->if_format =XFS_DINODE_FMT_LOCAL ; +xfs_init_local_fork (ip,XFS_DATA_FORK , buf, ip->i_disk_size); +xfs_trans_log_inode (tp, ip,XFS_ILOG_DDATA |XFS_ILOG_CORE ); +free: +kmem_free (buf); +return error; +} + static inline void xfs_swapext_clear_reflink( struct xfs_trans *tp,
@@ -457,6 +500,8 @@ xfs_swapext_do_postop_work( error =xfs_swapext_attr_to_sf (tp, sxi); else if (S_ISDIR(VFS_I(sxi->sxi_ip2)->i_mode)) error =xfs_swapext_dir_to_sf (tp, sxi); + else if (S_ISLNK(VFS_I(sxi->sxi_ip2)->i_mode)) + error =xfs_swapext_link_to_sf (tp, sxi); sxi->sxi_flags &= ~XFS_SWAP_EXT_CVT_INO2_SF ;if (error)return error;
@@ -1113,7 +1158,8 @@ xfs_swapext(if (req->req_flags &XFS_SWAP_REQ_CVT_INO2_SF )ASSERT (req->whichfork ==XFS_ATTR_FORK || (req->whichfork ==XFS_DATA_FORK && -S_ISDIR (VFS_I (req->ip2)->i_mode))); + (S_ISDIR (VFS_I (req->ip2)->i_mode) || +S_ISLNK (VFS_I (req->ip2)->i_mode))));if (req->blockcount ==0 )return ;
fs/xfs/libxfs/xfs_symlink_remote.c +47 -0
50 lines not on this page · raw message
fs/xfs/libxfs/xfs_symlink_remote.h +1 -0
@@ -22,5 +22,6 @@ int xfs_symlink_remote_read(struct xfs_inode *ip, char *link);int xfs_symlink_write_target (struct xfs_trans *tp,struct xfs_inode *ip,const char *target_path,int pathlen,xfs_fsblock_t fs_blocks,uint resblks); +int xfs_symlink_remote_truncate (struct xfs_trans *tp,struct xfs_inode *ip);#endif /* __XFS_SYMLINK_REMOTE_H */
fs/xfs/xfs_symlink.c +6 -43
69 lines not on this page · raw message
PATCH 23/25 xfs: make atomic extent swapping support realtime files
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that bmap items support the realtime device, we can add the necessary pieces to the atomic extent swapping code to support such things.
--- fs/xfs/libxfs/xfs_swapext.c | 165 ++++++++++++++++++++++++++++++++++++-- fs/xfs/xfs_bmap_util.c | 185 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_bmap_util.h | 7 ++ fs/xfs/xfs_inode.h | 5 + fs/xfs/xfs_trace.h | 11 ++- fs/xfs/xfs_xchgrange.c | 61 ++++++++++++++ fs/xfs/xfs_xchgrange.h | 2 7 files changed, 418 insertions(+), 18 deletions(-)
fs/xfs/libxfs/xfs_swapext.c +156 -9
@@ -31,6 +31,7 @@#include "xfs_dir2_priv.h" #include "xfs_dir2.h" #include "xfs_symlink_remote.h" +#include "xfs_rtbitmap.h" struct kmem_cache *xfs_swapext_intent_cache;
@@ -133,6 +134,102 @@ sxi_advance( sxi->sxi_blockcount -= irec->br_blockcount; } +#ifdef DEBUG +/* +* If we're going to do a BUI-only extent swap, ensure that all mappings are +* aligned to the realtime extent size. +*/ +static inline int +xfs_swapext_check_rt_extents ( +struct xfs_mount *mp, +const struct xfs_swapext_req *req) +{ +struct xfs_bmbt_irec irec1, irec2; +xfs_fileoff_t startoff1 = req->startoff1; +xfs_fileoff_t startoff2 = req->startoff2; +xfs_filblks_t blockcount = req->blockcount; +uint32_t mod; +int nimaps; +int error; + +/* xattrs don't live on the rt device */ +if (req->whichfork ==XFS_ATTR_FORK ) +return 0 ; + +/* +* Caller got permission to use SXI log items, so log recovery will +* finish the swap and not leave us with partially swapped rt extents +* exposed to userspace. +*/ +if (req->req_flags &XFS_SWAP_REQ_LOGGED ) +return 0 ; + +/* +* Allocation units must be fully mapped to a file range. For files +* with a single-fsblock allocation unit, this is trivial. +*/ +if (!xfs_inode_has_bigallocunit (req->ip2)) +return 0 ; + +/* +* For multi-fsblock allocation units, we must check the alignment of +* every single mapping. +*/ +while (blockcount >0 ) { +/* Read extent from the first file */ + nimaps =1 ; + error =xfs_bmapi_read (req->ip1, startoff1, blockcount, + &irec1, &nimaps,0 ); +if (error) +return error; +ASSERT (nimaps ==1 ); + +/* Read extent from the second file */ + nimaps =1 ; + error =xfs_bmapi_read (req->ip2, startoff2, + irec1.br_blockcount, &irec2, &nimaps, +0 ); +if (error) +return error; +ASSERT (nimaps ==1 ); + +/* +* We can only swap as many blocks as the smaller of the two +* extent maps. +*/ + irec1.br_blockcount =min (irec1.br_blockcount, + irec2.br_blockcount); + +/* Both mappings must be aligned to the realtime extent size. */ + mod =xfs_rtb_to_rtxoff (mp, irec1.br_startoff); +if (mod) { +ASSERT (mod ==0 ); +return -EINVAL ; + } + + mod =xfs_rtb_to_rtxoff (mp, irec1.br_startoff); +if (mod) { +ASSERT (mod ==0 ); +return -EINVAL ; + } + + mod =xfs_rtb_to_rtxoff (mp, irec1.br_blockcount); +if (mod) { +ASSERT (mod ==0 ); +return -EINVAL ; + } + + startoff1 += irec1.br_blockcount; + startoff2 += irec1.br_blockcount; + blockcount -= irec1.br_blockcount; + } + +return 0 ; +} +#else +# define xfs_swapext_check_rt_extents (mp, req) (0) +#endif +/* Check all extents to make sure we can actually swap them. */ int xfs_swapext_check_extents(
@@ -152,12 +249,7 @@ xfs_swapext_check_extents( ifp2->if_format == XFS_DINODE_FMT_LOCAL)return -EINVAL ; -/* We don't support realtime data forks yet. */ -if (!XFS_IS_REALTIME_INODE (req->ip1)) -return 0 ; -if (req->whichfork ==XFS_ATTR_FORK ) -return 0 ; -return -EINVAL ; +return xfs_swapext_check_rt_extents (mp, req); }#ifdef CONFIG_XFS_QUOTA
@@ -198,6 +290,8 @@ xfs_swapext_can_skip_mapping(struct xfs_swapext_intent *sxi, struct xfs_bmbt_irec *irec) { + struct xfs_mount *mp = sxi->sxi_ip1->i_mount; +/* Do not skip this mapping if the caller did not tell us to. */ if (!(sxi->sxi_flags &XFS_SWAP_EXT_INO1_WRITTEN ))return false;
@@ -210,10 +304,63 @@ xfs_swapext_can_skip_mapping(* The mapping is unwritten or a hole. It cannot be a delalloc * reservation because we already excluded those. It cannot be an * unwritten extent with dirty page cache because we flushed the page -* cache. We don't support realtime files yet, so we needn't (yet) -* deal with them. +* cache. For files where the allocation unit is 1FSB (files on the +* data dev, rt files if the extent size is 1FSB), we can safely +* skip this mapping. */ -return true; +if (!xfs_inode_has_bigallocunit (sxi->sxi_ip1)) +return true; + +/* +* For a realtime file with a multi-fsb allocation unit, the decision +* is trickier because we can only swap full allocation units. +* Unwritten mappings can appear in the middle of an rtx if the rtx is +* partially written, but they can also appear for preallocations. +* +* If the mapping is a hole, skip it entirely. Holes should align with +* rtx boundaries. +*/ +if (!xfs_bmap_is_real_extent (irec)) +return true; + +/* +* All mappings below this point are unwritten. +* +* - If the beginning is not aligned to an rtx, trim the end of the +* mapping so that it does not cross an rtx boundary, and swap it. +* +* - If both ends are aligned to an rtx, skip the entire mapping. +*/ +if (!isaligned_64 (irec->br_startoff, mp->m_sb.sb_rextsize)) { +xfs_fileoff_t new_end; + + new_end =roundup_64 (irec->br_startoff, mp->m_sb.sb_rextsize); + irec->br_blockcount =min (irec->br_blockcount, + new_end - irec->br_startoff); +return false; + } +if (isaligned_64 (irec->br_blockcount, mp->m_sb.sb_rextsize)) +return true; + +/* +* All mappings below this point are unwritten, start on an rtx +* boundary, and do not end on an rtx boundary. +* +* - If the mapping is longer than one rtx, trim the end of the mapping +* down to an rtx boundary and skip it. +* +* - The mapping is shorter than one rtx. Swap it. +*/ +if (irec->br_blockcount > mp->m_sb.sb_rextsize) { +xfs_fileoff_t new_end; + + new_end =rounddown_64 (irec->br_startoff + irec->br_blockcount, + mp->m_sb.sb_rextsize); + irec->br_blockcount = new_end - irec->br_startoff; +return true; + } + +return false; }/*
fs/xfs/xfs_bmap_util.c +183 -2
200 lines not on this page · raw message
fs/xfs/xfs_bmap_util.h +7 -0
@@ -76,4 +76,11 @@ int xfs_bmap_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip,int xfs_flush_unmap_range (struct xfs_inode *ip,xfs_off_t offset,xfs_off_t len); +#ifdef CONFIG_XFS_RT +int xfs_convert_bigalloc_file_space (struct xfs_inode *ip,loff_t pos, +uint64_t len); +#else +# define xfs_convert_bigalloc_file_space (ip, pos, len) (-EOPNOTSUPP) +#endif +#endif /* __XFS_BMAP_UTIL_H__ */
fs/xfs/xfs_inode.h +5 -0
@@ -311,6 +311,11 @@ static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip)return ip->i_diflags2 &XFS_DIFLAG2_NREXT64 ; } +static inline bool xfs_inode_has_bigallocunit (struct xfs_inode *ip) +{ +return XFS_IS_REALTIME_INODE (ip) && ip->i_mount->m_sb.sb_rextsize >1 ; +} +/* * Return the buftarg used for data allocations on a given inode. */
fs/xfs/xfs_trace.h +7 -4
@@ -1494,7 +1494,7 @@ DEFINE_IMAP_EVENT(xfs_iomap_alloc);DEFINE_IMAP_EVENT (xfs_iomap_found); DECLARE_EVENT_CLASS(xfs_simple_io_class, - TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), + TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, u64 count), TP_ARGS(ip, offset, count), TP_STRUCT__entry( __field(dev_t, dev)
@@ -1502,7 +1502,7 @@ DECLARE_EVENT_CLASS(xfs_simple_io_class, __field(loff_t, isize) __field(loff_t, disize) __field(loff_t, offset) -__field (size_t, count) +__field (u64, count) ),TP_fast_assign ( __entry->dev = VFS_I(ip)->i_sb->s_dev;
@@ -1513,7 +1513,7 @@ DECLARE_EVENT_CLASS(xfs_simple_io_class, __entry->count = count; ), TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx " - "pos 0x%llx bytecount 0x%zx", + "pos 0x%llx bytecount 0x%llx", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->isize,
@@ -1524,7 +1524,7 @@ DECLARE_EVENT_CLASS(xfs_simple_io_class,#define DEFINE_SIMPLE_IO_EVENT (name) \ DEFINE_EVENT(xfs_simple_io_class, name, \ - TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \ + TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, u64 count), \ TP_ARGS(ip, offset, count))DEFINE_SIMPLE_IO_EVENT (xfs_delalloc_enospc);DEFINE_SIMPLE_IO_EVENT (xfs_unwritten_convert);
@@ -3728,6 +3728,9 @@ TRACE_EVENT(xfs_ioctl_clone,/* unshare tracepoints */ DEFINE_SIMPLE_IO_EVENT (xfs_reflink_unshare);DEFINE_INODE_ERROR_EVENT (xfs_reflink_unshare_error); +#ifdef CONFIG_XFS_RT +DEFINE_SIMPLE_IO_EVENT (xfs_convert_bigalloc_file_space); +#endif /* CONFIG_XFS_RT */ /* copy on write */ DEFINE_INODE_IREC_EVENT (xfs_reflink_trim_around_shared);
fs/xfs/xfs_xchgrange.c +59 -2
96 lines not on this page · raw message
fs/xfs/xfs_xchgrange.h +1 -1
@@ -51,6 +51,6 @@ void xfs_xchg_range_rele_log_assist(struct xfs_mount *mp);int xfs_xchg_range (struct xfs_inode *ip1,struct xfs_inode *ip2,const struct xfs_exch_range *fxr,unsigned int xchg_flags);int xfs_xchg_range_prep (struct file *file1,struct file *file2, -struct xfs_exch_range *fxr); +struct xfs_exch_range *fxr,unsigned int xchg_flags);#endif /* __XFS_XCHGRANGE_H__ */
PATCH 24/25 xfs: support non-power-of-two rtextsize with exchange-range
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
The VFS exchange-range alignment checks use (fast) bitmasks to perform block alignment checks on the exchange parameters. Unfortunately, bitmasks require that the alignment size be a power of two. This isn't true for realtime devices, so we have to copy-pasta the VFS checks using long division for this to work properly.
--- fs/xfs/xfs_xchgrange.c | 102 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 91 insertions(+), 11 deletions(-)
fs/xfs/xfs_xchgrange.c +91 -11
@@ -808,6 +808,86 @@ xfs_xchg_range_need_convert_bigalloc(xfs_inode_has_bigallocunit (ip); } +/* +* Check the alignment of an exchange request when the allocation unit size +* isn't a power of two. The VFS helpers use (fast) bitmask-based alignment +* checks, but here we have to use slow long division. +*/ +static int +xfs_xchg_range_check_rtalign ( +struct xfs_inode *ip1, +struct xfs_inode *ip2, +const struct xfs_exch_range *fxr) +{ +struct xfs_mount *mp = ip1->i_mount; +uint32_t rextbytes; +uint64_t length = fxr->length; +uint64_t blen; +loff_t size1, size2; + + rextbytes =XFS_FSB_TO_B (mp, mp->m_sb.sb_rextsize); + size1 =i_size_read (VFS_I (ip1)); + size2 =i_size_read (VFS_I (ip2)); + +/* The start of both ranges must be aligned to a rt extent. */ +if (!isaligned_64 (fxr->file1_offset, rextbytes) || + !isaligned_64 (fxr->file2_offset, rextbytes)) +return -EINVAL ; + +/* +* If the caller asked for full files, check that the offset/length +* values cover all of both files. +*/ +if ((fxr->flags &XFS_EXCH_RANGE_FULL_FILES ) && + (fxr->file1_offset !=0 || fxr->file2_offset !=0 || + fxr->length != size1 || fxr->length != size2)) +return -EDOM ; + +if (fxr->flags &XFS_EXCH_RANGE_TO_EOF ) + length =max_t (int64_t, size1 - fxr->file1_offset, + size2 - fxr->file2_offset); + +/* +* If the user wanted us to exchange up to the infile's EOF, round up +* to the next rt extent boundary for this check. Do the same for the +* outfile. +* +* Otherwise, reject the range length if it's not rt extent aligned. +* We already confirmed the starting offsets' rt extent block +* alignment. +*/ +if (fxr->file1_offset + length == size1) + blen =roundup_64 (size1, rextbytes) - fxr->file1_offset; +else if (fxr->file2_offset + length == size2) + blen =roundup_64 (size2, rextbytes) - fxr->file2_offset; +else if (!isaligned_64 (length, rextbytes)) +return -EINVAL ; +else + blen = length; + +/* Don't allow overlapped exchanges within the same file. */ +if (ip1 == ip2 && + fxr->file2_offset + blen > fxr->file1_offset && + fxr->file1_offset + blen > fxr->file2_offset) +return -EINVAL ; + +/* +* Ensure that we don't exchange a partial EOF rt extent into the +* middle of another file. +*/ +if (isaligned_64 (length, rextbytes)) +return 0 ; + + blen = length; +if (fxr->file2_offset + length < size2) + blen =rounddown_64 (blen, rextbytes); + +if (fxr->file1_offset + blen < size1) + blen =rounddown_64 (blen, rextbytes); + +return blen == length ?0 : -EINVAL ; +} +/* Prepare two files to have their data exchanged. */ int xfs_xchg_range_prep(
@@ -818,6 +898,7 @@ xfs_xchg_range_prep( {struct xfs_inode *ip1 =XFS_I (file_inode (file1));struct xfs_inode *ip2 =XFS_I (file_inode (file2)); +unsigned int alloc_unit =xfs_inode_alloc_unitsize (ip2);int error;trace_xfs_xchg_range_prep (ip1, fxr, ip2,0 );
@@ -826,18 +907,17 @@ xfs_xchg_range_prep(if (XFS_IS_REALTIME_INODE (ip1) !=XFS_IS_REALTIME_INODE (ip2))return -EINVAL ; -/* -* The alignment checks in the VFS helpers cannot deal with allocation -* units that are not powers of 2. This can happen with the realtime -* volume if the extent size is set. Note that alignment checks are -* skipped if FULL_FILES is set. -*/ -if (!(fxr->flags &XFS_EXCH_RANGE_FULL_FILES ) && - !is_power_of_2 (xfs_inode_alloc_unitsize (ip2))) -return -EOPNOTSUPP ; +/* Check non-power of two alignment issues, if necessary. */ +if (XFS_IS_REALTIME_INODE (ip2) && !is_power_of_2 (alloc_unit)) { + error =xfs_xchg_range_check_rtalign (ip1, ip2, fxr); +if (error) +return error; - error =xfs_exch_range_prep (file1, file2, fxr, -xfs_inode_alloc_unitsize (ip2)); +/* Do the VFS checks with the regular block alignment. */ + alloc_unit = ip1->i_mount->m_sb.sb_blocksize; + } + + error =xfs_exch_range_prep (file1, file2, fxr, alloc_unit);if (error || fxr->length ==0 )return error;
PATCH 25/25 xfs: enable atomic swapext feature
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add the atomic swapext feature to the set of features that we will permit.
--- fs/xfs/libxfs/xfs_format.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +2 -1
@@ -398,7 +398,8 @@ xfs_sb_has_incompat_feature(*/ #define XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT (1U << 31)#define XFS_SB_FEAT_INCOMPAT_LOG_ALL \ - (XFS_SB_FEAT_INCOMPAT_LOG_XATTRS) + (XFS_SB_FEAT_INCOMPAT_LOG_XATTRS | \ + XFS_SB_FEAT_INCOMPAT_LOG_SWAPEXT)#define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_LOG_ALLstatic inline bool xfs_sb_has_incompat_log_feature(
PATCH 17/28 xfs: create temporary files for online repair
In reply to Darrick J. WongHi all,
As mentioned earlier, the repair strategy for file-based metadata is to build a new copy in a temporary file and swap the file fork mappings with the metadata inode. We've built the atomic extent swap facility, so now we need to build a facility for handling private temporary files.
The first step is to teach the filesystem to ignore the temporary files. We'll mark them as PRIVATE in the VFS so that the kernel security modules will leave it alone. The second step is to add the online repair code the ability to create a temporary file and reap extents from the temporary file after the extent swap.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-tempfiles
--- fs/xfs/Makefile | 1 fs/xfs/scrub/parent.c | 2 fs/xfs/scrub/reap.c | 445 +++++++++++++++++++++++++++++++++++++++++++++-- fs/xfs/scrub/reap.h | 21 ++ fs/xfs/scrub/scrub.c | 3 fs/xfs/scrub/scrub.h | 4 fs/xfs/scrub/tempfile.c | 251 +++++++++++++++++++++++++++ fs/xfs/scrub/tempfile.h | 28 +++ fs/xfs/scrub/trace.h | 96 ++++++++++ fs/xfs/xfs_export.c | 2 fs/xfs/xfs_inode.c | 3 fs/xfs/xfs_inode.h | 2 fs/xfs/xfs_itable.c | 8 + 13 files changed, 840 insertions(+), 26 deletions(-) create mode 100644 fs/xfs/scrub/tempfile.c create mode 100644 fs/xfs/scrub/tempfile.h
PATCH 1/4 xfs: hide private inodes from bulkstat and handle functions
From: Darrick J. Wong <[email protected]>
We're about to start adding functionality that uses internal inodes that are private to XFS. What this means is that userspace should never be able to access any information about these files, and should not be able to open these files by handle. Callers are not allowed to link these files into the directory tree, which should suffice to make these private inodes actually private.
--- fs/xfs/xfs_export.c | 2 +- fs/xfs/xfs_itable.c | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-)
fs/xfs/xfs_export.c +1 -1
@@ -160,7 +160,7 @@ xfs_nfs_get_inode( } } -if (VFS_I (ip)->i_generation != generation) { +if (VFS_I (ip)->i_generation != generation ||IS_PRIVATE (VFS_I (ip))) {xfs_irele (ip);return ERR_PTR (-ESTALE ); }
fs/xfs/xfs_itable.c +8 -0
@@ -97,6 +97,14 @@ xfs_bulkstat_one_int( vfsuid =i_uid_into_vfsuid (idmap, inode); vfsgid =i_gid_into_vfsgid (idmap, inode); +/* If this is a private inode, don't leak its details to userspace. */ +if (IS_PRIVATE (inode)) { +xfs_iunlock (ip,XFS_ILOCK_SHARED ); +xfs_irele (ip); + error = -EINVAL ; + goto out_advance; + } +/* xfs_iget returns the following without needing * further change. */
PATCH 2/4 xfs: create temporary files and directories for online repair
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach the online repair code how to create temporary files or directories. These temporary files can be used to stage reconstructed information until we're ready to perform an atomic extent swap to commit the new metadata.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/parent.c | 2 fs/xfs/scrub/scrub.c | 3 + fs/xfs/scrub/scrub.h | 4 + fs/xfs/scrub/tempfile.c | 251 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/tempfile.h | 28 +++++ fs/xfs/scrub/trace.h | 33 ++++++ fs/xfs/xfs_inode.c | 3 - fs/xfs/xfs_inode.h | 2 9 files changed, 324 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/tempfile.c create mode 100644 fs/xfs/scrub/tempfile.h
fs/xfs/Makefile +1 -0
@@ -207,6 +207,7 @@ xfs-y += $(addprefix scrub/, \ refcount_repair.o \ repair.o \ rmap_repair.o \ + tempfile.o \ xfbtree.o \ )
fs/xfs/scrub/parent.c +1 -1
@@ -143,7 +143,7 @@ xchk_parent_validate( }if (!xchk_fblock_xref_process_error (sc,XFS_DATA_FORK ,0 , &error))return error; -if (dp == sc->ip || !S_ISDIR (VFS_I (dp)->i_mode)) { +if (dp == sc->ip || dp == sc->tempip || !S_ISDIR (VFS_I (dp)->i_mode)) {xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 ); goto out_rele; }
fs/xfs/scrub/scrub.c +3 -0
@@ -17,6 +17,7 @@#include "xfs_scrub.h" #include "xfs_buf_xfile.h" #include "xfs_rmap.h" +#include "xfs_xchgrange.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -24,6 +25,7 @@#include "scrub/health.h" #include "scrub/stats.h" #include "scrub/xfile.h" +#include "scrub/tempfile.h" /* * Online Scrub and Repair
@@ -211,6 +213,7 @@ xchk_teardown( sc->buf =NULL ; } +xrep_tempfile_rele (sc);xchk_fsgates_disable (sc);return error; }
fs/xfs/scrub/scrub.h +4 -0
@@ -105,6 +105,10 @@ struct xfs_scrub {/* Lock flags for @ip. */ uint ilock_flags; +/* A temporary file on this filesystem, for staging new metadata. */ +struct xfs_inode *tempip; +uint temp_ilock_flags; +/* See the XCHK/XREP state flags below. */ unsigned int flags;
fs/xfs/scrub/tempfile.c new file +251 -0
251 lines not on this page · raw message
fs/xfs/scrub/tempfile.h new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2021-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_TEMPFILE_H__ +#define __XFS_SCRUB_TEMPFILE_H__ + +#ifdef CONFIG_XFS_ONLINE_REPAIR +int xrep_tempfile_create (struct xfs_scrub *sc,uint16_t mode); +void xrep_tempfile_rele (struct xfs_scrub *sc); + +bool xrep_tempfile_iolock_nowait (struct xfs_scrub *sc); +int xrep_tempfile_iolock_polled (struct xfs_scrub *sc); +void xrep_tempfile_iounlock (struct xfs_scrub *sc); + +void xrep_tempfile_ilock (struct xfs_scrub *sc); +bool xrep_tempfile_ilock_nowait (struct xfs_scrub *sc); +void xrep_tempfile_iunlock (struct xfs_scrub *sc); +#else +static inline void xrep_tempfile_iolock_both (struct xfs_scrub *sc) +{ +xchk_ilock (sc,XFS_IOLOCK_EXCL ); +} +# define xrep_tempfile_rele (sc) +#endif /* CONFIG_XFS_ONLINE_REPAIR */ + +#endif /* __XFS_SCRUB_TEMPFILE_H__ */
fs/xfs/scrub/trace.h +33 -0
@@ -2361,6 +2361,39 @@ TRACE_EVENT(xrep_rmap_live_update, __entry->flags) ); +TRACE_EVENT (xrep_tempfile_create, + TP_PROTO(struct xfs_scrub *sc), +TP_ARGS (sc), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(unsigned int, type) + __field(xfs_agnumber_t, agno) + __field(xfs_ino_t, inum) + __field(unsigned int, gen) + __field(unsigned int, flags) +__field (xfs_ino_t, temp_inum) + ), +TP_fast_assign ( + __entry->dev = sc->mp->m_super->s_dev; + __entry->ino = sc->file ? XFS_I(file_inode(sc->file))->i_ino : 0; + __entry->type = sc->sm->sm_type; + __entry->agno = sc->sm->sm_agno; + __entry->inum = sc->sm->sm_ino; + __entry->gen = sc->sm->sm_gen; + __entry->flags = sc->sm->sm_flags; + __entry->temp_inum = sc->tempip->i_ino; + ), +TP_printk ("dev %d:%d ino 0x%llx type %s inum 0x%llx gen 0x%x flags 0x%x temp_inum 0x%llx" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, +__print_symbolic (__entry->type,XFS_SCRUB_TYPE_STRINGS ), + __entry->inum, + __entry->gen, + __entry->flags, + __entry->temp_inum) +); +#endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
fs/xfs/xfs_inode.c +1 -2
@@ -42,7 +42,6 @@struct kmem_cache *xfs_inode_cache; -STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *); STATIC int xfs_iunlink_remove(struct xfs_trans *tp, struct xfs_perag *pag,struct xfs_inode *);
@@ -2153,7 +2152,7 @@ xfs_iunlink_insert_inode(* We place the on-disk inode on a list in the AGI. It will be pulled from this * list when the inode is freed. */ -STATIC int +int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip)
fs/xfs/xfs_inode.h +2 -0
@@ -612,6 +612,8 @@ extern struct kmem_cache *xfs_inode_cache;bool xfs_inode_needs_inactive (struct xfs_inode *ip); +int xfs_iunlink (struct xfs_trans *tp,struct xfs_inode *ip); +void xfs_end_io (struct work_struct *work);int xfs_ilock2_io_mmap (struct xfs_inode *ip1,struct xfs_inode *ip2);
PATCH 3/4 xfs: refactor live buffer invalidation for repairs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In an upcoming patch, we will need to be able to look for xfs_buf objects caching file-based metadata blocks without needing to walk the (possibly corrupt) structures to find all the buffers. Repair already has most of the code needed to scan the buffer cache, so hoist these utility functions.
--- fs/xfs/scrub/reap.c | 73 ++++++++++++++++++++++++++++++++++++--------------- fs/xfs/scrub/reap.h | 20 ++++++++++++++ 2 files changed, 71 insertions(+), 22 deletions(-)
fs/xfs/scrub/reap.c +51 -22
@@ -211,6 +211,48 @@ static inline void xreap_defer_finish_reset(struct xreap_state *rs) rs->force_roll = false; } +/* +* Compute the maximum length of a buffer cache scan (in units of sectors), +* given a quantity of fs blocks. +*/ +xfs_daddr_t +xrep_bufscan_max_sectors ( +struct xfs_mount *mp, +xfs_extlen_t fsblocks) +{ +int max_fsbs; + +/* Remote xattr values are the largest buffers that we support. */ + max_fsbs =xfs_attr3_rmt_blocks (mp,XFS_XATTR_SIZE_MAX ); + +return XFS_FSB_TO_BB (mp,min_t (xfs_extlen_t, fsblocks, max_fsbs)); +} + +/* +* Return an incore buffer from a sector scan, or NULL if there are no buffers +* left to return. +*/ +struct xfs_buf * +xrep_bufscan_advance ( +struct xfs_mount *mp, +struct xrep_bufscan *scan) +{ + scan->__sector_count += scan->daddr_step; +while (scan->__sector_count <= scan->max_sectors) { +struct xfs_buf *bp =NULL ; +int error; + + error =xfs_buf_incore (mp->m_ddev_targp, scan->daddr, + scan->__sector_count,XBF_LIVESCAN , &bp); +if (!error) +return bp; + + scan->__sector_count += scan->daddr_step; + } + +return NULL ; +} +/* Try to invalidate the incore buffers for an extent that we're freeing. */ STATIC void xreap_agextent_binval(
@@ -241,28 +283,15 @@ xreap_agextent_binval(* of any plausible size. */ while (bno < agbno_next) { -xfs_agblock_t fsbcount; -xfs_agblock_t max_fsbs; - -/* -* Max buffer size is the max remote xattr buffer size, which -* is one fs block larger than 64k. -*/ - max_fsbs =min_t (xfs_agblock_t, agbno_next - bno, -xfs_attr3_rmt_blocks (mp,XFS_XATTR_SIZE_MAX )); - -for (fsbcount =1 ; fsbcount <= max_fsbs; fsbcount++) { -struct xfs_buf *bp =NULL ; -xfs_daddr_t daddr; -int error; - - daddr =XFS_AGB_TO_DADDR (mp, agno, bno); - error =xfs_buf_incore (mp->m_ddev_targp, daddr, -XFS_FSB_TO_BB (mp, fsbcount), -XBF_LIVESCAN , &bp); -if (error) -continue ; - +struct xrep_bufscan scan = { + .daddr =XFS_AGB_TO_DADDR (mp, agno, bno), + .max_sectors =xrep_bufscan_max_sectors (mp, + agbno_next - bno), + .daddr_step =XFS_FSB_TO_BB (mp,1 ), + }; +struct xfs_buf *bp; + +while ((bp =xrep_bufscan_advance (mp, &scan)) !=NULL ) {xfs_trans_bjoin (sc->tp, bp);xfs_trans_binval (sc->tp, bp); rs->invalidated++;
fs/xfs/scrub/reap.h +20 -0
@@ -14,4 +14,24 @@ int xrep_reap_agblocks(struct xfs_scrub *sc, struct xagb_bitmap *bitmap,int xrep_reap_fsblocks (struct xfs_scrub *sc,struct xfsb_bitmap *bitmap,const struct xfs_owner_info *oinfo); +/* Buffer cache scan context. */ +struct xrep_bufscan { +/* Disk address for the buffers we want to scan. */ +xfs_daddr_t daddr; + +/* Maximum number of sectors to scan. */ +xfs_daddr_t max_sectors; + +/* Each round, increment the search length by this number of sectors. */ +xfs_daddr_t daddr_step; + +/* Internal scan state; initialize to zero. */ +xfs_daddr_t __sector_count; +}; + +xfs_daddr_t xrep_bufscan_max_sectors (struct xfs_mount *mp, +xfs_extlen_t fsblocks); +struct xfs_buf *xrep_bufscan_advance (struct xfs_mount *mp, +struct xrep_bufscan *scan); +#endif /* __XFS_SCRUB_REAP_H__ */
PATCH 4/4 xfs: add the ability to reap entire inode forks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In preparation for supporting repair of indexed file-based metadata (such as realtime bitmaps, directories, and extended attribute data), add a function to reap the old blocks after a metadata repair finishes. IOWs, this is an elaborate bunmapi call that deals with crosslinked blocks by unmapping them without freeing them, and also scans for incore buffers to invalidate.
--- fs/xfs/scrub/reap.c | 372 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/reap.h | 1 fs/xfs/scrub/trace.h | 63 ++++++++ 3 files changed, 436 insertions(+)
fs/xfs/scrub/reap.c +372 -0
@@ -675,3 +675,375 @@ xrep_reap_fsblocks(return 0 ; } + +/* +* Metadata files are not supposed to share blocks with anything else. +* If blocks are shared, we remove the reverse mapping (thus reducing the +* crosslink factor); if blocks are not shared, we also need to free them. +* +* This first step determines the longest subset of the passed-in imap +* (starting at its beginning) that is either crosslinked or not crosslinked. +* The blockcount will be adjust down as needed. +*/ +STATIC int +xreap_bmapi_select ( +struct xfs_scrub *sc, +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *imap, +bool *crosslinked) +{ +struct xfs_owner_info oinfo; +struct xfs_btree_cur *cur; +xfs_filblks_t len =1 ; +xfs_agblock_t bno; +xfs_agblock_t agbno; +xfs_agblock_t agbno_next; +int error; + + agbno =XFS_FSB_TO_AGBNO (sc->mp, imap->br_startblock); + agbno_next = agbno + imap->br_blockcount; + + cur =xfs_rmapbt_init_cursor (sc->mp, sc->tp, sc->sa.agf_bp, + sc->sa.pag); + +xfs_rmap_ino_owner (&oinfo, ip->i_ino, whichfork, imap->br_startoff); + error =xfs_rmap_has_other_keys (cur, agbno,1 , &oinfo, crosslinked); +if (error) + goto out_cur; + + bno = agbno +1 ; +while (bno < agbno_next) { +bool also_crosslinked; + + oinfo.oi_offset++; + error =xfs_rmap_has_other_keys (cur, bno,1 , &oinfo, + &also_crosslinked); +if (error) + goto out_cur; + +if (also_crosslinked != *crosslinked) +break ; + + len++; + bno++; + } + + imap->br_blockcount = len; +trace_xreap_bmapi_select (sc->sa.pag, agbno, len, *crosslinked); +out_cur: +xfs_btree_del_cursor (cur, error); +return error; +} + +/* +* Decide if this buffer can be joined to a transaction. This is true for most +* buffers, but there are two cases that we want to catch: large remote xattr +* value buffers are not logged and can overflow the buffer log item dirty +* bitmap size; and oversized cached buffers if things have really gone +* haywire. +*/ +static inline bool +xreap_buf_loggable ( +const struct xfs_buf *bp) +{ +int i; + +for (i =0 ; i < bp->b_map_count; i++) { +int chunks; +int map_size; + + chunks =DIV_ROUND_UP (BBTOB (bp->b_maps[i].bm_len), +XFS_BLF_CHUNK ); + map_size =DIV_ROUND_UP (chunks,NBWORD ); +if (map_size >XFS_BLF_DATAMAP_SIZE ) +return false; + } + +return true; +} + +/* +* Invalidate any buffers for this file mapping. The @imap blockcount may be +* adjusted downward if we need to roll the transaction. +*/ +STATIC int +xreap_bmapi_binval ( +struct xfs_scrub *sc, +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *imap) +{ +struct xfs_mount *mp = sc->mp; +struct xfs_perag *pag = sc->sa.pag; +int bmap_flags =xfs_bmapi_aflag (whichfork); +xfs_fileoff_t off; +xfs_fileoff_t max_off; +xfs_extlen_t scan_blocks; +xfs_agnumber_t agno = sc->sa.pag->pag_agno; +xfs_agblock_t bno; +xfs_agblock_t agbno; +xfs_agblock_t agbno_next; +unsigned int invalidated =0 ; +int error; + +/* +* Avoid invalidating AG headers and post-EOFS blocks because we never +* own those. +*/ + agbno = bno =XFS_FSB_TO_AGBNO (sc->mp, imap->br_startblock); + agbno_next = agbno + imap->br_blockcount; +if (!xfs_verify_agbno (pag, agbno) || + !xfs_verify_agbno (pag, agbno_next -1 )) +return 0 ; + +/* +* Buffers for file blocks can span multiple contiguous mappings. This +* means that for each block in the mapping, there could exist an +* xfs_buf indexed by that block with any length up to the maximum +* buffer size (remote xattr values) or to the next hole in the fork. +* To set up our binval scan, first we need to figure out the location +* of the next hole. +*/ + off = imap->br_startoff + imap->br_blockcount; + max_off = off +xfs_attr3_rmt_blocks (mp,XFS_XATTR_SIZE_MAX ); +while (off < max_off) { +struct xfs_bmbt_irec hmap; +int nhmaps =1 ; + + error =xfs_bmapi_read (ip, off, max_off - off, &hmap, + &nhmaps, bmap_flags); +if (error) +return error; +if (nhmaps !=1 || hmap.br_startblock ==DELAYSTARTBLOCK ) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +if (!xfs_bmap_is_real_extent (&hmap)) +break ; + + off = hmap.br_startoff + hmap.br_blockcount; + } + scan_blocks = off - imap->br_startoff; + +trace_xreap_bmapi_binval_scan (sc, imap, scan_blocks); + +/* +* If there are incore buffers for these blocks, invalidate them. If +* we can't (try)lock the buffer we assume it's owned by someone else +* and leave it alone. The buffer cache cannot detect aliasing, so +* employ nested loops to detect incore buffers of any plausible size. +*/ +while (bno < agbno_next) { +struct xrep_bufscan scan = { + .daddr =XFS_AGB_TO_DADDR (mp, agno, bno), + .max_sectors =xrep_bufscan_max_sectors (mp, + scan_blocks), + .daddr_step =XFS_FSB_TO_BB (mp,1 ), + }; +struct xfs_buf *bp; + +while ((bp =xrep_bufscan_advance (mp, &scan)) !=NULL ) { +if (xreap_buf_loggable (bp)) { +xfs_trans_bjoin (sc->tp, bp); +xfs_trans_binval (sc->tp, bp); + }else { +xfs_buf_stale (bp); +xfs_buf_relse (bp); + } + invalidated++; + +/* +* Stop invalidating if we've hit the limit; we should +* still have enough reservation left to free however +* much of the mapping we've seen so far. +*/ +if (invalidated >XREAP_MAX_BINVAL ) { + imap->br_blockcount = agbno_next - bno; + goto out; + } + } + + bno++; + scan_blocks--; + } + +out: +trace_xreap_bmapi_binval (sc->sa.pag, agbno, imap->br_blockcount); +return 0 ; +} + +/* +* Dispose of as much of the beginning of this file fork mapping as possible. +* The number of blocks disposed of is returned in @imap->br_blockcount. +*/ +STATIC int +xrep_reap_bmapi_iter ( +struct xfs_scrub *sc, +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *imap, +bool crosslinked) +{ +int error; + +if (crosslinked) { +/* +* If there are other rmappings, this block is cross linked and +* must not be freed. Remove the reverse mapping, leave the +* buffer cache in its possibly confused state, and move on. +* We don't want to risk discarding valid data buffers from +* anybody else who thinks they own the block, even though that +* runs the risk of stale buffer warnings in the future. +*/ +trace_xreap_dispose_unmap_extent (sc->sa.pag, +XFS_FSB_TO_AGBNO (sc->mp, imap->br_startblock), + imap->br_blockcount); + +/* +* Schedule removal of the mapping from the fork. We use +* deferred log intents in this function to control the exact +* sequence of metadata updates. +*/ +xfs_bmap_unmap_extent (sc->tp, ip, whichfork, imap); +xfs_trans_mod_dquot_byino (sc->tp, ip,XFS_TRANS_DQ_BCOUNT , + -(int64_t )imap->br_blockcount); +xfs_rmap_unmap_extent (sc->tp, ip, whichfork, imap); +return 0 ; + } + +/* +* If the block is not crosslinked, we can invalidate all the incore +* buffers for the extent, and then free the extent. This is a bit of +* a mess since we don't detect discontiguous buffers that are indexed +* by a block starting before the first block of the extent but overlap +* anyway. +*/ +trace_xreap_dispose_free_extent (sc->sa.pag, +XFS_FSB_TO_AGBNO (sc->mp, imap->br_startblock), + imap->br_blockcount); + +/* +* Invalidate as many buffers as we can, starting at the beginning of +* this mapping. If this function sets blockcount to zero, the +* transaction is full of logged buffer invalidations, so we need to +* return early so that we can roll and retry. +*/ + error =xreap_bmapi_binval (sc, ip, whichfork, imap); +if (error || imap->br_blockcount ==0 ) +return error; + +/* +* Schedule removal of the mapping from the fork. We use deferred log +* intents in this function to control the exact sequence of metadata +* updates. +*/ +xfs_bmap_unmap_extent (sc->tp, ip, whichfork, imap); +xfs_trans_mod_dquot_byino (sc->tp, ip,XFS_TRANS_DQ_BCOUNT , + -(int64_t )imap->br_blockcount); +return xfs_free_extent_later (sc->tp, imap->br_startblock, + imap->br_blockcount,NULL ,XFS_AG_RESV_NONE , true); +} + +/* +* Dispose of as much of this file extent as we can. Upon successful return, +* the imap will reflect the mapping that was removed from the fork. +*/ +STATIC int +xreap_ifork_extent ( +struct xfs_scrub *sc, +struct xfs_inode *ip, +int whichfork, +struct xfs_bmbt_irec *imap) +{ +xfs_agnumber_t agno; +bool crosslinked; +int error; + +ASSERT (sc->sa.pag ==NULL ); + +trace_xreap_ifork_extent (sc, ip, whichfork, imap); + + agno =XFS_FSB_TO_AGNO (sc->mp, imap->br_startblock); + sc->sa.pag =xfs_perag_get (sc->mp, agno); +if (!sc->sa.pag) +return -EFSCORRUPTED ; + + error =xfs_alloc_read_agf (sc->sa.pag, sc->tp,0 , &sc->sa.agf_bp); +if (error) + goto out_pag; + +/* +* Decide the fate of the blocks at the beginning of the mapping, then +* update the mapping to use it with the unmap calls. +*/ + error =xreap_bmapi_select (sc, ip, whichfork, imap, &crosslinked); +if (error) + goto out_agf; + + error =xrep_reap_bmapi_iter (sc, ip, whichfork, imap, crosslinked); +if (error) + goto out_agf; + +out_agf: +xfs_trans_brelse (sc->tp, sc->sa.agf_bp); + sc->sa.agf_bp =NULL ; +out_pag: +xfs_perag_put (sc->sa.pag); + sc->sa.pag =NULL ; +return error; +} + +/* +* Dispose of each block mapped to the given fork of the given file. Callers +* must hold ILOCK_EXCL, and ip can only be sc->ip or sc->tempip. The fork +* must not have any delalloc reservations. +*/ +int +xrep_reap_ifork ( +struct xfs_scrub *sc, +struct xfs_inode *ip, +int whichfork) +{ +xfs_fileoff_t off =0 ; +int bmap_flags =xfs_bmapi_aflag (whichfork); +int error; + +ASSERT (xfs_has_rmapbt (sc->mp)); +ASSERT (ip == sc->ip || ip == sc->tempip); +ASSERT (whichfork ==XFS_ATTR_FORK || !XFS_IS_REALTIME_INODE (ip)); + +while (off <XFS_MAX_FILEOFF ) { +struct xfs_bmbt_irec imap; +int nimaps =1 ; + +/* Read the next extent, skip past holes and delalloc. */ + error =xfs_bmapi_read (ip, off,XFS_MAX_FILEOFF - off, &imap, + &nimaps, bmap_flags); +if (error) +return error; +if (nimaps !=1 || imap.br_startblock ==DELAYSTARTBLOCK ) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +/* +* If this is a real space mapping, reap as much of it as we +* can in a single transaction. +*/ +if (xfs_bmap_is_real_extent (&imap)) { + error =xreap_ifork_extent (sc, ip, whichfork, &imap); +if (error) +return error; + + error =xfs_defer_finish (&sc->tp); +if (error) +return error; + } + + off = imap.br_startoff + imap.br_blockcount; + } + +return 0 ; +}
fs/xfs/scrub/reap.h +1 -0
@@ -13,6 +13,7 @@ int xrep_reap_agblocks(struct xfs_scrub *sc, struct xagb_bitmap *bitmap, const struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);int xrep_reap_fsblocks (struct xfs_scrub *sc,struct xfsb_bitmap *bitmap,const struct xfs_owner_info *oinfo); +int xrep_reap_ifork (struct xfs_scrub *sc,struct xfs_inode *ip,int whichfork);/* Buffer cache scan context. */ struct xrep_bufscan {
fs/xfs/scrub/trace.h +63 -0
81 lines not on this page · raw message
PATCH 18/28 xfs: online repair of realtime summaries
In reply to Darrick J. WongHi all,
We now have all the infrastructure we need to repair file metadata. We'll begin with the realtime summary file, because it is the least complex data structure. To support this we need to add three more pieces to the temporary file code from the previous patchset -- preallocating space in the temp file, formatting metadata into that space and writing the blocks to disk, and swapping the fork mappings atomically.
After that, the actual reconstruction of the realtime summary information is pretty simple, since we can simply write the incore copy computed by the rtsummary scrubber to the temporary file, swap the contents, and reap the old blocks.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=repair-rtsummary
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=repair-rtsummary
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=repair-rtsummary
--- fs/xfs/Makefile | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/repair.h | 3 fs/xfs/scrub/rtsummary.c | 33 ++- fs/xfs/scrub/rtsummary.h | 37 ++++ fs/xfs/scrub/rtsummary_repair.c | 177 +++++++++++++++++ fs/xfs/scrub/scrub.c | 14 + fs/xfs/scrub/scrub.h | 7 + fs/xfs/scrub/tempfile.c | 401 +++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/tempfile.h | 15 + fs/xfs/scrub/tempswap.h | 21 ++ fs/xfs/scrub/trace.h | 40 ++++ 12 files changed, 731 insertions(+), 19 deletions(-) create mode 100644 fs/xfs/scrub/rtsummary.h create mode 100644 fs/xfs/scrub/rtsummary_repair.c create mode 100644 fs/xfs/scrub/tempswap.h
PATCH 1/3 xfs: support preallocating and copying content into temporary files
From: Darrick J. Wong <[email protected]>
Create the routines we need to preallocate space in a temporary ondisk file and then copy the contents of an xfile into the tempfile. The upcoming rtsummary repair feature will construct the contents of a realtime summary file in memory, after which it will want to copy all that into the ondisk temporary file before atomically committing the new rtsummary contents.
--- fs/xfs/scrub/tempfile.c | 197 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/tempfile.h | 15 ++++ fs/xfs/scrub/trace.h | 39 +++++++++ 3 files changed, 251 insertions(+)
fs/xfs/scrub/tempfile.c +197 -0
@@ -14,14 +14,18 @@#include "xfs_inode.h" #include "xfs_ialloc.h" #include "xfs_quota.h" +#include "xfs_bmap.h" #include "xfs_bmap_btree.h" #include "xfs_trans_space.h" #include "xfs_dir2.h" #include "xfs_xchgrange.h" +#include "xfs_defer.h" #include "scrub/scrub.h" #include "scrub/common.h" +#include "scrub/repair.h" #include "scrub/trace.h" #include "scrub/tempfile.h" +#include "scrub/xfile.h" /* * Create a temporary file for reconstructing metadata, with the intention of
@@ -249,3 +253,196 @@ xrep_tempfile_rele(xchk_irele (sc, sc->tempip); sc->tempip =NULL ; } + +/* +* Make sure that the given range of the data fork of the temporary file is +* mapped to written blocks. The caller must ensure that both inodes are +* joined to the transaction. +*/ +int +xrep_tempfile_prealloc ( +struct xfs_scrub *sc, +xfs_fileoff_t off, +xfs_filblks_t len) +{ +struct xfs_bmbt_irec map; +xfs_fileoff_t end = off + len; +int error; + +ASSERT (sc->tempip !=NULL ); +ASSERT (!XFS_NOT_DQATTACHED (sc->mp, sc->tempip)); + +for (; off < end; off = map.br_startoff + map.br_blockcount) { +int nmaps =1 ; + +/* +* If we have a real extent mapping this block then we're +* in ok shape. +*/ + error =xfs_bmapi_read (sc->tempip, off, end - off, &map, &nmaps, +XFS_DATA_FORK ); +if (error) +return error; +if (nmaps ==0 ) { +ASSERT (nmaps !=0 ); +return -EFSCORRUPTED ; + } + +if (xfs_bmap_is_written_extent (&map)) +continue ; + +/* +* If we find a delalloc reservation then something is very +* very wrong. Bail out. +*/ +if (map.br_startblock ==DELAYSTARTBLOCK ) +return -EFSCORRUPTED ; + +/* +* Make sure this block has a real zeroed extent allocated to +* it. +*/ + nmaps =1 ; + error =xfs_bmapi_write (sc->tp, sc->tempip, off, end - off, +XFS_BMAPI_CONVERT |XFS_BMAPI_ZERO ,0 , &map, + &nmaps); +if (error) +return error; +if (nmaps !=1 ) +return -EFSCORRUPTED ; + +trace_xrep_tempfile_prealloc (sc,XFS_DATA_FORK , &map); + +/* Commit new extent and all deferred work. */ + error =xfs_defer_finish (&sc->tp); +if (error) +return error; + } + +return 0 ; +} + +/* +* Write data to each block of a file. The given range of the tempfile's data +* fork must already be populated with written extents. +*/ +int +xrep_tempfile_copyin ( +struct xfs_scrub *sc, +xfs_fileoff_t off, +xfs_filblks_t len, +xrep_tempfile_copyin_fn prep_fn, +void *data) +{ +LIST_HEAD (buffers_list); +struct xfs_mount *mp = sc->mp; +struct xfs_buf *bp; +xfs_fileoff_t flush_mask; +xfs_fileoff_t end = off + len; +loff_t pos =XFS_FSB_TO_B (mp, off); +int error =0 ; + +ASSERT (S_ISREG (VFS_I (sc->tempip)->i_mode)); + +/* Flush buffers to disk every 512K */ + flush_mask =XFS_B_TO_FSBT (mp, (1U <<19 )) -1 ; + +for (; off < end; off++, pos += mp->m_sb.sb_blocksize) { +struct xfs_bmbt_irec map; +int nmaps =1 ; + +/* Read block mapping for this file block. */ + error =xfs_bmapi_read (sc->tempip, off,1 , &map, &nmaps,0 ); +if (error) + goto out_err; +if (nmaps ==0 || !xfs_bmap_is_written_extent (&map)) { + error = -EFSCORRUPTED ; + goto out_err; + } + +/* Get the metadata buffer for this offset in the file. */ + error =xfs_trans_get_buf (sc->tp, mp->m_ddev_targp, +XFS_FSB_TO_DADDR (mp, map.br_startblock), + mp->m_bsize,0 , &bp); +if (error) + goto out_err; + +trace_xrep_tempfile_copyin (sc,XFS_DATA_FORK , &map); + +/* Read in a block's worth of data from the xfile. */ + error =prep_fn (sc, bp, data); +if (error) { +xfs_trans_brelse (sc->tp, bp); + goto out_err; + } + +/* Queue buffer, and flush if we have too much dirty data. */ +xfs_buf_delwri_queue_here (bp, &buffers_list); +xfs_trans_brelse (sc->tp, bp); + +if (!(off & flush_mask)) { + error =xfs_buf_delwri_submit (&buffers_list); +if (error) + goto out_err; + } + } + +/* +* Write the new blocks to disk. If the ordered list isn't empty after +* that, then something went wrong and we have to fail. This should +* never happen, but we'll check anyway. +*/ + error =xfs_buf_delwri_submit (&buffers_list); +if (error) + goto out_err; + +if (!list_empty (&buffers_list)) { +ASSERT (list_empty (&buffers_list)); + error = -EIO ; + goto out_err; + } + +return 0 ; + +out_err: +xfs_buf_delwri_cancel (&buffers_list); +return error; +} + +/* +* Set the temporary file's size. Caller must join the tempfile to the scrub +* transaction and is responsible for adjusting block mappings as needed. +*/ +int +xrep_tempfile_set_isize ( +struct xfs_scrub *sc, +unsigned long long isize) +{ +if (sc->tempip->i_disk_size == isize) +return 0 ; + + sc->tempip->i_disk_size = isize; +i_size_write (VFS_I (sc->tempip), isize); +return xrep_tempfile_roll_trans (sc); +} + +/* +* Roll a repair transaction involving the temporary file. Caller must join +* both the temporary file and the file being scrubbed to the transaction. +* This function return with both inodes joined to a new scrub transaction, +* or the usual negative errno. +*/ +int +xrep_tempfile_roll_trans ( +struct xfs_scrub *sc) +{ +int error; + +xfs_trans_log_inode (sc->tp, sc->tempip,XFS_ILOG_CORE ); + error =xrep_roll_trans (sc); +if (error) +return error; + +xfs_trans_ijoin (sc->tp, sc->tempip,0 ); +return 0 ; +}
fs/xfs/scrub/tempfile.h +15 -0
@@ -17,6 +17,21 @@ void xrep_tempfile_iounlock(struct xfs_scrub *sc);void xrep_tempfile_ilock (struct xfs_scrub *sc);bool xrep_tempfile_ilock_nowait (struct xfs_scrub *sc);void xrep_tempfile_iunlock (struct xfs_scrub *sc); + +int xrep_tempfile_prealloc (struct xfs_scrub *sc,xfs_fileoff_t off, +xfs_filblks_t len); + +enum xfs_blft ; + +typedef int (*xrep_tempfile_copyin_fn )(struct xfs_scrub *sc, +struct xfs_buf *bp,void *data); + +int xrep_tempfile_copyin (struct xfs_scrub *sc,xfs_fileoff_t off, +xfs_filblks_t len,xrep_tempfile_copyin_fn fn,void *data); + +int xrep_tempfile_set_isize (struct xfs_scrub *sc,unsigned long long isize); + +int xrep_tempfile_roll_trans (struct xfs_scrub *sc);#else static inline void xrep_tempfile_iolock_both (struct xfs_scrub *sc) {
fs/xfs/scrub/trace.h +39 -0
@@ -2396,6 +2396,45 @@ TRACE_EVENT(xrep_tempfile_create, __entry->temp_inum) ); +DECLARE_EVENT_CLASS (xrep_tempfile_class, + TP_PROTO(struct xfs_scrub *sc, int whichfork, + struct xfs_bmbt_irec *irec), +TP_ARGS (sc, whichfork, irec), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(int, whichfork) + __field(xfs_fileoff_t, lblk) + __field(xfs_filblks_t, len) + __field(xfs_fsblock_t, pblk) +__field (int, state) + ), +TP_fast_assign ( + __entry->dev = sc->mp->m_super->s_dev; + __entry->ino = sc->tempip->i_ino; + __entry->whichfork = whichfork; + __entry->lblk = irec->br_startoff; + __entry->len = irec->br_blockcount; + __entry->pblk = irec->br_startblock; + __entry->state = irec->br_state; + ), +TP_printk ("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, +__print_symbolic (__entry->whichfork,XFS_WHICHFORK_STRINGS ), + __entry->lblk, + __entry->len, + __entry->pblk, + __entry->state) +); +#define DEFINE_XREP_TEMPFILE_EVENT (name) \ +DEFINE_EVENT(xrep_tempfile_class, name, \ + TP_PROTO(struct xfs_scrub *sc, int whichfork, \ + struct xfs_bmbt_irec *irec), \ + TP_ARGS(sc, whichfork, irec)) +DEFINE_XREP_TEMPFILE_EVENT (xrep_tempfile_prealloc); +DEFINE_XREP_TEMPFILE_EVENT (xrep_tempfile_copyin); + TRACE_EVENT(xreap_ifork_extent, TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, const struct xfs_bmbt_irec *irec),
PATCH 2/3 xfs: teach the tempfile to support atomic extent swapping
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create some new routines to exchange the contents of a temporary file created to stage a repair with another ondisk file. This will be used by the realtime summary repair function to commit atomically the new rtsummary data, which will be staged in the tempfile.
The rest of XFS coordinates access to the realtime metadata inodes solely through the ILOCK. For repair to hold its exclusive access to the realtime summary file, it has to allocate a single large transaction and roll it repeatedly throughout the repair while holding the ILOCK. In turn, this means that for now there's only a partial swapext implementation for the temporary file, because we can only work within an existing transaction. Hence the only tempswap functions needed here are to estimate the resource requirements of swapext between, reserve more space/quota to an existing transaction, and kick off the actual swap. The rest will be added in a later patch in preparation for repairing xattrs and directories.
--- fs/xfs/scrub/scrub.c | 11 ++- fs/xfs/scrub/scrub.h | 7 ++ fs/xfs/scrub/tempfile.c | 204 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/tempswap.h | 21 +++++ fs/xfs/scrub/trace.h | 1 5 files changed, 241 insertions(+), 3 deletions(-) create mode 100644 fs/xfs/scrub/tempswap.h
fs/xfs/scrub/scrub.c +8 -3
@@ -149,14 +149,15 @@ xchk_probe(/* Scrub setup and teardown */ +#define FSGATES_MASK (XCHK_FSGATES_ALL | XREP_FSGATES_ALL)static inline void xchk_fsgates_disable (struct xfs_scrub *sc) { -if (!(sc->flags &XCHK_FSGATES_ALL )) +if (!(sc->flags &FSGATES_MASK ))return ; -trace_xchk_fsgates_disable (sc, sc->flags &XCHK_FSGATES_ALL ); +trace_xchk_fsgates_disable (sc, sc->flags &FSGATES_MASK );if (sc->flags &XCHK_FSGATES_DRAIN )xfs_drain_wait_disable ();
@@ -170,8 +171,12 @@ xchk_fsgates_disable(if (sc->flags &XCHK_FSGATES_RMAP )xfs_rmap_hook_disable (); - sc->flags &= ~XCHK_FSGATES_ALL ; +if (sc->flags &XREP_FSGATES_ATOMIC_XCHG ) +xfs_xchg_range_rele_log_assist (sc->mp); + + sc->flags &= ~FSGATES_MASK ; } +#undef FSGATES_MASK/* Free all the resources and finish the transactions. */ STATIC int
fs/xfs/scrub/scrub.h +7 -0
@@ -131,6 +131,7 @@ struct xfs_scrub {#define XCHK_FSGATES_QUOTA (1U << 4)/* quota live update enabled */ #define XCHK_FSGATES_DIRENTS (1U << 5)/* directory live update enabled */ #define XCHK_FSGATES_RMAP (1U << 6)/* rmapbt live update enabled */ +#define XREP_FSGATES_ATOMIC_XCHG (1U << 29)/* uses atomic file content exchange */ #define XREP_RESET_PERAG_RESV (1U << 30)/* must reset AG space reservation */ #define XREP_ALREADY_FIXED (1U << 31)/* checking our repair work */
@@ -145,6 +146,12 @@ struct xfs_scrub { XCHK_FSGATES_DIRENTS | \ XCHK_FSGATES_RMAP) +/* +* The sole XREP_FSGATES* flag reflects a log intent item that is protected +* by a log-incompat feature flag. No code patching in use here. +*/ +#define XREP_FSGATES_ALL (XREP_FSGATES_ATOMIC_XCHG) +/* Metadata scrubbers */ int xchk_tester (struct xfs_scrub *sc);int xchk_superblock (struct xfs_scrub *sc);
fs/xfs/scrub/tempfile.c +204 -0
219 lines not on this page · raw message
fs/xfs/scrub/tempswap.h new file +21 -0
@@ -0,0 +1,21 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2022-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_TEMPSWAP_H__ +#define __XFS_SCRUB_TEMPSWAP_H__ + +#ifdef CONFIG_XFS_ONLINE_REPAIR +struct xrep_tempswap { +struct xfs_swapext_req req; +}; + +int xrep_tempswap_grab_log_assist (struct xfs_scrub *sc); +int xrep_tempswap_trans_reserve (struct xfs_scrub *sc,int whichfork, +struct xrep_tempswap *ti); + +int xrep_tempswap_contents (struct xfs_scrub *sc,struct xrep_tempswap *ti); +#endif /* CONFIG_XFS_ONLINE_REPAIR */ + +#endif /* __XFS_SCRUB_TEMPFILE_H__ */
fs/xfs/scrub/trace.h +1 -0
@@ -125,6 +125,7 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_HEALTHY); { XCHK_FSGATES_QUOTA, "fsgates_quota" }, \ { XCHK_FSGATES_DIRENTS, "fsgates_dirents" }, \ { XCHK_FSGATES_RMAP, "fsgates_rmap" }, \ + { XREP_FSGATES_ATOMIC_XCHG, "fsgates_atomic_swapext" }, \ { XREP_RESET_PERAG_RESV, "reset_perag_resv" }, \ { XREP_ALREADY_FIXED, "already_fixed" }
PATCH 3/3 xfs: online repair of realtime summaries
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Repair the realtime summary data by constructing a new rtsummary file in the scrub temporary file, then atomically swapping the contents.
--- fs/xfs/Makefile | 1 fs/xfs/scrub/common.c | 1 fs/xfs/scrub/repair.h | 3 + fs/xfs/scrub/rtsummary.c | 33 ++++--- fs/xfs/scrub/rtsummary.h | 37 ++++++++ fs/xfs/scrub/rtsummary_repair.c | 177 +++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/scrub.c | 3 - 7 files changed, 239 insertions(+), 16 deletions(-) create mode 100644 fs/xfs/scrub/rtsummary.h create mode 100644 fs/xfs/scrub/rtsummary_repair.c
fs/xfs/Makefile +1 -0
@@ -213,6 +213,7 @@ xfs-y += $(addprefix scrub/, \ xfs-$(CONFIG_XFS_RT) += $(addprefix scrub/, \ rtbitmap_repair.o \ + rtsummary_repair.o \ ) xfs-$(CONFIG_XFS_QUOTA) += $(addprefix scrub/, \
fs/xfs/scrub/common.c +1 -0
@@ -31,6 +31,7 @@#include "xfs_ag.h" #include "xfs_error.h" #include "xfs_quota.h" +#include "xfs_swapext.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
fs/xfs/scrub/repair.h +3 -0
@@ -126,8 +126,10 @@ int xrep_fscounters(struct xfs_scrub *sc);#ifdef CONFIG_XFS_RT int xrep_rtbitmap (struct xfs_scrub *sc); +int xrep_rtsummary (struct xfs_scrub *sc);#else # define xrep_rtbitmap xrep_notsupported +# define xrep_rtsummary xrep_notsupported#endif /* CONFIG_XFS_RT */ #ifdef CONFIG_XFS_QUOTA
@@ -212,6 +214,7 @@ xrep_setup_nothing(#define xrep_quotacheck xrep_notsupported#define xrep_nlinks xrep_notsupported#define xrep_fscounters xrep_notsupported +#define xrep_rtsummary xrep_notsupported#endif /* CONFIG_XFS_ONLINE_REPAIR */
fs/xfs/scrub/rtsummary.c +18 -15
@@ -16,10 +16,14 @@#include "xfs_rtbitmap.h" #include "xfs_bit.h" #include "xfs_bmap.h" +#include "xfs_swapext.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h" #include "scrub/xfile.h" +#include "scrub/repair.h" +#include "scrub/tempswap.h" +#include "scrub/rtsummary.h" /* * Realtime Summary
@@ -31,18 +35,6 @@* (potentially large) amount of data in pageable memory. */ -struct xchk_rtsummary { -struct xfs_rtalloc_args args; - -uint64_t rextents; -uint64_t rbmblocks; -uint64_t rsumsize; -unsigned int rsumlevels; - -/* Memory buffer for the summary comparison. */ -union xfs_suminfo_raw words[]; -}; -/* Set us up to check the rtsummary file. */ int xchk_setup_rtsummary(
@@ -59,6 +51,12 @@ xchk_setup_rtsummary(return -ENOMEM ; sc->buf = rts; +if (xchk_could_repair (sc)) { + error =xrep_setup_rtsummary (sc, rts); +if (error) +return error; + } +/* * Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose.
@@ -69,7 +67,7 @@ xchk_setup_rtsummary(if (error)return error; - error =xchk_trans_alloc (sc,0 ); + error =xchk_trans_alloc (sc, rts->resblks);if (error)return error;
@@ -134,7 +132,7 @@ xfsum_store( sumoff << XFS_WORDLOG); } -static inline int +inline int xfsum_copyout( struct xfs_scrub *sc, xfs_rtsumoff_t sumoff,
@@ -361,7 +359,12 @@ xchk_rtsummary( error =xchk_rtsum_compare (sc); out_rbm: -/* Unlock the rtbitmap since we're done with it. */ +/* +* Unlock the rtbitmap since we're done with it. All other writers of +* the rt free space metadata grab the bitmap and summary ILOCKs in +* that order, so we're still protected against allocation activities +* even if we continue on to the repair function. +*/ xfs_iunlock (mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP );return error; }
fs/xfs/scrub/rtsummary.h new file +37 -0
@@ -0,0 +1,37 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020-2024 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_SCRUB_RTSUMMARY_H__ +#define __XFS_SCRUB_RTSUMMARY_H__ + +struct xchk_rtsummary { +#ifdef CONFIG_XFS_ONLINE_REPAIR +struct xrep_tempswap tempswap; +#endif +struct xfs_rtalloc_args args; + +uint64_t rextents; +uint64_t rbmblocks; +uint64_t rsumsize; +unsigned int rsumlevels; +unsigned int resblks; + +/* suminfo position of xfile as we write buffers to disk. */ +xfs_rtsumoff_t prep_wordoff; + +/* Memory buffer for the summary comparison. */ +union xfs_suminfo_raw words[]; +}; + +int xfsum_copyout (struct xfs_scrub *sc,xfs_rtsumoff_t sumoff, +union xfs_suminfo_raw *rawinfo,unsigned int nr_words); + +#ifdef CONFIG_XFS_ONLINE_REPAIR +int xrep_setup_rtsummary (struct xfs_scrub *sc,struct xchk_rtsummary *rts); +#else +# define xrep_setup_rtsummary (sc, rts) (0) +#endif /* CONFIG_XFS_ONLINE_REPAIR */ + +#endif /* __XFS_SCRUB_RTSUMMARY_H__ */
fs/xfs/scrub/rtsummary_repair.c new file +177 -0
177 lines not on this page · raw message
fs/xfs/scrub/scrub.c +2 -1
@@ -18,6 +18,7 @@#include "xfs_buf_xfile.h" #include "xfs_rmap.h" #include "xfs_xchgrange.h" +#include "xfs_swapext.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -357,7 +358,7 @@ static const struct xchk_meta_ops meta_scrub_ops[] = { .type = ST_FS, .setup = xchk_setup_rtsummary, .scrub = xchk_rtsummary, - .repair = xrep_notsupported, + .repair = xrep_rtsummary, }, [XFS_SCRUB_TYPE_UQUOTA] = { /* user quota */ .type = ST_FS,
PATCH 19/28 xfs: set and validate dir/attr block owners
In reply to Darrick J. WongHi all,
There are a couple of significant changes that need to be made to the directory and xattr code before we can support online repairs of those data structures.
The first change is because online repair is designed to use libxfs to create a replacement dir/xattr structure in a temporary file, and use atomic extent swapping to commit the corrected structure. To avoid the performance hit of walking every block of the new structure to rewrite the owner number before the swap, we instead change libxfs to allow callers of the dir and xattr code the ability to set an explicit owner number to be written into the header fields of any new blocks that are created. For regular operation this will be the directory inode number.
The second change is to update the dir/xattr code to actually *check* the owner number in each block that is read off the disk, since we don't currently do that.
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=dirattr-validate-owners
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=dirattr-validate-owners
--- fs/xfs/libxfs/xfs_attr.c | 10 +- fs/xfs/libxfs/xfs_attr_leaf.c | 59 +++++++++++--- fs/xfs/libxfs/xfs_attr_leaf.h | 4 + fs/xfs/libxfs/xfs_attr_remote.c | 13 +-- fs/xfs/libxfs/xfs_bmap.c | 1 fs/xfs/libxfs/xfs_da_btree.c | 168 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_da_btree.h | 3 + fs/xfs/libxfs/xfs_dir2.c | 5 + fs/xfs/libxfs/xfs_dir2.h | 4 + fs/xfs/libxfs/xfs_dir2_block.c | 44 ++++++---- fs/xfs/libxfs/xfs_dir2_data.c | 17 ++-- fs/xfs/libxfs/xfs_dir2_leaf.c | 99 ++++++++++++++++++----- fs/xfs/libxfs/xfs_dir2_node.c | 44 ++++++---- fs/xfs/libxfs/xfs_dir2_priv.h | 11 +-- fs/xfs/libxfs/xfs_swapext.c | 7 +- fs/xfs/scrub/attr.c | 1 fs/xfs/scrub/dabtree.c | 8 ++ fs/xfs/scrub/dir.c | 23 +++-- fs/xfs/scrub/readdir.c | 6 + fs/xfs/xfs_acl.c | 2 fs/xfs/xfs_attr_item.c | 1 fs/xfs/xfs_attr_list.c | 35 +++++++- fs/xfs/xfs_dir2_readdir.c | 6 + fs/xfs/xfs_ioctl.c | 2 fs/xfs/xfs_iops.c | 1 fs/xfs/xfs_trace.h | 7 +- fs/xfs/xfs_xattr.c | 2 27 files changed, 464 insertions(+), 119 deletions(-)
PATCH 1/9 xfs: add an explicit owner field to xfs_da_args
From: Darrick J. Wong <[email protected]>
Add an explicit owner field to xfs_da_args, which will make it easier for online fsck to set the owner field of the temporary directory and xattr structures that it builds to repair damaged metadata.
Note: I hopefully found all the xfs_da_args definitions by looking for automatic stack variable declarations and xfs_da_args.dp assignments:
git grep -E '(args.*dp =|struct xfs_da_args[[:space:]]*[a-z0-9][a-z0-9]*)'
--- fs/xfs/libxfs/xfs_attr_leaf.c | 2 ++ fs/xfs/libxfs/xfs_bmap.c | 1 + fs/xfs/libxfs/xfs_da_btree.h | 1 + fs/xfs/libxfs/xfs_dir2.c | 5 +++++ fs/xfs/libxfs/xfs_swapext.c | 2 ++ fs/xfs/scrub/attr.c | 1 + fs/xfs/scrub/dabtree.c | 1 + fs/xfs/scrub/dir.c | 3 ++- fs/xfs/scrub/readdir.c | 2 ++ fs/xfs/xfs_acl.c | 2 ++ fs/xfs/xfs_attr_item.c | 1 + fs/xfs/xfs_dir2_readdir.c | 1 + fs/xfs/xfs_ioctl.c | 2 ++ fs/xfs/xfs_iops.c | 1 + fs/xfs/xfs_trace.h | 7 +++++-- fs/xfs/xfs_xattr.c | 2 ++ 16 files changed, 31 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_attr_leaf.c +2 -0
@@ -975,6 +975,7 @@ xfs_attr_shortform_to_leaf( nargs.whichfork =XFS_ATTR_FORK ; nargs.trans = args->trans; nargs.op_flags =XFS_DA_OP_OKNOENT ; + nargs.owner = args->owner; sfe = &sf->list[0 ];for (i =0 ; i < sf->hdr.count; i++) {
@@ -1178,6 +1179,7 @@ xfs_attr3_leaf_to_shortform( nargs.whichfork =XFS_ATTR_FORK ; nargs.trans = args->trans; nargs.op_flags =XFS_DA_OP_OKNOENT ; + nargs.owner = args->owner;for (i =0 ; i < ichdr.count; entry++, i++) {if (entry->flags &XFS_ATTR_INCOMPLETE )
fs/xfs/libxfs/xfs_bmap.c +1 -0
@@ -958,6 +958,7 @@ xfs_bmap_add_attrfork_local( dargs.total = dargs.geo->fsbcount; dargs.whichfork =XFS_DATA_FORK ; dargs.trans = tp; + dargs.owner = ip->i_ino;return xfs_dir2_sf_to_block (&dargs); }
fs/xfs/libxfs/xfs_da_btree.h +1 -0
@@ -79,6 +79,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_ino_t owner;/* inode that owns the dir/attr data */ } xfs_da_args_t;/*
fs/xfs/libxfs/xfs_dir2.c +5 -0
@@ -250,6 +250,7 @@ xfs_dir_init( args->geo = dp->i_mount->m_dir_geo; args->dp = dp; args->trans = tp; + args->owner = dp->i_ino; error =xfs_dir2_sf_create (args, pdp->i_ino);kmem_free (args);return error;
@@ -295,6 +296,7 @@ xfs_dir_createname( args->whichfork =XFS_DATA_FORK ; args->trans = tp; args->op_flags =XFS_DA_OP_ADDNAME |XFS_DA_OP_OKNOENT ; + args->owner = dp->i_ino;if (!inum) args->op_flags |=XFS_DA_OP_JUSTCHECK ;
@@ -389,6 +391,7 @@ xfs_dir_lookup( args->whichfork =XFS_DATA_FORK ; args->trans = tp; args->op_flags =XFS_DA_OP_OKNOENT ; + args->owner = dp->i_ino;if (ci_name) args->op_flags |=XFS_DA_OP_CILOOKUP ;
@@ -462,6 +465,7 @@ xfs_dir_removename( args->total = total; args->whichfork =XFS_DATA_FORK ; args->trans = tp; + args->owner = dp->i_ino;if (dp->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) { rval =xfs_dir2_sf_removename (args);
@@ -523,6 +527,7 @@ xfs_dir_replace( args->total = total; args->whichfork =XFS_DATA_FORK ; args->trans = tp; + args->owner = dp->i_ino;if (dp->i_df.if_format ==XFS_DINODE_FMT_LOCAL ) { rval =xfs_dir2_sf_replace (args);
fs/xfs/libxfs/xfs_swapext.c +2 -0
@@ -526,6 +526,7 @@ xfs_swapext_attr_to_sf( .geo = tp->t_mountp->m_attr_geo, .whichfork = XFS_ATTR_FORK, .trans = tp, + .owner = sxi->sxi_ip2->i_ino, };struct xfs_buf *bp;int forkoff;
@@ -556,6 +557,7 @@ xfs_swapext_dir_to_sf( .geo = tp->t_mountp->m_dir_geo, .whichfork = XFS_DATA_FORK, .trans = tp, + .owner = sxi->sxi_ip2->i_ino, };struct xfs_dir2_sf_hdr sfh;struct xfs_buf *bp;
fs/xfs/scrub/attr.c +1 -0
@@ -169,6 +169,7 @@ xchk_xattr_listent( .hashval = xfs_da_hashname(name, namelen), .trans = context->tp, .valuelen = valuelen, + .owner = context->dp->i_ino, };struct xchk_xattr_buf *ab;struct xchk_xattr *sx;
fs/xfs/scrub/dabtree.c +1 -0
@@ -494,6 +494,7 @@ xchk_da_btree( ds->dargs.whichfork = whichfork; ds->dargs.trans = sc->tp; ds->dargs.op_flags =XFS_DA_OP_OKNOENT ; + ds->dargs.owner = sc->ip->i_ino; ds->state =xfs_da_state_alloc (&ds->dargs); ds->sc = sc; ds->private = private;
fs/xfs/scrub/dir.c +2 -1
@@ -621,10 +621,11 @@ xchk_directory_blocks( {struct xfs_bmbt_irec got;struct xfs_da_args args = { - .dp = sc ->ip, + .dp = sc->ip, .whichfork =XFS_DATA_FORK , .geo = sc->mp->m_dir_geo, .trans = sc->tp, + .owner = sc->ip->i_ino, };struct xfs_ifork *ifp =xfs_ifork_ptr (sc->ip,XFS_DATA_FORK );struct xfs_mount *mp = sc->mp;
fs/xfs/scrub/readdir.c +2 -0
@@ -275,6 +275,7 @@ xchk_dir_walk( .dp = dp, .geo = dp->i_mount->m_dir_geo, .trans = sc->tp, + .owner = dp->i_ino, };bool isblock;int error;
@@ -326,6 +327,7 @@ xchk_dir_lookup( .hashval = xfs_dir2_hashname(dp->i_mount, name), .whichfork = XFS_DATA_FORK, .op_flags = XFS_DA_OP_OKNOENT, + .owner = dp->i_ino, };bool isblock, isleaf;int error;
fs/xfs/xfs_acl.c +2 -0
@@ -135,6 +135,7 @@ xfs_get_acl(struct inode *inode, int type, bool rcu) .dp = ip, .attr_filter = XFS_ATTR_ROOT, .valuelen = XFS_ACL_MAX_SIZE(mp), + .owner = ip->i_ino, };int error;
@@ -178,6 +179,7 @@ __xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)struct xfs_da_args args = { .dp = ip, .attr_filter =XFS_ATTR_ROOT , + .owner = ip->i_ino, };int error;
fs/xfs/xfs_attr_item.c +1 -0
@@ -540,6 +540,7 @@ xfs_attri_recover_work( args->attr_filter = attrp->alfi_attr_filter &XFS_ATTRI_FILTER_MASK ; args->op_flags =XFS_DA_OP_RECOVERY |XFS_DA_OP_OKNOENT |XFS_DA_OP_LOGGED ; + args->owner = args->dp->i_ino;ASSERT (xfs_sb_version_haslogxattrs (&mp->m_sb));
fs/xfs/xfs_dir2_readdir.c +1 -0
@@ -534,6 +534,7 @@ xfs_readdir( args.dp = dp; args.geo = dp->i_mount->m_dir_geo; args.trans = tp; + args.owner = dp->i_ino;if (dp->i_df.if_format ==XFS_DINODE_FMT_LOCAL )return xfs_dir2_sf_getdents (&args, ctx);
fs/xfs/xfs_ioctl.c +2 -0
@@ -480,6 +480,7 @@ xfs_attrmulti_attr_get( .name = name, .namelen = strlen(name), .valuelen = *len, + .owner = XFS_I(inode)->i_ino, };int error;
@@ -513,6 +514,7 @@ xfs_attrmulti_attr_set( .attr_flags = xfs_attr_flags(flags), .name = name, .namelen = strlen(name), + .owner = XFS_I(inode)->i_ino, };int error;
fs/xfs/xfs_iops.c +1 -0
@@ -62,6 +62,7 @@ xfs_initxattrs( .namelen = strlen(xattr->name), .value = xattr->value, .valuelen = xattr->value_len, + .owner = ip->i_ino, }; error =xfs_attr_change (&args);if (error <0 )
fs/xfs/xfs_trace.h +5 -2
@@ -1927,6 +1927,7 @@ DECLARE_EVENT_CLASS(xfs_da_class, __field(xfs_dahash_t, hashval) __field(xfs_ino_t, inumber) __field(uint32_t, op_flags) +__field (xfs_ino_t, owner) ),TP_fast_assign ( __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
@@ -1937,9 +1938,10 @@ DECLARE_EVENT_CLASS(xfs_da_class, __entry->hashval = args->hashval; __entry->inumber = args->inumber; __entry->op_flags = args->op_flags; + __entry->owner = args->owner; ), TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " - "inumber 0x%llx op_flags %s", + "inumber 0x%llx op_flags %s owner 0x%llx", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->namelen,
@@ -1947,7 +1949,8 @@ DECLARE_EVENT_CLASS(xfs_da_class, __entry->namelen, __entry->hashval, __entry->inumber, - __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) + __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), + __entry->owner) )#define DEFINE_DIR2_EVENT (name) \
fs/xfs/xfs_xattr.c +2 -0
@@ -133,6 +133,7 @@ xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused, .namelen = strlen(name), .value = value, .valuelen = size, + .owner = XFS_I(inode)->i_ino, };int error;
@@ -159,6 +160,7 @@ xfs_xattr_set(const struct xattr_handler *handler, .namelen = strlen(name), .value = (void *)value, .valuelen = size, + .owner = XFS_I(inode)->i_ino, };int error;
PATCH 2/9 xfs: use the xfs_da_args owner field to set new dir/attr block owner
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When we're creating leaf, data, freespace, or dabtree blocks for directories and xattrs, use the explicit owner field (instead of the xfs_inode) to set the owner field. This will enable online repair to construct replacement data structures in a temporary file without having to change the owner fields prior to swapping the new and old structures.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 2 +- fs/xfs/libxfs/xfs_attr_remote.c | 4 ++-- fs/xfs/libxfs/xfs_da_btree.c | 2 +- fs/xfs/libxfs/xfs_dir2_block.c | 19 ++++++++++--------- fs/xfs/libxfs/xfs_dir2_data.c | 2 +- fs/xfs/libxfs/xfs_dir2_leaf.c | 11 +++++------ fs/xfs/libxfs/xfs_dir2_node.c | 2 +- 7 files changed, 21 insertions(+), 21 deletions(-)
fs/xfs/libxfs/xfs_attr_leaf.c +1 -1
@@ -1311,7 +1311,7 @@ xfs_attr3_leaf_create( ichdr.magic =XFS_ATTR3_LEAF_MAGIC ; hdr3->blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - hdr3->owner =cpu_to_be64 (dp->i_ino); + hdr3->owner =cpu_to_be64 (args->owner);uuid_copy (&hdr3->uuid, &mp->m_sb.sb_meta_uuid); ichdr.freemap[0 ].base =sizeof (struct xfs_attr3_leaf_hdr );
fs/xfs/libxfs/xfs_attr_remote.c +2 -2
@@ -522,8 +522,8 @@ xfs_attr_rmtval_set_value(return error; bp->b_ops = &xfs_attr3_rmt_buf_ops; -xfs_attr_rmtval_copyin (mp, bp, args->dp->i_ino, &offset, - &valuelen, &src); +xfs_attr_rmtval_copyin (mp, bp, args->owner, &offset, &valuelen, + &src); error =xfs_bwrite (bp);/* GROT: NOTE: synchronous write */ xfs_buf_relse (bp);
fs/xfs/libxfs/xfs_da_btree.c +1 -1
@@ -485,7 +485,7 @@ xfs_da3_node_create(memset (hdr3,0 ,sizeof (struct xfs_da3_node_hdr )); ichdr.magic =XFS_DA3_NODE_MAGIC ; hdr3->info.blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - hdr3->info.owner =cpu_to_be64 (args->dp->i_ino); + hdr3->info.owner =cpu_to_be64 (args->owner);uuid_copy (&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid); }else { ichdr.magic =XFS_DA_NODE_MAGIC ;
fs/xfs/libxfs/xfs_dir2_block.c +10 -9
@@ -163,12 +163,13 @@ xfs_dir3_block_read(static void xfs_dir3_block_init ( -struct xfs_mount *mp, -struct xfs_trans *tp, -struct xfs_buf *bp, -struct xfs_inode *dp) +struct xfs_da_args *args, +struct xfs_buf *bp) { -struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; +struct xfs_trans *tp = args->trans; +struct xfs_inode *dp = args->dp; +struct xfs_mount *mp = dp->i_mount; +struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; bp->b_ops = &xfs_dir3_block_buf_ops;xfs_trans_buf_set_type (tp, bp,XFS_BLFT_DIR_BLOCK_BUF );
@@ -177,7 +178,7 @@ xfs_dir3_block_init(memset (hdr3,0 ,sizeof (*hdr3)); hdr3->magic =cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ); hdr3->blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - hdr3->owner =cpu_to_be64 (dp->i_ino); + hdr3->owner =cpu_to_be64 (args->owner);uuid_copy (&hdr3->uuid, &mp->m_sb.sb_meta_uuid);return ;
@@ -1009,7 +1010,7 @@ xfs_dir2_leaf_to_block(/* * Start converting it to block form. */ -xfs_dir3_block_init (mp, tp, dbp, dp); +xfs_dir3_block_init (args, dbp); needlog =1 ; needscan =0 ;
@@ -1131,7 +1132,7 @@ xfs_dir2_sf_to_block( error =xfs_dir3_data_init (args, blkno, &bp);if (error) goto out_free; -xfs_dir3_block_init (mp, tp, bp, dp); +xfs_dir3_block_init (args, bp); hdr = bp->b_addr;/*
@@ -1171,7 +1172,7 @@ xfs_dir2_sf_to_block(* Create entry for . */ dep = bp->b_addr + offset; - dep->inumber =cpu_to_be64 (dp->i_ino); + dep->inumber =cpu_to_be64 (args->owner); dep->namelen =1 ; dep->name[0 ] ='.' ;xfs_dir2_data_put_ftype (mp, dep,XFS_DIR3_FT_DIR );
fs/xfs/libxfs/xfs_dir2_data.c +1 -1
@@ -725,7 +725,7 @@ xfs_dir3_data_init(memset (hdr3,0 ,sizeof (*hdr3)); hdr3->magic =cpu_to_be32 (XFS_DIR3_DATA_MAGIC ); hdr3->blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - hdr3->owner =cpu_to_be64 (dp->i_ino); + hdr3->owner =cpu_to_be64 (args->owner);uuid_copy (&hdr3->uuid, &mp->m_sb.sb_meta_uuid); }else
fs/xfs/libxfs/xfs_dir2_leaf.c +5 -6
@@ -304,12 +304,12 @@ xfs_dir3_leafn_read(*/ static void xfs_dir3_leaf_init ( -struct xfs_mount *mp, -struct xfs_trans *tp, +struct xfs_da_args *args,struct xfs_buf *bp, -xfs_ino_t owner,uint16_t type) { +struct xfs_mount *mp = args->dp->i_mount; +struct xfs_trans *tp = args->trans;struct xfs_dir2_leaf *leaf = bp->b_addr;ASSERT (type ==XFS_DIR2_LEAF1_MAGIC || type ==XFS_DIR2_LEAFN_MAGIC );
@@ -323,7 +323,7 @@ xfs_dir3_leaf_init( ?cpu_to_be16 (XFS_DIR3_LEAF1_MAGIC ) :cpu_to_be16 (XFS_DIR3_LEAFN_MAGIC ); leaf3->info.blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - leaf3->info.owner =cpu_to_be64 (owner); + leaf3->info.owner =cpu_to_be64 (args->owner);uuid_copy (&leaf3->info.uuid, &mp->m_sb.sb_meta_uuid); }else {memset (leaf,0 ,sizeof (*leaf));
@@ -356,7 +356,6 @@ xfs_dir3_leaf_get_buf( {struct xfs_inode *dp = args->dp;struct xfs_trans *tp = args->trans; -struct xfs_mount *mp = dp->i_mount;struct xfs_buf *bp;int error;
@@ -369,7 +368,7 @@ xfs_dir3_leaf_get_buf(if (error)return error; -xfs_dir3_leaf_init (mp, tp, bp, dp->i_ino, magic); +xfs_dir3_leaf_init (args, bp, magic);xfs_dir3_leaf_log_header (args, bp);if (magic ==XFS_DIR2_LEAF1_MAGIC )xfs_dir3_leaf_log_tail (args, bp);
fs/xfs/libxfs/xfs_dir2_node.c +1 -1
@@ -349,7 +349,7 @@ xfs_dir3_free_get_buf( hdr.magic =XFS_DIR3_FREE_MAGIC ; hdr3->hdr.blkno =cpu_to_be64 (xfs_buf_daddr (bp)); - hdr3->hdr.owner =cpu_to_be64 (dp->i_ino); + hdr3->hdr.owner =cpu_to_be64 (args->owner);uuid_copy (&hdr3->hdr.uuid, &mp->m_sb.sb_meta_uuid); }else hdr.magic =XFS_DIR2_FREE_MAGIC ;
PATCH 3/9 xfs: validate attr leaf buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a leaf block header checking function to validate the owner field of xattr leaf blocks.
--- fs/xfs/libxfs/xfs_attr.c | 10 ++++--- fs/xfs/libxfs/xfs_attr_leaf.c | 55 ++++++++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_attr_leaf.h | 4 ++- fs/xfs/libxfs/xfs_da_btree.c | 42 +++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_da_btree.h | 1 + fs/xfs/libxfs/xfs_swapext.c | 3 +- fs/xfs/scrub/dabtree.c | 7 +++++ fs/xfs/xfs_attr_list.c | 25 ++++++++++++++++--- 8 files changed, 128 insertions(+), 19 deletions(-)
fs/xfs/libxfs/xfs_attr.c +5 -5
@@ -647,8 +647,8 @@ xfs_attr_leaf_remove_attr(int forkoff;int error; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, - &bp); + error =xfs_attr3_leaf_read (args->trans, args->dp, args->owner, + args->blkno, &bp);if (error)return error;
@@ -679,7 +679,7 @@ xfs_attr_leaf_shrink(if (!xfs_attr_is_leaf (dp))return 0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); + error =xfs_attr3_leaf_read (args->trans, args->dp, args->owner,0 , &bp);if (error)return error;
@@ -1160,7 +1160,7 @@ xfs_attr_leaf_try_add(struct xfs_buf *bp;int error; - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); + error =xfs_attr3_leaf_read (args->trans, args->dp, args->owner,0 , &bp);if (error)return error;
@@ -1208,7 +1208,7 @@ xfs_attr_leaf_hasname( {int error =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , bp); + error =xfs_attr3_leaf_read (args->trans, args->dp, args->owner,0 , bp);if (error)return error;
fs/xfs/libxfs/xfs_attr_leaf.c +46 -9
111 lines not on this page · raw message
fs/xfs/libxfs/xfs_attr_leaf.h +3 -1
@@ -101,12 +101,14 @@ int xfs_attr_leaf_order(struct xfs_buf *leaf1_bp, struct xfs_buf *leaf2_bp);int xfs_attr_leaf_newentsize (struct xfs_da_args *args,int *local);int xfs_attr3_leaf_read (struct xfs_trans *tp,struct xfs_inode *dp, -xfs_dablk_t bno,struct xfs_buf **bpp); +xfs_ino_t owner,xfs_dablk_t bno,struct xfs_buf **bpp);void xfs_attr3_leaf_hdr_from_disk (struct xfs_da_geometry *geo,struct xfs_attr3_icleaf_hdr *to,struct xfs_attr_leafblock *from);void xfs_attr3_leaf_hdr_to_disk (struct xfs_da_geometry *geo,struct xfs_attr_leafblock *to,struct xfs_attr3_icleaf_hdr *from); +xfs_failaddr_t xfs_attr3_leaf_header_check (struct xfs_buf *bp, +xfs_ino_t owner);#endif /* __XFS_ATTR_LEAF_H__ */
fs/xfs/libxfs/xfs_da_btree.c +42 -0
84 lines not on this page · raw message
fs/xfs/libxfs/xfs_da_btree.h +1 -0
@@ -236,6 +236,7 @@ void xfs_da3_node_hdr_from_disk(struct xfs_mount *mp, struct xfs_da3_icnode_hdr *to, struct xfs_da_intnode *from);void xfs_da3_node_hdr_to_disk (struct xfs_mount *mp,struct xfs_da_intnode *to,struct xfs_da3_icnode_hdr *from); +xfs_failaddr_t xfs_da3_header_check (struct xfs_buf *bp,xfs_ino_t owner);extern struct kmem_cache *xfs_da_state_cache;
fs/xfs/libxfs/xfs_swapext.c +2 -1
@@ -535,7 +535,8 @@ xfs_swapext_attr_to_sf(if (!xfs_attr_is_leaf (sxi->sxi_ip2))return 0 ; - error =xfs_attr3_leaf_read (tp, sxi->sxi_ip2,0 , &bp); + error =xfs_attr3_leaf_read (tp, sxi->sxi_ip2, sxi->sxi_ip2->i_ino,0 , + &bp);if (error)return error;
fs/xfs/scrub/dabtree.c +7 -0
@@ -320,6 +320,7 @@ xchk_da_btree_block(struct xfs_da3_blkinfo *hdr3;struct xfs_da_args *dargs = &ds->dargs;struct xfs_inode *ip = ds->dargs.dp; +xfs_failaddr_t fa;xfs_ino_t owner;int *pmaxrecs;struct xfs_da3_icnode_hdr nodehdr;
@@ -442,6 +443,12 @@ xchk_da_btree_block( goto out_freebp; } + fa =xfs_da3_header_check (blk->bp, dargs->owner); +if (fa) { +xchk_da_set_corrupt (ds, level); + goto out_freebp; + } +/* * If we've been handed a block that is below the dabtree root, does * its hashval match what the parent block expected to see?
fs/xfs/xfs_attr_list.c +22 -3
@@ -215,6 +215,7 @@ xfs_attr_node_list_lookup(struct xfs_mount *mp = dp->i_mount;struct xfs_trans *tp = context->tp;struct xfs_buf *bp; +xfs_failaddr_t fa;int i;int error =0 ;unsigned int expected_level =0 ;
@@ -274,6 +275,12 @@ xfs_attr_node_list_lookup( } } + fa =xfs_attr3_leaf_header_check (bp, dp->i_ino); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); + goto out_releasebuf; + } +if (expected_level !=0 ) goto out_corruptbuf;
@@ -282,6 +289,7 @@ xfs_attr_node_list_lookup( out_corruptbuf:xfs_buf_mark_corrupt (bp); +out_releasebuf:xfs_trans_brelse (tp, bp);xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ;
@@ -298,6 +306,7 @@ xfs_attr_node_list(struct xfs_buf *bp;struct xfs_inode *dp = context->dp;struct xfs_mount *mp = dp->i_mount; +xfs_failaddr_t fa;int error =0 ;trace_xfs_attr_node_list (context);
@@ -331,6 +340,15 @@ xfs_attr_node_list(case XFS_ATTR_LEAF_MAGIC :case XFS_ATTR3_LEAF_MAGIC : leaf = bp->b_addr; + fa =xfs_attr3_leaf_header_check (bp, + dp->i_ino); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (context->tp, bp); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK ); + bp =NULL ; +break ; + }xfs_attr3_leaf_hdr_from_disk (mp->m_attr_geo, &leafhdr, leaf); entries =xfs_attr3_leaf_entryp (leaf);
@@ -381,8 +399,8 @@ xfs_attr_node_list(break ; cursor->blkno = leafhdr.forw;xfs_trans_brelse (context->tp, bp); - error =xfs_attr3_leaf_read (context->tp, dp, cursor->blkno, - &bp); + error =xfs_attr3_leaf_read (context->tp, dp, dp->i_ino, + cursor->blkno, &bp);if (error)return error; }
@@ -502,7 +520,8 @@ xfs_attr_leaf_list(trace_xfs_attr_leaf_list (context); context->cursor.blkno =0 ; - error =xfs_attr3_leaf_read (context->tp, context->dp,0 , &bp); + error =xfs_attr3_leaf_read (context->tp, context->dp, + context->dp->i_ino,0 , &bp);if (error)return error;
PATCH 4/9 xfs: validate attr remote value buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Check the owner field of xattr remote value blocks.
--- fs/xfs/libxfs/xfs_attr_remote.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_attr_remote.c +4 -5
@@ -280,12 +280,12 @@ xfs_attr_rmtval_copyout(struct xfs_mount *mp, struct xfs_buf *bp, struct xfs_inode *dp, + xfs_ino_t owner, int *offset, int *valuelen, uint8_t **dst) { char *src = bp->b_addr; -xfs_ino_t ino = dp->i_ino;xfs_daddr_t bno =xfs_buf_daddr (bp);int len =BBTOB (bp->b_length);int blksize = mp->m_attr_geo->blksize;
@@ -299,11 +299,11 @@ xfs_attr_rmtval_copyout( byte_cnt =min (*valuelen, byte_cnt);if (xfs_has_crc (mp)) { -if (xfs_attr3_rmt_hdr_ok (src, ino, *offset, +if (xfs_attr3_rmt_hdr_ok (src, owner, *offset, byte_cnt, bno)) {xfs_alert (mp,"remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)" , - bno, *offset, byte_cnt, ino); + bno, *offset, byte_cnt, owner);xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -427,8 +427,7 @@ xfs_attr_rmtval_get(return error; error =xfs_attr_rmtval_copyout (mp, bp, args->dp, - &offset, &valuelen, - &dst); + args->owner, &offset, &valuelen, &dst);xfs_buf_relse (bp);if (error)return error;
PATCH 5/9 xfs: validate dabtree node buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Check the owner field of dabtree node blocks.
--- fs/xfs/libxfs/xfs_da_btree.c | 108 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_da_btree.h | 1 fs/xfs/xfs_attr_list.c | 10 ++++ 3 files changed, 119 insertions(+)
fs/xfs/libxfs/xfs_da_btree.c +108 -0
@@ -251,6 +251,25 @@ xfs_da3_node_verify(return NULL ; } +xfs_failaddr_t +xfs_da3_node_header_check ( +struct xfs_buf *bp, +xfs_ino_t owner) +{ +struct xfs_mount *mp = bp->b_mount; + +if (xfs_has_crc (mp)) { +struct xfs_da3_blkinfo *hdr3 = bp->b_addr; + +ASSERT (hdr3->hdr.magic ==cpu_to_be16 (XFS_DA3_NODE_MAGIC )); + +if (be64_to_cpu (hdr3->owner) != owner) +return __this_address; + } + +return NULL ; +} + xfs_failaddr_t xfs_da3_header_check( struct xfs_buf *bp,
@@ -265,6 +284,8 @@ xfs_da3_header_check(switch (hdr->magic) {case cpu_to_be16 (XFS_ATTR3_LEAF_MAGIC ):return xfs_attr3_leaf_header_check (bp, owner); +case cpu_to_be16 (XFS_DA3_NODE_MAGIC ): +return xfs_da3_node_header_check (bp, owner); }return NULL ;
@@ -1217,6 +1238,7 @@ xfs_da3_root_join(struct xfs_da3_icnode_hdr oldroothdr;int error;struct xfs_inode *dp = state->args->dp; +xfs_failaddr_t fa;trace_xfs_da_root_join (state->args);
@@ -1243,6 +1265,13 @@ xfs_da3_root_join( error =xfs_da3_node_read (args->trans, dp, child, &bp, args->whichfork);if (error)return error; + fa =xfs_da3_header_check (bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (args->trans, bp); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + }xfs_da_blkinfo_onlychild_validate (bp->b_addr, oldroothdr.level);/*
@@ -1277,6 +1306,7 @@ xfs_da3_node_toosmall(struct xfs_da_blkinfo *info;xfs_dablk_t blkno;struct xfs_buf *bp; +xfs_failaddr_t fa;struct xfs_da3_icnode_hdr nodehdr;int count;int forward;
@@ -1351,6 +1381,13 @@ xfs_da3_node_toosmall( state->args->whichfork);if (error)return error; + fa =xfs_da3_node_header_check (bp, state->args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (state->args->trans, bp); +xfs_da_mark_sick (state->args); +return -EFSCORRUPTED ; + } node = bp->b_addr;xfs_da3_node_hdr_from_disk (dp->i_mount, &thdr, node);
@@ -1673,6 +1710,13 @@ xfs_da3_node_lookup_int(return -EFSCORRUPTED ; } + fa =xfs_da3_node_header_check (blk->bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (blk->bp, fa); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + } + blk->magic =XFS_DA_NODE_MAGIC ;/*
@@ -1845,6 +1889,7 @@ xfs_da3_blk_link(struct xfs_da_blkinfo *tmp_info;struct xfs_da_args *args;struct xfs_buf *bp; +xfs_failaddr_t fa;int before =0 ;int error;struct xfs_inode *dp = state->args->dp;
@@ -1888,6 +1933,13 @@ xfs_da3_blk_link( &bp, args->whichfork);if (error)return error; + fa =xfs_da3_header_check (bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (args->trans, bp); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + }ASSERT (bp !=NULL ); tmp_info = bp->b_addr;ASSERT (tmp_info->magic == old_info->magic);
@@ -1909,6 +1961,13 @@ xfs_da3_blk_link( &bp, args->whichfork);if (error)return error; + fa =xfs_da3_header_check (bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (args->trans, bp); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + }ASSERT (bp !=NULL ); tmp_info = bp->b_addr;ASSERT (tmp_info->magic == old_info->magic);
@@ -1938,6 +1997,7 @@ xfs_da3_blk_unlink(struct xfs_da_blkinfo *tmp_info;struct xfs_da_args *args;struct xfs_buf *bp; +xfs_failaddr_t fa;int error;/*
@@ -1968,6 +2028,13 @@ xfs_da3_blk_unlink( &bp, args->whichfork);if (error)return error; + fa =xfs_da3_header_check (bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (args->trans, bp); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + }ASSERT (bp !=NULL ); tmp_info = bp->b_addr;ASSERT (tmp_info->magic == save_info->magic);
@@ -1985,6 +2052,13 @@ xfs_da3_blk_unlink( &bp, args->whichfork);if (error)return error; + fa =xfs_da3_header_check (bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_trans_brelse (args->trans, bp); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + }ASSERT (bp !=NULL ); tmp_info = bp->b_addr;ASSERT (tmp_info->magic == save_info->magic);
@@ -2100,6 +2174,12 @@ xfs_da3_path_shift(switch (be16_to_cpu (info->magic)) {case XFS_DA_NODE_MAGIC :case XFS_DA3_NODE_MAGIC : + fa =xfs_da3_node_header_check (blk->bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (blk->bp, fa); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + } blk->magic =XFS_DA_NODE_MAGIC ;xfs_da3_node_hdr_from_disk (dp->i_mount, &nodehdr, bp->b_addr);
@@ -2404,6 +2484,13 @@ xfs_da3_swap_lastblock( error =xfs_da3_node_read (tp, dp, sib_blkno, &sib_buf, w);if (error) goto done; + fa =xfs_da3_header_check (sib_buf, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (sib_buf, fa); +xfs_da_mark_sick (args); + error = -EFSCORRUPTED ; + goto done; + } sib_info = sib_buf->b_addr; if (XFS_IS_CORRUPT(mp, be32_to_cpu(sib_info->forw) != last_blkno ||
@@ -2425,6 +2512,13 @@ xfs_da3_swap_lastblock( error =xfs_da3_node_read (tp, dp, sib_blkno, &sib_buf, w);if (error) goto done; + fa =xfs_da3_header_check (sib_buf, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (sib_buf, fa); +xfs_da_mark_sick (args); + error = -EFSCORRUPTED ; + goto done; + } sib_info = sib_buf->b_addr; if (XFS_IS_CORRUPT(mp, be32_to_cpu(sib_info->back) != last_blkno ||
@@ -2448,6 +2542,13 @@ xfs_da3_swap_lastblock( error =xfs_da3_node_read (tp, dp, par_blkno, &par_buf, w);if (error) goto done; + fa =xfs_da3_node_header_check (par_buf, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (par_buf, fa); +xfs_da_mark_sick (args); + error = -EFSCORRUPTED ; + goto done; + } par_node = par_buf->b_addr;xfs_da3_node_hdr_from_disk (dp->i_mount, &par_hdr, par_node); if (XFS_IS_CORRUPT(mp,
@@ -2497,6 +2598,13 @@ xfs_da3_swap_lastblock( error =xfs_da3_node_read (tp, dp, par_blkno, &par_buf, w);if (error) goto done; + fa =xfs_da3_node_header_check (par_buf, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (par_buf, fa); +xfs_da_mark_sick (args); + error = -EFSCORRUPTED ; + goto done; + } par_node = par_buf->b_addr;xfs_da3_node_hdr_from_disk (dp->i_mount, &par_hdr, par_node);if (XFS_IS_CORRUPT (mp, par_hdr.level != level)) {
fs/xfs/libxfs/xfs_da_btree.h +1 -0
@@ -237,6 +237,7 @@ void xfs_da3_node_hdr_from_disk(struct xfs_mount *mp,void xfs_da3_node_hdr_to_disk (struct xfs_mount *mp,struct xfs_da_intnode *to,struct xfs_da3_icnode_hdr *from);xfs_failaddr_t xfs_da3_header_check (struct xfs_buf *bp,xfs_ino_t owner); +xfs_failaddr_t xfs_da3_node_header_check (struct xfs_buf *bp,xfs_ino_t owner);extern struct kmem_cache *xfs_da_state_cache;
fs/xfs/xfs_attr_list.c +10 -0
@@ -240,6 +240,10 @@ xfs_attr_node_list_lookup( goto out_corruptbuf; } + fa =xfs_da3_node_header_check (bp, dp->i_ino); +if (fa) + goto out_corruptbuf; +xfs_da3_node_hdr_from_disk (mp, &nodehdr, node);/* Tree taller than we can handle; bail out! */
@@ -334,6 +338,12 @@ xfs_attr_node_list(case XFS_DA_NODE_MAGIC :case XFS_DA3_NODE_MAGIC :trace_xfs_attr_list_wrong_blk (context); + fa =xfs_da3_node_header_check (bp, + dp->i_ino); +if (fa) { +__xfs_buf_mark_corrupt (bp, fa); +xfs_dirattr_mark_sick (dp,XFS_ATTR_FORK ); + }xfs_trans_brelse (context->tp, bp); bp =NULL ;break ;
PATCH 6/9 xfs: validate directory leaf buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Check the owner field of directory leaf blocks.
--- fs/xfs/libxfs/xfs_da_btree.c | 16 ++++++++++ fs/xfs/libxfs/xfs_dir2.h | 2 + fs/xfs/libxfs/xfs_dir2_leaf.c | 64 +++++++++++++++++++++++++++++++++++++---- fs/xfs/libxfs/xfs_dir2_node.c | 3 +- fs/xfs/libxfs/xfs_dir2_priv.h | 4 +-- fs/xfs/scrub/dir.c | 2 + 6 files changed, 81 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_da_btree.c +16 -0
@@ -286,8 +286,12 @@ xfs_da3_header_check(return xfs_attr3_leaf_header_check (bp, owner);case cpu_to_be16 (XFS_DA3_NODE_MAGIC ):return xfs_da3_node_header_check (bp, owner); +case cpu_to_be16 (XFS_DIR3_LEAF1_MAGIC ): +case cpu_to_be16 (XFS_DIR3_LEAFN_MAGIC ): +return xfs_dir3_leaf_header_check (bp, owner); } +ASSERT (0 );return NULL ; }
@@ -1698,6 +1702,12 @@ xfs_da3_node_lookup_int(if (magic ==XFS_DIR2_LEAFN_MAGIC || magic ==XFS_DIR3_LEAFN_MAGIC ) { + fa =xfs_dir3_leaf_header_check (blk->bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (blk->bp, fa); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + } blk->magic =XFS_DIR2_LEAFN_MAGIC ; blk->hashval =xfs_dir2_leaf_lasthash (args->dp, blk->bp,NULL );
@@ -2206,6 +2216,12 @@ xfs_da3_path_shift(break ;case XFS_DIR2_LEAFN_MAGIC :case XFS_DIR3_LEAFN_MAGIC : + fa =xfs_dir3_leaf_header_check (blk->bp, args->owner); +if (fa) { +__xfs_buf_mark_corrupt (blk->bp, fa); +xfs_da_mark_sick (args); +return -EFSCORRUPTED ; + } blk->magic =XFS_DIR2_LEAFN_MAGIC ;ASSERT (level == path->active-1 ); blk->index =0 ;
fs/xfs/libxfs/xfs_dir2.h +2 -0
@@ -98,6 +98,8 @@ extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(extern int xfs_dir_ino_validate (struct xfs_mount *mp,xfs_ino_t ino); +xfs_failaddr_t xfs_dir3_leaf_header_check (struct xfs_buf *bp,xfs_ino_t owner); +extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;extern const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops;
fs/xfs/libxfs/xfs_dir2_leaf.c +58 -6
110 lines not on this page · raw message
fs/xfs/libxfs/xfs_dir2_node.c +2 -1
@@ -1562,7 +1562,8 @@ xfs_dir2_leafn_toosmall(/* * Read the sibling leaf block. */ - error =xfs_dir3_leafn_read (state->args->trans, dp, blkno, &bp); + error =xfs_dir3_leafn_read (state->args->trans, dp, + state->args->owner, blkno, &bp);if (error)return error;
fs/xfs/libxfs/xfs_dir2_priv.h +2 -2
@@ -95,9 +95,9 @@ void xfs_dir2_leaf_hdr_from_disk(struct xfs_mount *mp,void xfs_dir2_leaf_hdr_to_disk (struct xfs_mount *mp,struct xfs_dir2_leaf *to,struct xfs_dir3_icleaf_hdr *from);int xfs_dir3_leaf_read (struct xfs_trans *tp,struct xfs_inode *dp, -xfs_dablk_t fbno,struct xfs_buf **bpp); +xfs_ino_t owner,xfs_dablk_t fbno,struct xfs_buf **bpp);int xfs_dir3_leafn_read (struct xfs_trans *tp,struct xfs_inode *dp, -xfs_dablk_t fbno,struct xfs_buf **bpp); +xfs_ino_t owner,xfs_dablk_t fbno,struct xfs_buf **bpp);extern int xfs_dir2_block_to_leaf (struct xfs_da_args *args,struct xfs_buf *dbp);extern int xfs_dir2_leaf_addname (struct xfs_da_args *args);
fs/xfs/scrub/dir.c +1 -1
@@ -470,7 +470,7 @@ xchk_directory_leaf1_bestfree(int error;/* Read the free space block. */ - error =xfs_dir3_leaf_read (sc->tp, sc->ip, lblk, &bp); + error =xfs_dir3_leaf_read (sc->tp, sc->ip, sc->ip->i_ino, lblk, &bp);if (!xchk_fblock_process_error (sc,XFS_DATA_FORK , lblk, &error))return error;xchk_buffer_recheck (sc, bp);
PATCH 7/9 xfs: validate explicit directory data buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port the existing directory data header checking function to accept an owner number instead of an xfs_inode, then update the callsites to use xfs_da_args.owner when possible.
--- fs/xfs/libxfs/xfs_dir2.h | 1 + fs/xfs/libxfs/xfs_dir2_block.c | 3 ++- fs/xfs/libxfs/xfs_dir2_data.c | 15 +++++++++------ fs/xfs/libxfs/xfs_dir2_leaf.c | 21 +++++++++++---------- fs/xfs/libxfs/xfs_dir2_node.c | 7 +++---- fs/xfs/libxfs/xfs_dir2_priv.h | 3 ++- fs/xfs/scrub/dir.c | 14 +++++++------- fs/xfs/scrub/readdir.c | 2 +- fs/xfs/xfs_dir2_readdir.c | 3 ++- 9 files changed, 38 insertions(+), 31 deletions(-)
fs/xfs/libxfs/xfs_dir2.h +1 -0
@@ -99,6 +99,7 @@ extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(extern int xfs_dir_ino_validate (struct xfs_mount *mp,xfs_ino_t ino);xfs_failaddr_t xfs_dir3_leaf_header_check (struct xfs_buf *bp,xfs_ino_t owner); +xfs_failaddr_t xfs_dir3_data_header_check (struct xfs_buf *bp,xfs_ino_t owner);extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
fs/xfs/libxfs/xfs_dir2_block.c +2 -1
@@ -982,7 +982,8 @@ xfs_dir2_leaf_to_block(* Read the data block if we don't already have it, give up if it fails. */ if (!dbp) { - error =xfs_dir3_data_read (tp, dp, args->geo->datablk,0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, + args->geo->datablk,0 , &dbp);if (error)return error; }
fs/xfs/libxfs/xfs_dir2_data.c +9 -6
@@ -395,17 +395,19 @@ static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = { .verify_write = xfs_dir3_data_write_verify, }; -static xfs_failaddr_t +xfs_failaddr_t xfs_dir3_data_header_check ( -struct xfs_inode *dp, -struct xfs_buf *bp) +struct xfs_buf *bp, +xfs_ino_t owner) { -struct xfs_mount *mp = dp->i_mount; +struct xfs_mount *mp = bp->b_mount;if (xfs_has_crc (mp)) {struct xfs_dir3_data_hdr *hdr3 = bp->b_addr; -if (be64_to_cpu (hdr3->hdr.owner) != dp->i_ino) +ASSERT (hdr3->hdr.magic ==cpu_to_be32 (XFS_DIR3_DATA_MAGIC )); + +if (be64_to_cpu (hdr3->hdr.owner) != owner)return __this_address; }
@@ -416,6 +418,7 @@ intxfs_dir3_data_read ( struct xfs_trans *tp, struct xfs_inode *dp, + xfs_ino_t owner, xfs_dablk_t bno, unsigned int flags, struct xfs_buf **bpp)
@@ -429,7 +432,7 @@ xfs_dir3_data_read(return err;/* Check things that we can't do in the verifier. */ - fa =xfs_dir3_data_header_check (dp, *bpp); + fa =xfs_dir3_data_header_check (*bpp, owner);if (fa) {__xfs_buf_mark_corrupt (*bpp, fa);xfs_trans_brelse (tp, *bpp);
fs/xfs/libxfs/xfs_dir2_leaf.c +11 -10
@@ -884,9 +884,9 @@ xfs_dir2_leaf_addname(* Already had space in some data block. * Just read that one in. */ - error =xfs_dir3_data_read (tp, dp, -xfs_dir2_db_to_da (args->geo, use_block), -0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, +xfs_dir2_db_to_da (args->geo, use_block),0 , + &dbp);if (error) {xfs_trans_brelse (tp, lbp);return error;
@@ -1327,9 +1327,9 @@ xfs_dir2_leaf_lookup_int(if (newdb != curdb) {if (dbp)xfs_trans_brelse (tp, dbp); - error =xfs_dir3_data_read (tp, dp, -xfs_dir2_db_to_da (args->geo, newdb), -0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, +xfs_dir2_db_to_da (args->geo, newdb),0 , + &dbp);if (error) {xfs_trans_brelse (tp, lbp);return error;
@@ -1369,9 +1369,9 @@ xfs_dir2_leaf_lookup_int(ASSERT (cidb !=-1 );if (cidb != curdb) {xfs_trans_brelse (tp, dbp); - error =xfs_dir3_data_read (tp, dp, -xfs_dir2_db_to_da (args->geo, cidb), -0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, +xfs_dir2_db_to_da (args->geo, cidb),0 , + &dbp);if (error) {xfs_trans_brelse (tp, lbp);return error;
@@ -1665,7 +1665,8 @@ xfs_dir2_leaf_trim_data(/* * Read the offending data block. We need its buffer. */ - error =xfs_dir3_data_read (tp, dp,xfs_dir2_db_to_da (geo, db),0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, +xfs_dir2_db_to_da (geo, db),0 , &dbp);if (error)return error;
fs/xfs/libxfs/xfs_dir2_node.c +3 -4
@@ -863,7 +863,7 @@ xfs_dir2_leafn_lookup_for_entry(ASSERT (state->extravalid); curbp = state->extrablk.bp; }else { - error =xfs_dir3_data_read (tp, dp, + error =xfs_dir3_data_read (tp, dp, args->owner,xfs_dir2_db_to_da (args->geo, newdb),0 , &curbp);
@@ -1949,9 +1949,8 @@ xfs_dir2_node_addname_int( &freehdr, &findex); }else {/* Read the data block in. */ - error =xfs_dir3_data_read (tp, dp, -xfs_dir2_db_to_da (args->geo, dbno), -0 , &dbp); + error =xfs_dir3_data_read (tp, dp, args->owner, +xfs_dir2_db_to_da (args->geo, dbno),0 , &dbp); }if (error)return error;
fs/xfs/libxfs/xfs_dir2_priv.h +2 -1
@@ -78,7 +78,8 @@ extern void xfs_dir3_data_check(struct xfs_inode *dp, struct xfs_buf *bp);extern xfs_failaddr_t __xfs_dir3_data_check (struct xfs_inode *dp,struct xfs_buf *bp);int xfs_dir3_data_read (struct xfs_trans *tp,struct xfs_inode *dp, -xfs_dablk_t bno,unsigned int flags,struct xfs_buf **bpp); +xfs_ino_t owner,xfs_dablk_t bno,unsigned int flags, +struct xfs_buf **bpp);int xfs_dir3_data_readahead (struct xfs_inode *dp,xfs_dablk_t bno,unsigned int flags);
fs/xfs/scrub/dir.c +7 -7
@@ -196,8 +196,8 @@ xchk_dir_rec(xchk_da_set_corrupt (ds, level); goto out; } - error =xfs_dir3_data_read (ds->dargs.trans, dp, rec_bno, -XFS_DABUF_MAP_HOLE_OK , &bp); + error =xfs_dir3_data_read (ds->dargs.trans, dp, ds->dargs.owner, + rec_bno,XFS_DABUF_MAP_HOLE_OK , &bp);if (!xchk_fblock_process_error (ds->sc,XFS_DATA_FORK , rec_bno, &error)) goto out;
@@ -318,7 +318,8 @@ xchk_directory_data_bestfree( error =xfs_dir3_block_read (sc->tp, sc->ip, &bp); }else {/* dir data format */ - error =xfs_dir3_data_read (sc->tp, sc->ip, lblk,0 , &bp); + error =xfs_dir3_data_read (sc->tp, sc->ip, sc->ip->i_ino, lblk, +0 , &bp); }if (!xchk_fblock_process_error (sc,XFS_DATA_FORK , lblk, &error)) goto out;
@@ -531,10 +532,9 @@ xchk_directory_leaf1_bestfree(/* Check all the bestfree entries. */ for (i =0 ; i < bestcount; i++, bestp++) { best =be16_to_cpu (*bestp); - error =xfs_dir3_data_read (sc->tp, sc->ip, + error =xfs_dir3_data_read (sc->tp, sc->ip, args->owner,xfs_dir2_db_to_da (args->geo, i), -XFS_DABUF_MAP_HOLE_OK , - &dbp); +XFS_DABUF_MAP_HOLE_OK , &dbp);if (!xchk_fblock_process_error (sc,XFS_DATA_FORK , lblk, &error))break ;
@@ -597,7 +597,7 @@ xchk_directory_free_bestfree( stale++;continue ; } - error =xfs_dir3_data_read (sc->tp, sc->ip, + error =xfs_dir3_data_read (sc->tp, sc->ip, args->owner, (freehdr.firstdb + i) * args->geo->fsbcount,0 , &dbp); if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,
fs/xfs/scrub/readdir.c +1 -1
@@ -177,7 +177,7 @@ xchk_read_leaf_dir_buf(if (new_off > *curoff) *curoff = new_off; -return xfs_dir3_data_read (tp, dp, map.br_startoff,0 , bpp); +return xfs_dir3_data_read (tp, dp, dp->i_ino, map.br_startoff,0 , bpp); }/* Call a function for every entry in a leaf directory. */
fs/xfs/xfs_dir2_readdir.c +2 -1
@@ -284,7 +284,8 @@ xfs_dir2_leaf_readbuf( new_off =xfs_dir2_da_to_byte (geo, map.br_startoff);if (new_off > *cur_off) *cur_off = new_off; - error =xfs_dir3_data_read (args->trans, dp, map.br_startoff,0 , &bp); + error =xfs_dir3_data_read (args->trans, dp, args->owner, + map.br_startoff,0 , &bp);if (error) goto out;
PATCH 8/9 xfs: validate explicit directory block buffer owners
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Port the existing directory block header checking function to accept an owner number instead of an xfs_inode, then update the callsites to use xfs_da_args.owner when possible.
--- fs/xfs/libxfs/xfs_dir2.h | 1 + fs/xfs/libxfs/xfs_dir2_block.c | 22 ++++++++++++++-------- fs/xfs/libxfs/xfs_dir2_priv.h | 2 +- fs/xfs/libxfs/xfs_swapext.c | 2 +- fs/xfs/scrub/dir.c | 2 +- fs/xfs/scrub/readdir.c | 2 +- fs/xfs/xfs_dir2_readdir.c | 2 +- 7 files changed, 20 insertions(+), 13 deletions(-)
fs/xfs/libxfs/xfs_dir2.h +1 -0
@@ -100,6 +100,7 @@ extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);xfs_failaddr_t xfs_dir3_leaf_header_check (struct xfs_buf *bp,xfs_ino_t owner);xfs_failaddr_t xfs_dir3_data_header_check (struct xfs_buf *bp,xfs_ino_t owner); +xfs_failaddr_t xfs_dir3_block_header_check (struct xfs_buf *bp,xfs_ino_t owner);extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
fs/xfs/libxfs/xfs_dir2_block.c +14 -8
@@ -115,18 +115,23 @@ const struct xfs_buf_ops xfs_dir3_block_buf_ops = { .verify_struct = xfs_dir3_block_verify, }; -static xfs_failaddr_t +xfs_failaddr_t xfs_dir3_block_header_check ( -struct xfs_inode *dp, -struct xfs_buf *bp) +struct xfs_buf *bp, +xfs_ino_t owner) { -struct xfs_mount *mp = dp->i_mount; +struct xfs_mount *mp = bp->b_mount;if (xfs_has_crc (mp)) {struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; -if (be64_to_cpu (hdr3->owner) != dp->i_ino) +ASSERT (hdr3->magic ==cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC )); + +if (be64_to_cpu (hdr3->owner) != owner) { +xfs_err (NULL ,"dir block owner 0x%llx doesnt match block 0x%llx" , owner,be64_to_cpu (hdr3->owner)); +dump_stack ();return __this_address; + } }return NULL ;
@@ -136,6 +141,7 @@ intxfs_dir3_block_read ( struct xfs_trans *tp, struct xfs_inode *dp, + xfs_ino_t owner, struct xfs_buf **bpp) { struct xfs_mount *mp = dp->i_mount;
@@ -148,7 +154,7 @@ xfs_dir3_block_read(return err;/* Check things that we can't do in the verifier. */ - fa =xfs_dir3_block_header_check (dp, *bpp); + fa =xfs_dir3_block_header_check (*bpp, owner);if (fa) {__xfs_buf_mark_corrupt (*bpp, fa);xfs_trans_brelse (tp, *bpp);
@@ -383,7 +389,7 @@ xfs_dir2_block_addname( tp = args->trans;/* Read the (one and only) directory block into bp. */ - error =xfs_dir3_block_read (tp, dp, &bp); + error =xfs_dir3_block_read (tp, dp, args->owner, &bp);if (error)return error;
@@ -698,7 +704,7 @@ xfs_dir2_block_lookup_int( dp = args->dp; tp = args->trans; - error =xfs_dir3_block_read (tp, dp, &bp); + error =xfs_dir3_block_read (tp, dp, args->owner, &bp);if (error)return error;
fs/xfs/libxfs/xfs_dir2_priv.h +1 -1
@@ -51,7 +51,7 @@ extern int xfs_dir_cilookup_result(struct xfs_da_args *args,/* xfs_dir2_block.c */ extern int xfs_dir3_block_read (struct xfs_trans *tp,struct xfs_inode *dp, -struct xfs_buf **bpp); +xfs_ino_t owner,struct xfs_buf **bpp);extern int xfs_dir2_block_addname (struct xfs_da_args *args);extern int xfs_dir2_block_lookup (struct xfs_da_args *args);extern int xfs_dir2_block_removename (struct xfs_da_args *args);
fs/xfs/libxfs/xfs_swapext.c +1 -1
@@ -573,7 +573,7 @@ xfs_swapext_dir_to_sf(if (!isblock)return 0 ; - error =xfs_dir3_block_read (tp, sxi->sxi_ip2, &bp); + error =xfs_dir3_block_read (tp, sxi->sxi_ip2, sxi->sxi_ip2->i_ino, &bp);if (error)return error;
fs/xfs/scrub/dir.c +1 -1
@@ -315,7 +315,7 @@ xchk_directory_data_bestfree(/* dir block format */ if (lblk !=XFS_B_TO_FSBT (mp,XFS_DIR2_DATA_OFFSET ))xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , lblk); - error =xfs_dir3_block_read (sc->tp, sc->ip, &bp); + error =xfs_dir3_block_read (sc->tp, sc->ip, sc->ip->i_ino, &bp); }else {/* dir data format */ error = xfs_dir3_data_read(sc->tp, sc->ip, sc->ip->i_ino, lblk,
fs/xfs/scrub/readdir.c +1 -1
@@ -101,7 +101,7 @@ xchk_dir_walk_block(unsigned int off, next_off, end;int error; - error =xfs_dir3_block_read (sc->tp, dp, &bp); + error =xfs_dir3_block_read (sc->tp, dp, dp->i_ino, &bp);if (error)return error;
fs/xfs/xfs_dir2_readdir.c +1 -1
@@ -159,7 +159,7 @@ xfs_dir2_block_getdents(if (xfs_dir2_dataptr_to_db (geo, ctx->pos) > geo->datablk)return 0 ; - error =xfs_dir3_block_read (args->trans, dp, &bp); + error =xfs_dir3_block_read (args->trans, dp, args->owner, &bp);if (error)return error;