: xfs: realtime units cleanups
Hi everyone,
Christoph asked if I could resend the realtime space units cleanups that I mentioned earlier in [1]. The realtime modernization project is stuck deep in my dev branch behind the online repair series. For my own sanity I'm leaving them coupled together in djwong-dev instead of splitting them and trying to keep the two branches in sync.
Anyway, here's an RFC of the rt cleanups; if this somehow gets merged before online repair, I'll separate the fs/xfs/scrub/ diffs.
(Please please let's all help dchinner and cem have time and brainpower to review the online repair patchsets.)
--D
[1] https://lore.kernel.org/linux-xfs/20230918153848.GA348018@frogsfrogsfrogs/
cover xfs: minor bugfixes for rt stuff
Hi all,
This is a preparatory patchset that fixes a few miscellaneous bugs before we start in on larger cleanups of realtime units usage.
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-fixes
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=realtime-fixes
--- fs/xfs/libxfs/xfs_sb.h | 2 +- fs/xfs/xfs_rtalloc.c | 2 +- fs/xfs/xfs_rtalloc.h | 24 ++++++++++++------------ 3 files changed, 14 insertions(+), 14 deletions(-)
PATCH 1/3 xfs: bump max fsgeom struct version
From: Darrick J. Wong <[email protected]>
The latest version of the fs geometry structure is v5.
--- fs/xfs/libxfs/xfs_sb.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/libxfs/xfs_sb.h +1 -1
@@ -25,7 +25,7 @@ extern uint64_t xfs_sb_version_to_features(struct xfs_sb *sbp);extern int xfs_update_secondary_sbs (struct xfs_mount *mp); -#define XFS_FS_GEOM_MAX_STRUCT_VER (4) +#define XFS_FS_GEOM_MAX_STRUCT_VER (5)extern void xfs_fs_geometry (struct xfs_mount *mp,struct xfs_fsop_geom *geo,int struct_version); extern int xfs_sb_read_secondary(struct xfs_mount *mp,
Re: [PATCH 1/3] xfs: bump max fsgeom struct version
Quoted 3 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
The latest version of the fs geometry structure is v5.
The commit log and change left me a little confused, having it in a RT series even more. So I went out and tried to understand it:
- the fsgeom struct version is used by xfs_fs_geometry
- XFS_FS_GEOM_MAX_STRUCT_VER is not used in the kernel at all, but libxfs uses it to always query all information in db and mkfs
- commit 1b6d968de22bffd added the v5 structure, which mostly contains extra padding, but otherwise just reports the struct version for now
So this commit is a no-op for the kernel, and mostly a no-op for userspace as nothing looks at the new field, but probably useful for later changes.
Maybe capture this in the commit log.
With that:
Re: [PATCH 1/3] xfs: bump max fsgeom struct version
Quoted 16 lines · Christoph Hellwig
Quoted 3 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
The latest version of the fs geometry structure is v5.
The commit log and change left me a little confused, having it in a RT series even more. So I went out and tried to understand it:
- the fsgeom struct version is used by
xfs_fs_geometry
-XFS_FS_GEOM_MAX_STRUCT_VERis not used in the kernel at all, but libxfs uses it to always query all information in db and mkfs
- commit1b6d968de22bffdadded the v5 structure, which mostly contains extra padding, but otherwise just reports the struct version for now
Quoted 5 lines
So this commit is a no-op for the kernel, and mostly a no-op for userspace as nothing looks at the new field, but probably useful for later changes.
Maybe capture this in the commit log.
I've changed the commit message to:
xfs: bump max fsgeom struct version
The latest version of the fs geometry structure is v5. Bump this constant so that xfs_db and mkfs calls to libxfs_fs_geometry will fill out all the fields.
IOWs, this commit is a no-op for the kernel, but will be useful for userspace reporting in later changes.
Quoted 3 lines
With that:
Reviewed-by Christoph Hellwig <[email protected]>
Thank you!
--D
PATCH 2/3 xfs: prevent rt growfs when quota is enabled
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Quotas aren't (yet) supported with realtime, so we shouldn't allow userspace to set up a realtime section when quotas are enabled, even if they attached one via mount options. IOWS, you shouldn't be able to do:
# mkfs.xfs -f /dev/sda # mount /dev/sda /mnt -o rtdev=/dev/sdb # xfs_growfs -r /mnt
--- fs/xfs/xfs_rtalloc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/xfs_rtalloc.c +1 -1
@@ -959,7 +959,7 @@ xfs_growfs_rt(return -EINVAL ;/* Unsupported realtime features. */ -if (xfs_has_rmapbt (mp) ||xfs_has_reflink (mp)) +if (xfs_has_rmapbt (mp) ||xfs_has_reflink (mp) ||xfs_has_quota (mp))return -EOPNOTSUPP ; nrblocks = in->newblocks;
Re: [PATCH 2/3] xfs: prevent rt growfs when quota is enabled
Looks good:
PATCH 3/3 xfs: rt stubs should return negative errnos when rt disabled
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When realtime support is not compiled into the kernel, these functions should return negative errnos, not positive errnos. While we're at it, fix a broken macro declaration.
--- fs/xfs/xfs_rtalloc.h | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
fs/xfs/xfs_rtalloc.h +12 -12
@@ -143,17 +143,17 @@ int xfs_rtalloc_reinit_frextents(struct xfs_mount *mp);int xfs_rtfile_convert_unwritten (struct xfs_inode *ip,loff_t pos,uint64_t len);#else -# define xfs_rtallocate_extent (t,b,min,max,l,f,p,rb) (ENOSYS) -# define xfs_rtfree_extent (t,b,l) (ENOSYS) -# define xfs_rtfree_blocks (t,rb,rl) (ENOSYS) -# define xfs_rtpick_extent (m,t,l,rb) (ENOSYS) -# define xfs_growfs_rt (mp,in) (ENOSYS) -# define xfs_rtalloc_query_range (t,l,h,f,p) (ENOSYS) -# define xfs_rtalloc_query_all (m,t,f,p) (ENOSYS) -# define xfs_rtbuf_get (m,t,b,i,p) (ENOSYS) -# define xfs_verify_rtbno (m, r) (false) -# define xfs_rtalloc_extent_is_free (m,t,s,l,i) (ENOSYS) -# define xfs_rtalloc_reinit_frextents (m) (0) +# define xfs_rtallocate_extent (t,b,min,max,l,f,p,rb) (-ENOSYS) +# define xfs_rtfree_extent (t,b,l) (-ENOSYS) +# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS) +# define xfs_rtpick_extent (m,t,l,rb) (-ENOSYS) +# define xfs_growfs_rt (mp,in) (-ENOSYS) +# define xfs_rtalloc_query_range (m,t,l,h,f,p) (-ENOSYS) +# define xfs_rtalloc_query_all (m,t,f,p) (-ENOSYS) +# define xfs_rtbuf_get (m,t,b,i,p) (-ENOSYS) +# define xfs_verify_rtbno (m, r) (false) +# define xfs_rtalloc_extent_is_free (m,t,s,l,i) (-ENOSYS) +# define xfs_rtalloc_reinit_frextents (m) (0)static inline int /* error */ xfs_rtmount_init (xfs_mount_t *mp)/* file system mount structure */
@@ -164,7 +164,7 @@ xfs_rtmount_init(xfs_warn (mp,"Not built with CONFIG_XFS_RT" ); return -ENOSYS; } -# define xfs_rtmount_inodes (m) (((mp)->m_sb.sb_rblocks == 0)? 0 : (ENOSYS)) +# define xfs_rtmount_inodes (m) (((mp)->m_sb.sb_rblocks == 0)? 0 : (-ENOSYS))# define xfs_rtunmount_inodes (m)# define xfs_rtfile_convert_unwritten (ip, pos, len) (0)#endif /* CONFIG_XFS_RT */
Re: [PATCH 3/3] xfs: rt stubs should return negative errnos when rt disabled
Quoted 5 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
When realtime support is not compiled into the kernel, these functions should return negative errnos, not positive errnos. While we're at it, fix a broken macro declaration.
I would love to eventually see these as inline functions to also improve error checking. I'm not going to burden that on you now, though.
cover xfs: clean up realtime type usage
In reply to Darrick J. WongHi all,
The realtime code uses xfs_rtblock_t and xfs_fsblock_t in a lot of places, and it's very confusing. Clean up all the type usage so that an xfs_rtblock_t is always a block within the realtime volume, an xfs_fileoff_t is always a file offset within a realtime metadata file, and an xfs_rtxnumber_t is always a rt extent within the realtime volume.
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=clean-up-realtime-units
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=clean-up-realtime-units
--- fs/xfs/libxfs/xfs_bmap.c | 4 - fs/xfs/libxfs/xfs_format.h | 2 fs/xfs/libxfs/xfs_rtbitmap.c | 121 +++++++++++---------- fs/xfs/libxfs/xfs_rtbitmap.h | 79 ++++++++++++++ fs/xfs/libxfs/xfs_types.c | 4 - fs/xfs/libxfs/xfs_types.h | 8 + fs/xfs/scrub/bmap.c | 2 fs/xfs/scrub/fscounters.c | 2 fs/xfs/scrub/rtbitmap.c | 16 +-- fs/xfs/scrub/rtsummary.c | 6 + fs/xfs/scrub/trace.h | 7 + fs/xfs/xfs_bmap_item.c | 2 fs/xfs/xfs_bmap_util.c | 18 +-- fs/xfs/xfs_fsmap.c | 2 fs/xfs/xfs_rtalloc.c | 243 ++++++++++++++++++++++-------------------- fs/xfs/xfs_rtalloc.h | 89 +-------------- 16 files changed, 315 insertions(+), 290 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_rtbitmap.h
PATCH 1/7 xfs: make sure maxlen is still congruent with prod when rounding down
From: Darrick J. Wong <[email protected]>
In commit 2a6ca4baed62, we tried to fix an overflow problem in the realtime allocator that was caused by an overly large maxlen value causing xfs_rtcheck_range to run off the end of the realtime bitmap. Unfortunately, there is a subtle bug here -- maxlen (and minlen) both have to be aligned with @prod, but @prod can be larger than 1 if the user has set an extent size hint on the file, and that extent size hint is larger than the realtime extent size.
If the rt free space extents are not aligned to this file's extszhint because other files without extent size hints allocated space (or the number of rt extents is similarly not aligned), then it's possible that maxlen after clamping to sb_rextents will no longer be aligned to prod. The allocation will succeed just fine, but we still trip the assertion.
Fix the problem by reducing maxlen by any misalignment with prod. While we're at it, split the assertions into two so that we can tell which value had the bad alignment.
--- fs/xfs/xfs_rtalloc.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)
fs/xfs/xfs_rtalloc.c +19 -5
@@ -252,8 +252,13 @@ xfs_rtallocate_extent_block( end =XFS_BLOCKTOBIT (mp, bbno +1 ) -1 ; i <= end; i++) { -/* Make sure we don't scan off the end of the rt volume. */ +/* +* Make sure we don't run off the end of the rt volume. Be +* careful that adjusting maxlen downwards doesn't cause us to +* fail the alignment checks. +*/ maxlen =min (mp->m_sb.sb_rextents, i + maxlen) - i; + maxlen -= maxlen % prod;/* * See if there's a free extent of maxlen starting at i.
@@ -360,7 +365,8 @@ xfs_rtallocate_extent_exact(int isfree;/* extent is free */ xfs_rtblock_t next;/* next block to try (dummy) */ -ASSERT (minlen % prod ==0 && maxlen % prod ==0 ); +ASSERT (minlen % prod ==0 ); +ASSERT (maxlen % prod ==0 );/* * Check if the range in question (for maxlen) is free. */
@@ -443,7 +449,9 @@ xfs_rtallocate_extent_near(xfs_rtblock_t n;/* next block to try */ xfs_rtblock_t r;/* result block */ -ASSERT (minlen % prod ==0 && maxlen % prod ==0 ); +ASSERT (minlen % prod ==0 ); +ASSERT (maxlen % prod ==0 ); +/* * If the block number given is off the end, silently set it to * the last block.
@@ -451,8 +459,13 @@ xfs_rtallocate_extent_near(if (bno >= mp->m_sb.sb_rextents) bno = mp->m_sb.sb_rextents -1 ; -/* Make sure we don't run off the end of the rt volume. */ +/* +* Make sure we don't run off the end of the rt volume. Be careful +* that adjusting maxlen downwards doesn't cause us to fail the +* alignment checks. +*/ maxlen =min (mp->m_sb.sb_rextents, bno + maxlen) - bno; + maxlen -= maxlen % prod;if (maxlen < minlen) { *rtblock =NULLRTBLOCK ;return 0 ;
@@ -643,7 +656,8 @@ xfs_rtallocate_extent_size(xfs_rtblock_t r;/* result block number */ xfs_suminfo_t sum;/* summary information for extents */ -ASSERT (minlen % prod ==0 && maxlen % prod ==0 ); +ASSERT (minlen % prod ==0 ); +ASSERT (maxlen % prod ==0 );ASSERT (maxlen !=0 );/*
Re: [PATCH 1/7] xfs: make sure maxlen is still congruent with prod when rounding down
Quoted 3 lines · Darrick J. Wong
Fix the problem by reducing maxlen by any misalignment with prod. While we're at it, split the assertions into two so that we can tell which value had the bad alignment.
Yay, I always hate it when I trigger these compund asserts..
fs/xfs/xfs_rtalloc.c xfs_rtallocate_extent_block(
Quoted 5 lines
fs/xfs/xfs_rtalloc.c +2
-0maxlen =min (mp->m_sb.sb_rextents, i + maxlen) - i; + maxlen -= maxlen % prod; maxlen =min (mp->m_sb.sb_rextents, bno + maxlen) - bno; + maxlen -= maxlen % prod;
Not sure if that's bikeshedding, but this almost asks for a little helper with a comment.
Otherwise looks good:
Re: [PATCH 1/7] xfs: make sure maxlen is still congruent with prod when rounding down
Quoted 7 lines · Christoph Hellwig
Quoted 3 lines · Darrick J. Wong
Fix the problem by reducing maxlen by any misalignment with prod. While we're at it, split the assertions into two so that we can tell which value had the bad alignment.
Yay, I always hate it when I trigger these compund asserts..
Quoted 8 lines
fs/xfs/xfs_rtalloc.c xfs_rtallocate_extent_block(
Quoted 5 lines
fs/xfs/xfs_rtalloc.c +2
-0maxlen =min (mp->m_sb.sb_rextents, i + maxlen) - i; + maxlen -= maxlen % prod; maxlen =min (mp->m_sb.sb_rextents, bno + maxlen) - bno; + maxlen -= maxlen % prod;Not sure if that's bikeshedding, but this almost asks for a little helper with a comment.
How about:
/*
* Make sure we don't run off the end of the rt volume. Be careful that
* adjusting maxlen downwards doesn't cause us to fail the alignment checks. */
static inline xfs_extlen_t
xfs_rtallocate_clamp_len(
struct xfs_mount *mp,
xfs_rtblock_t startrtx,
xfs_extlen_t rtxlen,
xfs_extlen_t prod)
{
xfs_extlen_t ret;
ret = min(mp->m_sb.sb_rextents, startrtx + rtxlen) - startrtx;
return rounddown(ret, prod);
}minlen = xfs_rtallocate_clamp_len(mp, i, maxlen, prod);
and
minlen = xfs_rtalloc_clamp_len(mp, bno, maxlen, prod);
--D
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Christoph Hellwig
Reviewed-byRe: [PATCH 1/7] xfs: make sure maxlen is still congruent with prod when rounding down
Quoted 17 lines · Darrick J. Wong
/*
* Make sure we don't run off the end of the rt volume. Be careful that
* adjusting maxlen downwards doesn't cause us to fail the alignment checks. */
static inlinexfs_extlen_t
xfs_rtallocate_clamp_len(struct xfs_mount *mp, xfs_rtblock_t startrtx, xfs_extlen_t rtxlen, xfs_extlen_t prod) { xfs_extlen_t ret; ret = min(mp->m_sb.sb_rextents, startrtx + rtxlen) - startrtx; return rounddown(ret, prod); }
Quoted 5 lines
minlen = xfs_rtallocate_clamp_len(mp, i, maxlen, prod);and
minlen = xfs_rtalloc_clamp_len(mp, bno, maxlen, prod);
Looks good:
PATCH 2/7 xfs: move the xfs_rtbitmap.c declarations to xfs_rtbitmap.h
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move all the declarations for functionality in xfs_rtbitmap.c into a separate xfs_rtbitmap.h header file.
--- fs/xfs/libxfs/xfs_bmap.c | 2 + fs/xfs/libxfs/xfs_rtbitmap.c | 1 + fs/xfs/libxfs/xfs_rtbitmap.h | 82 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/fscounters.c | 2 + fs/xfs/scrub/rtbitmap.c | 2 + fs/xfs/scrub/rtsummary.c | 2 + fs/xfs/xfs_fsmap.c | 2 + fs/xfs/xfs_rtalloc.c | 1 + fs/xfs/xfs_rtalloc.h | 73 ------------------------------------- 9 files changed, 89 insertions(+), 78 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_rtbitmap.h
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -21,7 +21,7 @@#include "xfs_bmap.h" #include "xfs_bmap_util.h" #include "xfs_bmap_btree.h" -#include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_quota.h"
fs/xfs/libxfs/xfs_rtbitmap.c +1 -0
@@ -17,6 +17,7 @@#include "xfs_rtalloc.h" #include "xfs_error.h" #include "xfs_health.h" +#include "xfs_rtbitmap.h" /* * Realtime allocator bitmap functions shared with userspace.
fs/xfs/libxfs/xfs_rtbitmap.h new file +82 -0
82 lines not on this page · raw message
fs/xfs/scrub/fscounters.c +1 -1
@@ -16,7 +16,7 @@#include "xfs_health.h" #include "xfs_btree.h" #include "xfs_ag.h" -#include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include "xfs_inode.h" #include "xfs_icache.h" #include "scrub/scrub.h"
fs/xfs/scrub/rtbitmap.c +1 -1
@@ -11,7 +11,7 @@#include "xfs_mount.h" #include "xfs_log_format.h" #include "xfs_trans.h" -#include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include "xfs_inode.h" #include "xfs_bmap.h" #include "scrub/scrub.h"
fs/xfs/scrub/rtsummary.c +1 -1
@@ -13,7 +13,7 @@#include "xfs_inode.h" #include "xfs_log_format.h" #include "xfs_trans.h" -#include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include "xfs_bit.h" #include "xfs_bmap.h" #include "scrub/scrub.h"
fs/xfs/xfs_fsmap.c +1 -1
@@ -23,7 +23,7 @@#include "xfs_refcount.h" #include "xfs_refcount_btree.h" #include "xfs_alloc_btree.h" -#include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include "xfs_ag.h" /* Convert an xfs_fsmap to an fsmap. */
fs/xfs/xfs_rtalloc.c +1 -0
@@ -24,6 +24,7 @@#include "xfs_trace.h" #include "xfs_da_format.h" #include "xfs_imeta.h" +#include "xfs_rtbitmap.h" /* * Read and return the summary information for a given extent size,
fs/xfs/xfs_rtalloc.h +0 -73
98 lines not on this page · raw message
Re: [PATCH 2/7] xfs: move the xfs_rtbitmap.c declarations to xfs_rtbitmap.h
Looks good:
PATCH 3/7 xfs: convert xfs_extlen_t to xfs_rtxlen_t in the rt allocator
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
In most of the filesystem, we use xfs_extlen_t to store the length of a file (or AG) space mapping in units of fs blocks. Unfortunately, the realtime allocator also uses it to store the length of a rt space mapping in units of rt extents. This is confusing, since one rt extent can consist of many fs blocks.
Separate the two by introducing a new type (xfs_rtxlen_t) to store the length of a space mapping (in units of realtime extents) that would be found in a file.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 12 +++++----- fs/xfs/libxfs/xfs_rtbitmap.h | 11 ++++----- fs/xfs/libxfs/xfs_types.h | 1 + fs/xfs/scrub/rtbitmap.c | 2 +- fs/xfs/xfs_bmap_util.c | 6 +++-- fs/xfs/xfs_rtalloc.c | 50 +++++++++++++++++++++--------------------- fs/xfs/xfs_rtalloc.h | 10 ++++---- 7 files changed, 46 insertions(+), 46 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +6 -6
@@ -541,7 +541,7 @@ xfs_rtmodify_range( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ xfs_rtblock_t start, /* starting block to modify */ - xfs_extlen_t len, /* length of extent to modify */ + xfs_rtxlen_t len, /* length of extent to modify */ int val) /* 1 for free, 0 for allocated */ { xfs_rtword_t *b;/* current word in buffer */
@@ -697,7 +697,7 @@ xfs_rtfree_range( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ xfs_rtblock_t start, /* starting block to free */ - xfs_extlen_t len, /* length to free */ + xfs_rtxlen_t len, /* length to free */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ xfs_fsblock_t *rsb) /* in/out: summary block number */ {
@@ -773,7 +773,7 @@ xfs_rtcheck_range( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ xfs_rtblock_t start, /* starting block number of extent */ - xfs_extlen_t len, /* length of extent */ + xfs_rtxlen_t len, /* length of extent */ int val, /* 1 for free, 0 for allocated */ xfs_rtblock_t *new,/* out: first block not matching */ int *stat) /* out: 1 for matches, 0 for not */
@@ -949,7 +949,7 @@ xfs_rtcheck_alloc_range( xfs_mount_t *mp, /* file system mount point */ xfs_trans_t *tp, /* transaction pointer */ xfs_rtblock_t bno, /* starting block number of extent */ - xfs_extlen_t len) /* length of extent */ + xfs_rtxlen_t len) /* length of extent */ {xfs_rtblock_t new;/* dummy for xfs_rtcheck_range */ int stat;
@@ -972,7 +972,7 @@ int /* error */xfs_rtfree_extent ( xfs_trans_t *tp,/* transaction pointer */ xfs_rtblock_t bno, /* starting block number to free */ - xfs_extlen_t len) /* length of extent freed */ + xfs_rtxlen_t len) /* length of extent freed */ {int error;/* error value */ xfs_mount_t *mp;/* file system mount structure */
@@ -1123,7 +1123,7 @@ xfs_rtalloc_extent_is_free(struct xfs_mount *mp, struct xfs_trans *tp, xfs_rtblock_t start, - xfs_extlen_t len, + xfs_rtxlen_t len, bool *is_free) { xfs_rtblock_t end;
fs/xfs/libxfs/xfs_rtbitmap.h +5 -6
@@ -26,7 +26,7 @@ typedef int (*xfs_rtalloc_query_range_fn)(int xfs_rtbuf_get (struct xfs_mount *mp,struct xfs_trans *tp,xfs_rtblock_t block,int issum,struct xfs_buf **bpp);int xfs_rtcheck_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_extlen_t len,int val, +xfs_rtblock_t start,xfs_rtxlen_t len,int val,xfs_rtblock_t *new,int *stat); int xfs_rtfind_back(struct xfs_mount *mp, struct xfs_trans *tp, xfs_rtblock_t start, xfs_rtblock_t limit,
@@ -35,7 +35,7 @@ int xfs_rtfind_forw(struct xfs_mount *mp, struct xfs_trans *tp, xfs_rtblock_t start, xfs_rtblock_t limit, xfs_rtblock_t *rtblock);int xfs_rtmodify_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_extlen_t len,int val); +xfs_rtblock_t start,xfs_rtxlen_t len,int val); int xfs_rtmodify_summary_int(struct xfs_mount *mp, struct xfs_trans *tp, int log, xfs_rtblock_t bbno, int delta, struct xfs_buf **rbpp, xfs_fsblock_t *rsb,
@@ -44,7 +44,7 @@ int xfs_rtmodify_summary(struct xfs_mount *mp, struct xfs_trans *tp, int log, xfs_rtblock_t bbno, int delta, struct xfs_buf **rbpp, xfs_fsblock_t *rsb);int xfs_rtfree_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_extlen_t len, +xfs_rtblock_t start,xfs_rtxlen_t len,struct xfs_buf **rbpp,xfs_fsblock_t *rsb); int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp, const struct xfs_rtalloc_rec *low_rec,
@@ -53,9 +53,8 @@ int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp,int xfs_rtalloc_query_all (struct xfs_mount *mp,struct xfs_trans *tp,xfs_rtalloc_query_range_fn fn,void *priv); -bool xfs_verify_rtbno (struct xfs_mount *mp,xfs_rtblock_t rtbno);int xfs_rtalloc_extent_is_free (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_extlen_t len, +xfs_rtblock_t start,xfs_rtxlen_t len,bool *is_free);/* * Free an extent in the realtime subvolume. Length is expressed in
@@ -65,7 +64,7 @@ int /* error */xfs_rtfree_extent ( struct xfs_trans *tp, /* transaction pointer */ xfs_rtblock_t bno, /* starting block number to free */ - xfs_extlen_t len); /* length of extent freed */ + xfs_rtxlen_t len); /* length of extent freed *//* Same as above, but in units of rt blocks. */ int xfs_rtfree_blocks(struct xfs_trans *tp, xfs_fsblock_t rtbno,
fs/xfs/libxfs/xfs_types.h +1 -0
@@ -11,6 +11,7 @@ typedef uint32_t prid_t; /* project ID */typedef uint32_t xfs_agblock_t ;/* blockno in alloc. group */ typedef uint32_t xfs_agino_t ;/* inode # within allocation grp */ typedef uint32_t xfs_extlen_t ;/* extent length in blocks */ +typedef uint32_t xfs_rtxlen_t ;/* file extent length in rtextents */ typedef uint32_t xfs_agnumber_t ;/* allocation group number */ typedef uint64_t xfs_extnum_t ;/* # of extents in a file */ typedef uint32_t xfs_aextnum_t ;/* # extents in an attribute fork */
fs/xfs/scrub/rtbitmap.c +1 -1
@@ -145,7 +145,7 @@ xchk_xref_is_used_rt_space( {xfs_rtblock_t startext;xfs_rtblock_t endext; -xfs_rtblock_t extcount; +xfs_rtxlen_t extcount;bool is_free;int error;
fs/xfs/xfs_bmap_util.c +3 -3
@@ -77,13 +77,13 @@ xfs_bmap_rtalloc(struct xfs_mount *mp = ap->ip->i_mount;xfs_fileoff_t orig_offset = ap->offset;xfs_rtblock_t rtb; -xfs_extlen_t prod =0 ;/* product factor for allocators */ +xfs_rtxlen_t prod =0 ;/* product factor for allocators */ xfs_extlen_t mod =0 ;/* product factor for allocators */ -xfs_extlen_t ralen =0 ;/* realtime allocation length */ +xfs_rtxlen_t ralen =0 ;/* realtime allocation length */ xfs_extlen_t align;/* minimum allocation alignment */ xfs_extlen_t orig_length = ap->length;xfs_extlen_t minlen = mp->m_sb.sb_rextsize; -xfs_extlen_t raminlen; +xfs_rtxlen_t raminlen;bool rtlocked = false;bool ignore_locality = false;int error;
fs/xfs/xfs_rtalloc.c +25 -25
117 lines not on this page · raw message
fs/xfs/xfs_rtalloc.h +5 -5
@@ -25,11 +25,11 @@ int /* error */xfs_rtallocate_extent ( struct xfs_trans *tp, /* transaction pointer */ xfs_rtblock_t bno, /* starting block number to allocate */ - xfs_extlen_t minlen, /* minimum length to allocate */ - xfs_extlen_t maxlen, /* maximum length to allocate */ - xfs_extlen_t *len, /* out: actual length allocated */ + xfs_rtxlen_t minlen, /* minimum length to allocate */ + xfs_rtxlen_t maxlen, /* maximum length to allocate */ + xfs_rtxlen_t *len, /* out: actual length allocated */ int wasdel, /* was a delayed allocation extent */ - xfs_extlen_t prod, /* extent product factor */ + xfs_rtxlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock); /* out: start block allocated */
@@ -62,7 +62,7 @@ int /* error */xfs_rtpick_extent ( struct xfs_mount *mp, /* file system mount point */ struct xfs_trans *tp, /* transaction pointer */ - xfs_extlen_t len, /* allocation length (rtextents) */ + xfs_rtxlen_t len, /* allocation length (rtextents) */ xfs_rtblock_t *pick); /* result rt extent *//*
Re: [PATCH 3/7] xfs: convert xfs_extlen_t to xfs_rtxlen_t in the rt allocator
Quoted 11 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
In most of the filesystem, we use
xfs_extlen_tto store the length of a file (or AG) space mapping in units of fs blocks. Unfortunately, the realtime allocator also uses it to store the length of a rt space mapping in units of rt extents. This is confusing, since one rt extent can consist of many fs blocks.Separate the two by introducing a new type (
xfs_rtxlen_t) to store the length of a space mapping (in units of realtime extents) that would be found in a file.
Looks good:
PATCH 4/7 xfs: convert rt bitmap/summary block numbers to xfs_fileoff_t
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
We should use xfs_fileoff_t to store the file block offset of any location within the realtime bitmap or summary files.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 22 +++++++++++----------- fs/xfs/libxfs/xfs_rtbitmap.h | 12 ++++++------ fs/xfs/scrub/rtbitmap.c | 2 +- fs/xfs/xfs_rtalloc.c | 34 +++++++++++++++++----------------- 4 files changed, 35 insertions(+), 35 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +11 -11
@@ -56,7 +56,7 @@ intxfs_rtbuf_get ( xfs_mount_t *mp,/* file system mount structure */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t block, /* block number in bitmap or summary */ + xfs_fileoff_t block, /* block number in bitmap or summary */ int issum, /* is summary not bitmap */ struct xfs_buf **bpp) /* output: buffer for the block */ {
@@ -108,7 +108,7 @@ xfs_rtfind_back( {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */ -xfs_rtblock_t block;/* bitmap block number */ +xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */
@@ -283,7 +283,7 @@ xfs_rtfind_forw( {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */ -xfs_rtblock_t block;/* bitmap block number */ +xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */
@@ -453,15 +453,15 @@ xfs_rtmodify_summary_int( xfs_mount_t *mp, /* file system mount structure */ xfs_trans_t *tp, /* transaction pointer */ int log, /* log2 of extent size */ - xfs_rtblock_t bbno, /* bitmap block number */ + xfs_fileoff_t bbno, /* bitmap block number */ int delta, /* change to make to summary info */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ xfs_suminfo_t *sum) /* out: summary info for this block */ {struct xfs_buf *bp;/* buffer for the summary block */ int error;/* error value */ -xfs_fsblock_t sb;/* summary fsblock */ +xfs_fileoff_t sb;/* summary fsblock */ int so;/* index into the summary file */ xfs_suminfo_t *sp;/* pointer to returned data */
@@ -523,10 +523,10 @@ xfs_rtmodify_summary( xfs_mount_t *mp, /* file system mount structure */ xfs_trans_t *tp, /* transaction pointer */ int log, /* log2 of extent size */ - xfs_rtblock_t bbno, /* bitmap block number */ + xfs_fileoff_t bbno, /* bitmap block number */ int delta, /* change to make to summary info */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb) /* in/out: summary block number */ + xfs_fileoff_t *rsb) /* in/out: summary block number */ {return xfs_rtmodify_summary_int (mp, tp, log, bbno, delta, rbpp, rsb,NULL );
@@ -546,7 +546,7 @@ xfs_rtmodify_range( {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */ -xfs_rtblock_t block;/* bitmap block number */ +xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */
@@ -699,7 +699,7 @@ xfs_rtfree_range(xfs_rtblock_t start,/* starting block to free */ xfs_rtxlen_t len, /* length to free */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb) /* in/out: summary block number */ + xfs_fileoff_t *rsb) /* in/out: summary block number */ { xfs_rtblock_t end; /* end of the freed extent */int error;/* error value */
@@ -780,7 +780,7 @@ xfs_rtcheck_range( {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */ -xfs_rtblock_t block;/* bitmap block number */ +xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */
fs/xfs/libxfs/xfs_rtbitmap.h +6 -6
@@ -24,7 +24,7 @@ typedef int (*xfs_rtalloc_query_range_fn)(#ifdef CONFIG_XFS_RT int xfs_rtbuf_get (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t block,int issum,struct xfs_buf **bpp); +xfs_fileoff_t block,int issum,struct xfs_buf **bpp);int xfs_rtcheck_range (struct xfs_mount *mp,struct xfs_trans *tp,xfs_rtblock_t start,xfs_rtxlen_t len,int val,xfs_rtblock_t *new,int *stat);
@@ -37,15 +37,15 @@ int xfs_rtfind_forw(struct xfs_mount *mp, struct xfs_trans *tp,int xfs_rtmodify_range (struct xfs_mount *mp,struct xfs_trans *tp,xfs_rtblock_t start,xfs_rtxlen_t len,int val);int xfs_rtmodify_summary_int (struct xfs_mount *mp,struct xfs_trans *tp, -int log,xfs_rtblock_t bbno,int delta, -struct xfs_buf **rbpp,xfs_fsblock_t *rsb, +int log,xfs_fileoff_t bbno,int delta, +struct xfs_buf **rbpp,xfs_fileoff_t *rsb,xfs_suminfo_t *sum);int xfs_rtmodify_summary (struct xfs_mount *mp,struct xfs_trans *tp,int log, -xfs_rtblock_t bbno,int delta,struct xfs_buf **rbpp, -xfs_fsblock_t *rsb); +xfs_fileoff_t bbno,int delta,struct xfs_buf **rbpp, +xfs_fileoff_t *rsb);int xfs_rtfree_range (struct xfs_mount *mp,struct xfs_trans *tp,xfs_rtblock_t start,xfs_rtxlen_t len, -struct xfs_buf **rbpp,xfs_fsblock_t *rsb); +struct xfs_buf **rbpp,xfs_fileoff_t *rsb); int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp, const struct xfs_rtalloc_rec *low_rec, const struct xfs_rtalloc_rec *high_rec,
fs/xfs/scrub/rtbitmap.c +1 -1
@@ -77,7 +77,7 @@ xchk_rtbitmap_check_extents( {struct xfs_mount *mp = sc->mp;struct xfs_bmbt_irec map; -xfs_rtblock_t off; +xfs_fileoff_t off;int nmap;int error =0 ;
fs/xfs/xfs_rtalloc.c +17 -17
@@ -37,9 +37,9 @@ xfs_rtget_summary( xfs_mount_t *mp, /* file system mount structure */ xfs_trans_t *tp, /* transaction pointer */ int log, /* log2 of extent size */ - xfs_rtblock_t bbno, /* bitmap block number */ + xfs_fileoff_t bbno, /* bitmap block number */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ xfs_suminfo_t *sum) /* out: summary info for this block */ {return xfs_rtmodify_summary_int (mp, tp, log, bbno,0 , rbpp, rsb, sum);
@@ -55,9 +55,9 @@ xfs_rtany_summary(xfs_trans_t *tp,/* transaction pointer */ int low, /* low log2 extent size */ int high, /* high log2 extent size */ - xfs_rtblock_t bbno, /* bitmap block number */ + xfs_fileoff_t bbno, /* bitmap block number */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ int *stat) /* out: any good extents here? */ { int error; /* error value */
@@ -109,12 +109,12 @@ xfs_rtcopy_summary( xfs_mount_t *nmp, /* new file system mount point */ xfs_trans_t *tp) /* transaction pointer */ { -xfs_rtblock_t bbno;/* bitmap block number */ +xfs_fileoff_t bbno;/* bitmap block number */ struct xfs_buf *bp;/* summary buffer */ int error;/* error return value */ int log;/* summary level number (log length) */ xfs_suminfo_t sum;/* summary data */ -xfs_fsblock_t sumbno;/* summary block number */ +xfs_fileoff_t sumbno;/* summary block number */ bp =NULL ;for (log = omp->m_rsumlevels -1 ; log >=0 ; log--) {
@@ -151,7 +151,7 @@ xfs_rtallocate_range(xfs_rtblock_t start,/* start block to allocate */ xfs_rtxlen_t len, /* length to allocate */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb) /* in/out: summary block number */ + xfs_fileoff_t *rsb) /* in/out: summary block number */ { xfs_rtblock_t end; /* end of the allocated extent */int error;/* error value */
@@ -227,13 +227,13 @@ STATIC int /* error */xfs_rtallocate_extent_block ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t bbno, /* bitmap block number */ + xfs_fileoff_t bbno, /* bitmap block number */ xfs_rtxlen_t minlen, /* minimum length to allocate */ xfs_rtxlen_t maxlen, /* maximum length to allocate */ xfs_rtxlen_t *len,/* out: actual length allocated */ xfs_rtblock_t *nextp,/* out: next block to try */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb,/* in/out: summary block number */ + xfs_fileoff_t *rsb,/* in/out: summary block number */ xfs_rtxlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock) /* out: start block allocated */ {
@@ -357,7 +357,7 @@ xfs_rtallocate_extent_exact(xfs_rtxlen_t maxlen,/* maximum length to allocate */ xfs_rtxlen_t *len, /* out: actual length allocated */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ xfs_rtxlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock) /* out: start block allocated */ {
@@ -437,12 +437,12 @@ xfs_rtallocate_extent_near(xfs_rtxlen_t maxlen,/* maximum length to allocate */ xfs_rtxlen_t *len, /* out: actual length allocated */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ xfs_rtxlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock) /* out: start block allocated */ { int any; /* any useful extents from summary */ -xfs_rtblock_t bbno;/* bitmap block number */ +xfs_fileoff_t bbno;/* bitmap block number */ int error;/* error value */ int i;/* bitmap block offset (loop control) */ int j;/* secondary loop control */
@@ -646,12 +646,12 @@ xfs_rtallocate_extent_size(xfs_rtxlen_t maxlen,/* maximum length to allocate */ xfs_rtxlen_t *len, /* out: actual length allocated */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ - xfs_fsblock_t *rsb, /* in/out: summary block number */ + xfs_fileoff_t *rsb, /* in/out: summary block number */ xfs_rtxlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock) /* out: start block allocated */ { int error; /* error value */ -int i;/* bitmap block number */ +xfs_fileoff_t i;/* bitmap block number */ int l;/* level number (loop control) */ xfs_rtblock_t n;/* next block to be tried */ xfs_rtblock_t r;/* result block number */
@@ -927,7 +927,7 @@ xfs_growfs_rt( xfs_mount_t *mp, /* mount point for filesystem */ xfs_growfs_rt_t *in) /* growfs rt input struct */ { -xfs_rtblock_t bmbno;/* bitmap block number */ +xfs_fileoff_t bmbno;/* bitmap block number */ struct xfs_buf *bp;/* temporary buffer */ int error;/* error return value */ xfs_mount_t *nmp;/* new (fake) mount structure */
@@ -942,7 +942,7 @@ xfs_growfs_rt(xfs_extlen_t rbmblocks;/* current number of rt bitmap blocks */ xfs_extlen_t rsumblocks;/* current number of rt summary blks */ xfs_sb_t *sbp;/* old superblock */ -xfs_fsblock_t sumbno;/* summary block number */ +xfs_fileoff_t sumbno;/* summary block number */ uint8_t *rsum_cache;/* old summary cache */ sbp = &mp->m_sb;
@@ -1205,7 +1205,7 @@ xfs_rtallocate_extent(xfs_mount_t *mp = tp->t_mountp;int error;/* error value */ xfs_rtblock_t r;/* result allocated block */ -xfs_fsblock_t sb;/* summary file block number */ +xfs_fileoff_t sb;/* summary file block number */ struct xfs_buf *sumbp;/* summary file block buffer */ ASSERT (xfs_isilocked (mp->m_rbmip,XFS_ILOCK_EXCL ));
Re: [PATCH 4/7] xfs: convert rt bitmap/summary block numbers to xfs_fileoff_t
Looks good:
PATCH 5/7 xfs: convert rt bitmap extent lengths to xfs_rtbxlen_t
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
XFS uses xfs_rtblock_t for many different uses, which makes it much more difficult to perform a unit analysis on the codebase. One of these (ab)uses is when we need to store the length of a free space extent as stored in the realtime bitmap. Because there can be up to 2^64 realtime extents in a filesystem, we need a new type that is larger than xfs_rtxlen_t for callers that are querying the bitmap directly. This means scrub and growfs.
Create this type as "xfs_rtbxlen_t" and use it to store 64-bit rtx lengths. 'b' stands for 'bitmap' or 'big'; reader's choice.
--- fs/xfs/libxfs/xfs_format.h | 2 +- fs/xfs/libxfs/xfs_rtbitmap.h | 2 +- fs/xfs/libxfs/xfs_types.h | 1 + fs/xfs/scrub/trace.h | 3 ++- 4 files changed, 5 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_format.h +1 -1
@@ -97,7 +97,7 @@ typedef struct xfs_sb {uint32_t sb_blocksize;/* logical block size, bytes */ xfs_rfsblock_t sb_dblocks;/* number of data blocks */ xfs_rfsblock_t sb_rblocks;/* number of realtime blocks */ -xfs_rtblock_t sb_rextents;/* number of realtime extents */ +xfs_rtbxlen_t sb_rextents;/* number of realtime extents */ uuid_t sb_uuid;/* user-visible file system unique id */ xfs_fsblock_t sb_logstart;/* starting block of log if internal */ xfs_ino_t sb_rootino;/* root inode number */
fs/xfs/libxfs/xfs_rtbitmap.h +1 -1
@@ -13,7 +13,7 @@*/ struct xfs_rtalloc_rec {xfs_rtblock_t ar_startext; -xfs_rtblock_t ar_extcount; +xfs_rtbxlen_t ar_extcount; }; typedef int (*xfs_rtalloc_query_range_fn)(
fs/xfs/libxfs/xfs_types.h +1 -0
@@ -32,6 +32,7 @@ typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */typedef uint64_t xfs_rtblock_t ;/* extent (block) in realtime area */ typedef uint64_t xfs_fileoff_t ;/* block number in a file */ typedef uint64_t xfs_filblks_t ;/* number of blocks in a file */ +typedef uint64_t xfs_rtbxlen_t ;/* rtbitmap extent length in rtextents */ typedef int64_t xfs_srtblock_t ;/* signed version of xfs_rtblock_t */
fs/xfs/scrub/trace.h +2 -1
@@ -1261,7 +1261,8 @@ TRACE_EVENT(xfarray_sort_stats,#ifdef CONFIG_XFS_RT TRACE_EVENT(xchk_rtsum_record_free, TP_PROTO(struct xfs_mount *mp, xfs_rtblock_t start, - uint64_t len, unsigned int log, loff_t pos, xfs_suminfo_t v), + xfs_rtbxlen_t len, unsigned int log, loff_t pos, + xfs_suminfo_t v), TP_ARGS(mp, start, len, log, pos, v), TP_STRUCT__entry( __field(dev_t, dev)
Re: [PATCH 5/7] xfs: convert rt bitmap extent lengths to xfs_rtbxlen_t
Looks good:
PATCH 6/7 xfs: rename xfs_verify_rtext to xfs_verify_rtbext
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
This helper function validates that a range of *blocks* in the realtime section is completely contained within the realtime section. It does /not/ validate ranges of *rtextents*. Rename the function to avoid suggesting that it does, and change the type of the @len parameter since xfs_rtblock_t is a position unit, not a length unit.
--- fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/libxfs/xfs_types.c | 4 ++-- fs/xfs/libxfs/xfs_types.h | 4 ++-- fs/xfs/scrub/bmap.c | 2 +- fs/xfs/scrub/rtbitmap.c | 4 ++-- fs/xfs/scrub/rtsummary.c | 2 +- fs/xfs/xfs_bmap_item.c | 2 +- 7 files changed, 10 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -6257,7 +6257,7 @@ xfs_bmap_validate_extent_raw(return __this_address;if (rtfile && whichfork ==XFS_DATA_FORK ) { -if (!xfs_verify_rtext (mp, irec->br_startblock, +if (!xfs_verify_rtbext (mp, irec->br_startblock, irec->br_blockcount))return __this_address; }else {
fs/xfs/libxfs/xfs_types.c +2 -2
@@ -147,10 +147,10 @@ xfs_verify_rtbno(/* Verify that a realtime device extent is fully contained inside the volume. */ bool -xfs_verify_rtext ( +xfs_verify_rtbext (struct xfs_mount *mp,xfs_rtblock_t rtbno, -xfs_rtblock_t len) +xfs_filblks_t len) {if (rtbno + len <= rtbno)return false;
fs/xfs/libxfs/xfs_types.h +2 -2
@@ -240,8 +240,8 @@ bool xfs_verify_ino(struct xfs_mount *mp, xfs_ino_t ino);bool xfs_internal_inum (struct xfs_mount *mp,xfs_ino_t ino);bool xfs_verify_dir_ino (struct xfs_mount *mp,xfs_ino_t ino);bool xfs_verify_rtbno (struct xfs_mount *mp,xfs_rtblock_t rtbno); -bool xfs_verify_rtext (struct xfs_mount *mp,xfs_rtblock_t rtbno, -xfs_rtblock_t len); +bool xfs_verify_rtbext (struct xfs_mount *mp,xfs_rtblock_t rtbno, +xfs_filblks_t len);bool xfs_verify_icount (struct xfs_mount *mp,unsigned long long icount);bool xfs_verify_dablk (struct xfs_mount *mp,xfs_fileoff_t off); void xfs_icount_range(struct xfs_mount *mp, unsigned long long *min,
fs/xfs/scrub/bmap.c +1 -1
@@ -432,7 +432,7 @@ xchk_bmap_iextent(/* Make sure the extent points to a valid place. */ if (info->is_rt && - !xfs_verify_rtext (mp, irec->br_startblock, irec->br_blockcount)) + !xfs_verify_rtbext (mp, irec->br_startblock, irec->br_blockcount))xchk_fblock_set_corrupt (info->sc, info->whichfork, irec->br_startoff); if (!info->is_rt &&
fs/xfs/scrub/rtbitmap.c +2 -2
@@ -60,12 +60,12 @@ xchk_rtbitmap_rec( {struct xfs_scrub *sc = priv;xfs_rtblock_t startblock; -xfs_rtblock_t blockcount; +xfs_filblks_t blockcount; startblock = rec->ar_startext * mp->m_sb.sb_rextsize; blockcount = rec->ar_extcount * mp->m_sb.sb_rextsize; -if (!xfs_verify_rtext (mp, startblock, blockcount)) +if (!xfs_verify_rtbext (mp, startblock, blockcount))xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 );return 0 ; }
fs/xfs/scrub/rtsummary.c +1 -1
@@ -149,7 +149,7 @@ xchk_rtsum_record_free( rtbno = rec->ar_startext * mp->m_sb.sb_rextsize; rtlen = rec->ar_extcount * mp->m_sb.sb_rextsize; -if (!xfs_verify_rtext (mp, rtbno, rtlen)) { +if (!xfs_verify_rtbext (mp, rtbno, rtlen)) {xchk_ino_xref_set_corrupt (sc, mp->m_rbmip->i_ino);return -EFSCORRUPTED ; }
fs/xfs/xfs_bmap_item.c +1 -1
@@ -474,7 +474,7 @@ xfs_bui_validate(return false;if (map->me_flags &XFS_BMAP_EXTENT_REALTIME ) -return xfs_verify_rtext (mp, map->me_startblock, map->me_len); +return xfs_verify_rtbext (mp, map->me_startblock, map->me_len);return xfs_verify_fsbext (mp, map->me_startblock, map->me_len); }
Re: [PATCH 6/7] xfs: rename xfs_verify_rtext to xfs_verify_rtbext
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
This helper function validates that a range of *blocks* in the realtime section is completely contained within the realtime section. It does /not/ validate ranges of *rtextents*. Rename the function to avoid suggesting that it does, and change the type of the @len parameter since
xfs_rtblock_tis a position unit, not a length unit.
Looks good:
PATCH 7/7 xfs: convert rt extent numbers to xfs_rtxnum_t
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Further disambiguate the xfs_rtblock_t uses by creating a new type, xfs_rtxnum_t, to store the position of an extent within the realtime section, in units of rtextents.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 86 +++++++++++++-------------- fs/xfs/libxfs/xfs_rtbitmap.h | 26 ++++---- fs/xfs/libxfs/xfs_types.h | 2 + fs/xfs/scrub/rtbitmap.c | 6 +- fs/xfs/scrub/rtsummary.c | 2 - fs/xfs/scrub/trace.h | 4 + fs/xfs/xfs_bmap_util.c | 12 ++-- fs/xfs/xfs_rtalloc.c | 134 +++++++++++++++++++++--------------------- fs/xfs/xfs_rtalloc.h | 6 +- 9 files changed, 138 insertions(+), 140 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +43 -43
@@ -102,9 +102,9 @@ intxfs_rtfind_back ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t start, /* starting block to look at */ - xfs_rtblock_t limit, /* last block to look at */ - xfs_rtblock_t *rtblock) /* out: start block found */ + xfs_rtxnum_t start, /* starting rtext to look at */ + xfs_rtxnum_t limit, /* last rtext to look at */ + xfs_rtxnum_t *rtx) /* out: start rtext found */ {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */
@@ -112,9 +112,9 @@ xfs_rtfind_back(struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ -xfs_rtblock_t firstbit;/* first useful bit in the word */ -xfs_rtblock_t i;/* current bit number rel. to start */ -xfs_rtblock_t len;/* length of inspected area */ +xfs_rtxnum_t firstbit;/* first useful bit in the word */ +xfs_rtxnum_t i;/* current bit number rel. to start */ +xfs_rtxnum_t len;/* length of inspected area */ xfs_rtword_t mask;/* mask of relevant bits for value */ xfs_rtword_t want;/* mask for "good" values */ xfs_rtword_t wdiff;/* difference from wanted value */
@@ -163,7 +163,7 @@ xfs_rtfind_back(*/ xfs_trans_brelse (tp, bp); i = bit -XFS_RTHIBIT (wdiff); - *rtblock = start - i +1 ; + *rtx = start - i +1 ;return 0 ; } i = bit - firstbit +1 ;
@@ -209,7 +209,7 @@ xfs_rtfind_back(*/ xfs_trans_brelse (tp, bp); i +=XFS_NBWORD -1 -XFS_RTHIBIT (wdiff); - *rtblock = start - i +1 ; + *rtx = start - i +1 ;return 0 ; } i +=XFS_NBWORD ;
@@ -256,7 +256,7 @@ xfs_rtfind_back(*/ xfs_trans_brelse (tp, bp); i +=XFS_NBWORD -1 -XFS_RTHIBIT (wdiff); - *rtblock = start - i +1 ; + *rtx = start - i +1 ;return 0 ; }else i = len;
@@ -265,7 +265,7 @@ xfs_rtfind_back(* No match, return that we scanned the whole area. */ xfs_trans_brelse (tp, bp); - *rtblock = start - i +1 ; + *rtx = start - i +1 ;return 0 ; }
@@ -277,9 +277,9 @@ intxfs_rtfind_forw ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t start, /* starting block to look at */ - xfs_rtblock_t limit, /* last block to look at */ - xfs_rtblock_t *rtblock) /* out: start block found */ + xfs_rtxnum_t start, /* starting rtext to look at */ + xfs_rtxnum_t limit, /* last rtext to look at */ + xfs_rtxnum_t *rtx) /* out: start rtext found */ {xfs_rtword_t *b;/* current word in buffer */ int bit;/* bit number in the word */
@@ -287,9 +287,9 @@ xfs_rtfind_forw(struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ -xfs_rtblock_t i;/* current bit number rel. to start */ -xfs_rtblock_t lastbit;/* last useful bit in the word */ -xfs_rtblock_t len;/* length of inspected area */ +xfs_rtxnum_t i;/* current bit number rel. to start */ +xfs_rtxnum_t lastbit;/* last useful bit in the word */ +xfs_rtxnum_t len;/* length of inspected area */ xfs_rtword_t mask;/* mask of relevant bits for value */ xfs_rtword_t want;/* mask for "good" values */ xfs_rtword_t wdiff;/* difference from wanted value */
@@ -337,7 +337,7 @@ xfs_rtfind_forw(*/ xfs_trans_brelse (tp, bp); i =XFS_RTLOBIT (wdiff) - bit; - *rtblock = start + i -1 ; + *rtx = start + i -1 ;return 0 ; } i = lastbit - bit;
@@ -382,7 +382,7 @@ xfs_rtfind_forw(*/ xfs_trans_brelse (tp, bp); i +=XFS_RTLOBIT (wdiff); - *rtblock = start + i -1 ; + *rtx = start + i -1 ;return 0 ; } i +=XFS_NBWORD ;
@@ -426,7 +426,7 @@ xfs_rtfind_forw(*/ xfs_trans_brelse (tp, bp); i +=XFS_RTLOBIT (wdiff); - *rtblock = start + i -1 ; + *rtx = start + i -1 ;return 0 ; }else i = len;
@@ -435,7 +435,7 @@ xfs_rtfind_forw(* No match, return that we scanned the whole area. */ xfs_trans_brelse (tp, bp); - *rtblock = start + i -1 ; + *rtx = start + i -1 ;return 0 ; }
@@ -540,7 +540,7 @@ intxfs_rtmodify_range ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t start, /* starting block to modify */ + xfs_rtxnum_t start, /* starting rtext to modify */ xfs_rtxlen_t len, /* length of extent to modify */ int val) /* 1 for free, 0 for allocated */ {
@@ -696,15 +696,15 @@ intxfs_rtfree_range ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t start, /* starting block to free */ + xfs_rtxnum_t start, /* starting rtext to free */ xfs_rtxlen_t len, /* length to free */ struct xfs_buf **rbpp, /* in/out: summary block buffer */ xfs_fileoff_t *rsb) /* in/out: summary block number */ { -xfs_rtblock_t end;/* end of the freed extent */ +xfs_rtxnum_t end;/* end of the freed extent */ int error;/* error value */ -xfs_rtblock_t postblock;/* first block freed > end */ -xfs_rtblock_t preblock;/* first block freed < start */ +xfs_rtxnum_t postblock;/* first rtext freed > end */ +xfs_rtxnum_t preblock;/* first rtext freed < start */ end = start + len -1 ;/*
@@ -772,10 +772,10 @@ intxfs_rtcheck_range ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t start, /* starting block number of extent */ + xfs_rtxnum_t start, /* starting rtext number of extent */ xfs_rtxlen_t len, /* length of extent */ int val, /* 1 for free, 0 for allocated */ - xfs_rtblock_t *new,/* out: first block not matching */ + xfs_rtxnum_t *new,/* out: first rtext not matching */ int *stat) /* out: 1 for matches, 0 for not */ {xfs_rtword_t *b;/* current word in buffer */
@@ -784,8 +784,8 @@ xfs_rtcheck_range(struct xfs_buf *bp;/* buf for the block */ xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ -xfs_rtblock_t i;/* current bit number rel. to start */ -xfs_rtblock_t lastbit;/* last useful bit in word */ +xfs_rtxnum_t i;/* current bit number rel. to start */ +xfs_rtxnum_t lastbit;/* last useful bit in word */ xfs_rtword_t mask;/* mask of relevant bits for value */ xfs_rtword_t wdiff;/* difference from wanted value */ int word;/* word number in the buffer */
@@ -948,14 +948,14 @@ STATIC int /* error */xfs_rtcheck_alloc_range ( xfs_mount_t *mp,/* file system mount point */ xfs_trans_t *tp,/* transaction pointer */ - xfs_rtblock_t bno, /* starting block number of extent */ + xfs_rtxnum_t start, /* starting rtext number of extent */ xfs_rtxlen_t len) /* length of extent */ { -xfs_rtblock_t new;/* dummy for xfs_rtcheck_range */ +xfs_rtxnum_t new;/* dummy for xfs_rtcheck_range */ int stat;int error; - error =xfs_rtcheck_range (mp, tp, bno, len,0 , &new, &stat); + error =xfs_rtcheck_range (mp, tp, start, len,0 , &new, &stat);if (error)return error;ASSERT (stat);
@@ -971,7 +971,7 @@ xfs_rtcheck_alloc_range(int /* error */ xfs_rtfree_extent (xfs_trans_t *tp,/* transaction pointer */ -xfs_rtblock_t bno,/* starting block number to free */ +xfs_rtxnum_t start,/* starting rtext number to free */ xfs_rtxlen_t len)/* length of extent freed */ {int error;/* error value */
@@ -984,14 +984,14 @@ xfs_rtfree_extent(ASSERT (mp->m_rbmip->i_itemp !=NULL );ASSERT (xfs_isilocked (mp->m_rbmip,XFS_ILOCK_EXCL )); - error =xfs_rtcheck_alloc_range (mp, tp, bno, len); + error =xfs_rtcheck_alloc_range (mp, tp, start, len);if (error)return error;/* * Free the range of realtime blocks. */ - error =xfs_rtfree_range (mp, tp, bno, len, &sumbp, &sb); + error =xfs_rtfree_range (mp, tp, start, len, &sumbp, &sb);if (error) {return error; }
@@ -1025,7 +1025,7 @@ xfs_rtfree_blocks( xfs_filblks_t rtlen) {struct xfs_mount *mp = tp->t_mountp; -xfs_rtblock_t bno; +xfs_rtxnum_t start;xfs_filblks_t len;xfs_extlen_t mod;
@@ -1037,13 +1037,13 @@ xfs_rtfree_blocks(return -EIO ; } - bno =div_u64_rem (rtbno, mp->m_sb.sb_rextsize, &mod); + start =div_u64_rem (rtbno, mp->m_sb.sb_rextsize, &mod);if (mod) {ASSERT (mod ==0 );return -EIO ; } -return xfs_rtfree_extent (tp, bno, len); +return xfs_rtfree_extent (tp, start, len); }/* Find all the free records within a given range. */
@@ -1057,9 +1057,9 @@ xfs_rtalloc_query_range( void *priv) {struct xfs_rtalloc_rec rec; -xfs_rtblock_t rtstart; -xfs_rtblock_t rtend; -xfs_rtblock_t high_key; +xfs_rtxnum_t rtstart; +xfs_rtxnum_t rtend; +xfs_rtxnum_t high_key;int is_free;int error =0 ;
@@ -1122,11 +1122,11 @@ intxfs_rtalloc_extent_is_free ( struct xfs_mount *mp, struct xfs_trans *tp, - xfs_rtblock_t start, + xfs_rtxnum_t start, xfs_rtxlen_t len, bool *is_free) { - xfs_rtblock_t end; + xfs_rtxnum_t end;int matches;int error;
fs/xfs/libxfs/xfs_rtbitmap.h +12 -14
@@ -7,12 +7,10 @@#define __XFS_RTBITMAP_H__/* -* XXX: Most of the realtime allocation functions deal in units of realtime -* extents, not realtime blocks. This looks funny when paired with the type -* name and screams for a larger cleanup. +* Functions for walking free space rtextents in the realtime bitmap. */ struct xfs_rtalloc_rec { -xfs_rtblock_t ar_startext; +xfs_rtxnum_t ar_startext;xfs_rtbxlen_t ar_extcount; };
@@ -26,16 +24,16 @@ typedef int (*xfs_rtalloc_query_range_fn)(int xfs_rtbuf_get (struct xfs_mount *mp,struct xfs_trans *tp,xfs_fileoff_t block,int issum,struct xfs_buf **bpp);int xfs_rtcheck_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtxlen_t len,int val, -xfs_rtblock_t *new,int *stat); +xfs_rtxnum_t start,xfs_rtxlen_t len,int val, +xfs_rtxnum_t *new,int *stat);int xfs_rtfind_back (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtblock_t limit, -xfs_rtblock_t *rtblock); +xfs_rtxnum_t start,xfs_rtxnum_t limit, +xfs_rtxnum_t *rtblock);int xfs_rtfind_forw (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtblock_t limit, -xfs_rtblock_t *rtblock); +xfs_rtxnum_t start,xfs_rtxnum_t limit, +xfs_rtxnum_t *rtblock);int xfs_rtmodify_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtxlen_t len,int val); +xfs_rtxnum_t start,xfs_rtxlen_t len,int val); int xfs_rtmodify_summary_int(struct xfs_mount *mp, struct xfs_trans *tp, int log, xfs_fileoff_t bbno, int delta, struct xfs_buf **rbpp, xfs_fileoff_t *rsb,
@@ -44,7 +42,7 @@ int xfs_rtmodify_summary(struct xfs_mount *mp, struct xfs_trans *tp, int log, xfs_fileoff_t bbno, int delta, struct xfs_buf **rbpp, xfs_fileoff_t *rsb);int xfs_rtfree_range (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtxlen_t len, +xfs_rtxnum_t start,xfs_rtxlen_t len,struct xfs_buf **rbpp,xfs_fileoff_t *rsb); int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp, const struct xfs_rtalloc_rec *low_rec,
@@ -54,7 +52,7 @@ int xfs_rtalloc_query_all(struct xfs_mount *mp, struct xfs_trans *tp,xfs_rtalloc_query_range_fn fn, void *priv);int xfs_rtalloc_extent_is_free (struct xfs_mount *mp,struct xfs_trans *tp, -xfs_rtblock_t start,xfs_rtxlen_t len, +xfs_rtxnum_t start,xfs_rtxlen_t len,bool *is_free);/* * Free an extent in the realtime subvolume. Length is expressed in
@@ -63,7 +61,7 @@ int xfs_rtalloc_extent_is_free(struct xfs_mount *mp, struct xfs_trans *tp,int /* error */ xfs_rtfree_extent (struct xfs_trans *tp,/* transaction pointer */ -xfs_rtblock_t bno,/* starting block number to free */ +xfs_rtxnum_t start,/* starting rtext number to free */ xfs_rtxlen_t len);/* length of extent freed */ /* Same as above, but in units of rt blocks. */
fs/xfs/libxfs/xfs_types.h +2 -0
@@ -32,6 +32,7 @@ typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */typedef uint64_t xfs_rtblock_t ;/* extent (block) in realtime area */ typedef uint64_t xfs_fileoff_t ;/* block number in a file */ typedef uint64_t xfs_filblks_t ;/* number of blocks in a file */ +typedef uint64_t xfs_rtxnum_t ;/* rtextent number */ typedef uint64_t xfs_rtbxlen_t ;/* rtbitmap extent length in rtextents */ typedef int64_t xfs_srtblock_t ;/* signed version of xfs_rtblock_t */
@@ -49,6 +50,7 @@ typedef void * xfs_failaddr_t;#define NULLRFSBLOCK ((xfs_rfsblock_t)-1)#define NULLRTBLOCK ((xfs_rtblock_t)-1)#define NULLFILEOFF ((xfs_fileoff_t)-1) +#define NULLRTEXTNO ((xfs_rtxnum_t)-1)#define NULLAGBLOCK ((xfs_agblock_t)-1)#define NULLAGNUMBER ((xfs_agnumber_t)-1)
fs/xfs/scrub/rtbitmap.c +3 -3
@@ -59,7 +59,7 @@ xchk_rtbitmap_rec( void *priv) {struct xfs_scrub *sc = priv; -xfs_rtblock_t startblock; +xfs_rtxnum_t startblock;xfs_filblks_t blockcount; startblock = rec->ar_startext * mp->m_sb.sb_rextsize;
@@ -143,8 +143,8 @@ xchk_xref_is_used_rt_space( xfs_rtblock_t fsbno, xfs_extlen_t len) { -xfs_rtblock_t startext; -xfs_rtblock_t endext; +xfs_rtxnum_t startext; +xfs_rtxnum_t endext;xfs_rtxlen_t extcount;bool is_free;int error;
fs/xfs/scrub/rtsummary.c +1 -1
@@ -131,7 +131,7 @@ xchk_rtsum_record_free( {struct xfs_scrub *sc = priv;xfs_fileoff_t rbmoff; -xfs_rtblock_t rtbno; +xfs_rtxnum_t rtbno;xfs_filblks_t rtlen;xchk_rtsumoff_t offs;unsigned int lenlog;
fs/xfs/scrub/trace.h +2 -2
@@ -1260,14 +1260,14 @@ TRACE_EVENT(xfarray_sort_stats,#ifdef CONFIG_XFS_RT TRACE_EVENT(xchk_rtsum_record_free, - TP_PROTO(struct xfs_mount *mp, xfs_rtblock_t start, + TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, xfs_rtbxlen_t len, unsigned int log, loff_t pos, xfs_suminfo_t v), TP_ARGS(mp, start, len, log, pos, v), TP_STRUCT__entry( __field(dev_t, dev) __field(dev_t, rtdev) - __field(xfs_rtblock_t, start) + __field(xfs_rtxnum_t, start) __field(unsigned long long, len) __field(unsigned int, log) __field(loff_t, pos)
fs/xfs/xfs_bmap_util.c +5 -7
@@ -76,7 +76,7 @@ xfs_bmap_rtalloc( {struct xfs_mount *mp = ap->ip->i_mount;xfs_fileoff_t orig_offset = ap->offset; -xfs_rtblock_t rtb; +xfs_rtxnum_t rtx;xfs_rtxlen_t prod =0 ;/* product factor for allocators */ xfs_extlen_t mod =0 ;/* product factor for allocators */ xfs_rtxlen_t ralen =0 ;/* realtime allocation length */
@@ -145,8 +145,6 @@ xfs_bmap_rtalloc(* pick an extent that will space things out in the rt area. */ if (ap->eof && ap->offset ==0 ) { -xfs_rtblock_t rtx;/* realtime extent no */ - error =xfs_rtpick_extent (mp, ap->tp, ralen, &rtx);if (error)return error;
@@ -164,16 +162,16 @@ xfs_bmap_rtalloc( ap->blkno =0 ; else do_div(ap->blkno, mp->m_sb.sb_rextsize); - rtb = ap->blkno; + rtx = ap->blkno; ap->length = ralen; raminlen =max_t (xfs_extlen_t,1 , minlen / mp->m_sb.sb_rextsize); error =xfs_rtallocate_extent (ap->tp, ap->blkno, raminlen, ap->length, - &ralen, ap->wasdel, prod, &rtb); + &ralen, ap->wasdel, prod, &rtx);if (error)return error; -if (rtb !=NULLRTBLOCK ) { - ap->blkno = rtb * mp->m_sb.sb_rextsize; +if (rtx !=NULLRTEXTNO ) { + ap->blkno = rtx * mp->m_sb.sb_rextsize; ap->length = ralen * mp->m_sb.sb_rextsize; ap->ip->i_nblocks += ap->length;xfs_trans_log_inode (ap->tp, ap->ip,XFS_ILOG_CORE );
fs/xfs/xfs_rtalloc.c +67 -67
406 lines not on this page · raw message
fs/xfs/xfs_rtalloc.h +3 -3
@@ -24,13 +24,13 @@ struct xfs_trans;int /* error */ xfs_rtallocate_extent (struct xfs_trans *tp,/* transaction pointer */ -xfs_rtblock_t bno,/* starting block number to allocate */ +xfs_rtxnum_t start,/* starting rtext number to allocate */ xfs_rtxlen_t minlen,/* minimum length to allocate */ xfs_rtxlen_t maxlen,/* maximum length to allocate */ xfs_rtxlen_t *len,/* out: actual length allocated */ int wasdel,/* was a delayed allocation extent */ xfs_rtxlen_t prod,/* extent product factor */ -xfs_rtblock_t *rtblock);/* out: start block allocated */ +xfs_rtxnum_t *rtblock);/* out: start rtext allocated */ /*
@@ -63,7 +63,7 @@ xfs_rtpick_extent(struct xfs_mount *mp,/* file system mount point */ struct xfs_trans *tp, /* transaction pointer */ xfs_rtxlen_t len, /* allocation length (rtextents) */ - xfs_rtblock_t *pick); /* result rt extent */ + xfs_rtxnum_t *pick); /* result rt extent *//* * Grow the realtime area of the filesystem.
Re: [PATCH 7/7] xfs: convert rt extent numbers to xfs_rtxnum_t
Looks good:
Re: [PATCHSET RFC v1.0 0/7] xfs: clean up realtime type usage
In reply to Darrick J. WongQuoted 7 lines · Darrick J. Wong
Hi all,
The realtime code uses
xfs_rtblock_tandxfs_fsblock_tin a lot of places, and it's very confusing. Clean up all the type usage so that anxfs_rtblock_tis always a block within the realtime volume, anxfs_fileoff_tis always a file offset within a realtime metadata file, and anxfs_rtxnumber_tis always a rt extent within the realtime volume.
Question as a follow up: now that we have proper types for all the RT-specific units, what's the point of even keeping xfs_rtblock_t around vs always using xfs_fsblock_t or xfs_rfsblock_t?
Re: [PATCHSET RFC v1.0 0/7] xfs: clean up realtime type usage
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
Hi all,
The realtime code uses
xfs_rtblock_tandxfs_fsblock_tin a lot of places, and it's very confusing. Clean up all the type usage so that anxfs_rtblock_tis always a block within the realtime volume, anxfs_fileoff_tis always a file offset within a realtime metadata file, and anxfs_rtxnumber_tis always a rt extent within the realtime volume.
Quoted 3 lines
Question as a follow up: now that we have proper types for all the RT-specific units, what's the point of even keeping
xfs_rtblock_taround vs always usingxfs_fsblock_torxfs_rfsblock_t?
The primary advantage that I can think of is code readability -- all the xfs_*rtb_ functions take xfs_rtblock_t types, and you can follow them all the way through the rt allocator/rmap/refcount code. xfs_rtblock_t is a linear quantity even with rtgroups turned on.
The gross part is that one still has to know that br_startblock can be either xfs_fsblock_t or xfs_rtblock_t depending on inode and whichfork.
That said, I don't think gcc actually warns about silent casts from xfs_fsblock_t to xfs_rtblock_t.
--D
Re: [PATCHSET RFC v1.0 0/7] xfs: clean up realtime type usage
Quoted 7 lines · Darrick J. Wong
The primary advantage that I can think of is code readability -- all the xfs_*rtb_ functions take
xfs_rtblock_ttypes, and you can follow them all the way through the rt allocator/rmap/refcount code.xfs_rtblock_tis a linear quantity even with rtgroups turned on.The gross part is that one still has to know that
br_startblockcan be eitherxfs_fsblock_torxfs_rtblock_tdepending on inode and whichfork.
Yeah.
Quoted 2 lines
That said, I don't think gcc actually warns about silent casts from
xfs_fsblock_ttoxfs_rtblock_t.
typedefs in C are syntactix shugar. You will never get a warning about mixing typedefs for the same underlying type (and often also not for mixing with other integer types). Having an annotation for a strong typedef that can only do arithmetic on itself without casts or special annotations would be really handy, though.
Re: [PATCHSET RFC v1.0 0/7] xfs: clean up realtime type usage
Quoted 15 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
The primary advantage that I can think of is code readability -- all the xfs_*rtb_ functions take
xfs_rtblock_ttypes, and you can follow them all the way through the rt allocator/rmap/refcount code.xfs_rtblock_tis a linear quantity even with rtgroups turned on.The gross part is that one still has to know that
br_startblockcan be eitherxfs_fsblock_torxfs_rtblock_tdepending on inode and whichfork.Yeah.
Quoted 2 lines
That said, I don't think gcc actually warns about silent casts from
xfs_fsblock_ttoxfs_rtblock_t.
Quoted 5 lines
typedefs in C are syntactix shugar. You will never get a warning about mixing typedefs for the same underlying type (and often also not for mixing with other integer types). Having an annotation for a strong typedef that can only do arithmetic on itself without casts or special annotations would be really handy, though.
We can do it crappily in C with __bitwise and letting the static checker bots go wild. Some day when someone rewrites the entire codebase in Rust (HA!) then we'll be able to do:
struct xfs_fsblock_t(u64);
struct xfs_agblock_t(u32);
and (to the extent that I understand Rust) the Rust compiler will complain about stuffing xfs_agblock_t into an xfs_fsblock_t without a proper conversion.
--D
Re: [PATCHSET RFC v1.0 0/7] xfs: clean up realtime type usage
Quoted 10 lines · Darrick J. Wong
We can do it crappily in C with
__bitwiseand letting the static checker bots go wild. Some day when someone rewrites the entire codebase in Rust (HA!) then we'll be able to do:struct
xfs_fsblock_t(u64);
structxfs_agblock_t(u32);and (to the extent that I understand Rust) the Rust compiler will complain about stuffing
xfs_agblock_tinto anxfs_fsblock_twithout a proper conversion.
You can do the struct in C already. Linux actually does it for PTE types optionally. It's just a real pain in the butt if your regularly do arithmetics on it, which we do for the various block/size/offset types.
Quoted 2 lines
--D
---end quoted text---
cover xfs: refactor rt extent unit conversions
In reply to Darrick J. WongHi all,
This series replaces all the open-coded integer division and multiplication conversions between rt blocks and rt extents with calls to static inline helpers. Having cleaned all that up, the helpers are augmented to skip the expensive operations in favor of bit shifts and masking if the rt extent size is a power of two.
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=refactor-rt-unit-conversions
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=refactor-rt-unit-conversions
--- fs/xfs/libxfs/xfs_bmap.c | 19 +++----- fs/xfs/libxfs/xfs_rtbitmap.c | 4 +- fs/xfs/libxfs/xfs_rtbitmap.h | 88 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_sb.c | 2 + fs/xfs/libxfs/xfs_swapext.c | 7 ++- fs/xfs/libxfs/xfs_trans_inode.c | 1 fs/xfs/libxfs/xfs_trans_resv.c | 3 + fs/xfs/scrub/inode.c | 3 + fs/xfs/scrub/inode_repair.c | 3 + fs/xfs/scrub/rtbitmap.c | 18 +++----- fs/xfs/scrub/rtsummary.c | 4 +- fs/xfs/xfs_bmap_util.c | 38 +++++++---------- fs/xfs/xfs_fsmap.c | 14 +++--- fs/xfs/xfs_inode_item.c | 3 + fs/xfs/xfs_ioctl.c | 5 +- fs/xfs/xfs_linux.h | 12 +++++ fs/xfs/xfs_mount.h | 2 + fs/xfs/xfs_rtalloc.c | 16 ++++--- fs/xfs/xfs_super.c | 3 + fs/xfs/xfs_trans.c | 9 +++- fs/xfs/xfs_xchgrange.c | 4 +- 21 files changed, 180 insertions(+), 78 deletions(-)
PATCH 1/7 xfs: create a helper to convert rtextents to rtblocks
From: Darrick J. Wong <[email protected]>
Create a helper to convert a realtime extent to a realtime block. Later on we'll change the helper to use bit shifts when possible.
--- fs/xfs/libxfs/xfs_rtbitmap.h | 16 ++++++++++++++++ fs/xfs/scrub/rtbitmap.c | 4 ++-- fs/xfs/scrub/rtsummary.c | 4 ++-- fs/xfs/xfs_bmap_util.c | 9 +++++---- fs/xfs/xfs_fsmap.c | 6 +++--- fs/xfs/xfs_super.c | 3 ++- 6 files changed, 30 insertions(+), 12 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.h +16 -0
@@ -6,6 +6,22 @@#ifndef __XFS_RTBITMAP_H__#define __XFS_RTBITMAP_H__ +static inline xfs_rtblock_t +xfs_rtx_to_rtb ( +struct xfs_mount *mp, +xfs_rtxnum_t rtx) +{ +return rtx * mp->m_sb.sb_rextsize; +} + +static inline xfs_extlen_t +xfs_rtxlen_to_extlen ( +struct xfs_mount *mp, +xfs_rtxlen_t rtxlen) +{ +return rtxlen * mp->m_sb.sb_rextsize; +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/scrub/rtbitmap.c +2 -2
@@ -62,8 +62,8 @@ xchk_rtbitmap_rec(xfs_rtxnum_t startblock;xfs_filblks_t blockcount; - startblock = rec->ar_startext * mp->m_sb.sb_rextsize; - blockcount = rec->ar_extcount * mp->m_sb.sb_rextsize; + startblock =xfs_rtx_to_rtb (mp, rec->ar_startext); + blockcount =xfs_rtx_to_rtb (mp, rec->ar_extcount);if (!xfs_verify_rtbext (mp, startblock, blockcount))xchk_fblock_set_corrupt (sc,XFS_DATA_FORK ,0 );
fs/xfs/scrub/rtsummary.c +2 -2
@@ -146,8 +146,8 @@ xchk_rtsum_record_free( lenlog =XFS_RTBLOCKLOG (rec->ar_extcount); offs =XFS_SUMOFFS (mp, lenlog, rbmoff); - rtbno = rec->ar_startext * mp->m_sb.sb_rextsize; - rtlen = rec->ar_extcount * mp->m_sb.sb_rextsize; + rtbno =xfs_rtx_to_rtb (mp, rec->ar_startext); + rtlen =xfs_rtx_to_rtb (mp, rec->ar_extcount);if (!xfs_verify_rtbext (mp, rtbno, rtlen)) {xchk_ino_xref_set_corrupt (sc, mp->m_rbmip->i_ino);
fs/xfs/xfs_bmap_util.c +5 -4
@@ -29,6 +29,7 @@#include "xfs_iomap.h" #include "xfs_reflink.h" #include "xfs_swapext.h" +#include "xfs_rtbitmap.h" /* Kernel only BMAP related definitions and functions */
@@ -126,7 +127,7 @@ xfs_bmap_rtalloc(* XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't * adjust the starting point to match it. */ -if (ralen * mp->m_sb.sb_rextsize >=XFS_MAX_BMBT_EXTLEN ) +if (xfs_rtxlen_to_extlen (mp, ralen) >=XFS_MAX_BMBT_EXTLEN ) ralen =XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize;/*
@@ -148,7 +149,7 @@ xfs_bmap_rtalloc( error =xfs_rtpick_extent (mp, ap->tp, ralen, &rtx);if (error)return error; - ap->blkno = rtx * mp->m_sb.sb_rextsize; + ap->blkno =xfs_rtx_to_rtb (mp, rtx); }else { ap->blkno =0 ; }
@@ -171,8 +172,8 @@ xfs_bmap_rtalloc(return error;if (rtx !=NULLRTEXTNO ) { - ap->blkno = rtx * mp->m_sb.sb_rextsize; - ap->length = ralen * mp->m_sb.sb_rextsize; + ap->blkno =xfs_rtx_to_rtb (mp, rtx); + ap->length =xfs_rtxlen_to_extlen (mp, ralen); ap->ip->i_nblocks += ap->length;xfs_trans_log_inode (ap->tp, ap->ip,XFS_ILOG_CORE );if (ap->wasdel)
fs/xfs/xfs_fsmap.c +3 -3
@@ -483,11 +483,11 @@ xfs_getfsmap_rtdev_rtbitmap_helper(xfs_rtblock_t rtbno;xfs_daddr_t rec_daddr, len_daddr; - rtbno = rec->ar_startext * mp->m_sb.sb_rextsize; + rtbno =xfs_rtx_to_rtb (mp, rec->ar_startext); rec_daddr =XFS_FSB_TO_BB (mp, rtbno); irec.rm_startblock = rtbno; - rtbno = rec->ar_extcount * mp->m_sb.sb_rextsize; + rtbno =xfs_rtx_to_rtb (mp, rec->ar_extcount); len_daddr =XFS_FSB_TO_BB (mp, rtbno); irec.rm_blockcount = rtbno;
@@ -514,7 +514,7 @@ xfs_getfsmap_rtdev_rtbitmap(uint64_t eofs;int error; - eofs =XFS_FSB_TO_BB (mp, mp->m_sb.sb_rextents * mp->m_sb.sb_rextsize); + eofs =XFS_FSB_TO_BB (mp,xfs_rtx_to_rtb (mp, mp->m_sb.sb_rextents));if (keys[0 ].fmr_physical >= eofs)return 0 ; start_rtb = XFS_BB_TO_FSBT(mp,
fs/xfs/xfs_super.c +2 -1
@@ -44,6 +44,7 @@#include "xfs_dahash_test.h" #include "xfs_swapext_item.h" #include "xfs_parent.h" +#include "xfs_rtbitmap.h" #include "scrub/stats.h" #include "scrub/rcbag_btree.h"
@@ -893,7 +894,7 @@ xfs_fs_statfs( statp->f_blocks = sbp->sb_rblocks; freertx =percpu_counter_sum_positive (&mp->m_frextents); - statp->f_bavail = statp->f_bfree = freertx * sbp->sb_rextsize; + statp->f_bavail = statp->f_bfree =xfs_rtx_to_rtb (mp, freertx); }return 0 ;
Re: [PATCH 1/7] xfs: create a helper to convert rtextents to rtblocks
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a helper to convert a realtime extent to a realtime block. Later on we'll change the helper to use bit shifts when possible.
Looks good:
PATCH 2/7 xfs: create a helper to compute leftovers of realtime extents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a helper to compute the misalignment between a file extent (xfs_extlen_t) and a realtime extent.
--- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- fs/xfs/libxfs/xfs_rtbitmap.h | 9 +++++++++ fs/xfs/libxfs/xfs_trans_inode.c | 1 + fs/xfs/scrub/inode.c | 3 ++- fs/xfs/scrub/inode_repair.c | 3 ++- fs/xfs/xfs_bmap_util.c | 2 +- fs/xfs/xfs_inode_item.c | 3 ++- fs/xfs/xfs_ioctl.c | 5 +++-- 8 files changed, 22 insertions(+), 8 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +2 -2
@@ -3038,7 +3038,7 @@ xfs_bmap_extsize_align(* If realtime, and the result isn't a multiple of the realtime * extent size we need to remove blocks until it is. */ -if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { +if (rt && (temp =xfs_extlen_to_rtxmod (mp, align_alen))) {/* * We're not covering the original request, or * we won't be able to once we fix the length.
@@ -3065,7 +3065,7 @@ xfs_bmap_extsize_align(else { align_alen -= orig_off - align_off; align_off = orig_off; - align_alen -= align_alen % mp->m_sb.sb_rextsize; + align_alen -=xfs_extlen_to_rtxmod (mp, align_alen); }/* * Result doesn't cover the request, fail it.
fs/xfs/libxfs/xfs_rtbitmap.h +9 -0
@@ -22,6 +22,15 @@ xfs_rtxlen_to_extlen(return rtxlen * mp->m_sb.sb_rextsize; } +/* Compute the misalignment between an extent length and a realtime extent .*/ +static inline unsigned int +xfs_extlen_to_rtxmod ( +struct xfs_mount *mp, +xfs_extlen_t len) +{ +return len % mp->m_sb.sb_rextsize; +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/libxfs/xfs_trans_inode.c +1 -0
@@ -14,6 +14,7 @@#include "xfs_trans.h" #include "xfs_trans_priv.h" #include "xfs_inode_item.h" +#include "xfs_rtbitmap.h" #include <linux/iversion.h>
fs/xfs/scrub/inode.c +2 -1
@@ -20,6 +20,7 @@#include "xfs_reflink.h" #include "xfs_rmap.h" #include "xfs_bmap_util.h" +#include "xfs_rtbitmap.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/btree.h"
@@ -254,7 +255,7 @@ xchk_inode_extsize(*/ if ((flags &XFS_DIFLAG_RTINHERIT ) && (flags &XFS_DIFLAG_EXTSZINHERIT ) && - value % sc->mp->m_sb.sb_rextsize >0 ) +xfs_extlen_to_rtxmod (sc->mp, value) >0 )xchk_ino_set_warning (sc, ino); }
fs/xfs/scrub/inode_repair.c +2 -1
@@ -36,6 +36,7 @@#include "xfs_attr_leaf.h" #include "xfs_log_priv.h" #include "xfs_symlink_remote.h" +#include "xfs_rtbitmap.h" #include "scrub/xfs_scrub.h" #include "scrub/scrub.h" #include "scrub/common.h"
@@ -1599,7 +1600,7 @@ xrep_inode_extsize(/* Fix misaligned extent size hints on a directory. */ if ((sc->ip->i_diflags &XFS_DIFLAG_RTINHERIT ) && (sc->ip->i_diflags &XFS_DIFLAG_EXTSZINHERIT ) && - sc->ip->i_extsize % sc->mp->m_sb.sb_rextsize >0 ) { +xfs_extlen_to_rtxmod (sc->mp, sc->ip->i_extsize) >0 ) { sc->ip->i_extsize =0 ; sc->ip->i_diflags &= ~XFS_DIFLAG_EXTSZINHERIT ; }
fs/xfs/xfs_bmap_util.c +1 -1
@@ -98,7 +98,7 @@ xfs_bmap_rtalloc(if (error)return error;ASSERT (ap->length); -ASSERT (ap->length % mp->m_sb.sb_rextsize ==0 ); +ASSERT (xfs_extlen_to_rtxmod (mp, ap->length) ==0 );/* * If we shifted the file offset downward to satisfy an extent size
fs/xfs/xfs_inode_item.c +2 -1
@@ -19,6 +19,7 @@#include "xfs_log.h" #include "xfs_log_priv.h" #include "xfs_error.h" +#include "xfs_rtbitmap.h" #include <linux/iversion.h>
@@ -107,7 +108,7 @@ xfs_inode_item_precommit(*/ if ((ip->i_diflags &XFS_DIFLAG_RTINHERIT ) && (ip->i_diflags &XFS_DIFLAG_EXTSZINHERIT ) && - (ip->i_extsize % ip->i_mount->m_sb.sb_rextsize) >0 ) { +xfs_extlen_to_rtxmod (ip->i_mount, ip->i_extsize) >0 ) { ip->i_diflags &= ~(XFS_DIFLAG_EXTSIZE |XFS_DIFLAG_EXTSZINHERIT ); ip->i_extsize =0 ;
fs/xfs/xfs_ioctl.c +3 -2
@@ -41,6 +41,7 @@#include "xfs_xattr.h" #include "xfs_xchgrange.h" #include "xfs_file.h" +#include "xfs_rtbitmap.h" #include <linux/mount.h> #include <linux/namei.h>
@@ -1017,7 +1018,7 @@ xfs_fill_fsxattr(* later. */ if ((ip->i_diflags &XFS_DIFLAG_RTINHERIT ) && - ip->i_extsize % mp->m_sb.sb_rextsize >0 ) { +xfs_extlen_to_rtxmod (mp, ip->i_extsize) >0 ) { fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE |FS_XFLAG_EXTSZINHERIT ); fa->fsx_extsize =0 ;
@@ -1083,7 +1084,7 @@ xfs_ioctl_setattr_xflags(/* If realtime flag is set then must have realtime device */ if (fa->fsx_xflags &FS_XFLAG_REALTIME ) {if (mp->m_sb.sb_rblocks ==0 || mp->m_sb.sb_rextsize ==0 || - (ip->i_extsize % mp->m_sb.sb_rextsize)) +xfs_extlen_to_rtxmod (mp, ip->i_extsize))return -EINVAL ; }
Re: [PATCH 2/7] xfs: create a helper to compute leftovers of realtime extents
fs/xfs/libxfs/xfs_trans_inode.c line 20
Quoted 12 lines
fs/xfs/libxfs/xfs_trans_inode.c +1
-0@@ -14,6 +14,7 @@#include "xfs_trans.h" #include "xfs_trans_priv.h" #include "xfs_inode_item.h" +#include "xfs_rtbitmap.h" #include <linux/iversion.h>
This seems to just have slipped in here?
Otherwise looks good:
Re: [PATCH 2/7] xfs: create a helper to compute leftovers of realtime extents
Quoted 10 lines · Christoph Hellwig
Quoted 10 lines
fs/xfs/libxfs/xfs_trans_inode.c +1
-0@@ -14,6 +14,7 @@#include "xfs_trans.h" #include "xfs_trans_priv.h" #include "xfs_inode_item.h" +#include "xfs_rtbitmap.h"
Quoted 4 lines
fs/xfs/libxfs/xfs_trans_inode.c line 20
Quoted 2 lines
fs/xfs/libxfs/xfs_trans_inode.c +0
-0#include <linux/iversion.h> This seems to just have slipped in here?
Oops, good catch. I'll remove that.
Quoted 3 lines
Otherwise looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
--D
PATCH 3/7 xfs: create a helper to compute leftovers of realtime extents
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a helper to compute the realtime extent (xfs_rtxlen_t) from an extent length (xfs_extlen_t) value.
--- fs/xfs/libxfs/xfs_rtbitmap.h | 8 ++++++++ fs/xfs/libxfs/xfs_trans_resv.c | 3 ++- fs/xfs/xfs_bmap_util.c | 11 ++++------- fs/xfs/xfs_trans.c | 5 +++-- 4 files changed, 17 insertions(+), 10 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.h +8 -0
@@ -31,6 +31,14 @@ xfs_extlen_to_rtxmod(return len % mp->m_sb.sb_rextsize; } +static inline xfs_rtxlen_t +xfs_extlen_to_rtxlen ( +struct xfs_mount *mp, +xfs_extlen_t len) +{ +return len / mp->m_sb.sb_rextsize; +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/libxfs/xfs_trans_resv.c +2 -1
@@ -22,6 +22,7 @@#include "xfs_attr_item.h" #include "xfs_log.h" #include "xfs_da_format.h" +#include "xfs_rtbitmap.h" #define _ALLOC true#define _FREE false
@@ -223,7 +224,7 @@ xfs_rtalloc_block_count(unsigned int blksz =XFS_FSB_TO_B (mp,1 );unsigned int rtbmp_bytes; - rtbmp_bytes = (XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize) /NBBY ; + rtbmp_bytes =xfs_extlen_to_rtxlen (mp,XFS_MAX_BMBT_EXTLEN ) /NBBY ;return (howmany (rtbmp_bytes, blksz) +1 ) * num_ops; }
fs/xfs/xfs_bmap_util.c +4 -7
@@ -91,7 +91,7 @@ xfs_bmap_rtalloc( align =xfs_get_extsz_hint (ap->ip); retry: - prod = align / mp->m_sb.sb_rextsize; + prod =xfs_extlen_to_rtxlen (mp, align); error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, align,1 , ap->eof,0 , ap->conv, &ap->offset, &ap->length);
@@ -118,17 +118,14 @@ xfs_bmap_rtalloc( prod =1 ;/* * Set ralen to be the actual requested length in rtextents. -*/ - ralen = ap->length / mp->m_sb.sb_rextsize; -/* +* * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that * we rounded up to it, cut it back so it's valid again. * Note that if it's a really large request (bigger than * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't * adjust the starting point to match it. */ -if (xfs_rtxlen_to_extlen (mp, ralen) >=XFS_MAX_BMBT_EXTLEN ) - ralen =XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize; + ralen =xfs_extlen_to_rtxlen (mp,min (ap->length,XFS_MAX_BMBT_EXTLEN ));/* * Lock out modifications to both the RT bitmap and summary inodes
@@ -165,7 +162,7 @@ xfs_bmap_rtalloc(do_div (ap->blkno, mp->m_sb.sb_rextsize); rtx = ap->blkno; ap->length = ralen; - raminlen =max_t (xfs_extlen_t,1 , minlen / mp->m_sb.sb_rextsize); + raminlen =max_t (xfs_rtxlen_t,1 ,xfs_extlen_to_rtxlen (mp, minlen)); error =xfs_rtallocate_extent (ap->tp, ap->blkno, raminlen, ap->length, &ralen, ap->wasdel, prod, &rtx);if (error)
fs/xfs/xfs_trans.c +3 -2
@@ -24,6 +24,7 @@#include "xfs_dquot_item.h" #include "xfs_dquot.h" #include "xfs_icache.h" +#include "xfs_rtbitmap.h" struct kmem_cache *xfs_trans_cache;
@@ -1252,7 +1253,7 @@ xfs_trans_alloc_inode( retry: error =xfs_trans_alloc (mp, resv, dblocks, - rblocks / mp->m_sb.sb_rextsize, +xfs_extlen_to_rtxlen (mp, rblocks), force ?XFS_TRANS_RESERVE :0 , &tp);if (error)return error;
@@ -1298,7 +1299,7 @@ xfs_trans_reserve_more_inode( bool force_quota) {struct xfs_mount *mp = ip->i_mount; -unsigned int rtx = rblocks / mp->m_sb.sb_rextsize; +unsigned int rtx =xfs_extlen_to_rtxlen (mp, rblocks);int error;ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));
Re: [PATCH 3/7] xfs: create a helper to compute leftovers of realtime extents
Looks good:
PATCH 4/7 xfs: create helpers to convert rt block numbers to rt extent numbers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create helpers to do unit conversions of rt block numbers to rt extent numbers. There are two variations -- the suffix "t" denotes the one that returns only the truncated extent number; the other one also returns the misalignment. Convert all the div_u64_rem users; we'll do the do_div users in the next patch.
--- fs/xfs/libxfs/xfs_bmap.c | 7 +++---- fs/xfs/libxfs/xfs_rtbitmap.c | 4 ++-- fs/xfs/libxfs/xfs_rtbitmap.h | 17 +++++++++++++++++ fs/xfs/libxfs/xfs_swapext.c | 7 ++++--- fs/xfs/xfs_rtalloc.c | 8 ++++---- 5 files changed, 30 insertions(+), 13 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +3 -4
@@ -5336,7 +5336,6 @@ __xfs_bunmapi(int tmp_logflags;/* partial logging flags */ int wasdel;/* was a delayed alloc extent */ int whichfork;/* data or attribute fork */ -xfs_fsblock_t sum;xfs_filblks_t len = *rlen;/* length to unmap in file */ xfs_fileoff_t end;struct xfs_iext_cursor icur;
@@ -5433,8 +5432,7 @@ __xfs_bunmapi(if (!isrt || (flags &XFS_BMAPI_REMAP )) goto delete; - sum = del.br_startblock + del.br_blockcount; -div_u64_rem (sum, mp->m_sb.sb_rextsize, &mod); +xfs_rtb_to_rtx (mp, del.br_startblock + del.br_blockcount, &mod);if (mod) {/* * Realtime extent not lined up at the end.
@@ -5481,7 +5479,8 @@ __xfs_bunmapi( goto error0; goto nodelete; } -div_u64_rem (del.br_startblock, mp->m_sb.sb_rextsize, &mod); + +xfs_rtb_to_rtx (mp, del.br_startblock, &mod);if (mod) {xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
fs/xfs/libxfs/xfs_rtbitmap.c +2 -2
@@ -1031,13 +1031,13 @@ xfs_rtfree_blocks(ASSERT (rtlen <=XFS_MAX_BMBT_EXTLEN ); - len =div_u64_rem (rtlen, mp->m_sb.sb_rextsize, &mod); + len =xfs_rtb_to_rtx (mp, rtlen, &mod);if (mod) {ASSERT (mod ==0 );return -EIO ; } - start =div_u64_rem (rtbno, mp->m_sb.sb_rextsize, &mod); + start =xfs_rtb_to_rtx (mp, rtbno, &mod);if (mod) {ASSERT (mod ==0 );return -EIO ;
fs/xfs/libxfs/xfs_rtbitmap.h +17 -0
@@ -39,6 +39,23 @@ xfs_extlen_to_rtxlen(return len / mp->m_sb.sb_rextsize; } +static inline xfs_rtxnum_t +xfs_rtb_to_rtx ( +struct xfs_mount *mp, +xfs_rtblock_t rtbno, +xfs_extlen_t *mod) +{ +return div_u64_rem (rtbno, mp->m_sb.sb_rextsize, mod); +} + +static inline xfs_rtxnum_t +xfs_rtb_to_rtxt ( +struct xfs_mount *mp, +xfs_rtblock_t rtbno) +{ +return div_u64 (rtbno, mp->m_sb.sb_rextsize); +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/libxfs/xfs_swapext.c +4 -3
@@ -30,6 +30,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;
@@ -202,19 +203,19 @@ xfs_swapext_check_rt_extents( irec2.br_blockcount);/* Both mappings must be aligned to the realtime extent size. */ -div_u64_rem (irec1.br_startoff, mp->m_sb.sb_rextsize, &mod); +xfs_rtb_to_rtx (mp, irec1.br_startoff, &mod);if (mod) {ASSERT (mod ==0 );return -EINVAL ; } -div_u64_rem (irec2.br_startoff, mp->m_sb.sb_rextsize, &mod); +xfs_rtb_to_rtx (mp, irec1.br_startoff, &mod);if (mod) {ASSERT (mod ==0 );return -EINVAL ; } -div_u64_rem (irec1.br_blockcount, mp->m_sb.sb_rextsize, &mod); +xfs_rtb_to_rtx (mp, irec1.br_blockcount, &mod);if (mod) {ASSERT (mod ==0 );return -EINVAL ;
fs/xfs/xfs_rtalloc.c +4 -4
@@ -1496,16 +1496,16 @@ xfs_rtfile_want_conversion( struct xfs_bmbt_irec *irec) {xfs_fileoff_t rext_next; -uint32_t modoff, modcnt; +xfs_extlen_t modoff, modcnt;if (irec->br_state !=XFS_EXT_UNWRITTEN )return false; -div_u64_rem (irec->br_startoff, mp->m_sb.sb_rextsize, &modoff); +xfs_rtb_to_rtx (mp, irec->br_startoff, &modoff);if (modoff ==0 ) { -uint64_t rexts =div_u64_rem (irec->br_blockcount, - mp->m_sb.sb_rextsize, &modcnt); +xfs_rtbxlen_t rexts; + rexts =xfs_rtb_to_rtx (mp, irec->br_blockcount, &modcnt);if (rexts >0 ) {/* * Unwritten mapping starts at an rt extent boundary
Re: [PATCH 4/7] xfs: create helpers to convert rt block numbers to rt extent numbers
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create helpers to do unit conversions of rt block numbers to rt extent numbers. There are two variations -- the suffix "t" denotes the one that returns only the truncated extent number; the other one also returns the misalignment. Convert all the
div_u64_remusers; we'll do thedo_divusers in the next patch.
When trying to work with thee helpers I found the t prefix here a bit weird, as it works different than the T in say XFS_B_TO_FSB vs XFS_B_TO_FSBT which give you different results for the two versions. Here we get the same returned result, just with the additional return for the remainder.
Maybe have xfs_rtb_to_rtx and xfs_rtb_to_rtx_rem for the version with the modulo?
We also have quite a few places that only care about the mod, so an additƣonal xfs_rtb_rem/mod might be useful as well.
Re: [PATCH 4/7] xfs: create helpers to convert rt block numbers to rt extent numbers
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create helpers to do unit conversions of rt block numbers to rt extent numbers. There are two variations -- the suffix "t" denotes the one that returns only the truncated extent number; the other one also returns the misalignment. Convert all the
div_u64_remusers; we'll do thedo_divusers in the next patch.
Quoted 8 lines
When trying to work with thee helpers I found the t prefix here a bit weird, as it works different than the T in say
XFS_B_TO_FSBvsXFS_B_TO_FSBTwhich give you different results for the two versions. Here we get the same returned result, just with the additional return for the remainder.Maybe have
xfs_rtb_to_rtxandxfs_rtb_to_rtx_remfor the version with the modulo?
<nod> I've decided to go with:
/* Convert an rt block number into an rt extent number. */ static inline xfs_rtxnum_t
xfs_rtb_to_rtx(
struct xfs_mount *mp,
xfs_rtblock_t rtbno)
{
return div_u64(rtbno, mp->m_sb.sb_rextsize);
}/* Return the offset of an rt block number within an rt extent. */ static inline xfs_extlen_t
xfs_rtb_to_rtxoff(
struct xfs_mount *mp,
xfs_rtblock_t rtbno)
{
return do_div(rtbno, mp->m_sb.sb_rextsize);
}/*
* Crack an rt block number into an rt extent number and an offset within that
* rt extent. Returns the rt extent number directly and the offset in @off. */
static inline xfs_rtxnum_t
xfs_rtb_to_rtxrem(
struct xfs_mount *mp,
xfs_rtblock_t rtbno,
xfs_extlen_t *off)
{
return div_u64_rem(rtbno, mp->m_sb.sb_rextsize, off);
}Quoted 2 lines
We also have quite a few places that only care about the mod, so an additƣonal xfs_rtb_rem/mod might be useful as well.
Agreed, I had noticed that there were a fair number of places where we're really only checking for rtx alignment. xfs_rtb_to_rtxoff is the new helper.
--D
Re: [PATCH 4/7] xfs: create helpers to convert rt block numbers to rt extent numbers
Quoted 1 line · Darrick J. Wong
<nod> I've decided to go with:
This looks good to me, thanks.
PATCH 5/7 xfs: convert do_div calls to xfs_rtb_to_rtx helper calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert these calls to use the helpers, and clean up all these places where the same variable can have different units depending on where it is in the function.
--- fs/xfs/libxfs/xfs_bmap.c | 8 ++------ fs/xfs/scrub/rtbitmap.c | 14 +++++--------- fs/xfs/xfs_bmap_util.c | 10 ++++------ fs/xfs/xfs_fsmap.c | 8 ++++---- fs/xfs/xfs_rtalloc.c | 3 +-- 5 files changed, 16 insertions(+), 27 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +2 -6
@@ -4883,12 +4883,8 @@ xfs_bmap_del_extent_delay(ASSERT (got->br_startoff <= del->br_startoff);ASSERT (got_endoff >= del_endoff); -if (isrt) { -uint64_t rtexts =XFS_FSB_TO_B (mp, del->br_blockcount); - -do_div (rtexts, mp->m_sb.sb_rextsize); -xfs_mod_frextents (mp, rtexts); - } +if (isrt) +xfs_mod_frextents (mp,xfs_rtb_to_rtxt (mp, del->br_blockcount));/* * Update the inode delalloc counter now and wait to update the
fs/xfs/scrub/rtbitmap.c +5 -9
@@ -140,26 +140,22 @@ xchk_rtbitmap(void xchk_xref_is_used_rt_space (struct xfs_scrub *sc, -xfs_rtblock_t fsbno, +xfs_rtblock_t rtbno,xfs_extlen_t len) {xfs_rtxnum_t startext;xfs_rtxnum_t endext; -xfs_rtxlen_t extcount;bool is_free;int error;if (xchk_skip_xref (sc->sm))return ; - startext = fsbno; - endext = fsbno + len -1 ; -do_div (startext, sc->mp->m_sb.sb_rextsize); -do_div (endext, sc->mp->m_sb.sb_rextsize); - extcount = endext - startext +1 ; + startext =xfs_rtb_to_rtxt (sc->mp, rtbno); + endext =xfs_rtb_to_rtxt (sc->mp, rtbno + len -1 );xfs_ilock (sc->mp->m_rbmip,XFS_ILOCK_SHARED |XFS_ILOCK_RTBITMAP ); - error =xfs_rtalloc_extent_is_free (sc->mp, sc->tp, startext, extcount, - &is_free); + error =xfs_rtalloc_extent_is_free (sc->mp, sc->tp, startext, + endext - startext +1 , &is_free);if (!xchk_should_check_xref (sc, &error,NULL )) goto out_unlock;if (is_free)
fs/xfs/xfs_bmap_util.c +4 -6
@@ -157,14 +157,12 @@ xfs_bmap_rtalloc(* Realtime allocation, done through xfs_rtallocate_extent. */ if (ignore_locality) - ap->blkno =0 ; + rtx =0 ;else -do_div (ap->blkno, mp->m_sb.sb_rextsize); - rtx = ap->blkno; - ap->length = ralen; + rtx =xfs_rtb_to_rtxt (mp, ap->blkno); raminlen =max_t (xfs_rtxlen_t,1 ,xfs_extlen_to_rtxlen (mp, minlen)); - error =xfs_rtallocate_extent (ap->tp, ap->blkno, raminlen, ap->length, - &ralen, ap->wasdel, prod, &rtx); + error =xfs_rtallocate_extent (ap->tp, rtx, raminlen, ralen, &ralen, + ap->wasdel, prod, &rtx);if (error)return error;
fs/xfs/xfs_fsmap.c +4 -4
@@ -512,6 +512,7 @@ xfs_getfsmap_rtdev_rtbitmap(xfs_rtblock_t start_rtb;xfs_rtblock_t end_rtb;uint64_t eofs; +xfs_extlen_t mod;int error; eofs =XFS_FSB_TO_BB (mp,xfs_rtx_to_rtb (mp, mp->m_sb.sb_rextents));
@@ -539,10 +540,9 @@ xfs_getfsmap_rtdev_rtbitmap(* Set up query parameters to return free rtextents covering the range * we want. */ - alow.ar_startext = start_rtb; - ahigh.ar_startext = end_rtb; -do_div (alow.ar_startext, mp->m_sb.sb_rextsize); -if (do_div (ahigh.ar_startext, mp->m_sb.sb_rextsize)) + alow.ar_startext =xfs_rtb_to_rtxt (mp, start_rtb); + ahigh.ar_startext =xfs_rtb_to_rtx (mp, end_rtb, &mod); +if (mod) ahigh.ar_startext++; error =xfs_rtalloc_query_range (mp, tp, &alow, &ahigh, xfs_getfsmap_rtdev_rtbitmap_helper, info);
fs/xfs/xfs_rtalloc.c +1 -2
@@ -1056,8 +1056,7 @@ xfs_growfs_rt( nrblocks_step = (bmbno +1 ) *NBBY * nsbp->sb_blocksize * nsbp->sb_rextsize; nsbp->sb_rblocks =min (nrblocks, nrblocks_step); - nsbp->sb_rextents = nsbp->sb_rblocks; -do_div (nsbp->sb_rextents, nsbp->sb_rextsize); + nsbp->sb_rextents =xfs_rtb_to_rtxt (nmp, nsbp->sb_rblocks);ASSERT (nsbp->sb_rextents !=0 ); nsbp->sb_rextslog =xfs_highbit32 (nsbp->sb_rextents); nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog +1 ;
Re: [PATCH 5/7] xfs: convert do_div calls to xfs_rtb_to_rtx helper calls
fs/xfs/libxfs/xfs_bmap.c xfs_bmap_del_extent_delay( · line 4887
Quoted 8 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_bmap.c +2
-6-if (isrt) { -uint64_t rtexts =XFS_FSB_TO_B (mp, del->br_blockcount); - -do_div (rtexts, mp->m_sb.sb_rextsize); -xfs_mod_frextents (mp, rtexts); - } +if (isrt) +xfs_mod_frextents (mp,xfs_rtb_to_rtxt (mp, del->br_blockcount));
This is losing the XFS_FSB_TO_B conversion. Now that conversion is bogus and doesn't match the rest of the code, and only the fact that we don't currently support delalloc on the RT device has saved our ass since fa5c836ca8e. Maybe split this into a little prep patch with the a fixes tag?
Re: [PATCH 5/7] xfs: convert do_div calls to xfs_rtb_to_rtx helper calls
Quoted 15 lines · Christoph Hellwig
fs/xfs/libxfs/xfs_bmap.c xfs_bmap_del_extent_delay( · line 4887
Quoted 8 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_bmap.c +2
-6-if (isrt) { -uint64_t rtexts =XFS_FSB_TO_B (mp, del->br_blockcount); - -do_div (rtexts, mp->m_sb.sb_rextsize); -xfs_mod_frextents (mp, rtexts); - } +if (isrt) +xfs_mod_frextents (mp,xfs_rtb_to_rtxt (mp, del->br_blockcount));This is losing the
XFS_FSB_TO_Bconversion. Now that conversion is bogus and doesn't match the rest of the code, and only the fact that we don't currently support delalloc on the RT device has saved our ass sincefa5c836ca8e. Maybe split this into a little prep patch with the a fixes tag?
Done.
--D
PATCH 6/7 xfs: create rt extent rounding helpers for realtime extent blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a pair of functions to round rtblock numbers up or down to the nearest rt extent.
--- fs/xfs/libxfs/xfs_rtbitmap.h | 18 ++++++++++++++++++ fs/xfs/xfs_bmap_util.c | 8 +++----- fs/xfs/xfs_rtalloc.c | 4 ++-- fs/xfs/xfs_xchgrange.c | 4 ++-- 4 files changed, 25 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.h +18 -0
@@ -56,6 +56,24 @@ xfs_rtb_to_rtxt(return div_u64 (rtbno, mp->m_sb.sb_rextsize); } +/* Round this rtblock up to the nearest rt extent size. */ +static inline xfs_rtblock_t +xfs_rtb_roundup_rtx ( +struct xfs_mount *mp, +xfs_rtblock_t rtbno) +{ +return roundup_64 (rtbno, mp->m_sb.sb_rextsize); +} + +/* Round this rtblock down to the nearest rt extent size. */ +static inline xfs_rtblock_t +xfs_rtb_rounddown_rtx ( +struct xfs_mount *mp, +xfs_rtblock_t rtbno) +{ +return rounddown_64 (rtbno, mp->m_sb.sb_rextsize); +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/xfs_bmap_util.c +3 -5
@@ -685,7 +685,7 @@ xfs_can_free_eofblocks(*/ end_fsb =XFS_B_TO_FSB (mp, (xfs_ufsize_t )XFS_ISIZE (ip));if (XFS_IS_REALTIME_INODE (ip) && mp->m_sb.sb_rextsize >1 ) - end_fsb =roundup_64 (end_fsb, mp->m_sb.sb_rextsize); + end_fsb =xfs_rtb_roundup_rtx (mp, end_fsb); last_fsb =XFS_B_TO_FSB (mp, mp->m_super->s_maxbytes);if (last_fsb <= end_fsb)return false;
@@ -984,10 +984,8 @@ xfs_free_file_space(/* We can only free complete realtime extents. */ if (xfs_inode_has_bigrtextents (ip)) { - startoffset_fsb =roundup_64 (startoffset_fsb, - mp->m_sb.sb_rextsize); - endoffset_fsb =rounddown_64 (endoffset_fsb, - mp->m_sb.sb_rextsize); + startoffset_fsb =xfs_rtb_roundup_rtx (mp, startoffset_fsb); + endoffset_fsb =xfs_rtb_rounddown_rtx (mp, endoffset_fsb); }/*
fs/xfs/xfs_rtalloc.c +2 -2
@@ -1633,8 +1633,8 @@ xfs_rtfile_convert_unwritten(if (mp->m_sb.sb_rextsize ==1 )return 0 ; - off =rounddown_64 (XFS_B_TO_FSBT (mp, pos), mp->m_sb.sb_rextsize); - endoff =roundup_64 (XFS_B_TO_FSB (mp, pos + len), mp->m_sb.sb_rextsize); + off =xfs_rtb_rounddown_rtx (mp,XFS_B_TO_FSBT (mp, pos)); + endoff =xfs_rtb_roundup_rtx (mp,XFS_B_TO_FSB (mp, pos + len));trace_xfs_rtfile_convert_unwritten (ip, pos, len);
fs/xfs/xfs_xchgrange.c +2 -2
@@ -28,6 +28,7 @@#include "xfs_icache.h" #include "xfs_log.h" #include "xfs_rtalloc.h" +#include "xfs_rtbitmap.h" #include <linux/fsnotify.h> /*
@@ -1236,8 +1237,7 @@ xfs_xchg_range(* offsets and length in @fxr are safe to round up. */ if (XFS_IS_REALTIME_INODE (ip2)) - req.blockcount =roundup_64 (req.blockcount, - mp->m_sb.sb_rextsize); + req.blockcount =xfs_rtb_roundup_rtx (mp, req.blockcount); error =xfs_xchg_range_estimate (&req);if (error)
Re: [PATCH 6/7] xfs: create rt extent rounding helpers for realtime extent blocks
Looks good:
PATCH 7/7 xfs: use shifting and masking when converting rt extents, if possible
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Avoid the costs of integer division (32-bit and 64-bit) if the realtime extent size is a power of two.
--- fs/xfs/libxfs/xfs_rtbitmap.h | 20 ++++++++++++++++++++ fs/xfs/libxfs/xfs_sb.c | 2 ++ fs/xfs/xfs_linux.h | 12 ++++++++++++ fs/xfs/xfs_mount.h | 2 ++ fs/xfs/xfs_rtalloc.c | 1 + fs/xfs/xfs_trans.c | 4 ++++ 6 files changed, 41 insertions(+)
fs/xfs/libxfs/xfs_rtbitmap.h +20 -0
@@ -11,6 +11,9 @@ xfs_rtx_to_rtb( struct xfs_mount *mp, xfs_rtxnum_t rtx) { +if (mp->m_rtxblklog >=0 ) +return rtx << mp->m_rtxblklog; +return rtx * mp->m_sb.sb_rextsize; }
@@ -19,6 +22,9 @@ xfs_rtxlen_to_extlen( struct xfs_mount *mp, xfs_rtxlen_t rtxlen) { +if (mp->m_rtxblklog >=0 ) +return rtxlen << mp->m_rtxblklog; +return rtxlen * mp->m_sb.sb_rextsize; }
@@ -28,6 +34,9 @@ xfs_extlen_to_rtxmod( struct xfs_mount *mp, xfs_extlen_t len) { +if (mp->m_rtxblklog >=0 ) +return len & mp->m_rtxblkmask; +return len % mp->m_sb.sb_rextsize; }
@@ -36,6 +45,9 @@ xfs_extlen_to_rtxlen( struct xfs_mount *mp, xfs_extlen_t len) { +if (mp->m_rtxblklog >=0 ) +return len >> mp->m_rtxblklog; +return len / mp->m_sb.sb_rextsize; }
@@ -45,6 +57,11 @@ xfs_rtb_to_rtx( xfs_rtblock_t rtbno, xfs_extlen_t *mod) { +if (mp->m_rtxblklog >=0 ) { + *mod = rtbno & mp->m_rtxblkmask; +return rtbno >> mp->m_rtxblklog; + } +return div_u64_rem (rtbno, mp->m_sb.sb_rextsize, mod); }
@@ -53,6 +70,9 @@ xfs_rtb_to_rtxt( struct xfs_mount *mp, xfs_rtblock_t rtbno) { +if (mp->m_rtxblklog >=0 ) +return rtbno >> mp->m_rtxblklog; +return div_u64 (rtbno, mp->m_sb.sb_rextsize); }
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -1011,6 +1011,8 @@ xfs_sb_mount_common( mp->m_blockmask = sbp->sb_blocksize -1 ; mp->m_blockwsize = sbp->sb_blocksize >>XFS_WORDLOG ; mp->m_blockwmask = mp->m_blockwsize -1 ; + mp->m_rtxblklog =log2_if_power2 (sbp->sb_rextsize); + mp->m_rtxblkmask =mask64_if_power2 (sbp->sb_rextsize); mp->m_alloc_mxr[0 ] =xfs_allocbt_maxrecs (mp, sbp->sb_blocksize,1 ); mp->m_alloc_mxr[1 ] =xfs_allocbt_maxrecs (mp, sbp->sb_blocksize,0 );
fs/xfs/xfs_linux.h +12 -0
@@ -203,6 +203,18 @@ 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) +{ +return is_power_of_2 (b) ?ilog2 (b) :-1 ; +} + +/* If @b is a power of 2, return a mask of the lower bits, else return zero. */ +static inline unsigned long long mask64_if_power2 (unsigned long b) +{ +return is_power_of_2 (b) ? b -1 :0 ; +} +int xfs_rw_bdev (struct block_device *bdev,sector_t sector,unsigned int count,char *data,enum req_op op);
fs/xfs/xfs_mount.h +2 -0
@@ -120,6 +120,7 @@ typedef struct xfs_mount {uint8_t m_blkbb_log;/* blocklog - BBSHIFT */ uint8_t m_agno_log;/* log #ag's */ uint8_t m_sectbb_log;/* sectlog - BBSHIFT */ +int8_t m_rtxblklog;/* log2 of rextsize, if possible */ uint m_blockmask;/* sb_blocksize-1 */ uint m_blockwsize;/* sb_blocksize in words */ uint m_blockwmask;/* blockwsize-1 */
@@ -153,6 +154,7 @@ typedef struct xfs_mount {uint64_t m_features;/* active filesystem features */ uint64_t m_low_space[XFS_LOWSP_MAX ];uint64_t m_low_rtexts[XFS_LOWSP_MAX ]; +uint64_t m_rtxblkmask;/* rt extent block mask */ struct xfs_ino_geometry m_ino_geo;/* inode geometry */ struct xfs_trans_resv m_resv;/* precomputed res values */ /* low free space thresholds */
fs/xfs/xfs_rtalloc.c +1 -0
@@ -1052,6 +1052,7 @@ xfs_growfs_rt(* Calculate new sb and mount fields for this round. */ nsbp->sb_rextsize = in->extsize; + nmp->m_rtxblklog =-1 ;/* don't use shift or masking */ nsbp->sb_rbmblocks = bmbno +1 ; nrblocks_step = (bmbno +1 ) *NBBY * nsbp->sb_blocksize * nsbp->sb_rextsize;
fs/xfs/xfs_trans.c +4 -0
@@ -712,6 +712,10 @@ xfs_trans_unreserve_and_mod_sb( mp->m_sb.sb_agcount += tp->t_agcount_delta; mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta; mp->m_sb.sb_rextsize += tp->t_rextsize_delta; +if (tp->t_rextsize_delta) { + mp->m_rtxblklog =log2_if_power2 (mp->m_sb.sb_rextsize); + mp->m_rtxblkmask =mask64_if_power2 (mp->m_sb.sb_rextsize); + } mp->m_sb.sb_rbmblocks += tp->t_rbmblocks_delta; mp->m_sb.sb_rblocks += tp->t_rblocks_delta; mp->m_sb.sb_rextents += tp->t_rextents_delta;
Re: [PATCH 7/7] xfs: use shifting and masking when converting rt extents, if possible
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Avoid the costs of integer division (32-bit and 64-bit) if the realtime extent size is a power of two.
Looks good:
Do you have any data on how common non-power of two rtext sizes are? Might it be worth to add unlikely annotations?
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rtx_to_rtb( · line 17
Quoted 8 lines
fs/xfs/libxfs/xfs_rtbitmap.h +3
-0@@ -11,6 +11,9 @@ xfs_rtx_to_rtb( struct xfs_mount *mp, xfs_rtxnum_t rtx) { +if (mp->m_rtxblklog >=0 ) +return rtx << mp->m_rtxblklog; +return rtx * mp->m_sb.sb_rextsize;
i.e.
if (unlikely(mp->m_rtxblklog == ‐1)) return rtx * mp->m_sb.sb_rextsize; return rtx << mp->m_rtxblklog;
Re: [PATCH 7/7] xfs: use shifting and masking when converting rt extents, if possible
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Avoid the costs of integer division (32-bit and 64-bit) if the realtime extent size is a power of two.
Quoted 6 lines
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>Do you have any data on how common non-power of two rtext sizes are? Might it be worth to add unlikely annotations?
I don't really know about the historical uses. There might be old filesystems out there with a non-power-of-2 raid stripe size that are set up for full stripe allocations for speed.
We (oracle) are interested in using rt for PMD allocations on pmem/cxl devices and atomic writes on scsi/nvme devices. Both of those cases will only ever use powers of 2.
I'll add some if-test annotations and we'll see if anyone notices. ;)
--D
Quoted 15 lines
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rtx_to_rtb( · line 17
Quoted 8 lines
fs/xfs/libxfs/xfs_rtbitmap.h +3
-0@@ -11,6 +11,9 @@ xfs_rtx_to_rtb( struct xfs_mount *mp, xfs_rtxnum_t rtx) { +if (mp->m_rtxblklog >=0 ) +return rtx << mp->m_rtxblklog; +return rtx * mp->m_sb.sb_rextsize;i.e.
if (unlikely(mp->m_rtxblklog == ‐1)) return rtx * mp->m_sb.sb_rextsize; return rtx << mp->m_rtxblklog;
Re: [PATCH 7/7] xfs: use shifting and masking when converting rt extents, if possible
Quoted 18 lines · Darrick J. Wong
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Avoid the costs of integer division (32-bit and 64-bit) if the realtime extent size is a power of two.
Quoted 6 lines
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>Do you have any data on how common non-power of two rtext sizes are? Might it be worth to add unlikely annotations?
I don't really know about the historical uses. There might be old filesystems out there with a non-power-of-2 raid stripe size that are set up for full stripe allocations for speed.
Quoted 7 lines
We (oracle) are interested in using rt for PMD allocations on pmem/cxl devices and atomic writes on scsi/nvme devices. Both of those cases will only ever use powers of 2.
I'll add some if-test annotations and we'll see if anyone notices. ;)
--D
We are using 1044KB realtime extents (blocksize = 4096, rextsize = 261) for our blob storage system. It's a goofy number, but IIRC it was chosen because their most common blob sizes were single-digit multiples of a megabyte, and they wanted a large-ish (~1MB) realtime extent size to reduce external fragmentation, but they also wanted to store a bit of extra metadata without requiring an extra realtime extent and blowing up internal fragmentation.
Re: [PATCH 7/7] xfs: use shifting and masking when converting rt extents, if possible
Quoted 27 lines · Omar Sandoval
Quoted 18 lines · Darrick J. Wong
Quoted 6 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Avoid the costs of integer division (32-bit and 64-bit) if the realtime extent size is a power of two.
Quoted 6 lines
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>Do you have any data on how common non-power of two rtext sizes are? Might it be worth to add unlikely annotations?
I don't really know about the historical uses. There might be old filesystems out there with a non-power-of-2 raid stripe size that are set up for full stripe allocations for speed.
Quoted 7 lines
We (oracle) are interested in using rt for PMD allocations on pmem/cxl devices and atomic writes on scsi/nvme devices. Both of those cases will only ever use powers of 2.
I'll add some if-test annotations and we'll see if anyone notices. ;)
--D
Quoted 7 lines
We are using 1044KB realtime extents (blocksize = 4096, rextsize = 261) for our blob storage system. It's a goofy number, but IIRC it was chosen because their most common blob sizes were single-digit multiples of a megabyte, and they wanted a large-ish (~1MB) realtime extent size to reduce external fragmentation, but they also wanted to store a bit of extra metadata without requiring an extra realtime extent and blowing up internal fragmentation.
LOL, and here I thought I was only pushing weird sizes like 28k to drive willy crazy. ;) I wrapped some of the if tests in likely(); they can get ripped back out.
--D
cover xfs: refactor rtbitmap/summary macros
In reply to Darrick J. WongHi all,
In preparation for adding block headers and enforcing endian order in rtbitmap and rtsummary blocks, replace open-coded geometry computations and fugly macros with proper helper functions that can be typechecked. Soon we'll be needing to add more complex logic to the helpers.
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=refactor-rtbitmap-macros
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=refactor-rtbitmap-macros
--- fs/xfs/libxfs/xfs_format.h | 32 ++--- fs/xfs/libxfs/xfs_rtbitmap.c | 268 ++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_rtbitmap.h | 133 +++++++++++++++++++ fs/xfs/libxfs/xfs_trans_resv.c | 9 + fs/xfs/libxfs/xfs_types.h | 2 fs/xfs/scrub/rtsummary.c | 50 ++++--- fs/xfs/scrub/rtsummary.h | 6 - fs/xfs/scrub/rtsummary_repair.c | 7 + fs/xfs/scrub/trace.c | 1 fs/xfs/scrub/trace.h | 4 - fs/xfs/xfs_ondisk.h | 4 + fs/xfs/xfs_rtalloc.c | 39 +++--- 12 files changed, 408 insertions(+), 147 deletions(-)
PATCH 1/8 xfs: convert the rtbitmap block and bit macros to static inline functions
From: Darrick J. Wong <[email protected]>
Replace these macros with typechecked helper functions. Eventually we're going to add more logic to the helpers and it'll be easier if we don't have to macro it up.
--- fs/xfs/libxfs/xfs_format.h | 5 ----- fs/xfs/libxfs/xfs_rtbitmap.c | 22 +++++++++++----------- fs/xfs/libxfs/xfs_rtbitmap.h | 27 +++++++++++++++++++++++++++ fs/xfs/scrub/rtsummary.c | 2 +- fs/xfs/xfs_rtalloc.c | 20 ++++++++++---------- 5 files changed, 49 insertions(+), 27 deletions(-)
fs/xfs/libxfs/xfs_format.h +0 -5
@@ -1226,11 +1226,6 @@ static inline bool xfs_dinode_has_large_extent_counts( ((xfs_suminfo_t *)((bp)->b_addr + \ (((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp)))) -#define XFS_BITTOBLOCK (mp,bi) ((bi) >> (mp)->m_blkbit_log) -#define XFS_BLOCKTOBIT (mp,bb) ((bb) << (mp)->m_blkbit_log) -#define XFS_BITTOWORD (mp,bi) \ - ((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp))) -#define XFS_RTMIN (a,b) ((a) < (b) ? (a) : (b))#define XFS_RTMAX (a,b) ((a) > (b) ? (a) : (b))
fs/xfs/libxfs/xfs_rtbitmap.c +11 -11
@@ -123,7 +123,7 @@ xfs_rtfind_back(/* * Compute and read in starting bitmap block for starting block. */ - block =XFS_BITTOBLOCK (mp, start); + block =xfs_rtx_to_rbmblock (mp, start); error =xfs_rtbuf_get (mp, tp, block,0 , &bp);if (error) {return error;
@@ -132,7 +132,7 @@ xfs_rtfind_back(/* * Get the first word's index & point to it. */ - word =XFS_BITTOWORD (mp, start); + word =xfs_rtx_to_rbmword (mp, start); b = &bufp[word]; bit = (int )(start & (XFS_NBWORD -1 )); len = start - limit +1 ;
@@ -298,7 +298,7 @@ xfs_rtfind_forw(/* * Compute and read in starting bitmap block for starting block. */ - block =XFS_BITTOBLOCK (mp, start); + block =xfs_rtx_to_rbmblock (mp, start); error =xfs_rtbuf_get (mp, tp, block,0 , &bp);if (error) {return error;
@@ -307,7 +307,7 @@ xfs_rtfind_forw(/* * Get the first word's index & point to it. */ - word =XFS_BITTOWORD (mp, start); + word =xfs_rtx_to_rbmword (mp, start); b = &bufp[word]; bit = (int )(start & (XFS_NBWORD -1 )); len = limit - start +1 ;
@@ -559,7 +559,7 @@ xfs_rtmodify_range(/* * Compute starting bitmap block number. */ - block =XFS_BITTOBLOCK (mp, start); + block =xfs_rtx_to_rbmblock (mp, start);/* * Read the bitmap block, and point to its data. */
@@ -571,7 +571,7 @@ xfs_rtmodify_range(/* * Compute the starting word's address, and starting bit. */ - word =XFS_BITTOWORD (mp, start); + word =xfs_rtx_to_rbmword (mp, start); first = b = &bufp[word]; bit = (int )(start & (XFS_NBWORD -1 ));/*
@@ -737,7 +737,7 @@ xfs_rtfree_range(if (preblock < start) { error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (start - preblock), -XFS_BITTOBLOCK (mp, preblock),-1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, preblock),-1 , rbpp, rsb);if (error) {return error; }
@@ -749,7 +749,7 @@ xfs_rtfree_range(if (postblock > end) { error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (postblock - end), -XFS_BITTOBLOCK (mp, end +1 ),-1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, end +1 ),-1 , rbpp, rsb);if (error) {return error; }
@@ -760,7 +760,7 @@ xfs_rtfree_range(*/ error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (postblock +1 - preblock), -XFS_BITTOBLOCK (mp, preblock),1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, preblock),1 , rbpp, rsb);return error; }
@@ -793,7 +793,7 @@ xfs_rtcheck_range(/* * Compute starting bitmap block number */ - block =XFS_BITTOBLOCK (mp, start); + block =xfs_rtx_to_rbmblock (mp, start);/* * Read the bitmap block. */
@@ -805,7 +805,7 @@ xfs_rtcheck_range(/* * Compute the starting word's address, and starting bit. */ - word =XFS_BITTOWORD (mp, start); + word =xfs_rtx_to_rbmword (mp, start); b = &bufp[word]; bit = (int )(start & (XFS_NBWORD -1 ));/*
fs/xfs/libxfs/xfs_rtbitmap.h +27 -0
@@ -94,6 +94,33 @@ xfs_rtb_rounddown_rtx(return rounddown_64 (rtbno, mp->m_sb.sb_rextsize); } +/* Convert an rt extent number to a file block offset in the rt bitmap file. */ +static inline xfs_fileoff_t +xfs_rtx_to_rbmblock ( +struct xfs_mount *mp, +xfs_rtxnum_t rtx) +{ +return rtx >> mp->m_blkbit_log; +} + +/* Convert an rt extent number to a word offset within an rt bitmap block. */ +static inline unsigned int +xfs_rtx_to_rbmword ( +struct xfs_mount *mp, +xfs_rtxnum_t rtx) +{ +return (rtx >>XFS_NBWORDLOG ) &XFS_BLOCKWMASK (mp); +} + +/* Convert a file block offset in the rt bitmap file to an rt extent number. */ +static inline xfs_rtxnum_t +xfs_rbmblock_to_rtx ( +struct xfs_mount *mp, +xfs_fileoff_t rbmoff) +{ +return rbmoff << mp->m_blkbit_log; +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
fs/xfs/scrub/rtsummary.c +1 -1
@@ -142,7 +142,7 @@ xchk_rtsum_record_free(return error;/* Compute the relevant location in the rtsum file. */ - rbmoff =XFS_BITTOBLOCK (mp, rec->ar_startext); + rbmoff =xfs_rtx_to_rbmblock (mp, rec->ar_startext); lenlog =XFS_RTBLOCKLOG (rec->ar_extcount); offs =XFS_SUMOFFS (mp, lenlog, rbmoff);
fs/xfs/xfs_rtalloc.c +10 -10
@@ -182,7 +182,7 @@ xfs_rtallocate_range(*/ error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (postblock +1 - preblock), -XFS_BITTOBLOCK (mp, preblock),-1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, preblock),-1 , rbpp, rsb);if (error) {return error; }
@@ -193,7 +193,7 @@ xfs_rtallocate_range(if (preblock < start) { error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (start - preblock), -XFS_BITTOBLOCK (mp, preblock),1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, preblock),1 , rbpp, rsb);if (error) {return error; }
@@ -205,7 +205,7 @@ xfs_rtallocate_range(if (postblock > end) { error =xfs_rtmodify_summary (mp, tp,XFS_RTBLOCKLOG (postblock - end), -XFS_BITTOBLOCK (mp, end +1 ),1 , rbpp, rsb); +xfs_rtx_to_rbmblock (mp, end +1 ),1 , rbpp, rsb);if (error) {return error; }
@@ -249,8 +249,8 @@ xfs_rtallocate_extent_block(* Loop over all the extents starting in this bitmap block, * looking for one that's long enough. */ -for (i =XFS_BLOCKTOBIT (mp, bbno), besti =-1 , bestlen =0 , - end =XFS_BLOCKTOBIT (mp, bbno +1 ) -1 ; +for (i =xfs_rbmblock_to_rtx (mp, bbno), besti =-1 , bestlen =0 , + end =xfs_rbmblock_to_rtx (mp, bbno +1 ) -1 ; i <= end; i++) {/*
@@ -487,7 +487,7 @@ xfs_rtallocate_extent_near( *rtx = r;return 0 ; } - bbno =XFS_BITTOBLOCK (mp, start); + bbno =xfs_rtx_to_rbmblock (mp, start); i =0 ;ASSERT (minlen !=0 ); log2len =xfs_highbit32 (minlen);
@@ -706,8 +706,8 @@ xfs_rtallocate_extent_size(* allocator is beyond the next bitmap block, * skip to that bitmap block. */ -if (XFS_BITTOBLOCK (mp, n) > i +1 ) - i =XFS_BITTOBLOCK (mp, n) -1 ; +if (xfs_rtx_to_rbmblock (mp, n) > i +1 ) + i =xfs_rtx_to_rbmblock (mp, n) -1 ; } }/*
@@ -769,8 +769,8 @@ xfs_rtallocate_extent_size(* allocator is beyond the next bitmap block, * skip to that bitmap block. */ -if (XFS_BITTOBLOCK (mp, n) > i +1 ) - i =XFS_BITTOBLOCK (mp, n) -1 ; +if (xfs_rtx_to_rbmblock (mp, n) > i +1 ) + i =xfs_rtx_to_rbmblock (mp, n) -1 ; } }/*
Re: [PATCH 1/8] xfs: convert the rtbitmap block and bit macros to static inline functions
Looks good:
PATCH 2/8 xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Remove these trivial macros since they're not even part of the ondisk format.
--- fs/xfs/libxfs/xfs_format.h | 2 -- fs/xfs/libxfs/xfs_rtbitmap.c | 16 ++++++++-------- fs/xfs/libxfs/xfs_rtbitmap.h | 2 +- 3 files changed, 9 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_format.h +0 -2
@@ -1213,8 +1213,6 @@ static inline bool xfs_dinode_has_large_extent_counts(#define XFS_BLOCKSIZE (mp) ((mp)->m_sb.sb_blocksize)#define XFS_BLOCKMASK (mp) ((mp)->m_blockmask) -#define XFS_BLOCKWSIZE (mp) ((mp)->m_blockwsize) -#define XFS_BLOCKWMASK (mp) ((mp)->m_blockwmask)/* * RT Summary and bit manipulation macros.
fs/xfs/libxfs/xfs_rtbitmap.c +8 -8
@@ -181,7 +181,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp); + word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {/*
@@ -227,7 +227,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp); + word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {/*
@@ -345,7 +345,7 @@ xfs_rtfind_forw(* Go on to next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * If done with this block, get the previous one. */
@@ -390,7 +390,7 @@ xfs_rtfind_forw(* Go on to next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * If done with this block, get the next one. */
@@ -600,7 +600,7 @@ xfs_rtmodify_range(* Go on to the next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * Log the changed part of this block. * Get the next one.
@@ -640,7 +640,7 @@ xfs_rtmodify_range(* Go on to the next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * Log the changed part of this block. * Get the next one.
@@ -843,7 +843,7 @@ xfs_rtcheck_range(* Go on to next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * If done with this block, get the next one. */
@@ -889,7 +889,7 @@ xfs_rtcheck_range(* Go on to next block if that's where the next word is * and we need the next word. */ -if (++word ==XFS_BLOCKWSIZE (mp) && i < len) { +if (++word == mp->m_blockwsize && i < len) {/* * If done with this block, get the next one. */
fs/xfs/libxfs/xfs_rtbitmap.h +1 -1
@@ -109,7 +109,7 @@ xfs_rtx_to_rbmword( struct xfs_mount *mp, xfs_rtxnum_t rtx) { -return (rtx >>XFS_NBWORDLOG ) &XFS_BLOCKWMASK (mp); +return (rtx >>XFS_NBWORDLOG ) & (mp->m_blockwsize -1 ); }/* Convert a file block offset in the rt bitmap file to an rt extent number. */
Re: [PATCH 2/8] xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
Quoted 10 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.c +1
-1@@ -181,7 +181,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp); + word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {/*
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtfind_back( · line 232
Quoted 7 lines
fs/xfs/libxfs/xfs_rtbitmap.c +1
-1@@ -227,7 +227,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp); + word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {
Random rambling: there is a fairly large chunk of code duplicated here. Maybe the caching series and/or Dave's suggest args cleanup would be good opportunity to refactor it. Same for the next two clusters of two chunks.
The patch itself looks good:
Re: [PATCH 2/8] xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
Quoted 15 lines · Christoph Hellwig
Quoted 14 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.c +1
-2@@ -181,7 +181,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp); + word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {/* @@ -227,7 +227,7 @@ xfs_rtfind_back(return error; } bufp = bp->b_addr; - word =XFS_BLOCKWMASK (mp);
Quoted 8 lines
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtfind_back( · line 186
Quoted 3 lines
fs/xfs/libxfs/xfs_rtbitmap.c +1
-0+ word = mp->m_blockwsize -1 ; b = &bufp[word]; }else {Random rambling: there is a fairly large chunk of code duplicated here. Maybe the caching series and/or Dave's suggest args cleanup would be good opportunity to refactor it. Same for the next two clusters of two chunks.
Yeah, Dave and I will have to figure out how to integrate these two. I might just pull in his rtalloc_args patch at the end of this series.
--D
Quoted 3 lines
The patch itself looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Re: [PATCH 2/8] xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
Quoted 7 lines · Darrick J. Wong
Quoted 4 lines
Random rambling: there is a fairly large chunk of code duplicated here. Maybe the caching series and/or Dave's suggest args cleanup would be good opportunity to refactor it. Same for the next two clusters of two chunks.
Yeah, Dave and I will have to figure out how to integrate these two. I might just pull in his
rtalloc_argspatch at the end of this series.
They way I understood his review of Omars patches isn't that he has a rtalloc_args patch, but suggest adding that structure.
I can take care of that after your series and Omar has landed, together with the bitmap/summary access abstraction.
Re: [PATCH 2/8] xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Quoted 4 lines
Random rambling: there is a fairly large chunk of code duplicated here. Maybe the caching series and/or Dave's suggest args cleanup would be good opportunity to refactor it. Same for the next two clusters of two chunks.
Quoted 8 lines
Quoted 2 lines
Yeah, Dave and I will have to figure out how to integrate these two. I might just pull in his
rtalloc_argspatch at the end of this series.They way I understood his review of Omars patches isn't that he has a
rtalloc_argspatch, but suggest adding that structure.I can take care of that after your series and Omar has landed, together with the bitmap/summary access abstraction.
Ah. I stg import'd Dave's suggestionpatch and it more or less applied, so it's already in the work branch. It also reduced Omar's patchset quite a bit.
--D
PATCH 3/8 xfs: convert open-coded xfs_rtword_t pointer accesses to helper
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
There are a bunch of places where we use open-coded logic to find a pointer to an xfs_rtword_t within a rt bitmap buffer. Convert all that to helper functions for better type safety.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 59 ++++++++++++++++++++++-------------------- fs/xfs/libxfs/xfs_rtbitmap.h | 20 ++++++++++++++ 2 files changed, 51 insertions(+), 28 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +31 -28
@@ -110,7 +110,6 @@ xfs_rtfind_back(int bit;/* bit number in the word */ xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ -xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ xfs_rtxnum_t firstbit;/* first useful bit in the word */ xfs_rtxnum_t i;/* current bit number rel. to start */
@@ -128,12 +127,12 @@ xfs_rtfind_back(if (error) {return error; } - bufp = bp->b_addr; +/* * Get the first word's index & point to it. */ word =xfs_rtx_to_rbmword (mp, start); - b = &bufp[word]; + b =xfs_rbmblock_wordptr (bp, word); bit = (int )(start & (XFS_NBWORD -1 )); len = start - limit +1 ;/*
@@ -180,9 +179,9 @@ xfs_rtfind_back(if (error) {return error; } - bufp = bp->b_addr; + word = mp->m_blockwsize -1 ; - b = &bufp[word]; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the previous word in the buffer.
@@ -226,9 +225,9 @@ xfs_rtfind_back(if (error) {return error; } - bufp = bp->b_addr; + word = mp->m_blockwsize -1 ; - b = &bufp[word]; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the previous word in the buffer.
@@ -285,7 +284,6 @@ xfs_rtfind_forw(int bit;/* bit number in the word */ xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ -xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ xfs_rtxnum_t i;/* current bit number rel. to start */ xfs_rtxnum_t lastbit;/* last useful bit in the word */
@@ -303,12 +301,12 @@ xfs_rtfind_forw(if (error) {return error; } - bufp = bp->b_addr; +/* * Get the first word's index & point to it. */ word =xfs_rtx_to_rbmword (mp, start); - b = &bufp[word]; + b =xfs_rbmblock_wordptr (bp, word); bit = (int )(start & (XFS_NBWORD -1 )); len = limit - start +1 ;/*
@@ -354,8 +352,9 @@ xfs_rtfind_forw(if (error) {return error; } - b = bufp = bp->b_addr; + word =0 ; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the previous word in the buffer.
@@ -399,8 +398,9 @@ xfs_rtfind_forw(if (error) {return error; } - b = bufp = bp->b_addr; + word =0 ; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the next word in the buffer.
@@ -548,7 +548,6 @@ xfs_rtmodify_range(int bit;/* bit number in the word */ xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ -xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ xfs_rtword_t *first;/* first used word in the buffer */ int i;/* current bit number rel. to start */
@@ -567,12 +566,12 @@ xfs_rtmodify_range(if (error) {return error; } - bufp = bp->b_addr; +/* * Compute the starting word's address, and starting bit. */ word =xfs_rtx_to_rbmword (mp, start); - first = b = &bufp[word]; + first = b =xfs_rbmblock_wordptr (bp, word); bit = (int )(start & (XFS_NBWORD -1 ));/* * 0 (allocated) => all zeroes; 1 (free) => all ones.
@@ -606,14 +605,15 @@ xfs_rtmodify_range(* Get the next one. */ xfs_trans_log_buf (tp, bp, - (uint)((char *)first - (char *)bufp), - (uint)((char *)b - (char *)bufp)); + (uint)((char *)first - (char *)bp->b_addr), + (uint)((char *)b - (char *)bp->b_addr)); error =xfs_rtbuf_get (mp, tp, ++block,0 , &bp);if (error) {return error; } - first = b = bufp = bp->b_addr; + word =0 ; + first = b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the next word in the buffer
@@ -646,14 +646,15 @@ xfs_rtmodify_range(* Get the next one. */ xfs_trans_log_buf (tp, bp, - (uint)((char *)first - (char *)bufp), - (uint)((char *)b - (char *)bufp)); + (uint)((char *)first - (char *)bp->b_addr), + (uint)((char *)b - (char *)bp->b_addr)); error =xfs_rtbuf_get (mp, tp, ++block,0 , &bp);if (error) {return error; } - first = b = bufp = bp->b_addr; + word =0 ; + first = b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the next word in the buffer
@@ -683,8 +684,9 @@ xfs_rtmodify_range(* Log any remaining changed bytes. */ if (b > first) -xfs_trans_log_buf (tp, bp, (uint)((char *)first - (char *)bufp), - (uint)((char *)b - (char *)bufp -1 )); +xfs_trans_log_buf (tp, bp, + (uint)((char *)first - (char *)bp->b_addr), + (uint)((char *)b - (char *)bp->b_addr -1 ));return 0 ; }
@@ -782,7 +784,6 @@ xfs_rtcheck_range(int bit;/* bit number in the word */ xfs_fileoff_t block;/* bitmap block number */ struct xfs_buf *bp;/* buf for the block */ -xfs_rtword_t *bufp;/* starting word in buffer */ int error;/* error value */ xfs_rtxnum_t i;/* current bit number rel. to start */ xfs_rtxnum_t lastbit;/* last useful bit in word */
@@ -801,12 +802,12 @@ xfs_rtcheck_range(if (error) {return error; } - bufp = bp->b_addr; +/* * Compute the starting word's address, and starting bit. */ word =xfs_rtx_to_rbmword (mp, start); - b = &bufp[word]; + b =xfs_rbmblock_wordptr (bp, word); bit = (int )(start & (XFS_NBWORD -1 ));/* * 0 (allocated) => all zero's; 1 (free) => all one's.
@@ -852,8 +853,9 @@ xfs_rtcheck_range(if (error) {return error; } - b = bufp = bp->b_addr; + word =0 ; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the next word in the buffer.
@@ -898,8 +900,9 @@ xfs_rtcheck_range(if (error) {return error; } - b = bufp = bp->b_addr; + word =0 ; + b =xfs_rbmblock_wordptr (bp, word); }else {/* * Go on to the next word in the buffer.
fs/xfs/libxfs/xfs_rtbitmap.h +20 -0
@@ -121,6 +121,26 @@ xfs_rbmblock_to_rtx(return rbmoff << mp->m_blkbit_log; } +/* Return a pointer to a bitmap word within a rt bitmap block buffer. */ +static inline xfs_rtword_t * +xfs_rbmbuf_wordptr ( +void *buf, +unsigned int rbmword) +{ +xfs_rtword_t *wordp = buf; + +return &wordp[rbmword]; +} + +/* Return a pointer to a bitmap word within a rt bitmap block. */ +static inline xfs_rtword_t * +xfs_rbmblock_wordptr ( +struct xfs_buf *bp, +unsigned int rbmword) +{ +return xfs_rbmbuf_wordptr (bp->b_addr, rbmword); +} +/* * Functions for walking free space rtextents in the realtime bitmap. */
Re: [PATCH 3/8] xfs: convert open-coded xfs_rtword_t pointer accesses to helper
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rbmblock_to_rtx( · line 132
Quoted 9 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.h +9
-0+/* Return a pointer to a bitmap word within a rt bitmap block buffer. */ +static inline xfs_rtword_t * +xfs_rbmbuf_wordptr ( +void *buf, +unsigned int rbmword) +{ +xfs_rtword_t *wordp = buf; + +return &wordp[rbmword];
Superficial nitpick, I find the array dereference syntax here highly confusing as the passed in pointer is not an array at all.
In fact I wonder what the xfs_rbmbuf_wordptr helper is for? Even looking at your full patch stack xfs_rbmblock_wordptr seems like the only user.
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rbmblock_to_rtx( · line 141
Quoted 7 lines
fs/xfs/libxfs/xfs_rtbitmap.h +7
-0+/* Return a pointer to a bitmap word within a rt bitmap block. */ +static inline xfs_rtword_t * +xfs_rbmblock_wordptr ( +struct xfs_buf *bp, +unsigned int rbmword) +{ +return xfs_rbmbuf_wordptr (bp->b_addr, rbmword);
So I'd much rather just open code this as:
xfs_rtword_t *words = bp->b_addr; return words + rbmword;
and if I want to get really fancy I'd maybe rename rbmword to something like index which feels more readable than rbmword.
That beeing said the xfs_rbmblock_wordptr abstraction is very welcome.
Re: [PATCH 3/8] xfs: convert open-coded xfs_rtword_t pointer accesses to helper
Quoted 14 lines · Christoph Hellwig
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rbmblock_to_rtx( · line 132
Quoted 9 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.h +9
-0+/* Return a pointer to a bitmap word within a rt bitmap block buffer. */ +static inline xfs_rtword_t * +xfs_rbmbuf_wordptr ( +void *buf, +unsigned int rbmword) +{ +xfs_rtword_t *wordp = buf; + +return &wordp[rbmword];Superficial nitpick, I find the array dereference syntax here highly confusing as the passed in pointer is not an array at all.
Quoted 3 lines
In fact I wonder what the
xfs_rbmbuf_wordptrhelper is for? Even looking at your full patch stackxfs_rbmblock_wordptrseems like the only user.
IIRC an earlier version of this patchset actually tried to use xfs_rbmbuf_wordptr in the online repair code when it was building the new rtbitmap file contents. At some point I must've decided that it was easier to access the xfile directly.
So, yes, this helper can be deleted.
Quoted 10 lines
fs/xfs/libxfs/xfs_rtbitmap.h xfs_rbmblock_to_rtx( · line 141
Quoted 7 lines
fs/xfs/libxfs/xfs_rtbitmap.h +7
-0+/* Return a pointer to a bitmap word within a rt bitmap block. */ +static inline xfs_rtword_t * +xfs_rbmblock_wordptr ( +struct xfs_buf *bp, +unsigned int rbmword) +{ +return xfs_rbmbuf_wordptr (bp->b_addr, rbmword);So I'd much rather just open code this as:
Quoted 6 lines
xfs_rtword_t *words = bp->b_addr; return words + rbmword;and if I want to get really fancy I'd maybe rename rbmword to something like index which feels more readable than rbmword.
Done.
Quoted 1 line
That beeing said the
xfs_rbmblock_wordptrabstraction is very welcome.
Thanks!
--D
PATCH 4/8 xfs: convert rt summary macros to helpers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert the realtime summary file macros to helper functions so that we can improve type checking.
--- fs/xfs/libxfs/xfs_format.h | 9 +----- fs/xfs/libxfs/xfs_rtbitmap.c | 10 ++++--- fs/xfs/libxfs/xfs_rtbitmap.h | 59 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_types.h | 2 + fs/xfs/scrub/rtsummary.c | 16 ++++++----- fs/xfs/scrub/rtsummary.h | 4 +-- fs/xfs/scrub/rtsummary_repair.c | 7 +++-- 7 files changed, 83 insertions(+), 24 deletions(-)
fs/xfs/libxfs/xfs_format.h +1 -8
@@ -1215,15 +1215,8 @@ static inline bool xfs_dinode_has_large_extent_counts(#define XFS_BLOCKMASK (mp) ((mp)->m_blockmask)/* -* RT Summary and bit manipulation macros. +* RT bit manipulation macros. */ -#define XFS_SUMOFFS (mp,ls,bb) ((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb))) -#define XFS_SUMOFFSTOBLOCK (mp,s) \ - (((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog) -#define XFS_SUMPTR (mp,bp,so) \ - ((xfs_suminfo_t *)((bp)->b_addr + \ - (((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp)))) -#define XFS_RTMIN (a,b) ((a) < (b) ? (a) : (b))#define XFS_RTMAX (a,b) ((a) > (b) ? (a) : (b))
fs/xfs/libxfs/xfs_rtbitmap.c +6 -4
@@ -462,17 +462,18 @@ xfs_rtmodify_summary_int(struct xfs_buf *bp;/* buffer for the summary block */ int error;/* error value */ xfs_fileoff_t sb;/* summary fsblock */ -int so;/* index into the summary file */ +xfs_rtsumoff_t so;/* index into the summary file */ xfs_suminfo_t *sp;/* pointer to returned data */ +unsigned int infoword;/* * Compute entry number in the summary file. */ - so =XFS_SUMOFFS (mp, log, bbno); + so =xfs_rtsumoffs (mp, log, bbno);/* * Compute the block number in the summary file. */ - sb =XFS_SUMOFFSTOBLOCK (mp, so); + sb =xfs_rtsumoffs_to_block (mp, so);/* * If we have an old buffer, and the block number matches, use that. */
@@ -500,7 +501,8 @@ xfs_rtmodify_summary_int(/* * Point to the summary information, modify/log it, and/or copy it out. */ - sp =XFS_SUMPTR (mp, bp, so); + infoword =xfs_rtsumoffs_to_infoword (mp, so); + sp =xfs_rsumblock_infoptr (bp, infoword);if (delta) {uint first = (uint)((char *)sp - (char *)bp->b_addr);
fs/xfs/libxfs/xfs_rtbitmap.h +59 -0
65 lines not on this page · raw message
fs/xfs/libxfs/xfs_types.h +2 -0
@@ -19,6 +19,7 @@ typedef int64_t xfs_fsize_t; /* bytes in a file */typedef uint64_t xfs_ufsize_t ;/* unsigned bytes in a file */ typedef int32_t xfs_suminfo_t ;/* type of bitmap summary info */ +typedef uint32_t xfs_rtsumoff_t ;/* offset of an rtsummary info word */ typedef uint32_t xfs_rtword_t ;/* word type for bitmap manipulations */ typedef int64_t xfs_lsn_t ;/* log sequence number */
@@ -151,6 +152,7 @@ typedef uint32_t xfs_dqid_t;*/ #define XFS_NBBYLOG 3/* log2(NBBY) */ #define XFS_WORDLOG 2/* log2(sizeof(xfs_rtword_t)) */ +#define XFS_SUMINFOLOG 2/* log2(sizeof(xfs_suminfo_t)) */ #define XFS_NBWORDLOG (XFS_NBBYLOG + XFS_WORDLOG)#define XFS_NBWORD (1 << XFS_NBWORDLOG)#define XFS_WORDMASK ((1 << XFS_WORDLOG) - 1)
fs/xfs/scrub/rtsummary.c +9 -7
@@ -93,7 +93,7 @@ xchk_setup_rtsummary(static inline int xfsum_load (struct xfs_scrub *sc, -xchk_rtsumoff_t sumoff, +xfs_rtsumoff_t sumoff,xfs_suminfo_t *info) { return xfile_obj_load(sc->xfile, info, sizeof(xfs_suminfo_t),
@@ -103,7 +103,7 @@ xfsum_load(static inline int xfsum_store (struct xfs_scrub *sc, -xchk_rtsumoff_t sumoff, +xfs_rtsumoff_t sumoff,const xfs_suminfo_t info) { return xfile_obj_store(sc->xfile, &info, sizeof(xfs_suminfo_t),
@@ -113,7 +113,7 @@ xfsum_store(inline int xfsum_copyout (struct xfs_scrub *sc, -xchk_rtsumoff_t sumoff, +xfs_rtsumoff_t sumoff,xfs_suminfo_t *info,unsigned int nr_words) {
@@ -133,7 +133,7 @@ xchk_rtsum_record_free(xfs_fileoff_t rbmoff;xfs_rtxnum_t rtbno;xfs_filblks_t rtlen; -xchk_rtsumoff_t offs; +xfs_rtsumoff_t offs;unsigned int lenlog;xfs_suminfo_t v =0 ;int error =0 ;
@@ -144,7 +144,7 @@ xchk_rtsum_record_free(/* Compute the relevant location in the rtsum file. */ rbmoff =xfs_rtx_to_rbmblock (mp, rec->ar_startext); lenlog =XFS_RTBLOCKLOG (rec->ar_extcount); - offs =XFS_SUMOFFS (mp, lenlog, rbmoff); + offs =xfs_rtsumoffs (mp, lenlog, rbmoff); rtbno =xfs_rtx_to_rtb (mp, rec->ar_startext); rtlen =xfs_rtx_to_rtb (mp, rec->ar_extcount);
@@ -193,10 +193,11 @@ xchk_rtsum_compare(struct xfs_buf *bp;struct xfs_bmbt_irec map;xfs_fileoff_t off; -xchk_rtsumoff_t sumoff =0 ; +xfs_rtsumoff_t sumoff =0 ;int nmap;for (off =0 ; off <XFS_B_TO_FSB (mp, mp->m_rsumsize); off++) { +xfs_suminfo_t *ondisk_info;int error =0 ;if (xchk_should_terminate (sc, &error))
@@ -228,7 +229,8 @@ xchk_rtsum_compare(return error; } -if (memcmp (bp->b_addr, sc->buf, + ondisk_info =xfs_rsumblock_infoptr (bp,0 ); +if (memcmp (ondisk_info, sc->buf, mp->m_blockwsize <<XFS_WORDLOG ) !=0 )xchk_fblock_set_corrupt (sc,XFS_DATA_FORK , off);
fs/xfs/scrub/rtsummary.h +2 -2
@@ -6,9 +6,9 @@#ifndef __XFS_SCRUB_RTSUMMARY_H__#define __XFS_SCRUB_RTSUMMARY_H__ -typedef unsigned int xchk_rtsumoff_t ; +typedef unsigned int xfs_rtsumoff_t ; -int xfsum_copyout (struct xfs_scrub *sc,xchk_rtsumoff_t sumoff, +int xfsum_copyout (struct xfs_scrub *sc,xfs_rtsumoff_t sumoff,xfs_suminfo_t *info,unsigned int nr_words);#endif /* __XFS_SCRUB_RTSUMMARY_H__ */
fs/xfs/scrub/rtsummary_repair.c +4 -3
@@ -18,6 +18,7 @@#include "xfs_bmap.h" #include "xfs_bmap_btree.h" #include "xfs_swapext.h" +#include "xfs_rtbitmap.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -30,7 +31,7 @@struct xrep_rtsummary {/* suminfo position of xfile as we write buffers to disk. */ -xchk_rtsumoff_t prep_wordoff; +xfs_rtsumoff_t prep_wordoff; };/* Set us up to repair the rtsummary file. */
@@ -89,8 +90,8 @@ xrep_rtsummary_prep_buf( bp->b_ops = &xfs_rtbuf_ops; - error =xfsum_copyout (sc, rs->prep_wordoff, bp->b_addr, - mp->m_blockwsize); + error =xfsum_copyout (sc, rs->prep_wordoff, +xfs_rsumblock_infoptr (bp,0 ), mp->m_blockwsize);if (error)return error;
Re: [PATCH 4/8] xfs: convert rt summary macros to helpers
Looks good:
PATCH 5/8 xfs: create helpers for rtbitmap block/wordcount computations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create helper functions that compute the number of blocks or words necessary to store the rt bitmap.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 27 +++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtbitmap.h | 12 ++++++++++++ fs/xfs/libxfs/xfs_trans_resv.c | 9 +++++---- fs/xfs/scrub/rtsummary.c | 7 +++---- fs/xfs/xfs_rtalloc.c | 2 +- 5 files changed, 48 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +27 -0
@@ -1142,3 +1142,30 @@ xfs_rtalloc_extent_is_free( *is_free = matches;return 0 ; } + +/* +* Compute the number of rtbitmap blocks needed to track the given number of rt +* extents. +*/ +xfs_filblks_t +xfs_rtbitmap_blockcount ( +struct xfs_mount *mp, +xfs_rtbxlen_t rtextents) +{ +return howmany_64 (rtextents,NBBY * mp->m_sb.sb_blocksize); +} + +/* +* Compute the number of rtbitmap words needed to populate every block of a +* bitmap that is large enough to track the given number of rt extents. +*/ +unsigned long long +xfs_rtbitmap_wordcount ( +struct xfs_mount *mp, +xfs_rtbxlen_t rtextents) +{ +xfs_filblks_t blocks; + + blocks =xfs_rtbitmap_blockcount (mp, rtextents); +return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; +}
fs/xfs/libxfs/xfs_rtbitmap.h +12 -0
@@ -261,6 +261,11 @@ xfs_rtfree_extent(/* Same as above, but in units of rt blocks. */ int xfs_rtfree_blocks (struct xfs_trans *tp,xfs_fsblock_t rtbno,xfs_filblks_t rtlen); + +xfs_filblks_t xfs_rtbitmap_blockcount (struct xfs_mount *mp,xfs_rtbxlen_t + rtextents); +unsigned long long xfs_rtbitmap_wordcount (struct xfs_mount *mp, +xfs_rtbxlen_t rtextents);#else /* CONFIG_XFS_RT */ # define xfs_rtfree_extent (t,b,l) (-ENOSYS)# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS)
@@ -268,6 +273,13 @@ int xfs_rtfree_blocks(struct xfs_trans *tp, xfs_fsblock_t rtbno,# define xfs_rtalloc_query_all (m,t,f,p) (-ENOSYS)# define xfs_rtbuf_get (m,t,b,i,p) (-ENOSYS)# define xfs_rtalloc_extent_is_free (m,t,s,l,i) (-ENOSYS) +static inline xfs_filblks_t +xfs_rtbitmap_blockcount (struct xfs_mount *mp,xfs_rtbxlen_t rtextents) +{ +/* shut up gcc */ +return 0 ; +} +# define xfs_rtbitmap_wordcount (mp, r) (0)#endif /* CONFIG_XFS_RT */ #endif /* __XFS_RTBITMAP_H__ */
fs/xfs/libxfs/xfs_trans_resv.c +5 -4
@@ -221,11 +221,12 @@ xfs_rtalloc_block_count( struct xfs_mount *mp, unsigned int num_ops) { -unsigned int blksz =XFS_FSB_TO_B (mp,1 ); -unsigned int rtbmp_bytes; +unsigned int rtbmp_blocks; +xfs_rtxlen_t rtxlen; - rtbmp_bytes =xfs_extlen_to_rtxlen (mp,XFS_MAX_BMBT_EXTLEN ) /NBBY ; -return (howmany (rtbmp_bytes, blksz) +1 ) * num_ops; + rtxlen =xfs_extlen_to_rtxlen (mp,XFS_MAX_BMBT_EXTLEN ); + rtbmp_blocks =xfs_rtbitmap_blockcount (mp, rtxlen); +return (rtbmp_blocks +1 ) * num_ops; }/*
fs/xfs/scrub/rtsummary.c +3 -4
@@ -172,12 +172,11 @@ xchk_rtsum_compute( struct xfs_scrub *sc) {struct xfs_mount *mp = sc->mp; -unsigned long long rtbmp_bytes; +unsigned long long rtbmp_blocks;/* If the bitmap size doesn't match the computed size, bail. */ - rtbmp_bytes =howmany_64 (mp->m_sb.sb_rextents,NBBY ); -if (roundup_64 (rtbmp_bytes, mp->m_sb.sb_blocksize) != - mp->m_rbmip->i_disk_size) + rtbmp_blocks =xfs_rtbitmap_blockcount (mp, mp->m_sb.sb_rextents); +if (XFS_FSB_TO_B (mp, rtbmp_blocks) != mp->m_rbmip->i_disk_size)return -EFSCORRUPTED ; return xfs_rtalloc_query_all(sc->mp, sc->tp, xchk_rtsum_record_free,
fs/xfs/xfs_rtalloc.c +1 -1
@@ -996,7 +996,7 @@ xfs_growfs_rt(*/ nrextents = nrblocks;do_div (nrextents, in->extsize); - nrbmblocks =howmany_64 (nrextents,NBBY * sbp->sb_blocksize); + nrbmblocks =xfs_rtbitmap_blockcount (mp, nrextents); nrextslog =xfs_highbit32 (nrextents); nrsumlevels = nrextslog +1 ; nrsumsize = (uint )sizeof (xfs_suminfo_t) * nrsumlevels * nrbmblocks;
Re: [PATCH 5/8] xfs: create helpers for rtbitmap block/wordcount computations
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtalloc_extent_is_free( · line 1156
Quoted 11 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.c +11
-0+/* +* Compute the number of rtbitmap blocks needed to track the given number of rt +* extents. +*/ +xfs_filblks_t +xfs_rtbitmap_blockcount ( +struct xfs_mount *mp, +xfs_rtbxlen_t rtextents) +{ +return howmany_64 (rtextents,NBBY * mp->m_sb.sb_blocksize); +}
Given that this only has a few users, the !RT stub is a pain, and having a different result from before in the transaction reservation is somewhat unexpected change (even if harmless), maybe just mark this inline?
Quoted 4 lines
fs/xfs/libxfs/xfs_rtbitmap.c +4
-0+/* +* Compute the number of rtbitmap words needed to populate every block of a +* bitmap that is large enough to track the given number of rt extents. +*/
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtalloc_extent_is_free( · line 1171
Quoted 10 lines
fs/xfs/libxfs/xfs_rtbitmap.c +10
-0+unsigned long long +xfs_rtbitmap_wordcount ( +struct xfs_mount *mp, +xfs_rtbxlen_t rtextents) +{ +xfs_filblks_t blocks; + + blocks =xfs_rtbitmap_blockcount (mp, rtextents); +return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; +}
This one isn't used in this patch or the rest of the series. Maybe move it to the patch (-series) that adds the caller in the repair code?
Re: [PATCH 5/8] xfs: create helpers for rtbitmap block/wordcount computations
Quoted 16 lines · Christoph Hellwig
Review
Quoted 11 lines · Darrick J. Wong
(quoted diff) +11
-0+/* + * Compute the number of rtbitmap blocks needed to track the given number of rt + * extents. + */ +xfs_filblks_t +xfs_rtbitmap_blockcount( + struct xfs_mount *mp, + xfs_rtbxlen_t rtextents) +{ + return howmany_64(rtextents, NBBY * mp->m_sb.sb_blocksize); +}Given that this only has a few users, the !RT stub is a pain, and having a different result from before in the transaction reservation is somewhat unexpected change (even if harmless),
Ohh, right, I didn't even notice that the result changes slightly when the we go from dividing by NBBY before howmany'ing with blocksize to howmany'ing with (NBBY * blocksize).
Quoted 1 line
maybe just mark this inline?
I could make these inline functions at the bottom of xfs_rtbitmap.h, and even put them outside of the #ifdef RT bits. That'll get rid of two stubs for now, but later the rtgroups patchset wants to add a header to rtbitmap blocks. Then we'll need a function to compute the number of rtextents covered by a single bitmap block:
/* Compute the number of rt extents tracked by a single bitmap block. */ xfs_rtxnum_t
xfs_rtbitmap_rtx_per_rbmblock(
struct xfs_mount *mp)
{
unsigned int rbmblock_bytes = mp->m_sb.sb_blocksize;
if (xfs_has_rtgroups(mp))
rbmblock_bytes -= sizeof(struct xfs_rtbuf_blkinfo);
return rbmblock_bytes * NBBY;
}So then either this function will need to have a stub that returns a garbage value. Alternately, it could move out of xfs_rtbitmap.c.
Right now, xfs_rtbitmap_rtx_per_rbmblock isn't even a defined symbol for !RT, and the stub version of _wordcount and _blockcount return 0, which at least makes sense.
Quoted 10 lines
Quoted 10 lines
(quoted diff) +10
-0+/* + * Compute the number of rtbitmap words needed to populate every block of a + * bitmap that is large enough to track the given number of rt extents. + */ +unsigned long long +xfs_rtbitmap_wordcount( + struct xfs_mount *mp, + xfs_rtbxlen_t rtextents) +{ + xfs_filblks_t blocks;
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ + blocks = xfs_rtbitmap_blockcount(mp, rtextents); + return XFS_FSB_TO_B(mp, blocks) >> XFS_WORDLOG; +}This one isn't used in this patch or the rest of the series. Maybe move it to the patch (-series) that adds the caller in the repair code?
<shrug> The xfsprogs version of this patch uses this helper to decrapify the incore rtbitmap computation in xfs_repair:
repair/rt.c +5 -5
@@ -19,6 +19,8 @@void rtinit (xfs_mount_t *mp) { +unsigned long long wordcnt; +if (mp->m_sb.sb_rblocks ==0 )return ;
@@ -26,11 +28,9 @@ rtinit(xfs_mount_t *mp)* realtime init -- blockmap initialization is * handled by incore_init() */ -/* -sumfile = calloc(mp->m_rsumsize, 1); -*/ -if ((btmcompute =calloc (mp->m_sb.sb_rbmblocks * - mp->m_sb.sb_blocksize,1 )) ==NULL ) + wordcnt =libxfs_rtbitmap_wordcount (mp, mp->m_sb.sb_rextents); + btmcompute =calloc (wordcnt,sizeof (xfs_rtword_t)); +if (!btmcompute)do_error (_ ("couldn't allocate memory for incore realtime bitmap.\n" ));
So I'd rather leave these two helpers defined as they are.
--D
Re: [PATCH 5/8] xfs: create helpers for rtbitmap block/wordcount computations
Quoted 2 lines · Darrick J. Wong
<shrug> The xfsprogs version of this patch uses this helper to decrapify the incore rtbitmap computation in
xfs_repair:
Ok, let's keep them as-is.
PATCH 6/8 xfs: use accessor functions for bitmap words
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create get and set functions for rtbitmap words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk rtbitmap words so that the compiler can perform proper typechecking as we go back and forth.
In the upcoming rtgroups feature, we're going to fix the problem that rtwords are written in host endian order, which means we'll need the distinct rtword/rtword_raw types.
--- fs/xfs/libxfs/xfs_format.h | 8 ++++ fs/xfs/libxfs/xfs_rtbitmap.c | 78 +++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_rtbitmap.h | 10 ++++- fs/xfs/xfs_ondisk.h | 3 ++ 4 files changed, 75 insertions(+), 24 deletions(-)
fs/xfs/libxfs/xfs_format.h +8 -0
@@ -728,6 +728,14 @@ struct xfs_agfl { ASSERT(xfs_daddr_to_agno(mp, d) == \ xfs_daddr_to_agno(mp, (d) + (len) - 1))) +/* +* Realtime bitmap information is accessed by the word, which is currently +* stored in host-endian format. +*/ +union xfs_rtword_ondisk { +__u32 raw; +}; +/* * XFS Timestamps * ==============
fs/xfs/libxfs/xfs_rtbitmap.c +57 -21
221 lines not on this page · raw message
fs/xfs/libxfs/xfs_rtbitmap.h +7 -3
@@ -122,18 +122,18 @@ xfs_rbmblock_to_rtx( }/* Return a pointer to a bitmap word within a rt bitmap block buffer. */ -static inline xfs_rtword_t * +static inline union xfs_rtword_ondisk *xfs_rbmbuf_wordptr (void *buf,unsigned int rbmword) { -xfs_rtword_t *wordp = buf; +union xfs_rtword_ondisk *wordp = buf;return &wordp[rbmword]; }/* Return a pointer to a bitmap word within a rt bitmap block. */ -static inline xfs_rtword_t * +static inline union xfs_rtword_ondisk *xfs_rbmblock_wordptr (struct xfs_buf *bp,unsigned int rbmword)
@@ -266,6 +266,10 @@ xfs_filblks_t xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t rtextents);unsigned long long xfs_rtbitmap_wordcount (struct xfs_mount *mp,xfs_rtbxlen_t rtextents); +xfs_rtword_t xfs_rtbitmap_getword (struct xfs_mount *mp, +union xfs_rtword_ondisk *wordptr); +void xfs_rtbitmap_setword (struct xfs_mount *mp, +union xfs_rtword_ondisk *wordptr,xfs_rtword_t incore);#else /* CONFIG_XFS_RT */ # define xfs_rtfree_extent (t,b,l) (-ENOSYS)# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS)
fs/xfs/xfs_ondisk.h +3 -0
@@ -72,6 +72,9 @@ xfs_check_ondisk_structs(void)XFS_CHECK_STRUCT_SIZE (xfs_attr_leaf_map_t,4 );XFS_CHECK_STRUCT_SIZE (xfs_attr_leaf_name_local_t,4 ); +/* realtime structures */ + XFS_CHECK_STRUCT_SIZE(union xfs_rtword_ondisk, 4); +/* * m68k has problems with xfs_attr_leaf_name_remote_t, but we pad it to * 4 bytes anyway so it's not obviously a problem. Hence for the moment
Re: [PATCH 6/8] xfs: use accessor functions for bitmap words
Quoted 10 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create get and set functions for rtbitmap words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk rtbitmap words so that the compiler can perform proper typechecking as we go back and forth.
In the upcoming rtgroups feature, we're going to fix the problem that rtwords are written in host endian order, which means we'll need the distinct rtword/rtword_raw types.
I've been looking over this and I have to say I kinda hate the abstraction level.
Having to deal with both the union xfs_rtword_ondisk, and the normal in-memory rtword just feels cumbersome.
I'd go for an API that gets/sets the values based on [bp, word] indices instead. That would also need helpers for logging the buffer ranges based on indices, which seems helpful for the code quality anyway.
I don't really want to burden that on you and would offer to do that work myself after we work before this merged.
Re: [PATCH 6/8] xfs: use accessor functions for bitmap words
Quoted 18 lines · Christoph Hellwig
Quoted 10 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create get and set functions for rtbitmap words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk rtbitmap words so that the compiler can perform proper typechecking as we go back and forth.
In the upcoming rtgroups feature, we're going to fix the problem that rtwords are written in host endian order, which means we'll need the distinct rtword/rtword_raw types.
I've been looking over this and I have to say I kinda hate the abstraction level.
Having to deal with both the union
xfs_rtword_ondisk, and the normal in-memory rtword just feels cumbersome.
Quoted 6 lines
I'd go for an API that gets/sets the values based on [bp, word] indices instead. That would also need helpers for logging the buffer ranges based on indices, which seems helpful for the code quality anyway.
I don't really want to burden that on you and would offer to do that work myself after we work before this merged.
Hmm, so you want to go from:
union xfs_rtword_ondisk *start, *end, *b;
start = b = xfs_rbmblock_wordptr(bp, startword);
end = xfs_rbmblock_wordptr(bp, endword);
while (b < end) {
somevalue = xfs_rtbitmap_getword(mp, b);
somevalue |= somemask;
xfs_rtbitmap_setword(mp, b, somevalue);
b++;
}
xfs_trans_log_buf(tp, bp, start - bp->b_addr, b - bp->b_addr);to something like:
for (word = startword; word <= endword; word++) {
somevalue = xfs_rtbitmap_getword(mp, b);
somevalue |= somemask;
xfs_rtbitmap_setword(mp, bp, word, somevalue);
}
xfs_rtbitmap_log_buf(tp, bp, startword, endword);I think that could be done with relatively little churn, though it's unfortunate that the second version does 2x(shift + addition) each time it goes through the loop instead of the pointer increment that the first version does.
--D
Re: [PATCH 6/8] xfs: use accessor functions for bitmap words
Quoted 16 lines · Darrick J. Wong
Hmm, so you want to go from:
union xfs_rtword_ondisk *start, *end, *b; start = b = xfs_rbmblock_wordptr(bp, startword); end = xfs_rbmblock_wordptr(bp, endword); while (b < end) { somevalue = xfs_rtbitmap_getword(mp, b); somevalue |= somemask; xfs_rtbitmap_setword(mp, b, somevalue); b++; } xfs_trans_log_buf(tp, bp, start - bp->b_addr, b - bp->b_addr);
Quoted 8 lines
to something like:
for (word = startword; word <= endword; word++) { somevalue = xfs_rtbitmap_getword(mp, b); somevalue |= somemask; xfs_rtbitmap_setword(mp, bp, word, somevalue); } xfs_rtbitmap_log_buf(tp, bp, startword, endword);
Yes. (although xfs_rtbitmap_log_buf can't just take the words directly of course, and the xfs_rtbitmap_getword needs word and not the now not existing b).
Quoted 4 lines
I think that could be done with relatively little churn, though it's unfortunate that the second version does 2x(shift + addition) each time it goes through the loop instead of the pointer increment that the first version does.
I don't really think it matter compared to all the other overhead, and it keeps a much nicer API.
Re: [PATCH 6/8] xfs: use accessor functions for bitmap words
Quoted 30 lines · Christoph Hellwig
Quoted 16 lines · Darrick J. Wong
Hmm, so you want to go from:
union xfs_rtword_ondisk *start, *end, *b; start = b = xfs_rbmblock_wordptr(bp, startword); end = xfs_rbmblock_wordptr(bp, endword); while (b < end) { somevalue = xfs_rtbitmap_getword(mp, b); somevalue |= somemask; xfs_rtbitmap_setword(mp, b, somevalue); b++; } xfs_trans_log_buf(tp, bp, start - bp->b_addr, b - bp->b_addr);Quoted 8 lines
to something like:
for (word = startword; word <= endword; word++) { somevalue = xfs_rtbitmap_getword(mp, b); somevalue |= somemask; xfs_rtbitmap_setword(mp, bp, word, somevalue); } xfs_rtbitmap_log_buf(tp, bp, startword, endword);Yes. (although
xfs_rtbitmap_log_bufcan't just take the words directly of course, and thexfs_rtbitmap_getwordneeds word and not the now not existing b).
Quoted 7 lines
Quoted 4 lines
I think that could be done with relatively little churn, though it's unfortunate that the second version does 2x(shift + addition) each time it goes through the loop instead of the pointer increment that the first version does.
I don't really think it matter compared to all the other overhead, and it keeps a much nicer API.
<nod> I suppose one could go the horrid iter function route to get around the multiply, though at this point there's an awful lot of code to do something very simple:
struct xfs_rbmword_cur {
struct xfs_buf *bp;
xfs_rtword_t *wordptr;
unsigned int endword;
unsigned int word;
};static inline bool
xfs_rtbitmap_word_iter(
struct xfs_rbmword_cur *cur,
xfs_rtword_t *val)
{
if (cur->word >= cur->endword)
return false;
if (!cur->wordptr)
cur->wordptr = xfs_rbmblock_wordptr(cur->bp, cur->word);
*val = *cur->wordptr;
cur->word++;
cur->wordptr++;
return true;
}static inline void
xfs_rtbitmap_word_set(
struct xfs_rbmword_cur *cur,
xfs_rtword_t val)
{
*(cur->wordptr - 1) = val;
}Usage:
struct xfs_rbword_cur cur = {
.bp = bp,
.word = startword,
.endword = endword,
};
xfs_rtword_t val;
while (xfs_rtbitmap_word_iter(&cur, &val)) {
val |= somemask;
xfs_rtbitmap_word_set(cur, val);
}
xfs_rtbitmap_log_buf(tp, bp, startword, endword);--D
PATCH 7/8 xfs: create helpers for rtsummary block/wordcount computations
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create helper functions that compute the number of blocks or words necessary to store the rt summary file.
--- fs/xfs/libxfs/xfs_rtbitmap.c | 29 +++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_rtbitmap.h | 7 +++++++ fs/xfs/scrub/rtsummary.c | 5 ++++- fs/xfs/xfs_rtalloc.c | 17 +++++++---------- 4 files changed, 47 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_rtbitmap.c +29 -0
@@ -1205,3 +1205,32 @@ xfs_rtbitmap_wordcount( blocks =xfs_rtbitmap_blockcount (mp, rtextents);return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; } + +/* Compute the number of rtsummary blocks needed to track the given rt space. */ +xfs_filblks_t +xfs_rtsummary_blockcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +unsigned long long rsumwords; + + rsumwords = (unsigned long long )rsumlevels * rbmblocks; +return XFS_B_TO_FSB (mp, rsumwords <<XFS_WORDLOG ); +} + +/* +* Compute the number of rtsummary info words needed to populate every block of +* a summary file that is large enough to track the given rt space. +*/ +unsigned long long +xfs_rtsummary_wordcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +xfs_filblks_t blocks; + + blocks =xfs_rtsummary_blockcount (mp, rsumlevels, rbmblocks); +return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; +}
fs/xfs/libxfs/xfs_rtbitmap.h +7 -0
@@ -270,6 +270,11 @@ xfs_rtword_t xfs_rtbitmap_getword(struct xfs_mount *mp, union xfs_rtword_ondisk *wordptr);void xfs_rtbitmap_setword (struct xfs_mount *mp,union xfs_rtword_ondisk *wordptr,xfs_rtword_t incore); + +xfs_filblks_t xfs_rtsummary_blockcount (struct xfs_mount *mp, +unsigned int rsumlevels,xfs_extlen_t rbmblocks); +unsigned long long xfs_rtsummary_wordcount (struct xfs_mount *mp, +unsigned int rsumlevels,xfs_extlen_t rbmblocks);#else /* CONFIG_XFS_RT */ # define xfs_rtfree_extent (t,b,l) (-ENOSYS)# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS)
@@ -284,6 +289,8 @@ xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t rtextents)return 0 ; }# define xfs_rtbitmap_wordcount (mp, r) (0) +# define xfs_rtsummary_blockcount (mp, l, b) (0) +# define xfs_rtsummary_wordcount (mp, l, b) (0)#endif /* CONFIG_XFS_RT */ #endif /* __XFS_RTBITMAP_H__ */
fs/xfs/scrub/rtsummary.c +4 -1
@@ -41,6 +41,7 @@ xchk_setup_rtsummary(struct xfs_mount *mp = sc->mp;char *descr;size_t bufsize = mp->m_sb.sb_blocksize; +unsigned int wordcnt;unsigned int resblks =0 ;int error;
@@ -54,8 +55,10 @@ xchk_setup_rtsummary(* Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose. */ + wordcnt =xfs_rtsummary_wordcount (mp, mp->m_rsumlevels, + mp->m_sb.sb_rbmblocks); descr =xchk_xfile_descr (sc,"realtime summary file" ); - error =xfile_create (descr, mp->m_rsumsize, &sc->xfile); + error =xfile_create (descr, wordcnt <<XFS_WORDLOG , &sc->xfile);kfree (descr);if (error)return error;
fs/xfs/xfs_rtalloc.c +7 -10
@@ -999,8 +999,7 @@ xfs_growfs_rt( nrbmblocks =xfs_rtbitmap_blockcount (mp, nrextents); nrextslog =xfs_highbit32 (nrextents); nrsumlevels = nrextslog +1 ; - nrsumsize = (uint )sizeof (xfs_suminfo_t) * nrsumlevels * nrbmblocks; - nrsumblocks =XFS_B_TO_FSB (mp, nrsumsize); + nrsumblocks =xfs_rtsummary_blockcount (mp, nrsumlevels, nrbmblocks); nrsumsize =XFS_FSB_TO_B (mp, nrsumblocks);/* * New summary size can't be more than half the size of
@@ -1061,10 +1060,8 @@ xfs_growfs_rt(ASSERT (nsbp->sb_rextents !=0 ); nsbp->sb_rextslog =xfs_highbit32 (nsbp->sb_rextents); nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog +1 ; - nrsumsize = - (uint )sizeof (xfs_suminfo_t) * nrsumlevels * - nsbp->sb_rbmblocks; - nrsumblocks =XFS_B_TO_FSB (mp, nrsumsize); + nrsumblocks =xfs_rtsummary_blockcount (mp, nrsumlevels, + nsbp->sb_rbmblocks); nmp->m_rsumsize = nrsumsize =XFS_FSB_TO_B (mp, nrsumblocks);/* * Start a transaction, get the log reservation.
@@ -1270,6 +1267,7 @@ xfs_rtmount_init(struct xfs_buf *bp;/* buffer for last block of subvolume */ struct xfs_sb *sbp;/* filesystem superblock copy in mount */ xfs_daddr_t d;/* address of last block of subvolume */ +unsigned int rsumblocks;int error; sbp = &mp->m_sb;
@@ -1281,10 +1279,9 @@ xfs_rtmount_init(return -ENODEV ; } mp->m_rsumlevels = sbp->sb_rextslog +1 ; - mp->m_rsumsize = - (uint )sizeof (xfs_suminfo_t) * mp->m_rsumlevels * - sbp->sb_rbmblocks; - mp->m_rsumsize =roundup (mp->m_rsumsize, sbp->sb_blocksize); + rsumblocks =xfs_rtsummary_blockcount (mp, mp->m_rsumlevels, + mp->m_sb.sb_rbmblocks); + mp->m_rsumsize =XFS_FSB_TO_B (mp, rsumblocks); mp->m_rbmip = mp->m_rsumip =NULL ;/* * Check that the realtime section is an ok size.
Re: [PATCH 7/8] xfs: create helpers for rtsummary block/wordcount computations
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtbitmap_wordcount( · line 1220
Quoted 12 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.c +12
-0+/* Compute the number of rtsummary blocks needed to track the given rt space. */ +xfs_filblks_t +xfs_rtsummary_blockcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +unsigned long long rsumwords; + + rsumwords = (unsigned long long )rsumlevels * rbmblocks; +return XFS_B_TO_FSB (mp, rsumwords <<XFS_WORDLOG ); +}
This helper and its users make complete sense to me and looks good:
Quoted 17 lines
fs/xfs/libxfs/xfs_rtbitmap.c +15
-0+/* +* Compute the number of rtsummary info words needed to populate every block of +* a summary file that is large enough to track the given rt space. +*/ +unsigned long long +xfs_rtsummary_wordcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +xfs_filblks_t blocks; + + blocks =xfs_rtsummary_blockcount (mp, rsumlevels, rbmblocks); +return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; +}
fs/xfs/libxfs/xfs_rtbitmap.c xchk_setup_rtsummary( · line 62
Quoted 9 lines
fs/xfs/libxfs/xfs_rtbitmap.c +3
-1@@ -54,8 +55,10 @@ xchk_setup_rtsummary(* Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose. */ + wordcnt =xfs_rtsummary_wordcount (mp, mp->m_rsumlevels, + mp->m_sb.sb_rbmblocks); descr =xchk_xfile_descr (sc,"realtime summary file" ); - error =xfile_create (descr, mp->m_rsumsize, &sc->xfile); + error =xfile_create (descr, wordcnt <<XFS_WORDLOG , &sc->xfile);kfree (descr);
But this confuses me. What problem does it solve over just using m_rsumsize?
Re: [PATCH 7/8] xfs: create helpers for rtsummary block/wordcount computations
Quoted 34 lines · Christoph Hellwig
fs/xfs/libxfs/xfs_rtbitmap.c xfs_rtbitmap_wordcount( · line 1220
Quoted 12 lines · Darrick J. Wong
fs/xfs/libxfs/xfs_rtbitmap.c +12
-0+/* Compute the number of rtsummary blocks needed to track the given rt space. */ +xfs_filblks_t +xfs_rtsummary_blockcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +unsigned long long rsumwords; + + rsumwords = (unsigned long long )rsumlevels * rbmblocks; +return XFS_B_TO_FSB (mp, rsumwords <<XFS_WORDLOG ); +}This helper and its users make complete sense to me and looks good:
Reviewed-by Christoph Hellwig <[email protected]>Quoted 15 lines
fs/xfs/libxfs/xfs_rtbitmap.c +15
-0+/* +* Compute the number of rtsummary info words needed to populate every block of +* a summary file that is large enough to track the given rt space. +*/ +unsigned long long +xfs_rtsummary_wordcount ( +struct xfs_mount *mp, +unsigned int rsumlevels, +xfs_extlen_t rbmblocks) +{ +xfs_filblks_t blocks; + + blocks =xfs_rtsummary_blockcount (mp, rsumlevels, rbmblocks); +return XFS_FSB_TO_B (mp, blocks) >>XFS_WORDLOG ; +}
Quoted 13 lines
fs/xfs/scrub/rtsummary.c xchk_setup_rtsummary( · line 62
Quoted 10 lines
fs/xfs/scrub/rtsummary.c +3
-1@@ -54,8 +55,10 @@ xchk_setup_rtsummary(* Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose. */ + wordcnt =xfs_rtsummary_wordcount (mp, mp->m_rsumlevels, + mp->m_sb.sb_rbmblocks); descr =xchk_xfile_descr (sc,"realtime summary file" ); - error =xfile_create (descr, mp->m_rsumsize, &sc->xfile); + error =xfile_create (descr, wordcnt <<XFS_WORDLOG , &sc->xfile);kfree (descr);But this confuses me. What problem does it solve over just using
m_rsumsize?
The rtbitmap and rtsummary repair code should be computing rbmblocks and rsumsize from sb_rextents.
rbmblocks = xfs_rtbitmap_wordcount(mp, mp->m_sb.sb_rextents); rsumsize = xfs_rtsummary_wordcount(mp, mp->m_rsumlevels, rbmblocks);
From that, it should be checking isize and the data fork mappings of the file and the superblock values. Repair ought to map (or unmap) blocks as necessary, update isize if needed, and update the superblock if the values there are incorrect.
--D
Re: [PATCH 7/8] xfs: create helpers for rtsummary block/wordcount computations
Quoted 17 lines · Darrick J. Wong
Quoted 5 lines
Quoted 5 lines
fs/xfs/scrub/rtsummary.c +1
-0@@ -54,8 +55,10 @@ xchk_setup_rtsummary(* Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose. */ + wordcnt = xfs_rtsummary_wordcount(mp, mp->m_rsumlevels,Quoted 8 lines
fs/xfs/scrub/rtsummary.c xchk_setup_rtsummary( · line 62
Quoted 5 lines
fs/xfs/scrub/rtsummary.c +2
-1+ mp->m_sb.sb_rbmblocks); descr =xchk_xfile_descr (sc,"realtime summary file" ); - error =xfile_create (descr, mp->m_rsumsize, &sc->xfile); + error =xfile_create (descr, wordcnt <<XFS_WORDLOG , &sc->xfile);kfree (descr);But this confuses me. What problem does it solve over just using
m_rsumsize?The rtbitmap and rtsummary repair code should be computing rbmblocks and rsumsize from
sb_rextents.
Quoted 7 lines
rbmblocks =
xfs_rtbitmap_wordcount(mp, mp->m_sb.sb_rextents); rsumsize =xfs_rtsummary_wordcount(mp, mp->m_rsumlevels, rbmblocks);Quoted 1 line
From that, it should be checking isize and the data fork mappings of
the file and the superblock values. Repair ought to map (or unmap) blocks as necessary, update isize if needed, and update the superblock if the values there are incorrect.
So this is really a feature path that should be documented as such and not just be about adding a helper?
Re: [PATCH 7/8] xfs: create helpers for rtsummary block/wordcount computations
Quoted 21 lines · Christoph Hellwig
Quoted 20 lines · Darrick J. Wong
Quoted 5 lines
Quoted 5 lines
fs/xfs/scrub/rtsummary.c +1
-0@@ -54,8 +55,10 @@ xchk_setup_rtsummary(* Create an xfile to construct a new rtsummary file. The xfile allows * us to avoid pinning kernel memory for this purpose. */ + wordcnt = xfs_rtsummary_wordcount(mp, mp->m_rsumlevels,Quoted 8 lines
fs/xfs/scrub/rtsummary.c xchk_setup_rtsummary( · line 62
Quoted 5 lines
fs/xfs/scrub/rtsummary.c +2
-1+ mp->m_sb.sb_rbmblocks); descr =xchk_xfile_descr (sc,"realtime summary file" ); - error =xfile_create (descr, mp->m_rsumsize, &sc->xfile); + error =xfile_create (descr, wordcnt <<XFS_WORDLOG , &sc->xfile);kfree (descr);But this confuses me. What problem does it solve over just using
m_rsumsize?The rtbitmap and rtsummary repair code should be computing rbmblocks and rsumsize from
sb_rextents.rbmblocks =
xfs_rtbitmap_wordcount(mp, mp->m_sb.sb_rextents); rsumsize =xfs_rtsummary_wordcount(mp, mp->m_rsumlevels, rbmblocks);
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
From that, it should be checking isize and the data fork mappings of
the file and the superblock values. Repair ought to map (or unmap) blocks as necessary, update isize if needed, and update the superblock if the values there are incorrect.
So this is really a feature path that should be documented as such and not just be about adding a helper?
Yeah. If these rt cleanups land before online repair, then that whole hunk won't be in the patch that we merge anyway. In that case, I'll want the helpers simply to reduce the number of things I have to keep track of.
(meanwhile I think the pre-rtgroups rtbitmap and rtsummary code need some fixing...)
--D
PATCH 8/8 xfs: use accessor functions for summary info words
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create get and set functions for rtsummary words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk summary info words so that the compiler can perform proper typechecking.
--- fs/xfs/libxfs/xfs_format.h | 8 ++++++++ fs/xfs/libxfs/xfs_rtbitmap.c | 27 ++++++++++++++++++++++----- fs/xfs/libxfs/xfs_rtbitmap.h | 10 +++++++--- fs/xfs/scrub/rtsummary.c | 22 ++++++++++++---------- fs/xfs/scrub/rtsummary.h | 2 +- fs/xfs/scrub/trace.c | 1 + fs/xfs/scrub/trace.h | 4 ++-- fs/xfs/xfs_ondisk.h | 1 + 8 files changed, 54 insertions(+), 21 deletions(-)
fs/xfs/libxfs/xfs_format.h +8 -0
@@ -736,6 +736,14 @@ union xfs_rtword_ondisk {__u32 raw; }; +/* +* Realtime summary counts are accessed by the word, which is currently +* stored in host-endian format. +*/ +union xfs_suminfo_ondisk { +__u32 raw; +}; +/* * XFS Timestamps * ==============
fs/xfs/libxfs/xfs_rtbitmap.c +22 -5
@@ -466,6 +466,23 @@ xfs_rtfind_forw(return 0 ; } +inline xfs_suminfo_t +xfs_suminfo_get ( +struct xfs_mount *mp, +union xfs_suminfo_ondisk *infoptr) +{ +return infoptr->raw; +} + +inline void +xfs_suminfo_add ( +struct xfs_mount *mp, +union xfs_suminfo_ondisk *infoptr, +int delta) +{ + infoptr->raw += delta; +} +/* * Read and/or modify the summary information for a given extent size, * bitmap block combination.
@@ -490,7 +507,7 @@ xfs_rtmodify_summary_int(int error;/* error value */ xfs_fileoff_t sb;/* summary fsblock */ xfs_rtsumoff_t so;/* index into the summary file */ -xfs_suminfo_t *sp;/* pointer to returned data */ +union xfs_suminfo_ondisk *sp;/* pointer to returned data */ unsigned int infoword;/*
@@ -533,17 +550,17 @@ xfs_rtmodify_summary_int(if (delta) {uint first = (uint)((char *)sp - (char *)bp->b_addr); - *sp += delta; +xfs_suminfo_add (mp, sp, delta);if (mp->m_rsum_cache) { -if (*sp ==0 && log == mp->m_rsum_cache[bbno]) +if (sp->raw ==0 && log == mp->m_rsum_cache[bbno]) mp->m_rsum_cache[bbno]++; -if (*sp !=0 && log < mp->m_rsum_cache[bbno]) +if (sp->raw !=0 && log < mp->m_rsum_cache[bbno]) mp->m_rsum_cache[bbno] = log; }xfs_trans_log_buf (tp, bp, first, first +sizeof (*sp) -1 ); }if (sum) - *sum = *sp; + *sum =xfs_suminfo_get (mp, sp);return 0 ; }
fs/xfs/libxfs/xfs_rtbitmap.h +7 -3
@@ -181,18 +181,18 @@ xfs_rtsumoffs_to_infoword( }/* Return a pointer to a summary info word within a rt summary block buffer. */ -static inline xfs_suminfo_t * +static inline union xfs_suminfo_ondisk *xfs_rsumbuf_infoptr (void *buf,unsigned int infoword) { -xfs_suminfo_t *infop = buf; +union xfs_suminfo_ondisk *infop = buf;return &infop[infoword]; }/* Return a pointer to a summary info word within a rt summary block. */ -static inline xfs_suminfo_t * +static inline union xfs_suminfo_ondisk *xfs_rsumblock_infoptr (struct xfs_buf *bp,unsigned int infoword)
@@ -275,6 +275,10 @@ xfs_filblks_t xfs_rtsummary_blockcount(struct xfs_mount *mp, unsigned int rsumlevels, xfs_extlen_t rbmblocks);unsigned long long xfs_rtsummary_wordcount (struct xfs_mount *mp,unsigned int rsumlevels,xfs_extlen_t rbmblocks); +xfs_suminfo_t xfs_suminfo_get (struct xfs_mount *mp, +union xfs_suminfo_ondisk *infoptr); +void xfs_suminfo_add (struct xfs_mount *mp,union xfs_suminfo_ondisk *infoptr, +int delta);#else /* CONFIG_XFS_RT */ # define xfs_rtfree_extent (t,b,l) (-ENOSYS)# define xfs_rtfree_blocks (t,rb,rl) (-ENOSYS)
fs/xfs/scrub/rtsummary.c +12 -10
@@ -97,9 +97,10 @@ static inline intxfsum_load ( struct xfs_scrub *sc, xfs_rtsumoff_t sumoff, - xfs_suminfo_t *info) + union xfs_suminfo_ondisk *rawinfo) { - return xfile_obj_load(sc->xfile, info, sizeof(xfs_suminfo_t), + return xfile_obj_load(sc->xfile, rawinfo, + sizeof(union xfs_suminfo_ondisk ), sumoff << XFS_WORDLOG); }
@@ -107,9 +108,10 @@ static inline intxfsum_store ( struct xfs_scrub *sc, xfs_rtsumoff_t sumoff, - const xfs_suminfo_t info) + const union xfs_suminfo_ondisk rawinfo) { - return xfile_obj_store(sc->xfile, &info, sizeof(xfs_suminfo_t), + return xfile_obj_store(sc->xfile, &rawinfo, + sizeof(union xfs_suminfo_ondisk ), sumoff << XFS_WORDLOG); }
@@ -117,10 +119,10 @@ inline intxfsum_copyout ( struct xfs_scrub *sc, xfs_rtsumoff_t sumoff, - xfs_suminfo_t *info, + union xfs_suminfo_ondisk *rawinfo, unsigned int nr_words) { - return xfile_obj_load(sc->xfile, info, nr_words << XFS_WORDLOG, + return xfile_obj_load(sc->xfile, rawinfo, nr_words << XFS_WORDLOG, sumoff << XFS_WORDLOG); }
@@ -138,7 +140,7 @@ xchk_rtsum_record_free(xfs_filblks_t rtlen;xfs_rtsumoff_t offs;unsigned int lenlog; -xfs_suminfo_t v =0 ; +union xfs_suminfo_ondisk v;int error =0 ;if (xchk_should_terminate (sc, &error))
@@ -162,9 +164,9 @@ xchk_rtsum_record_free(if (error)return error; - v++; +xfs_suminfo_add (mp, &v,1 );trace_xchk_rtsum_record_free (mp, rec->ar_startext, rec->ar_extcount, - lenlog, offs, v); + lenlog, offs, &v);return xfsum_store (sc, offs, v); }
@@ -199,7 +201,7 @@ xchk_rtsum_compare(int nmap;for (off =0 ; off <XFS_B_TO_FSB (mp, mp->m_rsumsize); off++) { -xfs_suminfo_t *ondisk_info; +union xfs_suminfo_ondisk *ondisk_info;int error =0 ;if (xchk_should_terminate (sc, &error))
fs/xfs/scrub/rtsummary.h +1 -1
@@ -9,6 +9,6 @@typedef unsigned int xfs_rtsumoff_t ;int xfsum_copyout (struct xfs_scrub *sc,xfs_rtsumoff_t sumoff, -xfs_suminfo_t *info,unsigned int nr_words); +union xfs_suminfo_ondisk *info,unsigned int nr_words);#endif /* __XFS_SCRUB_RTSUMMARY_H__ */
fs/xfs/scrub/trace.c +1 -0
@@ -21,6 +21,7 @@#include "xfs_rmap.h" #include "xfs_parent.h" #include "xfs_imeta.h" +#include "xfs_rtbitmap.h" #include "scrub/scrub.h" #include "scrub/xfile.h" #include "scrub/xfarray.h"
fs/xfs/scrub/trace.h +2 -2
@@ -1262,7 +1262,7 @@ TRACE_EVENT(xfarray_sort_stats, TRACE_EVENT(xchk_rtsum_record_free, TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start, xfs_rtbxlen_t len, unsigned int log, loff_t pos, - xfs_suminfo_t v), + union xfs_suminfo_ondisk *v), TP_ARGS(mp, start, len, log, pos, v), TP_STRUCT__entry( __field(dev_t, dev)
@@ -1280,7 +1280,7 @@ TRACE_EVENT(xchk_rtsum_record_free, __entry->len = len; __entry->log = log; __entry->pos = pos; - __entry->v = v; + __entry->v =xfs_suminfo_get (mp, v); ), TP_printk("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u", MAJOR(__entry->dev), MINOR(__entry->dev),
fs/xfs/xfs_ondisk.h +1 -0
@@ -74,6 +74,7 @@ xfs_check_ondisk_structs(void)/* realtime structures */ XFS_CHECK_STRUCT_SIZE(union xfs_rtword_ondisk, 4); + XFS_CHECK_STRUCT_SIZE(union xfs_suminfo_ondisk, 4);/* * m68k has problems with xfs_attr_leaf_name_remote_t, but we pad it to
Re: [PATCH 8/8] xfs: use accessor functions for summary info words
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create get and set functions for rtsummary words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk summary info words so that the compiler can perform proper typechecking.
Same comment as for the bitmap access, including the same offer.
Re: [PATCH 8/8] xfs: use accessor functions for summary info words
Quoted 9 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create get and set functions for rtsummary words so that we can redefine the ondisk format with a specific endianness. Note that this requires the definition of a distinct type for ondisk summary info words so that the compiler can perform proper typechecking.
Same comment as for the bitmap access, including the same offer.
<nod> I'll take you up on that, if you think the tradeoffs is worth it. :)
--D