xfsprogs: Extend per-inode extent counters
v3 cover xfsprogs: Extend per-inode extent counters
This patchset implements the changes to userspace programs that are required to support extending inode's data and attr fork extent counter fields. The changes allow programs in xfsprogs to be able to create and work with filesystem instances with 64-bit data fork extent counter and 32-bit attr fork extent counter fields.
The patchset is based on Darrick's btree-dynamic-depth branch. These patches can also be obtained from
https://github.com/chandanr/xfsprogs-dev.git at branch xfs-incompat-extend-extcnt-v3.
Changelog:
V2 -> V3:
1. Introduce the ability to upgrade existing filesystems to use 64-bit extent counters if it is feasible to do so.
2. Report presence of 64-bit extent counters via xfs_info.
3. Add XFS_SB_FEAT_INCOMPAT_NREXT64 to XFS_SB_FEAT_INCOMPAT_ALL in a separate patch.
4. Rename mkfs.xfs option from extcnt64bit to nrext64.
V1 -> V2:
1. Rebase patches on top of Darrick's btree-dynamic-depth branch.
2. Add support for using the new bulkstat ioctl version to support 64-bit data fork extent counter field.
Chandan Babu R (15):
xfsprogs: Move extent count limits to xfs_format.h
xfsprogs: Introduce xfs_iext_max_nextents() helper
xfsprogs: Rename MAXEXTNUM, MAXAEXTNUM to XFS_IFORK_EXTCNT_MAXS32,
XFS_IFORK_EXTCNT_MAXS16
xfsprogs: Use xfs_extnum_t instead of basic data types
xfsprogs: Introduce xfs_dfork_nextents() helper
xfsprogs: xfs_dfork_nextents: Return extent count via an out argument
xfsprogs: Rename inode's extent counter fields based on their width
xfsprogs: Promote xfs_extnum_t and xfs_aextnum_t to 64 and 32-bits
respectively
xfsprogs: Enable bulkstat ioctl to support 64-bit extent counters
xfsprogs: Extend per-inode extent counter widths
xfsprogs: xfs_info: Report NREXT64 feature status
xfsprogs: Add XFS_SB_FEAT_INCOMPAT_NREXT64 to XFS_SB_FEAT_INCOMPAT_ALL
xfsprogs: Add nrext64 mkfs option
xfsprogs: Add support for upgrading to NREXT64 feature
xfsprogs: Define max extent length based on on-disk format definition
Darrick J. Wong (1):
xfsprogs: xfs_repair: allow administrators to add older v5 features
db/bmap.c | 21 ++- db/btdump.c | 11 +- db/check.c | 44 +++-- db/field.c | 4 - db/field.h | 2 - db/frag.c | 11 +- db/inode.c | 74 +++++++-- db/metadump.c | 14 +- fsr/xfs_fsr.c | 4 +- include/libxfs.h | 1 + include/libxlog.h | 6 +- include/xfs_inode.h | 5 + include/xfs_mount.h | 4 +- io/bulkstat.c | 3 +- libfrog/bulkstat.c | 55 ++++++- libfrog/fsgeom.c | 6 +- libxfs/libxfs_api_defs.h | 3 + libxfs/xfs_bmap.c | 74 +++++---- libxfs/xfs_format.h | 77 +++++++-- libxfs/xfs_fs.h | 20 ++- libxfs/xfs_ialloc.c | 2 + libxfs/xfs_inode_buf.c | 61 +++++-- libxfs/xfs_inode_fork.c | 33 ++-- libxfs/xfs_inode_fork.h | 23 ++- libxfs/xfs_log_format.h | 7 +- libxfs/xfs_rtbitmap.c | 4 +- libxfs/xfs_sb.c | 5 + libxfs/xfs_swapext.c | 6 +- libxfs/xfs_trans_inode.c | 5 + libxfs/xfs_trans_resv.c | 10 +- libxfs/xfs_types.h | 11 +- logprint/log_misc.c | 23 ++- logprint/log_print_all.c | 31 +++- logprint/log_print_trans.c | 2 +- man/man8/mkfs.xfs.8 | 7 + man/man8/xfs_admin.8 | 30 ++++ mkfs/xfs_mkfs.c | 29 +++- repair/attr_repair.c | 11 +- repair/bmap_repair.c | 23 ++- repair/dino_chunks.c | 6 +- repair/dinode.c | 143 ++++++++++++----- repair/dinode.h | 4 +- repair/globals.c | 5 + repair/globals.h | 5 + repair/phase2.c | 319 +++++++++++++++++++++++++++++++++++-- repair/phase4.c | 7 +- repair/prefetch.c | 7 +- repair/protos.h | 1 + repair/rmap.c | 4 +- repair/scan.c | 6 +- repair/xfs_repair.c | 55 +++++++ 51 files changed, 1076 insertions(+), 248 deletions(-)
Signature · 1 line
2.30.2
PATCH v3 1/16 xfsprogs: xfs_repair: allow administrators to add older v5 features
From: "Darrick J. Wong" <[email protected]>
Add to xfs_db the ability to add certain existing features (finobt, reflink, and rmapbt) to an existing filesystem if it's eligible.
--- include/libxfs.h | 1 + libxfs/libxfs_api_defs.h | 3 + man/man8/xfs_admin.8 | 30 +++++ repair/dino_chunks.c | 6 +- repair/dinode.c | 5 +- repair/globals.c | 4 + repair/globals.h | 4 + repair/phase2.c | 285 +++++++++++++++++++++++++++++++++++++-- repair/phase4.c | 5 +- repair/protos.h | 1 + repair/rmap.c | 4 +- repair/xfs_repair.c | 44 ++++++ 12 files changed, 377 insertions(+), 15 deletions(-)
include/libxfs.h +1 -0
@@ -79,6 +79,7 @@ struct iomap;#include "xfs_refcount.h" #include "xfs_btree_staging.h" #include "xfs_imeta.h" +#include "xfs_ag_resv.h" #ifndef ARRAY_SIZE #define ARRAY_SIZE (x) (sizeof(x) / sizeof((x)[0]))
libxfs/libxfs_api_defs.h +3 -0
@@ -21,6 +21,8 @@#define xfs_ag_init_headers libxfs_ag_init_headers#define xfs_ag_block_count libxfs_ag_block_count +#define xfs_ag_resv_free libxfs_ag_resv_free +#define xfs_ag_resv_init libxfs_ag_resv_init#define xfs_alloc_ag_max_usable libxfs_alloc_ag_max_usable#define xfs_allocbt_maxrecs libxfs_allocbt_maxrecs
@@ -121,6 +123,7 @@#define xfs_highbit32 libxfs_highbit32#define xfs_highbit64 libxfs_highbit64#define xfs_ialloc_calc_rootino libxfs_ialloc_calc_rootino +#define xfs_ialloc_read_agi libxfs_ialloc_read_agi#define xfs_icreate libxfs_icreate#define xfs_icreate_args_rootfile libxfs_icreate_args_rootfile#define xfs_idata_realloc libxfs_idata_realloc
man/man8/xfs_admin.8 +30 -0
@@ -149,6 +149,36 @@ Upgrade a filesystem to support larger timestamps up to the year 2486. The filesystem cannot be downgraded after this feature is enabled. Once enabled, the filesystem will not be mountable by older kernels. This feature was added to Linux 5.10. +.TP 0.4i +.B finobt +Track free inodes through a separate free inode btree index to speed up inode +allocation on old filesystems. +This upgrade can fail if any AG has less than 1% free space remaining. +The filesystem cannot be downgraded after this feature is enabled. +This feature was added to Linux 3.16. +.TP 0.4i +.B reflink +Enable sharing of file data blocks. +This upgrade can fail if any AG has less than 2% free space remaining. +The filesystem cannot be downgraded after this feature is enabled. +This feature was added to Linux 4.9. +.TP 0.4i +.B rmapbt +Store an index of the owners of on-disk blocks. +This enables much stronger cross-referencing of various metadata structures +and online repairs to space usage metadata. +The filesystem cannot be downgraded after this feature is enabled. +This upgrade can fail if any AG has less than 5% free space remaining. +This feature was added to Linux 4.8. +.TP 0.4i +.B metadir +Create a directory tree of metadata inodes instead of storing them all in the +superblock. +This is required for reverse mapping btrees and reflink support on the realtime +device. +The filesystem cannot be downgraded after this feature is enabled. +This upgrade can fail if any AG has less than 5% free space remaining. +This feature is not upstream yet. .RE .TP .BI \-U " uuid"
repair/dino_chunks.c +5 -1
@@ -963,7 +963,11 @@ next_readbuf: }if (status) { -if (mp->m_sb.sb_rootino == ino) { +if (wipe_pre_metadir_file (ino)) { +if (!ino_discovery) +do_warn ( +_ ("wiping pre-metadir metadata inode %" PRIu64".\n" ), ino); + }else if (mp->m_sb.sb_rootino == ino) { need_root_inode =1 ;if (!no_modify) {
repair/dinode.c +4 -1
@@ -2386,6 +2386,9 @@ process_dinode_int(ASSERT (uncertain ==0 || verify_mode !=0 );ASSERT (ino_bpp !=NULL || verify_mode !=0 ); +if (wipe_pre_metadir_file (lino)) + goto clear_bad_out; +/* * This is the only valid point to check the CRC; after this we may have * made changes which invalidate it, and the CRC is only updated again
@@ -2593,7 +2596,7 @@ _("bad (negative) size %" PRId64 " on inode %" PRIu64 "\n"),if (flags &XFS_DIFLAG_NEWRTBM ) {/* must be a rt bitmap inode */ if (lino != mp->m_sb.sb_rbmino) { -if (!uncertain) { +if (!uncertain && !add_metadir) {do_warn (_ ("inode %" PRIu64" not rt bitmap\n" ), lino);
repair/globals.c +4 -0
@@ -50,6 +50,10 @@ int convert_lazy_count; /* Convert lazy-count mode on/off */int lazy_count;/* What to set if to if converting */ bool add_inobtcount;/* add inode btree counts to AGI */ bool add_bigtime;/* add support for timestamps up to 2486 */ +bool add_finobt;/* add free inode btrees */ +bool add_reflink;/* add reference count btrees */ +bool add_rmapbt;/* add reverse mapping btrees */ +bool add_metadir;/* add metadata directory tree */ /* misc status variables */
repair/globals.h +4 -0
@@ -91,6 +91,10 @@ extern int convert_lazy_count; /* Convert lazy-count mode on/off */extern int lazy_count;/* What to set if to if converting */ extern bool add_inobtcount;/* add inode btree counts to AGI */ extern bool add_bigtime;/* add support for timestamps up to 2486 */ +extern bool add_finobt;/* add free inode btrees */ +extern bool add_reflink;/* add reference count btrees */ +extern bool add_rmapbt;/* add reverse mapping btrees */ +extern bool add_metadir;/* add metadata directory tree */ /* misc status variables */
repair/phase2.c +275 -10
320 lines not on this page · raw message
repair/phase4.c +4 -1
@@ -303,7 +303,10 @@ phase4(xfs_mount_t *mp)if (xfs_has_metadir (mp) && (is_inode_free (irec,1 ) || !inode_isadir (irec,1 ))) { need_metadir_inode = true; -if (no_modify) +if (add_metadir) +do_warn ( +_ ("metadata directory root inode needs to be initialized\n" )); +else if (no_modify)do_warn (_ ("metadata directory root inode would be lost\n" ));else
repair/protos.h +1 -0
@@ -43,3 +43,4 @@ void phase7(struct xfs_mount *, int);int verify_set_agheader (struct xfs_mount *,struct xfs_buf *,struct xfs_sb *,struct xfs_agf *,struct xfs_agi *,xfs_agnumber_t ); +bool wipe_pre_metadir_file (xfs_ino_t ino);
repair/rmap.c +2 -2
@@ -49,8 +49,8 @@ boolrmap_needs_work ( struct xfs_mount *mp) { -return xfs_has_reflink (mp) || -xfs_has_rmapbt (mp); +return xfs_has_reflink (mp) || add_reflink || +xfs_has_rmapbt (mp) || add_rmapbt; }/*
repair/xfs_repair.c +44 -0
62 lines not on this page · raw message
Signature · 1 line
2.30.2
PATCH v3 2/16 xfsprogs: Move extent count limits to xfs_format.h
In reply to Chandan Babu RMaximum values associated with extent counters i.e. Maximum extent length, Maximum data extents and Maximum xattr extents are dictated by the on-disk format. Hence move these definitions over to xfs_format.h.
--- libxfs/xfs_format.h | 7 +++++++ libxfs/xfs_types.h | 7 ------- 2 files changed, 7 insertions(+), 7 deletions(-)
libxfs/xfs_format.h +7 -0
@@ -872,6 +872,13 @@ enum xfs_dinode_fmt { { XFS_DINODE_FMT_BTREE, "btree" }, \ { XFS_DINODE_FMT_UUID, "uuid" } +/* +* Max values for extlen, extnum, aextnum. +*/ +#define MAXEXTLEN ((xfs_extlen_t)0x001fffff)/* 21 bits */ +#define MAXEXTNUM ((xfs_extnum_t)0x7fffffff)/* signed int */ +#define MAXAEXTNUM ((xfs_aextnum_t)0x7fff)/* signed short */ +/* * Inode minimum and maximum sizes. */
libxfs/xfs_types.h +0 -7
@@ -56,13 +56,6 @@ typedef void * xfs_failaddr_t;#define NULLFSINO ((xfs_ino_t)-1)#define NULLAGINO ((xfs_agino_t)-1) -/* -* Max values for extlen, extnum, aextnum. -*/ -#define MAXEXTLEN ((xfs_extlen_t)0x001fffff)/* 21 bits */ -#define MAXEXTNUM ((xfs_extnum_t)0x7fffffff)/* signed int */ -#define MAXAEXTNUM ((xfs_aextnum_t)0x7fff)/* signed short */ -/* * Minimum and maximum blocksize and sectorsize. * The blocksize upper limit is pretty much arbitrary.
Signature · 1 line
2.30.2
PATCH v3 3/16 xfsprogs: Introduce xfs_iext_max_nextents() helper
In reply to Chandan Babu Rxfs_iext_max_nextents() returns the maximum number of extents possible for one of data, cow or attribute fork. This helper will be extended further in a future commit when maximum extent counts associated with data/attribute forks are increased.
--- libxfs/xfs_bmap.c | 9 ++++----- libxfs/xfs_inode_buf.c | 8 +++----- libxfs/xfs_inode_fork.c | 5 +++-- libxfs/xfs_inode_fork.h | 9 +++++++++ repair/dinode.c | 7 ++++--- 5 files changed, 23 insertions(+), 15 deletions(-)
libxfs/xfs_bmap.c +4 -5
@@ -69,13 +69,12 @@ xfs_bmap_compute_maxlevels(* ATTR2 we have to assume the worst case scenario of a minimum size * available. */ -if (whichfork ==XFS_DATA_FORK ) { - maxleafents =MAXEXTNUM ; + maxleafents =xfs_iext_max_nextents (mp, whichfork); +if (whichfork ==XFS_DATA_FORK ) sz =xfs_bmdr_space_calc (MINDBTPTRS ); - }else { - maxleafents =MAXAEXTNUM ; +else sz =xfs_bmdr_space_calc (MINABTPTRS ); - } + maxrootrecs =xfs_bmdr_maxrecs (sz,0 ); minleafrecs = mp->m_bmap_dmnr[0 ]; minnoderecs = mp->m_bmap_dmnr[1 ];
libxfs/xfs_inode_buf.c +3 -5
@@ -340,6 +340,7 @@ xfs_dinode_verify_fork( int whichfork) {uint32_t di_nextents =XFS_DFORK_NEXTENTS (dip, whichfork); +xfs_extnum_t max_extents;switch (XFS_DFORK_FORMAT (dip, whichfork)) {case XFS_DINODE_FMT_LOCAL :
@@ -361,12 +362,9 @@ xfs_dinode_verify_fork(return __this_address;break ;case XFS_DINODE_FMT_BTREE : -if (whichfork ==XFS_ATTR_FORK ) { -if (di_nextents >MAXAEXTNUM ) -return __this_address; - }else if (di_nextents >MAXEXTNUM ) { + max_extents =xfs_iext_max_nextents (mp, whichfork); +if (di_nextents > max_extents)return __this_address; - }break ;default :return __this_address;
libxfs/xfs_inode_fork.c +3 -2
@@ -727,6 +727,7 @@ xfs_iext_count_may_overflow( int whichfork, int nr_to_add) { +struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp =XFS_IFORK_PTR (ip, whichfork);uint64_t max_exts;uint64_t nr_exts;
@@ -734,9 +735,9 @@ xfs_iext_count_may_overflow(if (whichfork ==XFS_COW_FORK )return 0 ; - max_exts = (whichfork ==XFS_ATTR_FORK ) ?MAXAEXTNUM :MAXEXTNUM ; + max_exts =xfs_iext_max_nextents (mp, whichfork); -if (XFS_TEST_ERROR (false, ip->i_mount,XFS_ERRTAG_REDUCE_MAX_IEXTENTS )) +if (XFS_TEST_ERROR (false, mp,XFS_ERRTAG_REDUCE_MAX_IEXTENTS )) max_exts =10 ; nr_exts = ifp->if_nextents + nr_to_add;
libxfs/xfs_inode_fork.h +9 -0
@@ -133,6 +133,15 @@ static inline int8_t xfs_ifork_format(struct xfs_ifork *ifp)return ifp->if_format; } +static inline xfs_extnum_t xfs_iext_max_nextents (struct xfs_mount *mp, +int whichfork) +{ +if (whichfork ==XFS_DATA_FORK || whichfork ==XFS_COW_FORK ) +return MAXEXTNUM ; + +return MAXAEXTNUM ; +} +struct xfs_ifork *xfs_ifork_alloc (enum xfs_dinode_fmt format,xfs_extnum_t nextents);struct xfs_ifork *xfs_iext_state_to_fork (struct xfs_inode *ip,int state);
repair/dinode.c +4 -3
@@ -1808,6 +1808,7 @@ _("bad attr fork offset %d in inode %" PRIu64 ", max=%zu\n"),*/ static int process_inode_blocks_and_extents( + struct xfs_mount *mp, xfs_dinode_t *dino, xfs_rfsblock_t nblocks, uint64_t nextents,
@@ -1831,7 +1832,7 @@ _("bad nblocks %llu for inode %" PRIu64 ", would reset to %" PRIu64 "\n"), } } -if (nextents >MAXEXTNUM ) { +if (nextents >xfs_iext_max_nextents (mp,XFS_DATA_FORK )) {do_warn (_ ("too many data fork extents (%" PRIu64") in inode %" PRIu64"\n" ), nextents, lino);
@@ -1854,7 +1855,7 @@ _("bad nextents %d for inode %" PRIu64 ", would reset to %" PRIu64 "\n"), } } -if (anextents >MAXAEXTNUM ) { +if (anextents >xfs_iext_max_nextents (mp,XFS_ATTR_FORK )) {do_warn (_ ("too many attr fork extents (%" PRIu64") in inode %" PRIu64"\n" ), anextents, lino);
@@ -2969,7 +2970,7 @@ _("Bad CoW extent size %u on inode %" PRIu64 ", "),/* * correct space counters if required */ -if (process_inode_blocks_and_extents (dino, totblocks + atotblocks, +if (process_inode_blocks_and_extents (mp, dino, totblocks + atotblocks, nextents, anextents, lino, dirty) !=0 ) goto clear_bad_out;
Signature · 1 line
2.30.2
PATCH v3 4/16 xfsprogs: Rename MAXEXTNUM, MAXAEXTNUM to XFS_IFORK_EXTCNT_MAXS32, XFS_IFORK_EXTCNT_MAXS16
In reply to Chandan Babu RIn preparation for introducing larger extent count limits, this commit renames existing extent count limits based on their signedness and width.
--- libxfs/xfs_format.h | 8 ++++---- libxfs/xfs_inode_fork.h | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-)
libxfs/xfs_format.h +4 -4
@@ -873,11 +873,11 @@ enum xfs_dinode_fmt { { XFS_DINODE_FMT_UUID, "uuid" }/* -* Max values for extlen, extnum, aextnum. +* Max values for extlen, disk inode's extent counters. */ -#define MAXEXTLEN ((xfs_extlen_t)0x001fffff)/* 21 bits */ -#define MAXEXTNUM ((xfs_extnum_t)0x7fffffff)/* signed int */ -#define MAXAEXTNUM ((xfs_aextnum_t)0x7fff)/* signed short */ +#define MAXEXTLEN ((xfs_extlen_t)0x1fffff)/* 21 bits */ +#define XFS_IFORK_EXTCNT_MAXS32 ((xfs_extnum_t)0x7fffffff)/* Signed 32-bits */ +#define XFS_IFORK_EXTCNT_MAXS16 ((xfs_aextnum_t)0x7fff)/* Signed 16-bits */ /* * Inode minimum and maximum sizes.
libxfs/xfs_inode_fork.h +2 -2
@@ -137,9 +137,9 @@ static inline xfs_extnum_t xfs_iext_max_nextents(struct xfs_mount *mp, int whichfork) {if (whichfork ==XFS_DATA_FORK || whichfork ==XFS_COW_FORK ) -return MAXEXTNUM ; +return XFS_IFORK_EXTCNT_MAXS32 ; -return MAXAEXTNUM ; +return XFS_IFORK_EXTCNT_MAXS16 ; } struct xfs_ifork *xfs_ifork_alloc(enum xfs_dinode_fmt format,
Signature · 1 line
2.30.2
PATCH v3 5/16 xfsprogs: Use xfs_extnum_t instead of basic data types
In reply to Chandan Babu Rxfs_extnum_t is the type to use to declare variables which have values obtained from xfs_dinode->di_[a]nextents. This commit replaces basic types (e.g. uint32_t) with xfs_extnum_t for such variables.
--- db/bmap.c | 2 +- db/frag.c | 2 +- libxfs/xfs_bmap.c | 2 +- libxfs/xfs_inode_buf.c | 2 +- libxfs/xfs_inode_fork.c | 2 +- repair/dinode.c | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-)
db/bmap.c +1 -1
@@ -47,7 +47,7 @@ bmap(int n;int nex;xfs_fsblock_t nextbno; -int nextents; +xfs_extnum_t nextents;xfs_bmbt_ptr_t *pp;xfs_bmdr_block_t *rblock;typnm_t typ;
db/frag.c +1 -1
@@ -273,7 +273,7 @@ process_fork( int whichfork) {extmap_t *extmap; -int nex; +xfs_extnum_t nex; nex =XFS_DFORK_NEXTENTS (dip, whichfork);if (!nex)
libxfs/xfs_bmap.c +1 -1
@@ -49,7 +49,7 @@ xfs_bmap_compute_maxlevels( {int level;/* btree level */ uint maxblocks;/* max blocks at this level */ -uint maxleafents;/* max leaf entries possible */ +xfs_extnum_t maxleafents;/* max leaf entries possible */ int maxrootrecs;/* max records in root block */ int minleafrecs;/* min records in leaf block */ int minnoderecs;/* min records in node block */
libxfs/xfs_inode_buf.c +1 -1
@@ -339,7 +339,7 @@ xfs_dinode_verify_fork( struct xfs_mount *mp, int whichfork) { - uint32_t di_nextents = XFS_DFORK_NEXTENTS(dip, whichfork); +xfs_extnum_t di_nextents =XFS_DFORK_NEXTENTS (dip, whichfork);xfs_extnum_t max_extents;switch (XFS_DFORK_FORMAT (dip, whichfork)) {
libxfs/xfs_inode_fork.c +1 -1
@@ -105,7 +105,7 @@ xfs_iformat_extents(struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp =XFS_IFORK_PTR (ip, whichfork);int state =xfs_bmap_fork_to_state (whichfork); -int nex =XFS_DFORK_NEXTENTS (dip, whichfork); +xfs_extnum_t nex =XFS_DFORK_NEXTENTS (dip, whichfork);int size = nex *sizeof (xfs_bmbt_rec_t);struct xfs_iext_cursor icur;struct xfs_bmbt_rec *dp;
repair/dinode.c +1 -1
@@ -967,7 +967,7 @@ process_exinode(xfs_bmbt_rec_t *rp;xfs_fileoff_t first_key;xfs_fileoff_t last_key; -int32_t numrecs; +xfs_extnum_t numrecs;int ret; lino =XFS_AGINO_TO_INO (mp, agno, ino);
Signature · 1 line
2.30.2
PATCH v3 6/16 xfsprogs: Introduce xfs_dfork_nextents() helper
In reply to Chandan Babu RThis commit replaces the macro XFS_DFORK_NEXTENTS() with the helper function xfs_dfork_nextents(). As of this commit, xfs_dfork_nextents() returns the same value as XFS_DFORK_NEXTENTS(). A future commit which extends inode's extent counter fields will add more logic to this helper.
This commit also replaces direct accesses to xfs_dinode->di_[a]nextents with calls to xfs_dfork_nextents().
No functional changes have been made.
--- db/bmap.c | 6 ++-- db/btdump.c | 4 +-- db/check.c | 27 ++++++++++------- db/frag.c | 6 ++-- db/inode.c | 14 +++++---- db/metadump.c | 4 +-- libxfs/xfs_format.h | 28 ++++++++++++++--- libxfs/xfs_inode_buf.c | 16 ++++++---- libxfs/xfs_inode_fork.c | 9 +++--- repair/attr_repair.c | 2 +- repair/bmap_repair.c | 4 +-- repair/dinode.c | 66 ++++++++++++++++++++++++----------------- repair/prefetch.c | 2 +- 13 files changed, 117 insertions(+), 71 deletions(-)
db/bmap.c +3 -3
@@ -68,7 +68,7 @@ bmap(ASSERT (fmt ==XFS_DINODE_FMT_LOCAL || fmt ==XFS_DINODE_FMT_EXTENTS || fmt ==XFS_DINODE_FMT_BTREE );if (fmt ==XFS_DINODE_FMT_EXTENTS ) { - nextents =XFS_DFORK_NEXTENTS (dip, whichfork); + nextents =xfs_dfork_nextents (dip, whichfork); xp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork);for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {if (!bmap_one_extent (ep, &curoffset, eoffset, &n, bep))
@@ -158,9 +158,9 @@ bmap_f(push_cur ();set_cur_inode (iocur_top->ino); dip = iocur_top->data; -if (be32_to_cpu (dip->di_nextents)) +if (xfs_dfork_nextents (dip,XFS_DATA_FORK )) dfork =1 ; -if (be16_to_cpu (dip->di_anextents)) +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK )) afork =1 ;pop_cur (); }
db/btdump.c +2 -2
@@ -166,13 +166,13 @@ dump_inode( dip = iocur_top->data;if (attrfork) { -if (!dip->di_anextents || +if (!xfs_dfork_nextents (dip,XFS_ATTR_FORK ) || dip->di_aformat !=XFS_DINODE_FMT_BTREE ) {dbprintf (_ ("attr fork not in btree format\n" ));return 0 ; } }else { -if (!dip->di_nextents || +if (!xfs_dfork_nextents (dip,XFS_DATA_FORK ) || dip->di_format !=XFS_DINODE_FMT_BTREE ) {dbprintf (_ ("data fork not in btree format\n" ));return 0 ;
db/check.c +16 -11
@@ -2720,7 +2720,7 @@ process_exinode(xfs_bmbt_rec_t *rp; rp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); - *nex =XFS_DFORK_NEXTENTS (dip, whichfork); + *nex =xfs_dfork_nextents (dip, whichfork);if (*nex <0 || *nex >XFS_DFORK_SIZE (dip, mp, whichfork) /sizeof (xfs_bmbt_rec_t)) {if (!sflag || id->ilist)
@@ -2744,12 +2744,14 @@ process_inode(inodata_t *id =NULL ;xfs_ino_t ino;xfs_extnum_t nextents =0 ; +xfs_extnum_t dnextents;int security;xfs_rfsblock_t totblocks;xfs_rfsblock_t totdblocks =0 ;xfs_rfsblock_t totiblocks =0 ;dbm_t type;xfs_extnum_t anextents =0 ; +xfs_extnum_t danextents;xfs_rfsblock_t atotdblocks =0 ;xfs_rfsblock_t atotiblocks =0 ;xfs_qcnt_t bc =0 ;
@@ -2878,14 +2880,17 @@ process_inode( error++;return ; } + + dnextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); + danextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); +if (verbose || (id && id->ilist) ||CHECK_BLIST (bno)) dbprintf(_("inode %lld mode %#o fmt %s " "afmt %s " "nex %d anex %d nblk %lld sz %lld%s%s%s%s%s%s%s\n"), id->ino, mode, fmtnames[(int)dip->di_format], fmtnames[(int)dip->di_aformat], - be32_to_cpu(dip->di_nextents), - be16_to_cpu(dip->di_anextents), + dnextents, danextents, be64_to_cpu(dip->di_nblocks), be64_to_cpu(dip->di_size), diflags & XFS_DIFLAG_REALTIME ? " rt" : "", diflags & XFS_DIFLAG_PREALLOC ? " pre" : "",
@@ -2903,19 +2908,19 @@ process_inode(if (xfs_has_metadir (mp) && id->ino == mp->m_sb.sb_metadirino)addlink_inode (id); - blkmap =blkmap_alloc (be32_to_cpu (dip->di_nextents)); + blkmap =blkmap_alloc (dnextents);break ;case S_IFREG :if (diflags &XFS_DIFLAG_REALTIME ) type =DBM_RTDATA ;else if (id->ino == mp->m_sb.sb_rbmino) { type =DBM_RTBITMAP ; - blkmap =blkmap_alloc (be32_to_cpu (dip->di_nextents)); + blkmap =blkmap_alloc (dnextents);if (!xfs_has_metadir (mp))addlink_inode (id); }else if (id->ino == mp->m_sb.sb_rsumino) { type =DBM_RTSUM ; - blkmap =blkmap_alloc (be32_to_cpu (dip->di_nextents)); + blkmap =blkmap_alloc (dnextents);if (!xfs_has_metadir (mp))addlink_inode (id); }
@@ -2923,7 +2928,7 @@ process_inode( id->ino == mp->m_sb.sb_gquotino || id->ino == mp->m_sb.sb_pquotino) { type =DBM_QUOTA ; - blkmap =blkmap_alloc (be32_to_cpu (dip->di_nextents)); + blkmap =blkmap_alloc (dnextents);if (!xfs_has_metadir (mp))addlink_inode (id); }
@@ -3006,17 +3011,17 @@ process_inode( be64_to_cpu(dip->di_nblocks), id->ino, totblocks); error++; } -if (nextents !=be32_to_cpu (dip->di_nextents)) { +if (nextents != dnextents) {if (v)dbprintf (_ ("bad nextents %d for inode %lld, counted %d\n" ), -be32_to_cpu (dip->di_nextents), id->ino, nextents); + dnextents, id->ino, nextents); error++; } -if (anextents !=be16_to_cpu (dip->di_anextents)) { +if (anextents != danextents) {if (v)dbprintf (_ ("bad anextents %d for inode %lld, counted " "%d\n" ), -be16_to_cpu (dip->di_anextents), id->ino, anextents); + danextents, id->ino, anextents); error++; }if (type ==DBM_DIR )
db/frag.c +4 -2
@@ -262,9 +262,11 @@ process_exinode( int whichfork) {xfs_bmbt_rec_t *rp; +xfs_extnum_t nextents; rp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); -process_bmbt_reclist (rp,XFS_DFORK_NEXTENTS (dip, whichfork), extmapp); + nextents =xfs_dfork_nextents (dip, whichfork); +process_bmbt_reclist (rp, nextents, extmapp); } static void
@@ -275,7 +277,7 @@ process_fork(extmap_t *extmap;xfs_extnum_t nex; - nex =XFS_DFORK_NEXTENTS (dip, whichfork); + nex =xfs_dfork_nextents (dip, whichfork);if (!nex)return ; extmap =extmap_alloc (nex);
db/inode.c +8 -6
@@ -278,7 +278,7 @@ inode_a_bmx_count(return 0 ;ASSERT ((char *)XFS_DFORK_APTR (dip) - (char *)dip ==byteize (startoff));return dip->di_aformat ==XFS_DINODE_FMT_EXTENTS ? -be16_to_cpu (dip->di_anextents) :0 ; +xfs_dfork_nextents (dip,XFS_ATTR_FORK ) :0 ; } static int
@@ -332,6 +332,7 @@ inode_a_size( {struct xfs_attr_shortform *asf;xfs_dinode_t *dip; +xfs_extnum_t nextents;ASSERT (startoff ==0 );ASSERT (idx ==0 );
@@ -341,8 +342,8 @@ inode_a_size( asf = (struct xfs_attr_shortform *)XFS_DFORK_APTR (dip);return bitize (be16_to_cpu (asf->hdr.totsize));case XFS_DINODE_FMT_EXTENTS : -return (int )be16_to_cpu (dip->di_anextents) * -bitsz (xfs_bmbt_rec_t); + nextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); + return nextents * bitsz(struct xfs_bmbt_rec);case XFS_DINODE_FMT_BTREE :return bitize ((int )XFS_DFORK_ASIZE (dip, mp));default :
@@ -503,7 +504,7 @@ inode_u_bmx_count( dip = obj;ASSERT ((char *)XFS_DFORK_DPTR (dip) - (char *)dip ==byteize (startoff));return dip->di_format ==XFS_DINODE_FMT_EXTENTS ? -be32_to_cpu (dip->di_nextents) :0 ; +xfs_dfork_nextents (dip,XFS_DATA_FORK ) :0 ; } static int
@@ -589,6 +590,7 @@ inode_u_size( int idx) {xfs_dinode_t *dip; +xfs_extnum_t nextents;ASSERT (startoff ==0 );ASSERT (idx ==0 );
@@ -599,8 +601,8 @@ inode_u_size(case XFS_DINODE_FMT_LOCAL :return bitize ((int )be64_to_cpu (dip->di_size));case XFS_DINODE_FMT_EXTENTS : -return (int )be32_to_cpu (dip->di_nextents) * -bitsz (xfs_bmbt_rec_t); + nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); + return nextents * bitsz(struct xfs_bmbt_rec);case XFS_DINODE_FMT_BTREE :return bitize ((int )XFS_DFORK_DSIZE (dip, mp));case XFS_DINODE_FMT_UUID :
db/metadump.c +2 -2
@@ -2314,7 +2314,7 @@ process_exinode( whichfork = (itype ==TYP_ATTR ) ?XFS_ATTR_FORK :XFS_DATA_FORK ; - nex =XFS_DFORK_NEXTENTS (dip, whichfork); + nex =xfs_dfork_nextents (dip, whichfork); used = nex *sizeof (xfs_bmbt_rec_t);if (nex <0 || used >XFS_DFORK_SIZE (dip, mp, whichfork)) {if (show_warnings)
@@ -2369,7 +2369,7 @@ static intprocess_dev_inode ( xfs_dinode_t *dip) { -if (XFS_DFORK_NEXTENTS (dip,XFS_DATA_FORK )) { +if (xfs_dfork_nextents (dip,XFS_DATA_FORK )) {if (show_warnings)print_warning ("inode %llu has unexpected extents" , (unsigned long long )cur_ino);
libxfs/xfs_format.h +24 -4
@@ -929,10 +929,30 @@ enum xfs_dinode_fmt { ((w) ==XFS_DATA_FORK ? \ (dip)->di_format : \ (dip)->di_aformat) -#define XFS_DFORK_NEXTENTS (dip,w) \ - ((w) == XFS_DATA_FORK ? \ - be32_to_cpu((dip)->di_nextents) : \ - be16_to_cpu((dip)->di_anextents)) + +static inline xfs_extnum_t +xfs_dfork_nextents ( +struct xfs_dinode *dip, +int whichfork) +{ +xfs_extnum_t nextents =0 ; + +switch (whichfork) { +case XFS_DATA_FORK : + nextents =be32_to_cpu (dip->di_nextents); +break ; + +case XFS_ATTR_FORK : + nextents =be16_to_cpu (dip->di_anextents); +break ; + +default : +ASSERT (0 ); +break ; + } + +return nextents; +}/* * For block and character special files the 32bit dev_t is stored at the
libxfs/xfs_inode_buf.c +11 -5
@@ -339,9 +339,11 @@ xfs_dinode_verify_fork( struct xfs_mount *mp, int whichfork) { -xfs_extnum_t di_nextents =XFS_DFORK_NEXTENTS (dip, whichfork); +xfs_extnum_t di_nextents;xfs_extnum_t max_extents; + di_nextents =xfs_dfork_nextents (dip, whichfork); +switch (XFS_DFORK_FORMAT (dip, whichfork)) {case XFS_DINODE_FMT_LOCAL :/*
@@ -471,6 +473,8 @@ xfs_dinode_verify(uint16_t flags;uint64_t flags2;uint64_t di_size; +xfs_rfsblock_t nblocks; +xfs_extnum_t nextents;if (dip->di_magic !=cpu_to_be16 (XFS_DINODE_MAGIC ))return __this_address;
@@ -501,10 +505,12 @@ xfs_dinode_verify(if ((S_ISLNK (mode) ||S_ISDIR (mode)) && di_size ==0 )return __this_address; + nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); + nextents +=xfs_dfork_nextents (dip,XFS_ATTR_FORK ); + nblocks =be64_to_cpu (dip->di_nblocks); +/* Fork checks carried over from xfs_iformat_fork */ -if (mode && -be32_to_cpu (dip->di_nextents) +be16_to_cpu (dip->di_anextents) > -be64_to_cpu (dip->di_nblocks)) +if (mode && nextents > nblocks)return __this_address;if (mode &&XFS_DFORK_BOFF (dip) > mp->m_sb.sb_inodesize)
@@ -561,7 +567,7 @@ xfs_dinode_verify(default :return __this_address; } -if (dip->di_anextents) +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK ))return __this_address; }
libxfs/xfs_inode_fork.c +5 -4
@@ -105,7 +105,7 @@ xfs_iformat_extents(struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp =XFS_IFORK_PTR (ip, whichfork);int state =xfs_bmap_fork_to_state (whichfork); -xfs_extnum_t nex =XFS_DFORK_NEXTENTS (dip, whichfork); +xfs_extnum_t nex =xfs_dfork_nextents (dip, whichfork);int size = nex *sizeof (xfs_bmbt_rec_t);struct xfs_iext_cursor icur;struct xfs_bmbt_rec *dp;
@@ -232,7 +232,7 @@ xfs_iformat_data_fork(* depend on it. */ ip->i_df.if_format = dip->di_format; - ip->i_df.if_nextents =be32_to_cpu (dip->di_nextents); + ip->i_df.if_nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK );switch (inode->i_mode &S_IFMT ) {case S_IFIFO :
@@ -299,14 +299,15 @@ xfs_iformat_attr_fork(struct xfs_inode *ip, struct xfs_dinode *dip) { + xfs_extnum_t naextents;int error =0 ;/* * Initialize the extent count early, as the per-format routines may * depend on it. */ - ip->i_afp =xfs_ifork_alloc (dip->di_aformat, -be16_to_cpu (dip->di_anextents)); + naextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); + ip->i_afp =xfs_ifork_alloc (dip->di_aformat, naextents);switch (ip->i_afp->if_format) {case XFS_DINODE_FMT_LOCAL :
repair/attr_repair.c +1 -1
@@ -1083,7 +1083,7 @@ process_longform_attr( bno =blkmap_get (blkmap,0 );if (bno ==NULLFSBLOCK ) {if (dip->di_aformat ==XFS_DINODE_FMT_EXTENTS && -be16_to_cpu (dip->di_anextents) ==0 ) +xfs_dfork_nextents (dip,XFS_ATTR_FORK ) ==0 )return (0 );/* the kernel can handle this state */ do_warn( _("block 0 of inode %" PRIu64 " attribute fork is missing\n"),
repair/bmap_repair.c +2 -2
@@ -572,7 +572,7 @@ rebuild_bmap(*/ switch (whichfork) {case XFS_DATA_FORK : -if ((*dinop)->di_nextents ==0 ) +if (!xfs_dfork_nextents (*dinop,XFS_DATA_FORK ))return 0 ; (*dinop)->di_format =XFS_DINODE_FMT_EXTENTS ; (*dinop)->di_nextents =0 ;
@@ -580,7 +580,7 @@ rebuild_bmap( *dirty =1 ;break ;case XFS_ATTR_FORK : -if ((*dinop)->di_anextents ==0 ) +if (!xfs_dfork_nextents (*dinop,XFS_ATTR_FORK ))return 0 ; (*dinop)->di_aformat =XFS_DINODE_FMT_EXTENTS ; (*dinop)->di_anextents =0 ;
repair/dinode.c +38 -28
180 lines not on this page · raw message
repair/prefetch.c +1 -1
@@ -393,7 +393,7 @@ pf_read_exinode( xfs_dinode_t *dino) {pf_read_bmbt_reclist (args, (xfs_bmbt_rec_t *)XFS_DFORK_DPTR (dino), -be32_to_cpu (dino->di_nextents)); +xfs_dfork_nextents (dino,XFS_DATA_FORK )); } static void
Signature · 1 line
2.30.2
PATCH v3 7/16 xfsprogs: xfs_dfork_nextents: Return extent count via an out argument
In reply to Chandan Babu RThis commit changes xfs_dfork_nextents() to return an error code. The extent count itself is now returned through an out argument. This facility will be used by a future commit to indicate an inconsistent ondisk extent count.
--- db/bmap.c | 19 ++++++++------ db/btdump.c | 11 +++++--- db/check.c | 23 ++++++++++++++--- db/frag.c | 7 +++--- db/inode.c | 26 +++++++++++++------ db/metadump.c | 12 +++++++-- libxfs/xfs_format.h | 14 ++++++----- libxfs/xfs_inode_buf.c | 16 +++++++++--- libxfs/xfs_inode_fork.c | 23 +++++++++++++---- repair/attr_repair.c | 11 +++++--- repair/bmap_repair.c | 11 ++++++-- repair/dinode.c | 56 ++++++++++++++++++++++++++++++++--------- repair/prefetch.c | 7 ++++-- 13 files changed, 175 insertions(+), 61 deletions(-)
db/bmap.c +12 -7
@@ -68,11 +68,13 @@ bmap(ASSERT (fmt ==XFS_DINODE_FMT_LOCAL || fmt ==XFS_DINODE_FMT_EXTENTS || fmt ==XFS_DINODE_FMT_BTREE );if (fmt ==XFS_DINODE_FMT_EXTENTS ) { - nextents =xfs_dfork_nextents (dip, whichfork); - xp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); -for (ep = xp; ep < &xp[nextents] && n < nex; ep++) { -if (!bmap_one_extent (ep, &curoffset, eoffset, &n, bep)) -break ; +if (!xfs_dfork_nextents (dip, whichfork, &nextents)) { + xp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); +for (ep = xp; ep < &xp[nextents] && n < nex; ep++) { +if (!bmap_one_extent (ep, &curoffset, eoffset, + &n, bep)) +break ; + } } }else if (fmt ==XFS_DINODE_FMT_BTREE ) {push_cur ();
@@ -155,12 +157,15 @@ bmap_f( } }if (afork + dfork ==0 ) { +xfs_extnum_t nextents;push_cur ();set_cur_inode (iocur_top->ino); dip = iocur_top->data; -if (xfs_dfork_nextents (dip,XFS_DATA_FORK )) +if (!xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents) && + nextents) dfork =1 ; -if (xfs_dfork_nextents (dip,XFS_ATTR_FORK )) +if (!xfs_dfork_nextents (dip,XFS_ATTR_FORK , &nextents) && + nextents) afork =1 ;pop_cur (); }
db/btdump.c +7 -4
@@ -153,6 +153,7 @@ dump_inode( bool dump_node_blocks, bool attrfork) { +xfs_extnum_t nextents;char *prefix;struct xfs_dinode *dip;int ret =0 ;
@@ -166,14 +167,16 @@ dump_inode( dip = iocur_top->data;if (attrfork) { -if (!xfs_dfork_nextents (dip,XFS_ATTR_FORK ) || - dip->di_aformat !=XFS_DINODE_FMT_BTREE ) { +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK , &nextents)) +return -1 ; +if (!nextents || dip->di_aformat !=XFS_DINODE_FMT_BTREE ) {dbprintf (_ ("attr fork not in btree format\n" ));return 0 ; } }else { -if (!xfs_dfork_nextents (dip,XFS_DATA_FORK ) || - dip->di_format !=XFS_DINODE_FMT_BTREE ) { +if (xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents)) +return -1 ; +if (!nextents || dip->di_format !=XFS_DINODE_FMT_BTREE ) {dbprintf (_ ("data fork not in btree format\n" ));return 0 ; }
db/check.c +19 -4
@@ -2718,10 +2718,17 @@ process_exinode( int whichfork) {xfs_bmbt_rec_t *rp; +int ret; rp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); - *nex =xfs_dfork_nextents (dip, whichfork); -if (*nex <0 || *nex >XFS_DFORK_SIZE (dip, mp, whichfork) / + ret =xfs_dfork_nextents (dip, whichfork, nex); +if (ret) { +if (!sflag || id->ilist) +dbprintf (_ ("Corrupt extent count for inode %lld\n" ), + id->ino); + error++; +return ; + }else if (*nex <0 || *nex >XFS_DFORK_SIZE (dip, mp, whichfork) /sizeof (xfs_bmbt_rec_t)) {if (!sflag || id->ilist) dbprintf(_("bad number of extents %d for inode %lld\n"),
@@ -2881,8 +2888,16 @@ process_inode(return ; } - dnextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); - danextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); +if (xfs_dfork_nextents (dip,XFS_DATA_FORK , &dnextents)) { +if (v) +dbprintf (_ ("Corrupt extent count for inode %lld\n" ), + id->ino); + error++; +return ; + } + +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK , &danextents)) +ASSERT (0 );if (verbose || (id && id->ilist) ||CHECK_BLIST (bno)) dbprintf(_("inode %lld mode %#o fmt %s "
db/frag.c +4 -3
@@ -263,9 +263,11 @@ process_exinode( {xfs_bmbt_rec_t *rp;xfs_extnum_t nextents; +int error; rp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR (dip, whichfork); - nextents =xfs_dfork_nextents (dip, whichfork); + error =xfs_dfork_nextents (dip, whichfork, &nextents); +ASSERT (error ==0 );process_bmbt_reclist (rp, nextents, extmapp); }
@@ -277,8 +279,7 @@ process_fork(extmap_t *extmap;xfs_extnum_t nex; - nex =xfs_dfork_nextents (dip, whichfork); -if (!nex) +if (xfs_dfork_nextents (dip, whichfork, &nex) || !nex)return ; extmap =extmap_alloc (nex);switch (XFS_DFORK_FORMAT (dip, whichfork)) {
db/inode.c +19 -7
@@ -269,6 +269,7 @@ inode_a_bmx_count( void *obj, int startoff) { +xfs_extnum_t nextents;xfs_dinode_t *dip;ASSERT (bitoffs (startoff) ==0 );
@@ -277,8 +278,12 @@ inode_a_bmx_count(if (!dip->di_forkoff)return 0 ;ASSERT ((char *)XFS_DFORK_APTR (dip) - (char *)dip ==byteize (startoff)); -return dip->di_aformat ==XFS_DINODE_FMT_EXTENTS ? -xfs_dfork_nextents (dip,XFS_ATTR_FORK ) :0 ; +if (dip->di_aformat !=XFS_DINODE_FMT_EXTENTS || +xfs_dfork_nextents (dip,XFS_ATTR_FORK , &nextents)) { + nextents =0 ; + } + +return nextents; } static int
@@ -342,7 +347,8 @@ inode_a_size( asf = (struct xfs_attr_shortform *)XFS_DFORK_APTR (dip);return bitize (be16_to_cpu (asf->hdr.totsize));case XFS_DINODE_FMT_EXTENTS : - nextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK , &nextents)) + nextents =0 ; return nextents * bitsz(struct xfs_bmbt_rec);case XFS_DINODE_FMT_BTREE :return bitize ((int )XFS_DFORK_ASIZE (dip, mp));
@@ -497,14 +503,19 @@ inode_u_bmx_count( void *obj, int startoff) { +xfs_extnum_t nextents;xfs_dinode_t *dip;ASSERT (bitoffs (startoff) ==0 );ASSERT (obj == iocur_top->data); dip = obj;ASSERT ((char *)XFS_DFORK_DPTR (dip) - (char *)dip ==byteize (startoff)); -return dip->di_format ==XFS_DINODE_FMT_EXTENTS ? -xfs_dfork_nextents (dip,XFS_DATA_FORK ) :0 ; +if (dip->di_format !=XFS_DINODE_FMT_EXTENTS || +xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents)) { + nextents =0 ; + } + +return nextents; } static int
@@ -590,7 +601,7 @@ inode_u_size( int idx) {xfs_dinode_t *dip; -xfs_extnum_t nextents; +xfs_extnum_t nextents =0 ;ASSERT (startoff ==0 );ASSERT (idx ==0 );
@@ -601,7 +612,8 @@ inode_u_size(case XFS_DINODE_FMT_LOCAL :return bitize ((int )be64_to_cpu (dip->di_size));case XFS_DINODE_FMT_EXTENTS : - nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); +if (xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents)) + nextents =0 ; return nextents * bitsz(struct xfs_bmbt_rec);case XFS_DINODE_FMT_BTREE :return bitize ((int )XFS_DFORK_DSIZE (dip, mp));
db/metadump.c +10 -2
@@ -2314,7 +2314,13 @@ process_exinode( whichfork = (itype ==TYP_ATTR ) ?XFS_ATTR_FORK :XFS_DATA_FORK ; - nex =xfs_dfork_nextents (dip, whichfork); +if (xfs_dfork_nextents (dip, whichfork, &nex)) { +if (show_warnings) +print_warning ("Corrupt extent count for inode %lld\n" , + (long long )cur_ino); +return 1 ; + } + used = nex *sizeof (xfs_bmbt_rec_t);if (nex <0 || used >XFS_DFORK_SIZE (dip, mp, whichfork)) {if (show_warnings)
@@ -2369,7 +2375,9 @@ static intprocess_dev_inode ( xfs_dinode_t *dip) { -if (xfs_dfork_nextents (dip,XFS_DATA_FORK )) { +xfs_extnum_t nextents; + +if (xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents) || nextents) {if (show_warnings)print_warning ("inode %llu has unexpected extents" , (unsigned long long )cur_ino);
libxfs/xfs_format.h +8 -6
@@ -930,28 +930,30 @@ enum xfs_dinode_fmt { (dip)->di_format : \ (dip)->di_aformat) -static inline xfs_extnum_t +static inline int xfs_dfork_nextents (struct xfs_dinode *dip, -int whichfork) +int whichfork, +xfs_extnum_t *nextents) { -xfs_extnum_t nextents =0 ; +int error =0 ;switch (whichfork) {case XFS_DATA_FORK : - nextents =be32_to_cpu (dip->di_nextents); + *nextents =be32_to_cpu (dip->di_nextents);break ;case XFS_ATTR_FORK : - nextents =be16_to_cpu (dip->di_anextents); + *nextents =be16_to_cpu (dip->di_anextents);break ;default :ASSERT (0 ); + error = -EFSCORRUPTED ;break ; } -return nextents; +return error; }/*
libxfs/xfs_inode_buf.c +12 -4
@@ -342,7 +342,8 @@ xfs_dinode_verify_fork(xfs_extnum_t di_nextents;xfs_extnum_t max_extents; - di_nextents =xfs_dfork_nextents (dip, whichfork); +if (xfs_dfork_nextents (dip, whichfork, &di_nextents)) +return __this_address;switch (XFS_DFORK_FORMAT (dip, whichfork)) {case XFS_DINODE_FMT_LOCAL :
@@ -475,6 +476,7 @@ xfs_dinode_verify(uint64_t di_size;xfs_rfsblock_t nblocks;xfs_extnum_t nextents; +xfs_extnum_t naextents;if (dip->di_magic !=cpu_to_be16 (XFS_DINODE_MAGIC ))return __this_address;
@@ -505,8 +507,13 @@ xfs_dinode_verify(if ((S_ISLNK (mode) ||S_ISDIR (mode)) && di_size ==0 )return __this_address; - nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); - nextents +=xfs_dfork_nextents (dip,XFS_ATTR_FORK ); +if (xfs_dfork_nextents (dip,XFS_DATA_FORK , &nextents)) +return __this_address; + +if (xfs_dfork_nextents (dip,XFS_ATTR_FORK , &naextents)) +return __this_address; + + nextents += naextents; nblocks =be64_to_cpu (dip->di_nblocks);/* Fork checks carried over from xfs_iformat_fork */
@@ -567,7 +574,8 @@ xfs_dinode_verify(default :return __this_address; } -if (xfs_dfork_nextents (dip,XFS_ATTR_FORK )) + +if (naextents)return __this_address; }
libxfs/xfs_inode_fork.c +18 -5
@@ -105,12 +105,19 @@ xfs_iformat_extents(struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp =XFS_IFORK_PTR (ip, whichfork);int state =xfs_bmap_fork_to_state (whichfork); -xfs_extnum_t nex =xfs_dfork_nextents (dip, whichfork); -int size = nex *sizeof (xfs_bmbt_rec_t); +xfs_extnum_t nex; +int size;struct xfs_iext_cursor icur;struct xfs_bmbt_rec *dp;struct xfs_bmbt_irec new;int i; +int error; + + error =xfs_dfork_nextents (dip, whichfork, &nex); +if (error) +return error; + + size = nex *sizeof (struct xfs_bmbt_rec );/* * If the number of extents is unreasonable, then something is wrong and
@@ -232,7 +239,10 @@ xfs_iformat_data_fork(* depend on it. */ ip->i_df.if_format = dip->di_format; - ip->i_df.if_nextents =xfs_dfork_nextents (dip,XFS_DATA_FORK ); + error =xfs_dfork_nextents (dip,XFS_DATA_FORK , + &ip->i_df.if_nextents); +if (error) +return error;switch (inode->i_mode &S_IFMT ) {case S_IFIFO :
@@ -300,13 +310,16 @@ xfs_iformat_attr_fork( struct xfs_dinode *dip) {xfs_extnum_t naextents; -int error =0 ; +int error; + + error =xfs_dfork_nextents (dip,XFS_ATTR_FORK , &naextents); +if (error) +return error;/* * Initialize the extent count early, as the per-format routines may * depend on it. */ - naextents =xfs_dfork_nextents (dip,XFS_ATTR_FORK ); ip->i_afp =xfs_ifork_alloc (dip->di_aformat, naextents);switch (ip->i_afp->if_format) {
repair/attr_repair.c +8 -3
@@ -1073,6 +1073,7 @@ process_longform_attr(struct blkmap *blkmap, int *repair) /* out - 1 if something was fixed */ { + xfs_extnum_t anextents;xfs_fsblock_t bno;struct xfs_buf *bp;struct xfs_da_blkinfo *info;
@@ -1082,9 +1083,13 @@ process_longform_attr( bno =blkmap_get (blkmap,0 );if (bno ==NULLFSBLOCK ) { -if (dip->di_aformat ==XFS_DINODE_FMT_EXTENTS && -xfs_dfork_nextents (dip,XFS_ATTR_FORK ) ==0 ) -return (0 );/* the kernel can handle this state */ +if (dip->di_aformat ==XFS_DINODE_FMT_EXTENTS ) { + error =xfs_dfork_nextents (dip,XFS_ATTR_FORK , + &anextents); +ASSERT (error ==0 ); +if (anextents ==0 ) +return (0 );/* the kernel can handle this state */ + }do_warn (_ ("block 0 of inode %" PRIu64" attribute fork is missing\n" ), ino);
repair/bmap_repair.c +9 -2
@@ -560,6 +560,7 @@ rebuild_bmap(struct xfs_buf *bp;unsigned long long resblks;xfs_daddr_t bp_bn; +xfs_extnum_t nextents;int bp_length;int error;
@@ -572,7 +573,10 @@ rebuild_bmap(*/ switch (whichfork) {case XFS_DATA_FORK : -if (!xfs_dfork_nextents (*dinop,XFS_DATA_FORK )) + error =xfs_dfork_nextents (*dinop, whichfork, &nextents); +if (error) +return error; +if (nextents ==0 )return 0 ; (*dinop)->di_format =XFS_DINODE_FMT_EXTENTS ; (*dinop)->di_nextents =0 ;
@@ -580,7 +584,10 @@ rebuild_bmap( *dirty =1 ;break ;case XFS_ATTR_FORK : -if (!xfs_dfork_nextents (*dinop,XFS_ATTR_FORK )) + error =xfs_dfork_nextents (*dinop, whichfork, &nextents); +if (error) +return error; +if (nextents ==0 )return 0 ; (*dinop)->di_aformat =XFS_DINODE_FMT_EXTENTS ; (*dinop)->di_anextents =0 ;
repair/dinode.c +44 -12
152 lines not on this page · raw message
repair/prefetch.c +5 -2
@@ -392,8 +392,11 @@ pf_read_exinode( prefetch_args_t *args, xfs_dinode_t *dino) { -pf_read_bmbt_reclist (args, (xfs_bmbt_rec_t *)XFS_DFORK_DPTR (dino), -xfs_dfork_nextents (dino,XFS_DATA_FORK )); +xfs_extnum_t nextents; + +if (!xfs_dfork_nextents (dino,XFS_DATA_FORK , &nextents)) +pf_read_bmbt_reclist (args, + (xfs_bmbt_rec_t *)XFS_DFORK_DPTR (dino), nextents); } static void
Signature · 1 line
2.30.2
PATCH v3 8/16 xfsprogs: Rename inode's extent counter fields based on their width
In reply to Chandan Babu RThis commit renames extent counter fields in "struct xfs_dinode" and "struct xfs_log_dinode" based on the width of the fields. As of this commit, the 32-bit field will be used to count data fork extents and the 16-bit field will be used to count attr fork extents.
This change is done to enable a future commit to introduce a new 64-bit extent counter field.
--- db/inode.c | 4 ++-- libxfs/xfs_format.h | 8 ++++---- libxfs/xfs_inode_buf.c | 4 ++-- libxfs/xfs_log_format.h | 4 ++-- logprint/log_misc.c | 4 ++-- logprint/log_print_all.c | 2 +- repair/bmap_repair.c | 4 ++-- repair/dinode.c | 6 +++--- 8 files changed, 18 insertions(+), 18 deletions(-)
db/inode.c +2 -2
@@ -100,8 +100,8 @@ const field_t inode_core_flds[] = { { "size", FLDT_FSIZE, OI(COFF(size)), C1, 0, TYP_NONE }, { "nblocks", FLDT_DRFSBNO, OI(COFF(nblocks)), C1, 0, TYP_NONE }, { "extsize", FLDT_EXTLEN, OI(COFF(extsize)), C1, 0, TYP_NONE }, - { "nextents", FLDT_EXTNUM, OI(COFF(nextents)), C1, 0, TYP_NONE }, - { "naextents", FLDT_AEXTNUM, OI(COFF(anextents)), C1, 0, TYP_NONE }, + { "nextents32", FLDT_EXTNUM, OI(COFF(nextents32)), C1, 0, TYP_NONE }, + { "nextents16", FLDT_AEXTNUM, OI(COFF(nextents16)), C1, 0, TYP_NONE }, { "forkoff", FLDT_UINT8D, OI(COFF(forkoff)), C1, 0, TYP_NONE }, { "aformat", FLDT_DINODE_FMT, OI(COFF(aformat)), C1, 0, TYP_NONE }, { "dmevmask", FLDT_UINT32X, OI(COFF(dmevmask)), C1, 0, TYP_NONE },
libxfs/xfs_format.h +4 -4
@@ -802,8 +802,8 @@ typedef struct xfs_dinode {__be64 di_size;/* number of bytes in file */ __be64 di_nblocks;/* # of direct & btree blocks used */ __be32 di_extsize;/* basic/minimum extent size for file */ -__be32 di_nextents;/* number of extents in data fork */ -__be16 di_anextents;/* number of extents in attribute fork*/ +__be32 di_nextents32;/* 32-bit extent counter */ +__be16 di_nextents16;/* 16-bit extent counter */ __u8 di_forkoff;/* attr fork offs, <<3 for 64b align */ __s8 di_aformat;/* format of attr fork's data */ __be32 di_dmevmask;/* DMIG event mask */
@@ -940,11 +940,11 @@ xfs_dfork_nextents(switch (whichfork) {case XFS_DATA_FORK : - *nextents =be32_to_cpu (dip->di_nextents); + *nextents =be32_to_cpu (dip->di_nextents32);break ;case XFS_ATTR_FORK : - *nextents =be16_to_cpu (dip->di_anextents); + *nextents =be16_to_cpu (dip->di_nextents16);break ;default :
libxfs/xfs_inode_buf.c +2 -2
@@ -310,8 +310,8 @@ xfs_inode_to_disk( to->di_size =cpu_to_be64 (ip->i_disk_size); to->di_nblocks =cpu_to_be64 (ip->i_nblocks); to->di_extsize =cpu_to_be32 (ip->i_extsize); - to->di_nextents =cpu_to_be32 (xfs_ifork_nextents (&ip->i_df)); - to->di_anextents =cpu_to_be16 (xfs_ifork_nextents (ip->i_afp)); + to->di_nextents32 =cpu_to_be32 (xfs_ifork_nextents (&ip->i_df)); + to->di_nextents16 =cpu_to_be16 (xfs_ifork_nextents (ip->i_afp)); to->di_forkoff = ip->i_forkoff; to->di_aformat =xfs_ifork_format (ip->i_afp); to->di_flags =cpu_to_be16 (ip->i_diflags);
libxfs/xfs_log_format.h +2 -2
@@ -402,8 +402,8 @@ struct xfs_log_dinode {xfs_fsize_t di_size;/* number of bytes in file */ xfs_rfsblock_t di_nblocks;/* # of direct & btree blocks used */ xfs_extlen_t di_extsize;/* basic/minimum extent size for file */ -xfs_extnum_t di_nextents;/* number of extents in data fork */ -xfs_aextnum_t di_anextents;/* number of extents in attribute fork*/ +uint32_t di_nextents32;/* number of extents in data fork */ +uint16_t di_nextents16;/* number of extents in attribute fork*/ uint8_t di_forkoff;/* attr fork offs, <<3 for 64b align */ int8_t di_aformat;/* format of attr fork's data */ uint32_t di_dmevmask;/* DMIG event mask */
logprint/log_misc.c +2 -2
@@ -452,9 +452,9 @@ xlog_print_trans_inode_core( xlog_extract_dinode_ts(ip->di_ctime));printf (_ ("size 0x%llx nblocks 0x%llx extsize 0x%x nextents 0x%x\n" ), (unsigned long long )ip->di_size, (unsigned long long )ip->di_nblocks, - ip->di_extsize, ip->di_nextents); + ip->di_extsize, ip->di_nextents32);printf (_ ("naextents 0x%x forkoff %d dmevmask 0x%x dmstate 0x%hx\n" ), - ip->di_anextents, (int )ip->di_forkoff, ip->di_dmevmask, + ip->di_nextents16, (int )ip->di_forkoff, ip->di_dmevmask, ip->di_dmstate);printf (_ ("flags 0x%x gen 0x%x\n" ), ip->di_flags, ip->di_gen);
logprint/log_print_all.c +1 -1
@@ -257,7 +257,7 @@ xlog_recover_print_inode_core(printf (_ (" size:0x%llx nblks:0x%llx exsize:%d " "nextents:%d anextents:%d\n" ), (unsigned long long ) di->di_size, (unsigned long long )di->di_nblocks, - di->di_extsize, di->di_nextents, (int )di->di_anextents); + di->di_extsize, di->di_nextents32, (int )di->di_nextents16); printf(_(" forkoff:%d dmevmask:0x%x dmstate:%d flags:0x%x " "gen:%u\n"), (int)di->di_forkoff, di->di_dmevmask, (int)di->di_dmstate,
repair/bmap_repair.c +2 -2
@@ -579,7 +579,7 @@ rebuild_bmap(if (nextents ==0 )return 0 ; (*dinop)->di_format =XFS_DINODE_FMT_EXTENTS ; - (*dinop)->di_nextents =0 ; + (*dinop)->di_nextents32 =0 ;libxfs_dinode_calc_crc (mp, *dinop); *dirty =1 ;break ;
@@ -590,7 +590,7 @@ rebuild_bmap(if (nextents ==0 )return 0 ; (*dinop)->di_aformat =XFS_DINODE_FMT_EXTENTS ; - (*dinop)->di_anextents =0 ; + (*dinop)->di_nextents16 =0 ;libxfs_dinode_calc_crc (mp, *dinop); *dirty =1 ;break ;
repair/dinode.c +3 -3
@@ -78,7 +78,7 @@ _("would have cleared inode %" PRIu64 " attributes\n"), ino_num);if (anextents !=0 ) {if (no_modify)return (1 ); - dino->di_anextents =cpu_to_be16 (0 ); + dino->di_nextents16 =cpu_to_be16 (0 ); }if (dino->di_aformat !=XFS_DINODE_FMT_EXTENTS ) {
@@ -1872,7 +1872,7 @@ _("too many data fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),do_warn (_ ("correcting nextents for inode %" PRIu64", was %d - counted %" PRIu64"\n" ), lino, dnextents, nextents); - dino->di_nextents =cpu_to_be32 (nextents); + dino->di_nextents32 =cpu_to_be32 (nextents); *dirty =1 ; }else { do_warn(
@@ -1896,7 +1896,7 @@ _("too many attr fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),do_warn (_ ("correcting anextents for inode %" PRIu64", was %d - counted %" PRIu64"\n" ), lino, dnextents, anextents); - dino->di_anextents =cpu_to_be16 (anextents); + dino->di_nextents16 =cpu_to_be16 (anextents); *dirty =1 ; }else { do_warn(
Signature · 1 line
2.30.2
PATCH v3 9/16 xfsprogs: Promote xfs_extnum_t and xfs_aextnum_t to 64 and 32-bits respectively
In reply to Chandan Babu RA future commit will introduce a 64-bit on-disk data extent counter and a 32-bit on-disk attr extent counter. This commit promotes xfs_extnum_t and xfs_aextnum_t to 64 and 32-bits in order to correctly handle in-core versions of these quantities.
--- libxfs/xfs_bmap.c | 4 ++-- libxfs/xfs_inode_fork.c | 2 +- libxfs/xfs_inode_fork.h | 2 +- libxfs/xfs_types.h | 4 ++-- repair/dinode.c | 20 ++++++++++---------- repair/dinode.h | 4 ++-- repair/scan.c | 6 +++--- 7 files changed, 21 insertions(+), 21 deletions(-)
libxfs/xfs_bmap.c +2 -2
@@ -47,9 +47,9 @@ xfs_bmap_compute_maxlevels( xfs_mount_t *mp, /* file system mount structure */ int whichfork) /* data or attr fork */ { +xfs_extnum_t maxleafents;/* max leaf entries possible */ int level;/* btree level */ uint maxblocks;/* max blocks at this level */ -xfs_extnum_t maxleafents;/* max leaf entries possible */ int maxrootrecs;/* max records in root block */ int minleafrecs;/* min records in leaf block */ int minnoderecs;/* min records in node block */
@@ -466,7 +466,7 @@ error0:if (bp_release)xfs_trans_brelse (NULL , bp); error_norelse: -xfs_warn (mp,"%s: BAD after btree leaves for %d extents" , +xfs_warn (mp,"%s: BAD after btree leaves for %llu extents" , __func__, i);xfs_err (mp,"%s: CORRUPTED BTREE OR SOMETHING" , __func__);xfs_force_shutdown (mp,SHUTDOWN_CORRUPT_INCORE );
libxfs/xfs_inode_fork.c +1 -1
@@ -124,7 +124,7 @@ xfs_iformat_extents(* we just bail out rather than crash in kmem_alloc() or memcpy() below. */ if (unlikely (size <0 || size >XFS_DFORK_SIZE (dip, mp, whichfork))) { -xfs_warn (ip->i_mount,"corrupt inode %Lu ((a)extents = %d)." , +xfs_warn (ip->i_mount,"corrupt inode %Lu ((a)extents = %llu)." , (unsigned long long ) ip->i_ino, nex); xfs_inode_verifier_error(ip, -EFSCORRUPTED, "xfs_iformat_extents(1)", dip, sizeof(*dip),
libxfs/xfs_inode_fork.h +1 -1
@@ -21,9 +21,9 @@ struct xfs_ifork {void *if_root;/* extent tree root */ char *if_data;/* inline file data */ } if_u1; +xfs_extnum_t if_nextents;/* # of extents in this fork */ short if_broot_bytes;/* bytes allocated for root */ int8_t if_format;/* format of this fork */ -xfs_extnum_t if_nextents;/* # of extents in this fork */ };/*
libxfs/xfs_types.h +2 -2
@@ -12,8 +12,8 @@ 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_agnumber_t ;/* allocation group number */ -typedef int32_t xfs_extnum_t ;/* # of extents in a file */ -typedef int16_t xfs_aextnum_t ;/* # extents in an attribute fork */ +typedef uint64_t xfs_extnum_t ;/* # of extents in a file */ +typedef uint32_t xfs_aextnum_t ;/* # extents in an attribute fork */ typedef int64_t xfs_fsize_t ;/* bytes in a file */ typedef uint64_t xfs_ufsize_t ;/* unsigned bytes in a file */
repair/dinode.c +10 -10
@@ -357,7 +357,7 @@ static int process_bmbt_reclist_int( xfs_mount_t *mp, xfs_bmbt_rec_t *rp, - int *numrecs, + xfs_extnum_t *numrecs, int type, xfs_ino_t ino, xfs_rfsblock_t *tot,
@@ -680,7 +680,7 @@ int process_bmbt_reclist( xfs_mount_t *mp, xfs_bmbt_rec_t *rp, - int *numrecs, + xfs_extnum_t *numrecs, int type, xfs_ino_t ino, xfs_rfsblock_t *tot,
@@ -703,7 +703,7 @@ int scan_bmbt_reclist( xfs_mount_t *mp, xfs_bmbt_rec_t *rp, - int *numrecs, + xfs_extnum_t *numrecs, int type, xfs_ino_t ino, xfs_rfsblock_t *tot,
@@ -1091,7 +1091,7 @@ _("mismatch between format (%d) and size (%" PRId64 ") in symlink inode %" PRIu6*/ if (numrecs > max_symlink_blocks) {do_warn ( -_ ("bad number of extents (%d) in symlink %" PRIu64" data fork\n" ), +_ ("bad number of extents (%lu) in symlink %" PRIu64" data fork\n" ), numrecs, lino);return (1 ); }
@@ -1652,7 +1652,7 @@ _("realtime summary inode %" PRIu64 " has bad type 0x%x, "),if (mp->m_sb.sb_rblocks ==0 && nextents !=0 ) {do_warn ( -_ ("bad # of extents (%d) for realtime summary inode %" PRIu64"\n" ), +_ ("bad # of extents (%lu) for realtime summary inode %" PRIu64"\n" ), nextents, lino);return 1 ; }
@@ -1677,7 +1677,7 @@ _("realtime bitmap inode %" PRIu64 " has bad type 0x%x, "),if (mp->m_sb.sb_rblocks ==0 && nextents !=0 ) {do_warn ( -_ ("bad # of extents (%d) for realtime bitmap inode %" PRIu64"\n" ), +_ ("bad # of extents (%lu) for realtime bitmap inode %" PRIu64"\n" ), nextents, lino);return 1 ; }
@@ -1870,13 +1870,13 @@ _("too many data fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),if (nextents != dnextents) {if (!no_modify) {do_warn ( -_ ("correcting nextents for inode %" PRIu64", was %d - counted %" PRIu64"\n" ), +_ ("correcting nextents for inode %" PRIu64", was %lu - counted %" PRIu64"\n" ), lino, dnextents, nextents); dino->di_nextents32 =cpu_to_be32 (nextents); *dirty =1 ; }else {do_warn ( -_ ("bad nextents %d for inode %" PRIu64", would reset to %" PRIu64"\n" ), +_ ("bad nextents %lu for inode %" PRIu64", would reset to %" PRIu64"\n" ), dnextents, lino, nextents); } }
@@ -1894,13 +1894,13 @@ _("too many attr fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),if (anextents != dnextents) {if (!no_modify) {do_warn ( -_ ("correcting anextents for inode %" PRIu64", was %d - counted %" PRIu64"\n" ), +_ ("correcting anextents for inode %" PRIu64", was %lu - counted %" PRIu64"\n" ), lino, dnextents, anextents); dino->di_nextents16 =cpu_to_be16 (anextents); *dirty =1 ; }else {do_warn ( -_ ("bad anextents %d for inode %" PRIu64", would reset to %" PRIu64"\n" ), +_ ("bad anextents %lu for inode %" PRIu64", would reset to %" PRIu64"\n" ), dnextents, lino, anextents); } }
repair/dinode.h +2 -2
@@ -20,7 +20,7 @@ convert_extent( int process_bmbt_reclist(xfs_mount_t *mp, xfs_bmbt_rec_t *rp, - int *numrecs, + xfs_extnum_t *numrecs, int type, xfs_ino_t ino, xfs_rfsblock_t *tot,
@@ -34,7 +34,7 @@ int scan_bmbt_reclist( xfs_mount_t *mp, xfs_bmbt_rec_t *rp, - int *numrecs, + xfs_extnum_t *numrecs, int type, xfs_ino_t ino, xfs_rfsblock_t *tot,
repair/scan.c +3 -3
@@ -223,7 +223,7 @@ scan_bmapbt(xfs_fileoff_t first_key;xfs_fileoff_t last_key;char *forkname =get_forkname (whichfork); -int numrecs; +xfs_extnum_t numrecs;xfs_agnumber_t agno;xfs_agblock_t agbno;int state;
@@ -443,7 +443,7 @@ _("couldn't add inode %"PRIu64" bmbt block %"PRIu64" reverse-mapping data."),if (numrecs > mp->m_bmap_dmxr[0 ] || (isroot ==0 && numrecs < mp->m_bmap_dmnr[0 ])) {do_warn ( -_ ("inode %" PRIu64" bad # of bmap records (%u, min - %u, max - %u)\n" ), +_ ("inode %" PRIu64" bad # of bmap records (%lu, min - %u, max - %u)\n" ), ino, numrecs, mp->m_bmap_dmnr[0 ], mp->m_bmap_dmxr[0 ]);return (1 );
@@ -495,7 +495,7 @@ _("out-of-order bmap key (file offset) in inode %" PRIu64 ", %s fork, fsbno %" Pif (numrecs > mp->m_bmap_dmxr[1 ] || (isroot ==0 && numrecs < mp->m_bmap_dmnr[1 ])) {do_warn ( -_ ("inode %" PRIu64" bad # of bmap records (%u, min - %u, max - %u)\n" ), +_ ("inode %" PRIu64" bad # of bmap records (%lu, min - %u, max - %u)\n" ), ino, numrecs, mp->m_bmap_dmnr[1 ], mp->m_bmap_dmxr[1 ]);return (1 ); }
Signature · 1 line
2.30.2
PATCH v3 10/16 xfsprogs: Enable bulkstat ioctl to support 64-bit extent counters
In reply to Chandan Babu RThis commit adds support to libfrog to enable reporting 64-bit extent counters to its users. In order to do so bulkstat ioctl is now invoked with the newly introduced XFS_BULK_IREQ_BULKSTAT_NREXT64 flag. If the ioctl call fails with -EINVAL error, the commit falls back to invoking the bulkstat ioctl without passing XFS_BULK_IREQ_BULKSTAT_NREXT64 flag.
--- fsr/xfs_fsr.c | 4 ++-- io/bulkstat.c | 3 ++- libfrog/bulkstat.c | 55 ++++++++++++++++++++++++++++++++++++++++++---- libxfs/xfs_fs.h | 19 +++++++++++----- 4 files changed, 69 insertions(+), 12 deletions(-)
fsr/xfs_fsr.c +2 -2
@@ -606,7 +606,7 @@ cmp(const void *s1, const void *s2) (bs1->bs_version ==XFS_BULKSTAT_VERSION_V5 && bs2->bs_version == XFS_BULKSTAT_VERSION_V5)); -return (bs2->bs_extents - bs1->bs_extents); +return (bs2->bs_extents64 - bs1->bs_extents64); }/*
@@ -670,7 +670,7 @@ fsrfs(char *mntdir, xfs_ino_t startino, int targetrange)for (p = buf, endp = (buf + buflenout); p < endp ; p++) {/* Do some obvious checks now */ if (((p->bs_mode &S_IFMT ) !=S_IFREG ) || - (p->bs_extents <2 )) + (p->bs_extents64 <2 ))continue ; ret = open_handle(&file_fd, fshandlep, p,
io/bulkstat.c +2 -1
@@ -49,7 +49,7 @@ dump_bulkstat(printf ("\tbs_extsize_blks = %" PRIu32"\n" , bstat->bs_extsize_blks);printf ("\tbs_nlink = %" PRIu32"\n" , bstat->bs_nlink); -printf ("\tbs_extents = %" PRIu32"\n" , bstat->bs_extents); +printf ("\tbs_extents32 = %" PRIu32"\n" , bstat->bs_extents32);printf ("\tbs_aextents = %" PRIu32"\n" , bstat->bs_aextents);printf ("\tbs_version = %" PRIu16"\n" , bstat->bs_version);printf ("\tbs_forkoff = %" PRIu16"\n" , bstat->bs_forkoff);
@@ -57,6 +57,7 @@ dump_bulkstat(printf ("\tbs_sick = 0x%" PRIx16"\n" , bstat->bs_sick);printf ("\tbs_checked = 0x%" PRIx16"\n" , bstat->bs_checked);printf ("\tbs_mode = 0%" PRIo16"\n" , bstat->bs_mode); +printf ("\tbs_extents64 = %" PRIu64"\n" , bstat->bs_extents64); }; static void
libfrog/bulkstat.c +51 -4
125 lines not on this page · raw message
libxfs/xfs_fs.h +14 -5
@@ -394,7 +394,7 @@ struct xfs_bulkstat {uint32_t bs_extsize_blks;/* extent size hint, blocks */ uint32_t bs_nlink;/* number of links */ -uint32_t bs_extents;/* number of extents */ +uint32_t bs_extents32;/* 32-bit data fork extent counter */ uint32_t bs_aextents;/* attribute number of extents */ uint16_t bs_version;/* structure version */ uint16_t bs_forkoff;/* inode fork offset in bytes */
@@ -403,8 +403,9 @@ struct xfs_bulkstat {uint16_t bs_checked;/* checked inode metadata */ uint16_t bs_mode;/* type and mode */ uint16_t bs_pad2;/* zeroed */ +uint64_t bs_extents64;/* 64-bit data fork extent counter */ -uint64_t bs_pad[7 ];/* zeroed */ +uint64_t bs_pad[6 ];/* zeroed */ };#define XFS_BULKSTAT_VERSION_V1 (1)
@@ -469,7 +470,8 @@ struct xfs_bulk_ireq {uint32_t icount;/* I: count of entries in buffer */ uint32_t ocount;/* O: count of entries filled out */ uint32_t agno;/* I: see comment for IREQ_AGNO */ -uint64_t reserved[5 ];/* must be zero */ +uint64_t bulkstat_flags;/* I: Bulkstat operation flags */ +uint64_t reserved[4 ];/* must be zero */ };/*
@@ -492,9 +494,16 @@ struct xfs_bulk_ireq {*/ #define XFS_BULK_IREQ_METADIR (1 << 2) -#define XFS_BULK_IREQ_FLAGS_ALL (XFS_BULK_IREQ_AGNO | \ +#define XFS_BULK_IREQ_BULKSTAT (1 << 3) + +#define XFS_BULK_IREQ_FLAGS_ALL (XFS_BULK_IREQ_AGNO | \ XFS_BULK_IREQ_SPECIAL | \ - XFS_BULK_IREQ_METADIR) + XFS_BULK_IREQ_METADIR | \ + XFS_BULK_IREQ_BULKSTAT) + +#define XFS_BULK_IREQ_BULKSTAT_NREXT64 (1 << 0) + +#define XFS_BULK_IREQ_BULKSTAT_FLAGS_ALL (XFS_BULK_IREQ_BULKSTAT_NREXT64)/* Operate on the root directory inode. */ #define XFS_BULK_IREQ_SPECIAL_ROOT (1)
Signature · 1 line
2.30.2
PATCH v3 11/16 xfsprogs: Extend per-inode extent counter widths
In reply to Chandan Babu RThis commit adds a new 64-bit per-inode data extent counter. However the maximum number of extents that a data fork can hold is limited to 2^48 extents. This feature is available only when XFS_SB_FEAT_INCOMPAT_EXTCOUNT_64BIT feature bit is enabled on the filesystem. Also, enabling this feature bit causes attr fork extent counter to use the 32-bit extent counter that was previously used to hold the data fork extent counter. This implies that the attr fork can now occupy a maximum of 2^32 extents.
--- db/field.c | 4 -- db/field.h | 2 - db/inode.c | 44 +++++++++++++++++-- include/libxlog.h | 6 ++- include/xfs_inode.h | 5 +++ include/xfs_mount.h | 4 +- libxfs/xfs_bmap.c | 8 ++-- libxfs/xfs_format.h | 87 ++++++++++++++++++++++++++------------ libxfs/xfs_fs.h | 1 + libxfs/xfs_ialloc.c | 2 + libxfs/xfs_inode_buf.c | 25 ++++++++++- libxfs/xfs_inode_fork.h | 18 ++++++-- libxfs/xfs_log_format.h | 3 +- libxfs/xfs_sb.c | 3 ++ libxfs/xfs_trans_inode.c | 5 +++ logprint/log_misc.c | 23 +++++++--- logprint/log_print_all.c | 31 +++++++++++--- logprint/log_print_trans.c | 2 +- repair/bmap_repair.c | 10 ++++- repair/dinode.c | 15 +++++-- 20 files changed, 229 insertions(+), 69 deletions(-)
db/field.c +0 -4
@@ -25,8 +25,6 @@#include "symlink.h" const ftattr_t ftattrtab[] = { - {FLDT_AEXTNUM ,"aextnum" , fp_num,"%d" ,SI (bitsz (xfs_aextnum_t)), -FTARG_SIGNED ,NULL ,NULL }, {FLDT_AGBLOCK ,"agblock" , fp_num,"%u" ,SI (bitsz (xfs_agblock_t)),FTARG_DONULL , fa_agblock,NULL }, {FLDT_AGBLOCKNZ ,"agblocknz" , fp_num,"%u" ,SI (bitsz (xfs_agblock_t)),
@@ -300,8 +298,6 @@ const ftattr_t ftattrtab[] = { FTARG_DONULL, fa_drtbno, NULL }, { FLDT_EXTLEN, "extlen", fp_num, "%u", SI(bitsz(xfs_extlen_t)), 0, NULL, NULL }, - {FLDT_EXTNUM ,"extnum" , fp_num,"%d" ,SI (bitsz (xfs_extnum_t)), - FTARG_SIGNED, NULL, NULL }, {FLDT_FSIZE ,"fsize" , fp_num,"%lld" ,SI (bitsz (xfs_fsize_t)), FTARG_SIGNED, NULL, NULL }, { FLDT_INO, "ino", fp_num, "%llu", SI(bitsz(xfs_ino_t)), FTARG_DONULL,
db/field.h +0 -2
@@ -5,7 +5,6 @@*/ typedef enum fldt { - FLDT_AEXTNUM, FLDT_AGBLOCK, FLDT_AGBLOCKNZ, FLDT_AGF,
@@ -143,7 +142,6 @@ typedef enum fldt {FLDT_DRFSBNO ,FLDT_DRTBNO ,FLDT_EXTLEN , -FLDT_EXTNUM ,FLDT_FSIZE ,FLDT_INO , FLDT_INOBT,
db/inode.c +41 -3
74 lines not on this page · raw message
include/libxlog.h +4 -2
@@ -89,13 +89,15 @@ extern int xlog_find_tail(struct xlog *log, xfs_daddr_t *head_blk,extern int xlog_recover (struct xlog *log,int readonly);extern void xlog_recover_print_data (char *p,int len); -extern void xlog_recover_print_logitem (struct xlog_recover_item *item); +extern void xlog_recover_print_logitem (struct xlog *log, +struct xlog_recover_item *item);extern void xlog_recover_print_trans_head (struct xlog_recover *tr);extern int xlog_print_find_oldest (struct xlog *log,xfs_daddr_t *last_blk);/* for transactional view */ extern void xlog_recover_print_trans_head (struct xlog_recover *tr); -extern void xlog_recover_print_trans (struct xlog_recover *trans, +extern void xlog_recover_print_trans (struct xlog *log, +struct xlog_recover *trans,struct list_head *itemq,int print);extern int xlog_do_recovery_pass (struct xlog *log,xfs_daddr_t head_blk,xfs_daddr_t tail_blk,int pass);
include/xfs_inode.h +5 -0
@@ -211,6 +211,11 @@ static inline bool xfs_inode_has_bigrtextents(struct xfs_inode *ip)return XFS_IS_REALTIME_INODE (ip) && ip->i_mount->m_sb.sb_rextsize >1 ; } +static inline bool xfs_inode_has_nrext64 (struct xfs_inode *ip) +{ +return ip->i_diflags2 &XFS_DIFLAG2_NREXT64 ; +} +static inline bool xfs_is_always_cow_inode (struct xfs_inode *ip) {return false;
include/xfs_mount.h +3 -1
@@ -153,8 +153,9 @@ typedef struct xfs_mount {#define XFS_FEAT_NEEDSREPAIR (1ULL << 25)/* needs xfs_repair */ #define XFS_FEAT_ATOMIC_SWAP (1ULL << 26)/* extent swap log items */ #define XFS_FEAT_METADIR (1ULL << 27)/* metadata directory tree */ +#define XFS_FEAT_NREXT64 (1ULL << 28)/* 64-bit inode extent counters */ -#define __XFS_HAS_FEAT (name,NAME ) \ +#define __XFS_HAS_FEAT (name,NAME ) \ static inline bool xfs_has_ ## name (struct xfs_mount *mp) \ { \ return mp->m_features & XFS_FEAT_ ## NAME; \
@@ -198,6 +199,7 @@ __XFS_HAS_FEAT(bigtime, BIGTIME) __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR) __XFS_HAS_FEAT(atomicswap, ATOMIC_SWAP) __XFS_HAS_FEAT(metadir, METADIR) +__XFS_HAS_FEAT (nrext64,NREXT64 )/* * Decide if this filesystem can use log-assisted ("atomic") extent swapping.
libxfs/xfs_bmap.c +3 -5
@@ -48,18 +48,16 @@ xfs_bmap_compute_maxlevels( int whichfork) /* data or attr fork */ {xfs_extnum_t maxleafents;/* max leaf entries possible */ +xfs_rfsblock_t maxblocks;/* max blocks at this level */ int level;/* btree level */ -uint maxblocks;/* max blocks at this level */ int maxrootrecs;/* max records in root block */ int minleafrecs;/* min records in leaf block */ int minnoderecs;/* min records in node block */ int sz;/* root block size */ /* -* The maximum number of extents in a file, hence the maximum number of -* leaf entries, is controlled by the size of the on-disk extent count, -* either a signed 32-bit number for the data fork, or a signed 16-bit -* number for the attr fork. +* The maximum number of extents in a fork, hence the maximum number of +* leaf entries, is controlled by the size of the on-disk extent count. * * Note that we can no longer assume that if we are in ATTR1 that the * fork offset of all the inodes will be
libxfs/xfs_format.h +59 -28
142 lines not on this page · raw message
libxfs/xfs_fs.h +1 -0
@@ -254,6 +254,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_ATOMIC_SWAP (1 << 23)/* atomic swapext */ #define XFS_FSOP_GEOM_FLAGS_METADIR (1 << 24)/* metadata directories */ +#define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 25)/* 64-bit extent counter */ /* * Minimum and maximum sizes need for growth checks.
libxfs/xfs_ialloc.c +2 -0
@@ -2831,6 +2831,8 @@ xfs_ialloc_setup_geometry( igeo->new_diflags2 =0 ;if (xfs_has_bigtime (mp)) igeo->new_diflags2 |=XFS_DIFLAG2_BIGTIME ; +if (xfs_has_nrext64 (mp)) + igeo->new_diflags2 |=XFS_DIFLAG2_NREXT64 ;/* Compute inode btree geometry. */ igeo->agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
libxfs/xfs_inode_buf.c +23 -2
@@ -282,6 +282,27 @@ xfs_inode_to_disk_ts(return ts; } +static inline void +xfs_inode_to_disk_iext_counters ( +struct xfs_inode *ip, +struct xfs_dinode *to) +{ +if (xfs_inode_has_nrext64 (ip)) { + to->di_nextents64 =cpu_to_be64 (xfs_ifork_nextents (&ip->i_df)); + to->di_nextents32 =cpu_to_be32 (xfs_ifork_nextents (ip->i_afp)); +/* +* We might be upgrading the inode to use wider extent counters +* than was previously used. Hence zero the unused field. +*/ + to->di_nextents16 =cpu_to_be16 (0 ); + }else { +if (xfs_has_v3inodes (ip->i_mount)) + to->di_nextents64 =0 ; + to->di_nextents32 =cpu_to_be32 (xfs_ifork_nextents (&ip->i_df)); + to->di_nextents16 =cpu_to_be16 (xfs_ifork_nextents (ip->i_afp)); + } +} + void xfs_inode_to_disk( struct xfs_inode *ip,
@@ -310,8 +331,6 @@ xfs_inode_to_disk( to->di_size =cpu_to_be64 (ip->i_disk_size); to->di_nblocks =cpu_to_be64 (ip->i_nblocks); to->di_extsize =cpu_to_be32 (ip->i_extsize); - to->di_nextents32 =cpu_to_be32 (xfs_ifork_nextents (&ip->i_df)); - to->di_nextents16 =cpu_to_be16 (xfs_ifork_nextents (ip->i_afp)); to->di_forkoff = ip->i_forkoff; to->di_aformat =xfs_ifork_format (ip->i_afp); to->di_flags =cpu_to_be16 (ip->i_diflags);
@@ -331,6 +350,8 @@ xfs_inode_to_disk( to->di_version =2 ; to->di_flushiter =cpu_to_be16 (ip->i_flushiter); } + +xfs_inode_to_disk_iext_counters (ip, to); } static xfs_failaddr_t
libxfs/xfs_inode_fork.h +15 -3
@@ -136,10 +136,22 @@ static inline int8_t xfs_ifork_format(struct xfs_ifork *ifp)static inline xfs_extnum_t xfs_iext_max_nextents (struct xfs_mount *mp,int whichfork) { -if (whichfork ==XFS_DATA_FORK || whichfork ==XFS_COW_FORK ) -return XFS_IFORK_EXTCNT_MAXS32 ; +bool has_64bit_extcnt =xfs_has_nrext64 (mp); -return XFS_IFORK_EXTCNT_MAXS16 ; +switch (whichfork) { +case XFS_DATA_FORK : +case XFS_COW_FORK : +return has_64bit_extcnt ?XFS_IFORK_EXTCNT_MAXU48 + :XFS_IFORK_EXTCNT_MAXS32 ; + +case XFS_ATTR_FORK : +return has_64bit_extcnt ?XFS_IFORK_EXTCNT_MAXU32 + :XFS_IFORK_EXTCNT_MAXS16 ; + +default : +ASSERT (0 ); +return 0 ; + } } struct xfs_ifork *xfs_ifork_alloc(enum xfs_dinode_fmt format,
libxfs/xfs_log_format.h +2 -1
@@ -429,7 +429,8 @@ struct xfs_log_dinode {uint64_t di_flags2;/* more random flags */ uint32_t di_cowextsize;/* basic cow extent size for file */ -uint8_t di_pad2[12 ];/* more padding for future expansion */ +uint8_t di_pad2[4 ];/* more padding for future expansion */ +uint64_t di_nextents64;/* higher part of data fork extent count */ /* fields only written to during inode creation */ xfs_log_timestamp_t di_crtime;/* time created */
libxfs/xfs_sb.c +3 -0
@@ -1173,6 +1173,9 @@ xfs_fs_geometry( geo->flags |=XFS_FSOP_GEOM_FLAGS_ATOMIC_SWAP ;if (xfs_has_metadir (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_METADIR ; +if (xfs_has_nrext64 (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_NREXT64 ; + geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
libxfs/xfs_trans_inode.c +5 -0
@@ -141,6 +141,11 @@ xfs_trans_log_inode( flags |=XFS_ILOG_CORE ; } +if ((flags &XFS_ILOG_CORE ) && +xfs_has_nrext64 (ip->i_mount) && + !xfs_inode_has_nrext64 (ip)) + ip->i_diflags2 |=XFS_DIFLAG2_NREXT64 ; +/* * Inode verifiers do not check that the extent size hint is an integer * multiple of the rt extent size on a directory with both rtinherit
logprint/log_misc.c +18 -5
@@ -438,8 +438,11 @@ xlog_print_trans_qoff(char **ptr, uint len)static void xlog_print_trans_inode_core ( +struct xfs_mount *mp,struct xfs_log_dinode *ip) { +xfs_extnum_t nextents; +printf (_ ("INODE CORE\n" )); printf(_("magic 0x%hx mode 0%ho version %d format %d\n"), ip->di_magic, ip->di_mode, (int)ip->di_version,
@@ -450,11 +453,21 @@ xlog_print_trans_inode_core(xlog_extract_dinode_ts (ip->di_atime),xlog_extract_dinode_ts (ip->di_mtime), xlog_extract_dinode_ts(ip->di_ctime)); -printf (_ ("size 0x%llx nblocks 0x%llx extsize 0x%x nextents 0x%x\n" ), + +if (ip->di_flags2 &XFS_DIFLAG2_NREXT64 ) + nextents = ip->di_nextents64; +else + nextents = ip->di_nextents32; +printf (_ ("size 0x%llx nblocks 0x%llx extsize 0x%x nextents 0x%lx\n" ), (unsigned long long )ip->di_size, (unsigned long long )ip->di_nblocks, - ip->di_extsize, ip->di_nextents32); -printf (_ ("naextents 0x%x forkoff %d dmevmask 0x%x dmstate 0x%hx\n" ), - ip->di_nextents16, (int )ip->di_forkoff, ip->di_dmevmask, + ip->di_extsize, nextents); + +if (ip->di_flags2 &XFS_DIFLAG2_NREXT64 ) + nextents = ip->di_nextents32; +else + nextents = ip->di_nextents16; +printf (_ ("naextents 0x%lx forkoff %d dmevmask 0x%x dmstate 0x%hx\n" ), + nextents, (int )ip->di_forkoff, ip->di_dmevmask, ip->di_dmstate);printf (_ ("flags 0x%x gen 0x%x\n" ), ip->di_flags, ip->di_gen);
@@ -564,7 +577,7 @@ xlog_print_trans_inode(memmove (&dino, *ptr,sizeof (dino)); mode = dino.di_mode &S_IFMT ; size = (int )dino.di_size; -xlog_print_trans_inode_core (&dino); +xlog_print_trans_inode_core (log->l_mp, &dino); *ptr +=xfs_log_dinode_size (log->l_mp); skip_count--;
logprint/log_print_all.c +24 -7
@@ -238,9 +238,13 @@ xlog_recover_print_dquot( STATIC voidxlog_recover_print_inode_core ( +struct xlog *log,struct xfs_log_dinode *di) { -printf (_ (" CORE inode:\n" )); +xfs_extnum_t nextents; +xfs_aextnum_t anextents; + +printf (_ (" CORE inode:\n" ));if (!print_inode)return ; printf(_(" magic:%c%c mode:0x%x ver:%d format:%d\n"),
@@ -254,10 +258,19 @@ xlog_recover_print_inode_core(xlog_extract_dinode_ts (di->di_mtime), xlog_extract_dinode_ts(di->di_ctime));printf (_ (" flushiter:%d\n" ), di->di_flushiter); + +if (di->di_flags2 &XFS_DIFLAG2_NREXT64 ) { + nextents = di->di_nextents64; + anextents = di->di_nextents32; + }else { + nextents = di->di_nextents32; + anextents = di->di_nextents16; + } +printf (_ (" size:0x%llx nblks:0x%llx exsize:%d " -"nextents:%d anextents:%d\n" ), (unsigned long long ) +"nextents:%lu anextents:%u\n" ), (unsigned long long ) di->di_size, (unsigned long long )di->di_nblocks, - di->di_extsize, di->di_nextents32, (int )di->di_nextents16); + di->di_extsize, nextents, anextents); printf(_(" forkoff:%d dmevmask:0x%x dmstate:%d flags:0x%x " "gen:%u\n"), (int)di->di_forkoff, di->di_dmevmask, (int)di->di_dmstate,
@@ -270,6 +283,7 @@ xlog_recover_print_inode_core( STATIC voidxlog_recover_print_inode ( +struct xlog *log,struct xlog_recover_item *item) {struct xfs_inode_log_format f_buf;
@@ -291,7 +305,7 @@ xlog_recover_print_inode(ASSERT (item->ri_buf[1 ].i_len == offsetof(struct xfs_log_dinode , di_next_unlinked) || item->ri_buf[1 ].i_len ==sizeof (struct xfs_log_dinode )); -xlog_recover_print_inode_core ((struct xfs_log_dinode *) +xlog_recover_print_inode_core (log, (struct xfs_log_dinode *) item->ri_buf[1 ].i_addr); hasdata = (f->ilf_fields &XFS_ILOG_DFORK ) !=0 ;
@@ -386,6 +400,7 @@ xlog_recover_print_icreate(void xlog_recover_print_logitem ( +struct xlog *log,struct xlog_recover_item *item) {switch (ITEM_TYPE (item)) {
@@ -396,7 +411,7 @@ xlog_recover_print_logitem(xlog_recover_print_icreate (item);break ;case XFS_LI_INODE : -xlog_recover_print_inode (item); +xlog_recover_print_inode (log, item);break ;case XFS_LI_EFD :xlog_recover_print_efd (item);
@@ -442,6 +457,7 @@ xlog_recover_print_logitem(static void xlog_recover_print_item ( +struct xlog *log,struct xlog_recover_item *item) {int i;
@@ -507,11 +523,12 @@ xlog_recover_print_item( (long)item->ri_buf[i].i_addr, item->ri_buf[i].i_len); }printf ("\n" ); -xlog_recover_print_logitem (item); +xlog_recover_print_logitem (log, item); }void xlog_recover_print_trans ( +struct xlog *log,struct xlog_recover *trans,struct list_head *itemq,int print)
@@ -524,5 +541,5 @@ xlog_recover_print_trans(print_xlog_record_line ();xlog_recover_print_trans_head (trans);list_for_each_entry (item, itemq, ri_list) -xlog_recover_print_item (item); +xlog_recover_print_item (log, item); }
logprint/log_print_trans.c +1 -1
@@ -24,7 +24,7 @@ xlog_recover_do_trans(struct xlog_recover *trans, int pass) { - xlog_recover_print_trans(trans, &trans->r_itemq, 3); + xlog_recover_print_trans(log, trans, &trans->r_itemq, 3);return 0 ; }
repair/bmap_repair.c +8 -2
@@ -579,7 +579,10 @@ rebuild_bmap(if (nextents ==0 )return 0 ; (*dinop)->di_format =XFS_DINODE_FMT_EXTENTS ; - (*dinop)->di_nextents32 =0 ; +if (be64_to_cpu ((*dinop)->di_flags2) &XFS_DIFLAG2_NREXT64 ) + (*dinop)->di_nextents64 =0 ; +else + (*dinop)->di_nextents32 =0 ;libxfs_dinode_calc_crc (mp, *dinop); *dirty =1 ;break ;
@@ -590,7 +593,10 @@ rebuild_bmap(if (nextents ==0 )return 0 ; (*dinop)->di_aformat =XFS_DINODE_FMT_EXTENTS ; - (*dinop)->di_nextents16 =0 ; +if (be64_to_cpu ((*dinop)->di_flags2) &XFS_DIFLAG2_NREXT64 ) + (*dinop)->di_nextents32 =0 ; +else + (*dinop)->di_nextents16 =0 ;libxfs_dinode_calc_crc (mp, *dinop); *dirty =1 ;break ;
repair/dinode.c +12 -3
@@ -78,7 +78,10 @@ _("would have cleared inode %" PRIu64 " attributes\n"), ino_num);if (anextents !=0 ) {if (no_modify)return (1 ); - dino->di_nextents16 =cpu_to_be16 (0 ); +if (xfs_dinode_has_nrext64 (dino)) + dino->di_nextents32 =0 ; +else + dino->di_nextents16 =0 ; }if (dino->di_aformat !=XFS_DINODE_FMT_EXTENTS ) {
@@ -1872,7 +1875,10 @@ _("too many data fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),do_warn (_ ("correcting nextents for inode %" PRIu64", was %lu - counted %" PRIu64"\n" ), lino, dnextents, nextents); - dino->di_nextents32 =cpu_to_be32 (nextents); +if (xfs_dinode_has_nrext64 (dino)) + dino->di_nextents64 =cpu_to_be64 (nextents); +else + dino->di_nextents32 =cpu_to_be32 (nextents); *dirty =1 ; }else { do_warn(
@@ -1896,7 +1902,10 @@ _("too many attr fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),do_warn (_ ("correcting anextents for inode %" PRIu64", was %lu - counted %" PRIu64"\n" ), lino, dnextents, anextents); - dino->di_nextents16 =cpu_to_be16 (anextents); +if (xfs_dinode_has_nrext64 (dino)) + dino->di_nextents32 =cpu_to_be32 (anextents); +else + dino->di_nextents16 =cpu_to_be16 (anextents); *dirty =1 ; }else { do_warn(
Signature · 1 line
2.30.2
PATCH v3 12/16 xfsprogs: xfs_info: Report NREXT64 feature status
In reply to Chandan Babu RThis commit adds support to libfrog to obtain information about the availability of NREXT64 feature in the underlying filesystem.
--- libfrog/fsgeom.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
libfrog/fsgeom.c +4 -2
@@ -31,6 +31,7 @@ xfs_report_geom(int bigtime_enabled;int inobtcount;int metadir; +int nrext64; isint = geo->logstart >0 ; lazycount = geo->flags &XFS_FSOP_GEOM_FLAGS_LAZYSB ?1 :0 ;
@@ -49,12 +50,13 @@ xfs_report_geom( bigtime_enabled = geo->flags &XFS_FSOP_GEOM_FLAGS_BIGTIME ?1 :0 ; inobtcount = geo->flags &XFS_FSOP_GEOM_FLAGS_INOBTCNT ?1 :0 ; metadir = geo->flags &XFS_FSOP_GEOM_FLAGS_METADIR ?1 :0 ; + nrext64 = geo->flags &XFS_FSOP_GEOM_FLAGS_NREXT64 ?1 :0 ; printf(_( "meta-data=%-22s isize=%-6d agcount=%u, agsize=%u blks\n" " =%-22s sectsz=%-5u attr=%u, projid32bit=%u\n" " =%-22s crc=%-8u finobt=%u, sparse=%u, rmapbt=%u\n" -" =%-22s reflink=%-4u bigtime=%u inobtcount=%u\n" +" =%-22s reflink=%-4u bigtime=%u inobtcount=%u nrext64=%u\n" " =%-22s metadir=%-4u\n" "data =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n" " =%-22s sunit=%-6u swidth=%u blks\n"
@@ -65,7 +67,7 @@ xfs_report_geom( mntpoint, geo->inodesize, geo->agcount, geo->agblocks,"" , geo->sectsize, attrversion, projid32bit,"" , crcs_enabled, finobt_enabled, spinodes, rmapbt_enabled, -"" , reflink_enabled, bigtime_enabled, inobtcount, +"" , reflink_enabled, bigtime_enabled, inobtcount, nrext64,"" , metadir,"" , geo->blocksize, (unsigned long long )geo->datablocks, geo->imaxpct,
Signature · 1 line
2.30.2
PATCH v3 13/16 xfsprogs: Add XFS_SB_FEAT_INCOMPAT_NREXT64 to XFS_SB_FEAT_INCOMPAT_ALL
In reply to Chandan Babu R--- libxfs/xfs_format.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
libxfs/xfs_format.h +2 -1
@@ -395,7 +395,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_META_UUID| \ XFS_SB_FEAT_INCOMPAT_BIGTIME| \ XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR| \ - XFS_SB_FEAT_INCOMPAT_METADIR) + XFS_SB_FEAT_INCOMPAT_METADIR| \ + XFS_SB_FEAT_INCOMPAT_NREXT64)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline bool
Signature · 1 line
2.30.2
PATCH v3 14/16 xfsprogs: Add nrext64 mkfs option
In reply to Chandan Babu REnabling nrext64 option on mkfs.xfs command line extends the maximum values of inode data and attr fork extent counters to 2^48 - 1 and 2^32 - 1 respectively. This also sets the XFS_SB_FEAT_INCOMPAT_NREXT64 incompat flag on the superblock preventing older kernels from mounting such a filesystem.
--- libxfs/xfs_sb.c | 2 ++ man/man8/mkfs.xfs.8 | 7 +++++++ mkfs/xfs_mkfs.c | 23 +++++++++++++++++++++++ 3 files changed, 32 insertions(+)
libxfs/xfs_sb.c +2 -0
@@ -124,6 +124,8 @@ xfs_sb_version_to_features( features |=XFS_FEAT_NEEDSREPAIR ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_METADIR ) features |=XFS_FEAT_METADIR ; +if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_NREXT64 ) + features |=XFS_FEAT_NREXT64 ;if (sbp->sb_features_log_incompat &XFS_SB_FEAT_INCOMPAT_LOG_ATOMIC_SWAP ) features |=XFS_FEAT_ATOMIC_SWAP ;
man/man8/mkfs.xfs.8 +7 -0
@@ -650,6 +650,13 @@ space over time such that no free extents are large enough to accommodate a chunk of 64 inodes. Without this feature enabled, inode allocations can fail with out of space errors under severe fragmented free space conditions. +.TP +.BI nrext64[= value] +Extend maximum values of inode data and attr fork extent counters from 2^31 - +1 and 2^15 - 1 to 2^48 - 1 and 2^32 - 1 respectively. If the value is +omitted, 1 is assumed. This feature is disabled by default. This feature is +only available for filesystems formatted with -m crc=1. +.TP .RE .PP .PD 0
mkfs/xfs_mkfs.c +23 -0
@@ -78,6 +78,7 @@ enum {I_ATTR ,I_PROJID32BIT ,I_SPINODES , +I_NREXT64 , I_MAX_OPTS, };
@@ -433,6 +434,7 @@ static struct opt_params iopts = { [I_ATTR] = "attr", [I_PROJID32BIT] = "projid32bit", [I_SPINODES] = "sparse", + [I_NREXT64 ] ="nrext64" , }, .subopt_params = { { .index =I_ALIGN ,
@@ -481,6 +483,12 @@ static struct opt_params iopts = { .maxval = 1, .defaultval = 1, }, + { .index = I_NREXT64, + .conflicts = { { NULL, LAST_CONFLICT } }, + .minval = 0, + .maxval = 1, + .defaultval = 1, + } }, };
@@ -813,6 +821,7 @@ struct sb_feat_args {bool metadir;/* XFS_SB_FEAT_INCOMPAT_METADIR */ bool nodalign;bool nortalign; +bool nrext64; };struct cli_params {
@@ -1594,6 +1603,9 @@ inode_opts_parser(case I_SPINODES : cli->sb_feat.spinodes =getnum (value, opts, subopt);break ; +case I_NREXT64 : + cli->sb_feat.nrext64 =getnum (value, opts, subopt); +break ;default :return -EINVAL ; }
@@ -2181,6 +2193,14 @@ _("metadata directory not supported without CRC support\n"));usage (); } cli->sb_feat.metadir = false; + +if (cli->sb_feat.nrext64 && +cli_opt_set (&iopts,I_NREXT64 )) { +fprintf (stderr, +_ ("64 bit extent count not supported without CRC support\n" )); +usage (); + } + cli->sb_feat.nrext64 = false; }if (!cli->sb_feat.finobt) {
@@ -3175,6 +3195,8 @@ sb_set_features( sbp->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_SPINODES ; } +if (fp->nrext64) + sbp->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_NREXT64 ; }/*
@@ -3887,6 +3909,7 @@ main( .nodalign = false, .nortalign = false, .bigtime = false, + .nrext64 = false, }, };
Signature · 1 line
2.30.2
PATCH v3 15/16 xfsprogs: Add support for upgrading to NREXT64 feature
In reply to Chandan Babu R--- repair/globals.c | 1 + repair/globals.h | 1 + repair/phase2.c | 34 ++++++++++++++++++++++++++++++++++ repair/xfs_repair.c | 11 +++++++++++ 4 files changed, 47 insertions(+)
repair/globals.c +1 -0
@@ -54,6 +54,7 @@ bool add_finobt; /* add free inode btrees */bool add_reflink;/* add reference count btrees */ bool add_rmapbt;/* add reverse mapping btrees */ bool add_metadir;/* add metadata directory tree */ +bool add_nrext64;/* misc status variables */
repair/globals.h +1 -0
@@ -95,6 +95,7 @@ extern bool add_finobt; /* add free inode btrees */extern bool add_reflink;/* add reference count btrees */ extern bool add_rmapbt;/* add reverse mapping btrees */ extern bool add_metadir;/* add metadata directory tree */ +extern bool add_nrext64;/* misc status variables */
repair/phase2.c +34 -0
@@ -191,6 +191,7 @@ check_new_v5_geometry(struct xfs_perag *pag;xfs_agnumber_t agno;xfs_ino_t rootino; +uint old_bm_maxlevels[2 ];int min_logblocks;int error;
@@ -201,6 +202,12 @@ check_new_v5_geometry(memcpy (&old_sb, &mp->m_sb,sizeof (struct xfs_sb ));memcpy (&mp->m_sb, new_sb,sizeof (struct xfs_sb )); + old_bm_maxlevels[0 ] = mp->m_bm_maxlevels[0 ]; + old_bm_maxlevels[1 ] = mp->m_bm_maxlevels[1 ]; + +xfs_bmap_compute_maxlevels (mp,XFS_DATA_FORK ); +xfs_bmap_compute_maxlevels (mp,XFS_ATTR_FORK ); +/* Do we have a big enough log? */ min_logblocks =libxfs_log_calc_minimum_size (mp);if (old_sb.sb_logblocks < min_logblocks) {
@@ -288,6 +295,9 @@ check_new_v5_geometry( pag->pagi_init =0 ; } + mp->m_bm_maxlevels[0 ] = old_bm_maxlevels[0 ]; + mp->m_bm_maxlevels[1 ] = old_bm_maxlevels[1 ]; +/* * Put back the old superblock. */
@@ -429,6 +439,28 @@ set_metadir(return true; } +static bool +set_nrext64 ( +struct xfs_mount *mp, +struct xfs_sb *new_sb) +{ +if (!xfs_has_crc (mp)) { +printf ( +_ ("Nrext64 only supported on V5 filesystems.\n" )); +exit (0 ); + } + +if (xfs_has_nrext64 (mp)) { +printf (_ ("Filesystem already supports nrext64.\n" )); +exit (0 ); + } + +printf (_ ("Adding nrext64 to filesystem.\n" )); + new_sb->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_NREXT64 ; + new_sb->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR ; +return true; +} +/* Perform the user's requested upgrades on filesystem. */ static void upgrade_filesystem(
@@ -453,6 +485,8 @@ upgrade_filesystem( dirty |=set_rmapbt (mp, &new_sb);if (add_metadir) dirty |=set_metadir (mp, &new_sb); +if (add_nrext64) + dirty |=set_nrext64 (mp, &new_sb);if (!dirty)return ;
repair/xfs_repair.c +11 -0
@@ -71,6 +71,7 @@ enum c_opt_nums {CONVERT_REFLINK ,CONVERT_RMAPBT ,CONVERT_METADIR , +CONVERT_NREXT64 , C_MAX_OPTS, };
@@ -82,6 +83,7 @@ static char *c_opts[] = { [CONVERT_REFLINK] = "reflink", [CONVERT_RMAPBT] = "rmapbt", [CONVERT_METADIR] = "metadir", + [CONVERT_NREXT64] = "nrext64", [C_MAX_OPTS] = NULL, };
@@ -368,6 +370,15 @@ process_args(int argc, char **argv) _("-c metadir only supports upgrades\n")); add_metadir = true;break ; +case CONVERT_NREXT64 : +if (!val) +do_abort ( +_ ("-c nrext64 requires a parameter\n" )); +if (strtol (val,NULL ,0 ) !=1 ) +do_abort ( +_ ("-c nrext64 only supports upgrades\n" )); + add_nrext64 = true; +break ;default :unknown ('c' , val);break ;
Signature · 1 line
2.30.2
PATCH v3 16/16 xfsprogs: Define max extent length based on on-disk format definition
In reply to Chandan Babu RThe maximum extent length depends on maximum block count that can be stored in a BMBT record. Hence this commit defines MAXEXTLEN based on BMBT_BLOCKCOUNT_BITLEN.
While at it, the commit also renames MAXEXTLEN to XFS_MAX_EXTLEN.
--- db/metadump.c | 2 +- libxfs/xfs_bmap.c | 53 +++++++++++++++++++++-------------------- libxfs/xfs_format.h | 20 +++++++--------- libxfs/xfs_inode_buf.c | 4 ++-- libxfs/xfs_rtbitmap.c | 4 ++-- libxfs/xfs_swapext.c | 6 ++--- libxfs/xfs_trans_resv.c | 10 ++++---- mkfs/xfs_mkfs.c | 6 ++--- repair/bmap_repair.c | 2 +- repair/phase4.c | 2 +- 10 files changed, 54 insertions(+), 55 deletions(-)
db/metadump.c +1 -1
@@ -20,7 +20,7 @@#include "field.h" #include "dir2.h" -#define DEFAULT_MAX_EXT_SIZE MAXEXTLEN +#define DEFAULT_MAX_EXT_SIZE XFS_MAX_EXTLEN/* copy all metadata structures to/from a file */
libxfs/xfs_bmap.c +27 -26
173 lines not on this page · raw message
libxfs/xfs_format.h +9 -11
@@ -884,17 +884,6 @@ enum xfs_dinode_fmt { { XFS_DINODE_FMT_BTREE, "btree" }, \ { XFS_DINODE_FMT_UUID, "uuid" } -/* -* Max values for extlen, disk inode's extent counters. -*/ - -#define MAXEXTLEN ((xfs_extlen_t)0x1fffff)/* 21 bits */ -#define XFS_IFORK_EXTCNT_MAXU48 ((xfs_extnum_t)0xffffffffffff)/* Unsigned 48-bits */ -#define XFS_IFORK_EXTCNT_MAXU32 ((xfs_aextnum_t)0xffffffff)/* Unsigned 32-bits */ -#define XFS_IFORK_EXTCNT_MAXS32 ((xfs_extnum_t)0x7fffffff)/* Signed 32-bits */ -#define XFS_IFORK_EXTCNT_MAXS16 ((xfs_aextnum_t)0x7fff)/* Signed 16-bits */ - -/* * Inode minimum and maximum sizes. */
@@ -1700,6 +1689,15 @@ typedef struct xfs_bmbt_rec {typedef uint64_t xfs_bmbt_rec_base_t ;/* use this for casts */ typedef xfs_bmbt_rec_t xfs_bmdr_rec_t ; +/* +* Max values for extlen, disk inode's extent counters. +*/ +#define XFS_MAX_EXTLEN ((xfs_extlen_t)(1 << BMBT_BLOCKCOUNT_BITLEN) - 1) +#define XFS_IFORK_EXTCNT_MAXU48 ((xfs_extnum_t)0xffffffffffff)/* Unsigned 48-bits */ +#define XFS_IFORK_EXTCNT_MAXU32 ((xfs_aextnum_t)0xffffffff)/* Unsigned 32-bits */ +#define XFS_IFORK_EXTCNT_MAXS32 ((xfs_extnum_t)0x7fffffff)/* Signed 32-bits */ +#define XFS_IFORK_EXTCNT_MAXS16 ((xfs_aextnum_t)0x7fff)/* Signed 16-bits */ +/* * Values and macros for delayed-allocation startblock fields. */
libxfs/xfs_inode_buf.c +2 -2
@@ -744,7 +744,7 @@ xfs_inode_validate_extsize(if (extsize_bytes % blocksize_bytes)return __this_address; -if (extsize >MAXEXTLEN ) +if (extsize >XFS_MAX_EXTLEN )return __this_address;if (!rt_flag && extsize > mp->m_sb.sb_agblocks /2 )
@@ -801,7 +801,7 @@ xfs_inode_validate_cowextsize(if (cowextsize_bytes % mp->m_sb.sb_blocksize)return __this_address; -if (cowextsize >MAXEXTLEN ) +if (cowextsize >XFS_MAX_EXTLEN )return __this_address;if (cowextsize > mp->m_sb.sb_agblocks /2 )
libxfs/xfs_rtbitmap.c +2 -2
@@ -1013,7 +1013,7 @@ xfs_rtfree_extent(/* * Free some blocks in the realtime subvolume. rtbno and rtlen are in units of * rt blocks, not rt extents; must be aligned to the rt extent size; and rtlen -* cannot exceed MAXEXTLEN. +* cannot exceed XFS_MAX_EXTLEN. */ int xfs_rtfree_blocks(
@@ -1026,7 +1026,7 @@ xfs_rtfree_blocks(xfs_filblks_t len;xfs_extlen_t mod; -ASSERT (rtlen <=MAXEXTLEN ); +ASSERT (rtlen <=XFS_MAX_EXTLEN ); len =div_u64_rem (rtlen, mp->m_sb.sb_rextsize, &mod);if (mod) {
libxfs/xfs_swapext.c +3 -3
@@ -755,7 +755,7 @@ can_merge(if (b1->br_startoff + b1->br_blockcount == b2->br_startoff && b1->br_startblock + b1->br_blockcount == b2->br_startblock && b1->br_state == b2->br_state && - b1->br_blockcount + b2->br_blockcount <=MAXEXTLEN ) + b1->br_blockcount + b2->br_blockcount <=XFS_MAX_EXTLEN )return true;return false;
@@ -797,7 +797,7 @@ delta_nextents_step( state |=CRIGHT_CONTIG ;if ((state &CBOTH_CONTIG ) ==CBOTH_CONTIG && left->br_startblock + curr->br_startblock + - right->br_startblock >MAXEXTLEN ) + right->br_startblock >XFS_MAX_EXTLEN ) state &= ~CRIGHT_CONTIG ;if (nhole)
@@ -808,7 +808,7 @@ delta_nextents_step( state |=NRIGHT_CONTIG ;if ((state &NBOTH_CONTIG ) ==NBOTH_CONTIG && left->br_startblock + new->br_startblock + - right->br_startblock >MAXEXTLEN ) + right->br_startblock >XFS_MAX_EXTLEN ) state &= ~NRIGHT_CONTIG ;switch (state & (CLEFT_CONTIG |CRIGHT_CONTIG |CHOLE )) {
libxfs/xfs_trans_resv.c +5 -5
@@ -208,8 +208,8 @@ xfs_calc_inode_chunk_res(/* * Per-extent log reservation for the btree changes involved in freeing or * allocating a realtime extent. We have to be able to log as many rtbitmap -* blocks as needed to mark inuse MAXEXTLEN blocks' worth of realtime extents, -* as well as the realtime summary block. +* blocks as needed to mark inuse XFS_MAX_EXTLEN blocks' worth of realtime +* extents, as well as the realtime summary block. */ static unsigned int xfs_rtalloc_log_count(
@@ -219,7 +219,7 @@ xfs_rtalloc_log_count(unsigned int blksz =XFS_FSB_TO_B (mp,1 );unsigned int rtbmp_bytes; - rtbmp_bytes = (MAXEXTLEN / mp->m_sb.sb_rextsize) /NBBY ; + rtbmp_bytes = (XFS_MAX_EXTLEN / mp->m_sb.sb_rextsize) /NBBY ;return (howmany (rtbmp_bytes, blksz) +1 ) * num_ops; }
@@ -278,7 +278,7 @@ xfs_refcount_log_reservation(* the inode's bmap btree: max depth * block size * the agfs of the ags from which the extents are allocated: 2 * sector * the superblock free block counter: sector size -* the realtime bitmap: ((MAXEXTLEN / rtextsize) / NBBY) bytes +* the realtime bitmap: ((XFS_MAX_EXTLEN / rtextsize) / NBBY) bytes * the realtime summary: 1 block * the allocation btrees: 2 trees * (2 * max depth - 1) * block size * And the bmap_finish transaction can free bmap blocks in a join (t3):
@@ -333,7 +333,7 @@ xfs_calc_write_reservation(* the agf for each of the ags: 2 * sector size * the agfl for each of the ags: 2 * sector size * the super block to reflect the freed blocks: sector size -* the realtime bitmap: 2 exts * ((MAXEXTLEN / rtextsize) / NBBY) bytes +* the realtime bitmap: 2 exts * ((XFS_MAX_EXTLEN / rtextsize) / NBBY) bytes * the realtime summary: 2 exts * 1 block * worst case split in allocation btrees per extent assuming 2 extents: * 2 exts * 2 trees * (2 * max depth - 1) * block size
mkfs/xfs_mkfs.c +3 -3
@@ -2427,7 +2427,7 @@ validate_extsize_hint(fprintf (stderr,_ ("illegal extent size hint %lld, must be less than %u.\n" ), (long long )cli->fsx.fsx_extsize, -min (MAXEXTLEN , mp->m_sb.sb_agblocks /2 )); +min (XFS_MAX_EXTLEN , mp->m_sb.sb_agblocks /2 ));usage (); }
@@ -2450,7 +2450,7 @@ _("illegal extent size hint %lld, must be less than %u.\n"),fprintf (stderr,_ ("illegal extent size hint %lld, must be less than %u and a multiple of %u.\n" ), (long long )cli->fsx.fsx_extsize, -min (MAXEXTLEN , mp->m_sb.sb_agblocks /2 ), +min (XFS_MAX_EXTLEN , mp->m_sb.sb_agblocks /2 ), mp->m_sb.sb_rextsize);usage (); }
@@ -2479,7 +2479,7 @@ validate_cowextsize_hint(fprintf (stderr,_ ("illegal CoW extent size hint %lld, must be less than %u.\n" ), (long long )cli->fsx.fsx_cowextsize, -min (MAXEXTLEN , mp->m_sb.sb_agblocks /2 )); +min (XFS_MAX_EXTLEN , mp->m_sb.sb_agblocks /2 ));usage (); } }
repair/bmap_repair.c +1 -1
@@ -64,7 +64,7 @@ xrep_bmap_from_rmap( do { irec.br_blockcount = min_t(xfs_filblks_t, blockcount, - MAXEXTLEN); + XFS_MAX_EXTLEN); libxfs_bmbt_disk_set_all(&rbe, &irec); error = slab_add(rb->bmap_records, &rbe);
repair/phase4.c +1 -1
@@ -393,7 +393,7 @@ phase4(xfs_mount_t *mp)if (rt_start ==0 ) { rt_start = bno; rt_len =1 ; - }else if (rt_len ==MAXEXTLEN ) { + }else if (rt_len ==XFS_MAX_EXTLEN ) {/* * large extent case */
Signature · 1 line
2.30.2