xfs: btree bulk loading
v5 cover xfs: btree bulk loading
Hi all,
This series creates a bulk loading function for metadata btree cursors.
We start by creating the idea of a "fake root" for each of the btree root types (AG header and inode) so that we can use a special btree cursor to stage a new btree without altering anything that might already exist.
Next, we add utility functions to compute the desired btree shape for a given number of records, load records into new leaf blocks, compute the node blocks from that, and present the new root ready for commit.
Finally we extend all four per-AG btree cursor types to support staging cursors and therefore bulk loading. This will be used by upcoming patch series to implement online repair and refactor offline repair.
For v4, fix a lot of review comments from Brian Foster, most of which relate to disentangling thornier parts of the code; and clarifying the documentation so that someone other than the author can understand what is going on here. :)
For v5, a few documentation tweaks and moving the btree staging code to a separate file since it's really a new use for btree cursors.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This has been lightly tested with fstests. 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-bulk-loading-5.7
PATCH v5 1/7 xfs: introduce fake roots for ag-rooted btrees
From: Darrick J. Wong <[email protected]>
Create an in-core fake root for AG-rooted btree types so that callers can generate a whole new btree using the upcoming btree bulk load function without making the new tree accessible from the rest of the filesystem. It is up to the individual btree type to provide a function to create a staged cursor (presumably with the appropriate callouts to update the fakeroot) and then commit the staged root back into the filesystem.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_btree.c | 3 + fs/xfs/libxfs/xfs_btree.h | 11 ++ fs/xfs/libxfs/xfs_btree_staging.c | 179 +++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_btree_staging.h | 27 ++++++ fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 28 ++++++ 7 files changed, 249 insertions(+), 1 deletion(-) create mode 100644 fs/xfs/libxfs/xfs_btree_staging.c create mode 100644 fs/xfs/libxfs/xfs_btree_staging.h
fs/xfs/Makefile +1 -0
@@ -41,6 +41,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_bmap.o \ xfs_bmap_btree.o \ xfs_btree.o \ + xfs_btree_staging.o \ xfs_da_btree.o \ xfs_defer.o \ xfs_dir2.o \
fs/xfs/libxfs/xfs_btree.c +3 -0
@@ -20,6 +20,7 @@#include "xfs_trace.h" #include "xfs_alloc.h" #include "xfs_log.h" +#include "xfs_btree_staging.h" /* * Cursor allocation zone.
@@ -382,6 +383,8 @@ xfs_btree_del_cursor(/* * Free the cursor. */ +if (unlikely (cur->bc_flags &XFS_BTREE_STAGING )) +kmem_free ((void *)cur->bc_ops);kmem_cache_free (xfs_btree_cur_zone, cur); }
fs/xfs/libxfs/xfs_btree.h +10 -1
@@ -179,7 +179,10 @@ union xfs_btree_irec {/* Per-AG btree information. */ struct xfs_btree_cur_ag { - struct xfs_buf *agbp; + union { + struct xfs_buf *agbp; + struct xbtree_afakeroot *afake; /* for staging cursor */ + }; xfs_agnumber_t agno; union { struct {
@@ -238,6 +241,12 @@ typedef struct xfs_btree_cur#define XFS_BTREE_LASTREC_UPDATE (1<<2)/* track last rec externally */ #define XFS_BTREE_CRC_BLOCKS (1<<3)/* uses extended btree blocks */ #define XFS_BTREE_OVERLAPPING (1<<4)/* overlapping intervals */ +/* +* The root of this btree is a fakeroot structure so that we can stage a btree +* rebuild without leaving it accessible via primary metadata. The ops struct +* is dynamically allocated and must be freed when the cursor is deleted. +*/ +#define XFS_BTREE_STAGING (1<<5)#define XFS_BTREE_NOERROR 0
fs/xfs/libxfs/xfs_btree_staging.c new file +179 -0
179 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree_staging.h new file +27 -0
@@ -0,0 +1,27 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* +* Copyright (C) 2020 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_BTREE_STAGING_H__ +#define __XFS_BTREE_STAGING_H__ + +/* Fake root for an AG-rooted btree. */ +struct xbtree_afakeroot { +/* AG block number of the new btree root. */ +xfs_agblock_t af_root; + +/* Height of the new btree. */ +unsigned int af_levels; + +/* Number of blocks used by the btree. */ +unsigned int af_blocks; +}; + +/* Cursor interactions with with fake roots for AG-rooted btrees. */ +void xfs_btree_stage_afakeroot (struct xfs_btree_cur *cur, +struct xbtree_afakeroot *afake); +void xfs_btree_commit_afakeroot (struct xfs_btree_cur *cur,struct xfs_trans *tp, +struct xfs_buf *agbp,const struct xfs_btree_ops *ops); + +#endif /* __XFS_BTREE_STAGING_H__ */
fs/xfs/xfs_trace.c +1 -0
@@ -27,6 +27,7 @@#include "xfs_log_recover.h" #include "xfs_filestream.h" #include "xfs_fsmap.h" +#include "xfs_btree_staging.h" /* * We include this last to have the helpers above available for the trace
fs/xfs/xfs_trace.h +28 -0
@@ -3605,6 +3605,34 @@ TRACE_EVENT(xfs_check_new_dalign, __entry->calc_rootino) ) +TRACE_EVENT (xfs_btree_commit_afakeroot, + TP_PROTO(struct xfs_btree_cur *cur), +TP_ARGS (cur), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_btnum_t, btnum) + __field(xfs_agnumber_t, agno) + __field(xfs_agblock_t, agbno) + __field(unsigned int, levels) + __field(unsigned int, blocks) + ), +TP_fast_assign ( + __entry->dev = cur->bc_mp->m_super->s_dev; + __entry->btnum = cur->bc_btnum; + __entry->agno = cur->bc_ag.agno; + __entry->agbno = cur->bc_ag.afake->af_root; + __entry->levels = cur->bc_ag.afake->af_levels; + __entry->blocks = cur->bc_ag.afake->af_blocks; + ), +TP_printk ("dev %d:%d btree %s ag %u levels %u blocks %u root %u" , +MAJOR (__entry->dev),MINOR (__entry->dev), +__print_symbolic (__entry->btnum,XFS_BTNUM_STRINGS ), + __entry->agno, + __entry->levels, + __entry->blocks, + __entry->agbno) +) +#endif /* _TRACE_XFS_H */ #undef TRACE_INCLUDE_PATH
Re: [PATCH 1/7] xfs: introduce fake roots for ag-rooted btrees
fs/xfs/Makefile xfs-y += $(addprefix libxfs/, \ · line 44
Quoted 9 lines
fs/xfs/Makefile +1
-0@@ -41,6 +41,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_bmap.o \ xfs_bmap_btree.o \ xfs_btree.o \ + xfs_btree_staging.o \
We only needs this for online repair don't we? Can we exclude the file from the build for xfs configs without scrub/repair?
Re: [PATCH 1/7] xfs: introduce fake roots for ag-rooted btrees
Quoted 4 lines · Christoph Hellwig
Quoted 4 lines
fs/xfs/Makefile +0
-0
Quoted 8 lines
fs/xfs/Makefile xfs-y += $(addprefix libxfs/, \ · line 44
Quoted 5 lines
fs/xfs/Makefile +1
-0@@ -41,6 +41,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_bmap.o \ xfs_bmap_btree.o \ xfs_btree.o \ + xfs_btree_staging.o \We only needs this for online repair don't we? Can we exclude the file from the build for xfs configs without scrub/repair?
That could be done, provided we don't mind having #ifdef CONFIG_XFS_ONLINE_REPAIR checks in the parts of libxfs that call xfs_btree_commit_afakeroot and xfs_btree_stage_*fakeroot.
After which we'll have to work around that in xfsprogs when I (re)send my series to refactor all the open-coded btree creation code out of xfs_repair.
Not a big deal if others want to save ~9k of space (debug mode is on):
text data bss dec hex filename
8767 313 0 9080 2378 fs/xfs/libxfs/xfs_btree_staging.o
--D
PATCH v5 2/7 xfs: introduce fake roots for inode-rooted btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create an in-core fake root for inode-rooted btree types so that callers can generate a whole new btree using the upcoming btree bulk load function without making the new tree accessible from the rest of the filesystem. It is up to the individual btree type to provide a function to create a staged cursor (presumably with the appropriate callouts to update the fakeroot) and then commit the staged root back into the filesystem.
--- fs/xfs/libxfs/xfs_btree.c | 14 +++++- fs/xfs/libxfs/xfs_btree.h | 3 + fs/xfs/libxfs/xfs_btree_staging.c | 84 +++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_btree_staging.h | 28 ++++++++++++ fs/xfs/xfs_trace.h | 33 +++++++++++++++ 5 files changed, 160 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_btree.c +12 -2
@@ -645,6 +645,17 @@ xfs_btree_ptr_addr( ((char *)block +xfs_btree_ptr_offset (cur, n, level)); } +struct xfs_ifork * +xfs_btree_ifork_ptr ( +struct xfs_btree_cur *cur) +{ +ASSERT (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ); + +if (cur->bc_flags &XFS_BTREE_STAGING ) +return cur->bc_ino.ifake->if_fork; +return XFS_IFORK_PTR (cur->bc_ino.ip, cur->bc_ino.whichfork); +} +/* * Get the root block which is stored in the inode. *
@@ -655,9 +666,8 @@ STATIC struct xfs_btree_block *xfs_btree_get_iroot ( struct xfs_btree_cur *cur) { -struct xfs_ifork *ifp; +struct xfs_ifork *ifp =xfs_btree_ifork_ptr (cur); - ifp =XFS_IFORK_PTR (cur->bc_ino.ip, cur->bc_ino.whichfork);return (struct xfs_btree_block *)ifp->if_broot; }
fs/xfs/libxfs/xfs_btree.h +3 -0
@@ -10,6 +10,7 @@ struct xfs_buf;struct xfs_inode ;struct xfs_mount ;struct xfs_trans ; +struct xfs_ifork ;extern kmem_zone_t *xfs_btree_cur_zone;
@@ -198,6 +199,7 @@ struct xfs_btree_cur_ag {/* Btree-in-inode cursor information */ struct xfs_btree_cur_ino {struct xfs_inode *ip; +struct xbtree_ifakeroot *ifake;/* for staging cursor */ int allocated;short forksize;char whichfork;
@@ -509,6 +511,7 @@ union xfs_btree_key *xfs_btree_high_key_from_key(struct xfs_btree_cur *cur,int xfs_btree_has_record (struct xfs_btree_cur *cur,union xfs_btree_irec *low,union xfs_btree_irec *high,bool *exists);bool xfs_btree_has_more_records (struct xfs_btree_cur *cur); +struct xfs_ifork *xfs_btree_ifork_ptr (struct xfs_btree_cur *cur);/* Does this cursor point to the last block in the given level? */ static inline bool
fs/xfs/libxfs/xfs_btree_staging.c +84 -0
87 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree_staging.h +28 -0
@@ -24,4 +24,32 @@ void xfs_btree_stage_afakeroot(struct xfs_btree_cur *cur,void xfs_btree_commit_afakeroot (struct xfs_btree_cur *cur,struct xfs_trans *tp,struct xfs_buf *agbp,const struct xfs_btree_ops *ops); +/* Fake root for an inode-rooted btree. */ +struct xbtree_ifakeroot { +/* Fake inode fork. */ +struct xfs_ifork *if_fork; + +/* Number of blocks used by the btree. */ +int64_t if_blocks; + +/* Height of the new btree. */ +unsigned int if_levels; + +/* Number of bytes available for this fork in the inode. */ +unsigned int if_fork_size; + +/* Fork format. */ +unsigned int if_format; + +/* Number of records. */ +unsigned int if_extents; +}; + +/* Cursor interactions with with fake roots for inode-rooted btrees. */ +void xfs_btree_stage_ifakeroot (struct xfs_btree_cur *cur, +struct xbtree_ifakeroot *ifake, +struct xfs_btree_ops **new_ops); +void xfs_btree_commit_ifakeroot (struct xfs_btree_cur *cur,struct xfs_trans *tp, +int whichfork,const struct xfs_btree_ops *ops); +#endif /* __XFS_BTREE_STAGING_H__ */
fs/xfs/xfs_trace.h +33 -0
@@ -3633,6 +3633,39 @@ TRACE_EVENT(xfs_btree_commit_afakeroot, __entry->agbno) ) +TRACE_EVENT (xfs_btree_commit_ifakeroot, + TP_PROTO(struct xfs_btree_cur *cur), +TP_ARGS (cur), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_btnum_t, btnum) + __field(xfs_agnumber_t, agno) + __field(xfs_agino_t, agino) + __field(unsigned int, levels) + __field(unsigned int, blocks) +__field (int, whichfork) + ), +TP_fast_assign ( + __entry->dev = cur->bc_mp->m_super->s_dev; + __entry->btnum = cur->bc_btnum; + __entry->agno = XFS_INO_TO_AGNO(cur->bc_mp, + cur->bc_ino.ip->i_ino); + __entry->agino = XFS_INO_TO_AGINO(cur->bc_mp, + cur->bc_ino.ip->i_ino); + __entry->levels = cur->bc_ino.ifake->if_levels; + __entry->blocks = cur->bc_ino.ifake->if_blocks; + __entry->whichfork = cur->bc_ino.whichfork; + ), +TP_printk ("dev %d:%d btree %s ag %u agino %u whichfork %s levels %u blocks %u" , +MAJOR (__entry->dev),MINOR (__entry->dev), +__print_symbolic (__entry->btnum,XFS_BTNUM_STRINGS ), + __entry->agno, + __entry->agino, + __entry->whichfork ==XFS_ATTR_FORK ?"attr" :"data" , + __entry->levels, + __entry->blocks) +) +#endif /* _TRACE_XFS_H */ #undef TRACE_INCLUDE_PATH
PATCH v5 3/7 xfs: support bulk loading of staged btrees
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new btree function that enables us to bulk load a btree cursor. This will be used by the upcoming online repair patches to generate new btrees. This avoids the programmatic inefficiency of calling xfs_btree_insert in a loop (which generates a lot of log traffic) in favor of stamping out new btree blocks with ordered buffers, and then committing both the new root and scheduling the removal of the old btree blocks in a single transaction commit.
The design of this new generic code is based off the btree rebuilding code in xfs_repair's phase 5 code, with the explicit goal of enabling us to share that code between scrub and repair. It has the additional feature of being able to control btree block loading factors.
--- fs/xfs/libxfs/xfs_btree.c | 14 - fs/xfs/libxfs/xfs_btree.h | 16 + fs/xfs/libxfs/xfs_btree_staging.c | 616 +++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_btree_staging.h | 68 ++++ fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 85 +++++ 6 files changed, 793 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_btree.c +7 -7
@@ -1027,7 +1027,7 @@ xfs_btree_ptr_is_null(return ptr->s ==cpu_to_be32 (NULLAGBLOCK ); } -STATIC void +void xfs_btree_set_ptr_null (struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr)
@@ -1063,7 +1063,7 @@ xfs_btree_get_sibling( } } -STATIC void +void xfs_btree_set_sibling( struct xfs_btree_cur *cur, struct xfs_btree_block *block,
@@ -1141,7 +1141,7 @@ xfs_btree_init_block( btnum, level, numrecs, owner, 0); } -STATIC void +void xfs_btree_init_block_cur( struct xfs_btree_cur *cur, struct xfs_buf *bp,
@@ -1233,7 +1233,7 @@ xfs_btree_set_refs( } } -STATIC int +int xfs_btree_get_buf_block( struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr,
@@ -1293,7 +1293,7 @@ xfs_btree_read_buf_block(/* * Copy keys from one btree block to another. */ -STATIC void +void xfs_btree_copy_keys( struct xfs_btree_cur *cur, union xfs_btree_key *dst_key,
@@ -1321,11 +1321,11 @@ xfs_btree_copy_recs(/* * Copy block pointers from one btree block to another. */ -STATIC void +void xfs_btree_copy_ptrs (struct xfs_btree_cur *cur,union xfs_btree_ptr *dst_ptr, -union xfs_btree_ptr *src_ptr, +const union xfs_btree_ptr *src_ptr,int numptrs) {ASSERT (numptrs >=0 );
fs/xfs/libxfs/xfs_btree.h +16 -0
@@ -530,4 +530,20 @@ xfs_btree_islastblock(return block->bb_u.s.bb_rightsib ==cpu_to_be32 (NULLAGBLOCK ); } +void xfs_btree_set_ptr_null (struct xfs_btree_cur *cur, +union xfs_btree_ptr *ptr); +int xfs_btree_get_buf_block (struct xfs_btree_cur *cur,union xfs_btree_ptr *ptr, +struct xfs_btree_block **block,struct xfs_buf **bpp); +void xfs_btree_set_sibling (struct xfs_btree_cur *cur, +struct xfs_btree_block *block,union xfs_btree_ptr *ptr, +int lr); +void xfs_btree_init_block_cur (struct xfs_btree_cur *cur, +struct xfs_buf *bp,int level,int numrecs); +void xfs_btree_copy_ptrs (struct xfs_btree_cur *cur, +union xfs_btree_ptr *dst_ptr, +const union xfs_btree_ptr *src_ptr,int numptrs); +void xfs_btree_copy_keys (struct xfs_btree_cur *cur, +union xfs_btree_key *dst_key,union xfs_btree_key *src_key, +int numkeys); +#endif /* __XFS_BTREE_H__ */
fs/xfs/libxfs/xfs_btree_staging.c +616 -0
619 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree_staging.h +68 -0
72 lines not on this page · raw message
fs/xfs/xfs_trace.c +1 -0
@@ -6,6 +6,7 @@#include "xfs.h" #include "xfs_fs.h" #include "xfs_shared.h" +#include "xfs_bit.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_trace.h +85 -0
97 lines not on this page · raw message
PATCH v5 4/7 xfs: add support for free space btree staging cursors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the free space btrees. This is needed both for online repair and also to convert xfs_repair to use btree bulk loading.
--- fs/xfs/libxfs/xfs_alloc_btree.c | 98 +++++++++++++++++++++++++++++++-------- fs/xfs/libxfs/xfs_alloc_btree.h | 7 +++ 2 files changed, 86 insertions(+), 19 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +79 -19
@@ -12,6 +12,7 @@#include "xfs_sb.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_alloc_btree.h" #include "xfs_alloc.h" #include "xfs_extent_busy.h"
@@ -19,7 +20,6 @@#include "xfs_trace.h" #include "xfs_trans.h" - STATIC struct xfs_btree_cur *xfs_allocbt_dup_cursor (struct xfs_btree_cur *cur)
@@ -471,6 +471,41 @@ static const struct xfs_btree_ops xfs_cntbt_ops = { .recs_inorder = xfs_cntbt_recs_inorder, }; +/* Allocate most of a new allocation btree cursor. */ +STATIC struct xfs_btree_cur * +xfs_allocbt_init_common ( +struct xfs_mount *mp, +struct xfs_trans *tp, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + +ASSERT (btnum ==XFS_BTNUM_BNO || btnum ==XFS_BTNUM_CNT ); + + cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); + + cur->bc_tp = tp; + cur->bc_mp = mp; + cur->bc_btnum = btnum; + cur->bc_blocklog = mp->m_sb.sb_blocklog; + cur->bc_ag.agno = agno; + cur->bc_ag.abt.active = false; + +if (btnum ==XFS_BTNUM_CNT ) { + cur->bc_ops = &xfs_cntbt_ops; + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); + }else { + cur->bc_ops = &xfs_bnobt_ops; + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); + } + +if (xfs_sb_version_hascrc (&mp->m_sb)) + cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; + +return cur; +} +/* * Allocate a new allocation btree cursor. */
@@ -485,36 +520,61 @@ xfs_allocbt_init_cursor(struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur; -ASSERT (btnum ==XFS_BTNUM_BNO || btnum ==XFS_BTNUM_CNT ); - - cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); - - cur->bc_tp = tp; - cur->bc_mp = mp; - cur->bc_btnum = btnum; - cur->bc_blocklog = mp->m_sb.sb_blocklog; - + cur =xfs_allocbt_init_common (mp, tp, agno, btnum);if (btnum ==XFS_BTNUM_CNT ) { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); - cur->bc_ops = &xfs_cntbt_ops; cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_CNT ]); - cur->bc_flags =XFS_BTREE_LASTREC_UPDATE ; + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ; }else { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); - cur->bc_ops = &xfs_bnobt_ops; cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_BNO ]); } cur->bc_ag.agbp = agbp; - cur->bc_ag.agno = agno; - cur->bc_ag.abt.active = false; -if (xfs_sb_version_hascrc (&mp->m_sb)) - cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; +return cur; +} +/* Create a free space btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_allocbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + + cur =xfs_allocbt_init_common (mp,NULL , agno, btnum); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Install a new free space btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_allocbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS ); + +if (cur->bc_btnum ==XFS_BTNUM_BNO ) { +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_bnobt_ops); + }else { + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ; +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_cntbt_ops); + } +} +/* * Calculate number of records in an alloc btree block. */
fs/xfs/libxfs/xfs_alloc_btree.h +7 -0
@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size depends on a superblock flag.
@@ -48,8 +49,14 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_allocbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_allocbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_allocbt_maxrecs (struct xfs_mount *,int ,int );extern xfs_extlen_t xfs_allocbt_calc_size (struct xfs_mount *mp,unsigned long long len); +void xfs_allocbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_ALLOC_BTREE_H__ */
Re: [PATCH 4/7] xfs: add support for free space btree staging cursors
Quoted 17 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the free space btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_alloc_btree.c | 98 +++++++++++++++++++++++++++++++-------- fs/xfs/libxfs/xfs_alloc_btree.h | 7 +++ 2 files changed, 86 insertions(+), 19 deletions(-)fs/xfs/libxfs/xfs_alloc_btree.c +0
-0
...
Quoted 1 line
fs/xfs/libxfs/xfs_alloc_btree.c +0
-0@@ -485,36 +520,61 @@ xfs_allocbt_init_cursor(
...
Quoted 14 lines
fs/xfs/libxfs/xfs_alloc_btree.c +13
-0+/* +* Install a new free space btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_allocbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; +
fs/xfs/libxfs/xfs_alloc_btree.c xfs_allocbt_init_cursor( · line 573
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc_btree.c +10
-0+ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS ); + +if (cur->bc_btnum ==XFS_BTNUM_BNO ) { +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_bnobt_ops); + }else { + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ;
Any reason this is set here and not at init time for the staging cursor?
Brian
Quoted 35 lines
fs/xfs/libxfs/xfs_alloc_btree.c +4
-0+xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_cntbt_ops); + } +} +/* * Calculate number of records in an alloc btree block. */ fs/xfs/libxfs/xfs_alloc_btree.h +7
-0@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size depends on a superblock flag. @@ -48,8 +49,14 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_allocbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_allocbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_allocbt_maxrecs (struct xfs_mount *,int ,int );extern xfs_extlen_t xfs_allocbt_calc_size (struct xfs_mount *mp,unsigned long long len); +void xfs_allocbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_ALLOC_BTREE_H__ */
Re: [PATCH 4/7] xfs: add support for free space btree staging cursors
Quoted 39 lines · Brian Foster
Quoted 17 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the free space btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_alloc_btree.c | 98 +++++++++++++++++++++++++++++++-------- fs/xfs/libxfs/xfs_alloc_btree.h | 7 +++ 2 files changed, 86 insertions(+), 19 deletions(-)fs/xfs/libxfs/xfs_alloc_btree.c +0
-0...
Quoted 1 line
fs/xfs/libxfs/xfs_alloc_btree.c +0
-0@@ -485,36 +520,61 @@ xfs_allocbt_init_cursor(...
Quoted 18 lines
fs/xfs/libxfs/xfs_alloc_btree.c +17
-0+/* +* Install a new free space btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_allocbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels);
Quoted 8 lines
fs/xfs/libxfs/xfs_alloc_btree.c xfs_allocbt_init_cursor( · line 573
Quoted 6 lines
fs/xfs/libxfs/xfs_alloc_btree.c +6
-0+xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS ); + +if (cur->bc_btnum ==XFS_BTNUM_BNO ) { +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_bnobt_ops); + }else { + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ;Any reason this is set here and not at init time for the staging cursor?
Originally it was so that ->update_lastrec couldn't get called, but since you're not supposed to be calling the regular btree operations anyway I suppose it doesn't matter if the flag is set in staging cursors... will fix.
--D
Quoted 38 lines
Brian
Quoted 35 lines
fs/xfs/libxfs/xfs_alloc_btree.c +4
-0+xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_cntbt_ops); + } +} +/* * Calculate number of records in an alloc btree block. */ fs/xfs/libxfs/xfs_alloc_btree.h +7
-0@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size depends on a superblock flag. @@ -48,8 +49,14 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_allocbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_allocbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_allocbt_maxrecs (struct xfs_mount *,int ,int );extern xfs_extlen_t xfs_allocbt_calc_size (struct xfs_mount *mp,unsigned long long len); +void xfs_allocbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_ALLOC_BTREE_H__ */
PATCH v2 4/7 xfs: add support for free space btree staging cursors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the free space btrees. This is needed both for online repair and also to convert xfs_repair to use btree bulk loading.
---
v2: leave the LASTREC_UPDATE flag setting alone
--- fs/xfs/libxfs/xfs_alloc_btree.c | 93 ++++++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_alloc_btree.h | 7 +++ 2 files changed, 84 insertions(+), 16 deletions(-)
fs/xfs/libxfs/xfs_alloc_btree.c +77 -16
@@ -12,6 +12,7 @@#include "xfs_sb.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_alloc_btree.h" #include "xfs_alloc.h" #include "xfs_extent_busy.h"
@@ -471,18 +472,14 @@ static const struct xfs_btree_ops xfs_cntbt_ops = { .recs_inorder = xfs_cntbt_recs_inorder, }; -/* -* Allocate a new allocation btree cursor. -*/ -struct xfs_btree_cur */* new alloc btree cursor */ -xfs_allocbt_init_cursor ( -struct xfs_mount *mp,/* file system mount point */ -struct xfs_trans *tp,/* transaction pointer */ -struct xfs_buf *agbp,/* buffer for agf structure */ -xfs_agnumber_t agno,/* allocation group number */ -xfs_btnum_t btnum)/* btree identifier */ +/* Allocate most of a new allocation btree cursor. */ +STATIC struct xfs_btree_cur * +xfs_allocbt_init_common ( +struct xfs_mount *mp, +struct xfs_trans *tp, +xfs_agnumber_t agno, +xfs_btnum_t btnum) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur;ASSERT (btnum ==XFS_BTNUM_BNO || btnum ==XFS_BTNUM_CNT );
@@ -495,17 +492,14 @@ xfs_allocbt_init_cursor( cur->bc_blocklog = mp->m_sb.sb_blocklog;if (btnum ==XFS_BTNUM_CNT ) { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); cur->bc_ops = &xfs_cntbt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_CNT ]); + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); cur->bc_flags =XFS_BTREE_LASTREC_UPDATE ; }else { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); cur->bc_ops = &xfs_bnobt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_BNO ]); + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); } - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; cur->bc_ag.abt.active = false;
@@ -515,6 +509,73 @@ xfs_allocbt_init_cursor(return cur; } +/* +* Allocate a new allocation btree cursor. +*/ +struct xfs_btree_cur */* new alloc btree cursor */ +xfs_allocbt_init_cursor ( +struct xfs_mount *mp,/* file system mount point */ +struct xfs_trans *tp,/* transaction pointer */ +struct xfs_buf *agbp,/* buffer for agf structure */ +xfs_agnumber_t agno,/* allocation group number */ +xfs_btnum_t btnum)/* btree identifier */ +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_allocbt_init_common (mp, tp, agno, btnum); +if (btnum ==XFS_BTNUM_CNT ) + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_CNT ]); +else + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_BNO ]); + + cur->bc_ag.agbp = agbp; + +return cur; +} + +/* Create a free space btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_allocbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + + cur =xfs_allocbt_init_common (mp,NULL , agno, btnum); +xfs_btree_stage_afakeroot (cur, afake); +return cur; +} + +/* +* Install a new free space btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_allocbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS ); + +if (cur->bc_btnum ==XFS_BTNUM_BNO ) { +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_bnobt_ops); + }else { + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ; +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_cntbt_ops); + } +} +/* * Calculate number of records in an alloc btree block. */
fs/xfs/libxfs/xfs_alloc_btree.h +7 -0
@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size depends on a superblock flag.
@@ -48,8 +49,14 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_allocbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_allocbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_allocbt_maxrecs (struct xfs_mount *,int ,int );extern xfs_extlen_t xfs_allocbt_calc_size (struct xfs_mount *mp,unsigned long long len); +void xfs_allocbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_ALLOC_BTREE_H__ */
Re: [PATCH v2 4/7] xfs: add support for free space btree staging cursors
Quoted 10 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the free space btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>---
v2: leave theLASTREC_UPDATEflag setting alone
---
Quoted 164 lines
fs/xfs/libxfs/xfs_alloc_btree.c | 93 ++++++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_alloc_btree.h | 7 +++ 2 files changed, 84 insertions(+), 16 deletions(-)fs/xfs/libxfs/xfs_alloc_btree.c +77
-16@@ -12,6 +12,7 @@#include "xfs_sb.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_alloc_btree.h" #include "xfs_alloc.h" #include "xfs_extent_busy.h" @@ -471,18 +472,14 @@ static const struct xfs_btree_ops xfs_cntbt_ops = { .recs_inorder = xfs_cntbt_recs_inorder, }; -/* -* Allocate a new allocation btree cursor. -*/ -struct xfs_btree_cur */* new alloc btree cursor */ -xfs_allocbt_init_cursor ( -struct xfs_mount *mp,/* file system mount point */ -struct xfs_trans *tp,/* transaction pointer */ -struct xfs_buf *agbp,/* buffer for agf structure */ -xfs_agnumber_t agno,/* allocation group number */ -xfs_btnum_t btnum)/* btree identifier */ +/* Allocate most of a new allocation btree cursor. */ +STATIC struct xfs_btree_cur * +xfs_allocbt_init_common ( +struct xfs_mount *mp, +struct xfs_trans *tp, +xfs_agnumber_t agno, +xfs_btnum_t btnum) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur;ASSERT (btnum ==XFS_BTNUM_BNO || btnum ==XFS_BTNUM_CNT );@@ -495,17 +492,14 @@ xfs_allocbt_init_cursor( cur->bc_blocklog = mp->m_sb.sb_blocklog;if (btnum ==XFS_BTNUM_CNT ) { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); cur->bc_ops = &xfs_cntbt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_CNT ]); + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtc_2); cur->bc_flags =XFS_BTREE_LASTREC_UPDATE ; }else { - cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); cur->bc_ops = &xfs_bnobt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_BNO ]); + cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_abtb_2); } - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; cur->bc_ag.abt.active = false;@@ -515,6 +509,73 @@ xfs_allocbt_init_cursor(return cur; } +/* +* Allocate a new allocation btree cursor. +*/ +struct xfs_btree_cur */* new alloc btree cursor */ +xfs_allocbt_init_cursor ( +struct xfs_mount *mp,/* file system mount point */ +struct xfs_trans *tp,/* transaction pointer */ +struct xfs_buf *agbp,/* buffer for agf structure */ +xfs_agnumber_t agno,/* allocation group number */ +xfs_btnum_t btnum)/* btree identifier */ +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_allocbt_init_common (mp, tp, agno, btnum); +if (btnum ==XFS_BTNUM_CNT ) + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_CNT ]); +else + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_BNO ]); + + cur->bc_ag.agbp = agbp; + +return cur; +} + +/* Create a free space btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_allocbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + + cur =xfs_allocbt_init_common (mp,NULL , agno, btnum); +xfs_btree_stage_afakeroot (cur, afake); +return cur; +} + +/* +* Install a new free space btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_allocbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS ); + +if (cur->bc_btnum ==XFS_BTNUM_BNO ) { +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_bnobt_ops); + }else { + cur->bc_flags |=XFS_BTREE_LASTREC_UPDATE ; +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_cntbt_ops); + } +} +/* * Calculate number of records in an alloc btree block. */ fs/xfs/libxfs/xfs_alloc_btree.h +7
-0@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size depends on a superblock flag. @@ -48,8 +49,14 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_allocbt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_allocbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_allocbt_maxrecs (struct xfs_mount *,int ,int );extern xfs_extlen_t xfs_allocbt_calc_size (struct xfs_mount *mp,unsigned long long len); +void xfs_allocbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_ALLOC_BTREE_H__ */
PATCH v5 5/7 xfs: add support for inode btree staging cursors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the inode btrees. This is needed both for online repair and also to convert xfs_repair to use btree bulk loading.
--- fs/xfs/libxfs/xfs_ialloc_btree.c | 82 ++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_ialloc_btree.h | 6 +++ 2 files changed, 76 insertions(+), 12 deletions(-)
fs/xfs/libxfs/xfs_ialloc_btree.c +70 -12
@@ -12,6 +12,7 @@#include "xfs_bit.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_ialloc.h" #include "xfs_ialloc_btree.h" #include "xfs_alloc.h"
@@ -20,7 +21,6 @@#include "xfs_trans.h" #include "xfs_rmap.h" - STATIC int xfs_inobt_get_minrecs( struct xfs_btree_cur *cur,
@@ -400,32 +400,27 @@ static const struct xfs_btree_ops xfs_finobt_ops = { };/* -* Allocate a new inode btree cursor. +* Initialize a new inode btree cursor. */ -struct xfs_btree_cur */* new inode btree cursor */ -xfs_inobt_init_cursor ( +static struct xfs_btree_cur * +xfs_inobt_init_common (struct xfs_mount *mp,/* file system mount point */ struct xfs_trans *tp,/* transaction pointer */ -struct xfs_buf *agbp,/* buffer for agi structure */ xfs_agnumber_t agno,/* allocation group number */ xfs_btnum_t btnum)/* ialloc or free ino btree */ { -struct xfs_agi *agi = agbp->b_addr;struct xfs_btree_cur *cur; cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); - cur->bc_tp = tp; cur->bc_mp = mp; cur->bc_btnum = btnum;if (btnum ==XFS_BTNUM_INO ) { - cur->bc_nlevels =be32_to_cpu (agi->agi_level); - cur->bc_ops = &xfs_inobt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_ibt_2); + cur->bc_ops = &xfs_inobt_ops; }else { - cur->bc_nlevels =be32_to_cpu (agi->agi_free_level); - cur->bc_ops = &xfs_finobt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_fibt_2); + cur->bc_ops = &xfs_finobt_ops; } cur->bc_blocklog = mp->m_sb.sb_blocklog;
@@ -433,12 +428,75 @@ xfs_inobt_init_cursor(if (xfs_sb_version_hascrc (&mp->m_sb)) cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; +return cur; +} + +/* Create an inode btree cursor. */ +struct xfs_btree_cur * +xfs_inobt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; +struct xfs_agi *agi = agbp->b_addr; + + cur =xfs_inobt_init_common (mp, tp, agno, btnum); +if (btnum ==XFS_BTNUM_INO ) + cur->bc_nlevels =be32_to_cpu (agi->agi_level); +else + cur->bc_nlevels =be32_to_cpu (agi->agi_free_level); + cur->bc_ag.agbp = agbp; +return cur; +} +/* Create an inode btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_inobt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + + cur =xfs_inobt_init_common (mp,NULL , agno, btnum); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Install a new inobt btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_inobt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agi *agi = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + +if (cur->bc_btnum ==XFS_BTNUM_INO ) { + agi->agi_root =cpu_to_be32 (afake->af_root); + agi->agi_level =cpu_to_be32 (afake->af_levels); +xfs_ialloc_log_agi (tp, agbp,XFS_AGI_ROOT |XFS_AGI_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_inobt_ops); + }else { + agi->agi_free_root =cpu_to_be32 (afake->af_root); + agi->agi_free_level =cpu_to_be32 (afake->af_levels); +xfs_ialloc_log_agi (tp, agbp,XFS_AGI_FREE_ROOT | +XFS_AGI_FREE_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_finobt_ops); + } +} +/* * Calculate number of records in an inobt btree block. */
fs/xfs/libxfs/xfs_ialloc_btree.h +6 -0
@@ -48,6 +48,9 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_inobt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_inobt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_inobt_maxrecs (struct xfs_mount *,int ,int );/* ir_holemask to inode allocation bitmap conversion */
@@ -68,4 +71,7 @@ int xfs_inobt_cur(struct xfs_mount *mp, struct xfs_trans *tp, xfs_agnumber_t agno, xfs_btnum_t btnum, struct xfs_btree_cur **curpp, struct xfs_buf **agi_bpp); +void xfs_inobt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_IALLOC_BTREE_H__ */
Re: [PATCH 5/7] xfs: add support for inode btree staging cursors
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the inode btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>---
Quoted 163 lines
fs/xfs/libxfs/xfs_ialloc_btree.c | 82 ++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_ialloc_btree.h | 6 +++ 2 files changed, 76 insertions(+), 12 deletions(-)fs/xfs/libxfs/xfs_ialloc_btree.c +70
-12@@ -12,6 +12,7 @@#include "xfs_bit.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_ialloc.h" #include "xfs_ialloc_btree.h" #include "xfs_alloc.h" @@ -20,7 +21,6 @@#include "xfs_trans.h" #include "xfs_rmap.h" - STATIC int xfs_inobt_get_minrecs( struct xfs_btree_cur *cur,@@ -400,32 +400,27 @@ static const struct xfs_btree_ops xfs_finobt_ops = { };/* -* Allocate a new inode btree cursor. +* Initialize a new inode btree cursor. */ -struct xfs_btree_cur */* new inode btree cursor */ -xfs_inobt_init_cursor ( +static struct xfs_btree_cur * +xfs_inobt_init_common (struct xfs_mount *mp,/* file system mount point */ struct xfs_trans *tp,/* transaction pointer */ -struct xfs_buf *agbp,/* buffer for agi structure */ xfs_agnumber_t agno,/* allocation group number */ xfs_btnum_t btnum)/* ialloc or free ino btree */ { -struct xfs_agi *agi = agbp->b_addr;struct xfs_btree_cur *cur; cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); - cur->bc_tp = tp; cur->bc_mp = mp; cur->bc_btnum = btnum;if (btnum ==XFS_BTNUM_INO ) { - cur->bc_nlevels =be32_to_cpu (agi->agi_level); - cur->bc_ops = &xfs_inobt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_ibt_2); + cur->bc_ops = &xfs_inobt_ops; }else { - cur->bc_nlevels =be32_to_cpu (agi->agi_free_level); - cur->bc_ops = &xfs_finobt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_fibt_2); + cur->bc_ops = &xfs_finobt_ops; } cur->bc_blocklog = mp->m_sb.sb_blocklog;@@ -433,12 +428,75 @@ xfs_inobt_init_cursor(if (xfs_sb_version_hascrc (&mp->m_sb)) cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; +return cur; +} + +/* Create an inode btree cursor. */ +struct xfs_btree_cur * +xfs_inobt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; +struct xfs_agi *agi = agbp->b_addr; + + cur =xfs_inobt_init_common (mp, tp, agno, btnum); +if (btnum ==XFS_BTNUM_INO ) + cur->bc_nlevels =be32_to_cpu (agi->agi_level); +else + cur->bc_nlevels =be32_to_cpu (agi->agi_free_level); + cur->bc_ag.agbp = agbp; +return cur; +} +/* Create an inode btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_inobt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno, +xfs_btnum_t btnum) +{ +struct xfs_btree_cur *cur; + + cur =xfs_inobt_init_common (mp,NULL , agno, btnum); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Install a new inobt btree root. Caller is responsible for invalidating +* and freeing the old btree blocks. +*/ +void +xfs_inobt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agi *agi = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + +if (cur->bc_btnum ==XFS_BTNUM_INO ) { + agi->agi_root =cpu_to_be32 (afake->af_root); + agi->agi_level =cpu_to_be32 (afake->af_levels); +xfs_ialloc_log_agi (tp, agbp,XFS_AGI_ROOT |XFS_AGI_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_inobt_ops); + }else { + agi->agi_free_root =cpu_to_be32 (afake->af_root); + agi->agi_free_level =cpu_to_be32 (afake->af_levels); +xfs_ialloc_log_agi (tp, agbp,XFS_AGI_FREE_ROOT | +XFS_AGI_FREE_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_finobt_ops); + } +} +/* * Calculate number of records in an inobt btree block. */ fs/xfs/libxfs/xfs_ialloc_btree.h +6
-0@@ -48,6 +48,9 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_inobt_init_cursor (struct xfs_mount *,struct xfs_trans *,struct xfs_buf *,xfs_agnumber_t ,xfs_btnum_t ); +struct xfs_btree_cur *xfs_inobt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno, +xfs_btnum_t btnum);extern int xfs_inobt_maxrecs (struct xfs_mount *,int ,int );/* ir_holemask to inode allocation bitmap conversion */ @@ -68,4 +71,7 @@ int xfs_inobt_cur(struct xfs_mount *mp, struct xfs_trans *tp, xfs_agnumber_t agno, xfs_btnum_t btnum, struct xfs_btree_cur **curpp, struct xfs_buf **agi_bpp); +void xfs_inobt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_IALLOC_BTREE_H__ */
PATCH v5 6/7 xfs: add support for refcount btree staging cursors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the refcount btrees. This is needed both for online repair and also to convert xfs_repair to use btree bulk loading.
--- fs/xfs/libxfs/xfs_refcount_btree.c | 70 +++++++++++++++++++++++++++++++----- fs/xfs/libxfs/xfs_refcount_btree.h | 6 +++ 2 files changed, 66 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_refcount_btree.c +60 -10
@@ -12,6 +12,7 @@#include "xfs_sb.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_refcount_btree.h" #include "xfs_alloc.h" #include "xfs_error.h"
@@ -311,41 +312,90 @@ static const struct xfs_btree_ops xfs_refcountbt_ops = { };/* -* Allocate a new refcount btree cursor. +* Initialize a new refcount btree cursor. */ -struct xfs_btree_cur * -xfs_refcountbt_init_cursor ( +static struct xfs_btree_cur * +xfs_refcountbt_init_common (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_buf *agbp,xfs_agnumber_t agno) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur;ASSERT (agno !=NULLAGNUMBER );ASSERT (agno < mp->m_sb.sb_agcount); - cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); + cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); cur->bc_tp = tp; cur->bc_mp = mp; cur->bc_btnum =XFS_BTNUM_REFC ; cur->bc_blocklog = mp->m_sb.sb_blocklog; - cur->bc_ops = &xfs_refcountbt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_refcbt_2); - cur->bc_nlevels =be32_to_cpu (agf->agf_refcount_level); - - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; cur->bc_ag.refc.nr_ops =0 ; cur->bc_ag.refc.shape_changes =0 ; + cur->bc_ops = &xfs_refcountbt_ops; +return cur; +} + +/* Create a btree cursor. */ +struct xfs_btree_cur * +xfs_refcountbt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_refcountbt_init_common (mp, tp, agno); + cur->bc_nlevels =be32_to_cpu (agf->agf_refcount_level); + cur->bc_ag.agbp = agbp; +return cur; +} + +/* Create a btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_refcountbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno) +{ +struct xfs_btree_cur *cur; + cur =xfs_refcountbt_init_common (mp,NULL , agno); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Swap in the new btree root. Once we pass this point the newly rebuilt btree +* is in place and we have to kill off all the old btree blocks. +*/ +void +xfs_refcountbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_refcount_root =cpu_to_be32 (afake->af_root); + agf->agf_refcount_level =cpu_to_be32 (afake->af_levels); + agf->agf_refcount_blocks =cpu_to_be32 (afake->af_blocks); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_REFCOUNT_BLOCKS | +XFS_AGF_REFCOUNT_ROOT | +XFS_AGF_REFCOUNT_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_refcountbt_ops); +} +/* * Calculate the number of records in a refcount btree block. */
fs/xfs/libxfs/xfs_refcount_btree.h +6 -0
@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size
@@ -46,6 +47,8 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_refcountbt_init_cursor (struct xfs_mount *mp,struct xfs_trans *tp,struct xfs_buf *agbp,xfs_agnumber_t agno); +struct xfs_btree_cur *xfs_refcountbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno);extern int xfs_refcountbt_maxrecs (int blocklen,bool leaf);extern void xfs_refcountbt_compute_maxlevels (struct xfs_mount *mp);
@@ -58,4 +61,7 @@ extern int xfs_refcountbt_calc_reserves(struct xfs_mount *mp, struct xfs_trans *tp, xfs_agnumber_t agno, xfs_extlen_t *ask, xfs_extlen_t *used); +void xfs_refcountbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_REFCOUNT_BTREE_H__ */
Re: [PATCH 6/7] xfs: add support for refcount btree staging cursors
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the refcount btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>---
Quoted 148 lines
fs/xfs/libxfs/xfs_refcount_btree.c | 70 +++++++++++++++++++++++++++++++----- fs/xfs/libxfs/xfs_refcount_btree.h | 6 +++ 2 files changed, 66 insertions(+), 10 deletions(-)fs/xfs/libxfs/xfs_refcount_btree.c +60
-10@@ -12,6 +12,7 @@#include "xfs_sb.h" #include "xfs_mount.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_refcount_btree.h" #include "xfs_alloc.h" #include "xfs_error.h" @@ -311,41 +312,90 @@ static const struct xfs_btree_ops xfs_refcountbt_ops = { };/* -* Allocate a new refcount btree cursor. +* Initialize a new refcount btree cursor. */ -struct xfs_btree_cur * -xfs_refcountbt_init_cursor ( +static struct xfs_btree_cur * +xfs_refcountbt_init_common (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_buf *agbp,xfs_agnumber_t agno) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur;ASSERT (agno !=NULLAGNUMBER );ASSERT (agno < mp->m_sb.sb_agcount); - cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); + cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS ); cur->bc_tp = tp; cur->bc_mp = mp; cur->bc_btnum =XFS_BTNUM_REFC ; cur->bc_blocklog = mp->m_sb.sb_blocklog; - cur->bc_ops = &xfs_refcountbt_ops; cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_refcbt_2); - cur->bc_nlevels =be32_to_cpu (agf->agf_refcount_level); - - cur->bc_ag.agbp = agbp; cur->bc_ag.agno = agno; cur->bc_flags |=XFS_BTREE_CRC_BLOCKS ; cur->bc_ag.refc.nr_ops =0 ; cur->bc_ag.refc.shape_changes =0 ; + cur->bc_ops = &xfs_refcountbt_ops; +return cur; +} + +/* Create a btree cursor. */ +struct xfs_btree_cur * +xfs_refcountbt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_refcountbt_init_common (mp, tp, agno); + cur->bc_nlevels =be32_to_cpu (agf->agf_refcount_level); + cur->bc_ag.agbp = agbp; +return cur; +} + +/* Create a btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_refcountbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno) +{ +struct xfs_btree_cur *cur; + cur =xfs_refcountbt_init_common (mp,NULL , agno); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Swap in the new btree root. Once we pass this point the newly rebuilt btree +* is in place and we have to kill off all the old btree blocks. +*/ +void +xfs_refcountbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_refcount_root =cpu_to_be32 (afake->af_root); + agf->agf_refcount_level =cpu_to_be32 (afake->af_levels); + agf->agf_refcount_blocks =cpu_to_be32 (afake->af_blocks); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_REFCOUNT_BLOCKS | +XFS_AGF_REFCOUNT_ROOT | +XFS_AGF_REFCOUNT_LEVEL ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_refcountbt_ops); +} +/* * Calculate the number of records in a refcount btree block. */ fs/xfs/libxfs/xfs_refcount_btree.h +6
-0@@ -13,6 +13,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* * Btree block header size @@ -46,6 +47,8 @@ struct xfs_mount;extern struct xfs_btree_cur *xfs_refcountbt_init_cursor (struct xfs_mount *mp,struct xfs_trans *tp,struct xfs_buf *agbp,xfs_agnumber_t agno); +struct xfs_btree_cur *xfs_refcountbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno);extern int xfs_refcountbt_maxrecs (int blocklen,bool leaf);extern void xfs_refcountbt_compute_maxlevels (struct xfs_mount *mp);@@ -58,4 +61,7 @@ extern int xfs_refcountbt_calc_reserves(struct xfs_mount *mp, struct xfs_trans *tp, xfs_agnumber_t agno, xfs_extlen_t *ask, xfs_extlen_t *used); +void xfs_refcountbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp); +#endif /* __XFS_REFCOUNT_BTREE_H__ */
PATCH v5 7/7 xfs: add support for rmap btree staging cursors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the rmap btrees. This is needed both for online repair and also to convert xfs_repair to use btree bulk loading.
--- fs/xfs/libxfs/xfs_rmap_btree.c | 67 ++++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_rmap_btree.h | 5 +++ 2 files changed, 62 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_rmap_btree.c +57 -10
@@ -14,6 +14,7 @@#include "xfs_trans.h" #include "xfs_alloc.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_rmap.h" #include "xfs_rmap_btree.h" #include "xfs_trace.h"
@@ -448,17 +449,12 @@ static const struct xfs_btree_ops xfs_rmapbt_ops = { .recs_inorder = xfs_rmapbt_recs_inorder, }; -/* -* Allocate a new allocation btree cursor. -*/ -struct xfs_btree_cur * -xfs_rmapbt_init_cursor ( +static struct xfs_btree_cur * +xfs_rmapbt_init_common (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_buf *agbp,xfs_agnumber_t agno) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur; cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS );
@@ -468,16 +464,67 @@ xfs_rmapbt_init_cursor( cur->bc_btnum =XFS_BTNUM_RMAP ; cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING ; cur->bc_blocklog = mp->m_sb.sb_blocklog; - cur->bc_ops = &xfs_rmapbt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAP ]); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); + cur->bc_ag.agno = agno; + cur->bc_ops = &xfs_rmapbt_ops; +return cur; +} + +/* Create a new reverse mapping btree cursor. */ +struct xfs_btree_cur * +xfs_rmapbt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_rmapbt_init_common (mp, tp, agno); + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAP ]); cur->bc_ag.agbp = agbp; - cur->bc_ag.agno = agno; +return cur; +} + +/* Create a new reverse mapping btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_rmapbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno) +{ +struct xfs_btree_cur *cur; + cur =xfs_rmapbt_init_common (mp,NULL , agno); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Install a new reverse mapping btree root. Caller is responsible for +* invalidating and freeing the old btree blocks. +*/ +void +xfs_rmapbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); + agf->agf_rmap_blocks =cpu_to_be32 (afake->af_blocks); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS | +XFS_AGF_RMAP_BLOCKS ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_rmapbt_ops); +} +/* * Calculate number of records in an rmap btree block. */
fs/xfs/libxfs/xfs_rmap_btree.h +5 -0
@@ -9,6 +9,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* rmaps only exist on crc enabled filesystems */ #define XFS_RMAP_BLOCK_LEN XFS_BTREE_SBLOCK_CRC_LEN
@@ -43,6 +44,10 @@ struct xfs_mount;struct xfs_btree_cur *xfs_rmapbt_init_cursor (struct xfs_mount *mp,struct xfs_trans *tp,struct xfs_buf *bp,xfs_agnumber_t agno); +struct xfs_btree_cur *xfs_rmapbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno); +void xfs_rmapbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp);int xfs_rmapbt_maxrecs (int blocklen,int leaf);extern void xfs_rmapbt_compute_maxlevels (struct xfs_mount *mp);
Re: [PATCH 7/7] xfs: add support for rmap btree staging cursors
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Add support for btree staging cursors for the rmap btrees. This is needed both for online repair and also to convert
xfs_repairto use btree bulk loading.Signed-off-by Darrick J. Wong <[email protected]>---
Quoted 132 lines
fs/xfs/libxfs/xfs_rmap_btree.c | 67 ++++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_rmap_btree.h | 5 +++ 2 files changed, 62 insertions(+), 10 deletions(-)fs/xfs/libxfs/xfs_rmap_btree.c +57
-10@@ -14,6 +14,7 @@#include "xfs_trans.h" #include "xfs_alloc.h" #include "xfs_btree.h" +#include "xfs_btree_staging.h" #include "xfs_rmap.h" #include "xfs_rmap_btree.h" #include "xfs_trace.h" @@ -448,17 +449,12 @@ static const struct xfs_btree_ops xfs_rmapbt_ops = { .recs_inorder = xfs_rmapbt_recs_inorder, }; -/* -* Allocate a new allocation btree cursor. -*/ -struct xfs_btree_cur * -xfs_rmapbt_init_cursor ( +static struct xfs_btree_cur * +xfs_rmapbt_init_common (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_buf *agbp,xfs_agnumber_t agno) { -struct xfs_agf *agf = agbp->b_addr;struct xfs_btree_cur *cur; cur =kmem_zone_zalloc (xfs_btree_cur_zone,KM_NOFS );@@ -468,16 +464,67 @@ xfs_rmapbt_init_cursor( cur->bc_btnum =XFS_BTNUM_RMAP ; cur->bc_flags =XFS_BTREE_CRC_BLOCKS |XFS_BTREE_OVERLAPPING ; cur->bc_blocklog = mp->m_sb.sb_blocklog; - cur->bc_ops = &xfs_rmapbt_ops; - cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAP ]); cur->bc_statoff =XFS_STATS_CALC_INDEX (xs_rmap_2); + cur->bc_ag.agno = agno; + cur->bc_ops = &xfs_rmapbt_ops; +return cur; +} + +/* Create a new reverse mapping btree cursor. */ +struct xfs_btree_cur * +xfs_rmapbt_init_cursor ( +struct xfs_mount *mp, +struct xfs_trans *tp, +struct xfs_buf *agbp, +xfs_agnumber_t agno) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xfs_btree_cur *cur; + + cur =xfs_rmapbt_init_common (mp, tp, agno); + cur->bc_nlevels =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAP ]); cur->bc_ag.agbp = agbp; - cur->bc_ag.agno = agno; +return cur; +} + +/* Create a new reverse mapping btree cursor with a fake root for staging. */ +struct xfs_btree_cur * +xfs_rmapbt_stage_cursor ( +struct xfs_mount *mp, +struct xbtree_afakeroot *afake, +xfs_agnumber_t agno) +{ +struct xfs_btree_cur *cur; + cur =xfs_rmapbt_init_common (mp,NULL , agno); +xfs_btree_stage_afakeroot (cur, afake);return cur; } +/* +* Install a new reverse mapping btree root. Caller is responsible for +* invalidating and freeing the old btree blocks. +*/ +void +xfs_rmapbt_commit_staged_btree ( +struct xfs_btree_cur *cur, +struct xfs_trans *tp, +struct xfs_buf *agbp) +{ +struct xfs_agf *agf = agbp->b_addr; +struct xbtree_afakeroot *afake = cur->bc_ag.afake; + +ASSERT (cur->bc_flags &XFS_BTREE_STAGING ); + + agf->agf_roots[cur->bc_btnum] =cpu_to_be32 (afake->af_root); + agf->agf_levels[cur->bc_btnum] =cpu_to_be32 (afake->af_levels); + agf->agf_rmap_blocks =cpu_to_be32 (afake->af_blocks); +xfs_alloc_log_agf (tp, agbp,XFS_AGF_ROOTS |XFS_AGF_LEVELS | +XFS_AGF_RMAP_BLOCKS ); +xfs_btree_commit_afakeroot (cur, tp, agbp, &xfs_rmapbt_ops); +} +/* * Calculate number of records in an rmap btree block. */ fs/xfs/libxfs/xfs_rmap_btree.h +5
-0@@ -9,6 +9,7 @@struct xfs_buf ;struct xfs_btree_cur ;struct xfs_mount ; +struct xbtree_afakeroot ;/* rmaps only exist on crc enabled filesystems */ #define XFS_RMAP_BLOCK_LEN XFS_BTREE_SBLOCK_CRC_LEN@@ -43,6 +44,10 @@ struct xfs_mount;struct xfs_btree_cur *xfs_rmapbt_init_cursor (struct xfs_mount *mp,struct xfs_trans *tp,struct xfs_buf *bp,xfs_agnumber_t agno); +struct xfs_btree_cur *xfs_rmapbt_stage_cursor (struct xfs_mount *mp, +struct xbtree_afakeroot *afake,xfs_agnumber_t agno); +void xfs_rmapbt_commit_staged_btree (struct xfs_btree_cur *cur, +struct xfs_trans *tp,struct xfs_buf *agbp);int xfs_rmapbt_maxrecs (int blocklen,int leaf);extern void xfs_rmapbt_compute_maxlevels (struct xfs_mount *mp);