Skip to content

Commit

Permalink
xfs: Introduce per-inode 64-bit extent counters
Browse files Browse the repository at this point in the history 
This commit introduces new fields in the on-disk inode format to support
64-bit data fork extent counters and 32-bit attribute fork extent
counters. The new fields will be used only when an inode has
XFS_DIFLAG2_NREXT64 flag set. Otherwise we continue to use the regular 32-bit
data fork extent counters and 16-bit attribute fork extent counters.

Signed-off-by: Chandan Babu R <chandan.babu@oracle.com>
Suggested-by: Dave Chinner <dchinner@redhat.com>
  • Loading branch information
@intel-lab-lkp
Chandan Babu R authored and intel-lab-lkp committed Jan 21, 2022
1 parent 98b0928 commit f12e8b5
Show file tree
Hide file tree
Showing 6 changed files with 174 additions and 27 deletions.
22 changes: 18 additions & 4 deletions fs/xfs/libxfs/xfs_format.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -792,16 +792,30 @@ struct xfs_dinode {
__be32 di_nlink; /* number of links to file */
__be16 di_projid_lo; /* lower part of owner's project id */
__be16 di_projid_hi; /* higher part owner's project id */
__u8 di_pad[6]; /* unused, zeroed space */
__be16 di_flushiter; /* incremented on flush */
union {
__be64 di_big_nextents;/* NREXT64 data extents */
__u8 di_v3_pad[8]; /* !NREXT64 V3 inode zeroed space */
struct {
__u8 di_v2_pad[6]; /* V2 inode zeroed space */
__be16 di_flushiter; /* V2 inode incremented on flush */
};
};
xfs_timestamp_t di_atime; /* time last accessed */
xfs_timestamp_t di_mtime; /* time last modified */
xfs_timestamp_t di_ctime; /* time created/inode modified */
__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*/
union {
struct {
__be32 di_big_anextents; /* NREXT64 attr extents */
__be16 di_nrext64_pad; /* NREXT64 unused, zero */
} __packed;
struct {
__be32 di_nextents; /* !NREXT64 data extents */
__be16 di_anextents; /* !NREXT64 attr extents */
} __packed;
};
__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 */
Expand Down
49 changes: 45 additions & 4 deletions fs/xfs/libxfs/xfs_inode_buf.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -279,6 +279,25 @@ 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_big_nextents = cpu_to_be64(xfs_ifork_nextents(&ip->i_df));
to->di_big_anextents = cpu_to_be32(xfs_ifork_nextents(ip->i_afp));
/*
* We might be upgrading the inode to use larger extent counters
* than was previously used. Hence zero the unused field.
*/
to->di_nrext64_pad = cpu_to_be16(0);
} else {
to->di_nextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_df));
to->di_anextents = cpu_to_be16(xfs_ifork_nextents(ip->i_afp));
}
}

void
xfs_inode_to_disk(
struct xfs_inode *ip,
Expand All @@ -296,7 +315,6 @@ xfs_inode_to_disk(
to->di_projid_lo = cpu_to_be16(ip->i_projid & 0xffff);
to->di_projid_hi = cpu_to_be16(ip->i_projid >> 16);

memset(to->di_pad, 0, sizeof(to->di_pad));
to->di_atime = xfs_inode_to_disk_ts(ip, inode->i_atime);
to->di_mtime = xfs_inode_to_disk_ts(ip, inode->i_mtime);
to->di_ctime = xfs_inode_to_disk_ts(ip, inode->i_ctime);
Expand All @@ -307,8 +325,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_nextents = cpu_to_be32(xfs_ifork_nextents(&ip->i_df));
to->di_anextents = 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);
Expand All @@ -323,11 +339,14 @@ xfs_inode_to_disk(
to->di_lsn = cpu_to_be64(lsn);
memset(to->di_pad2, 0, sizeof(to->di_pad2));
uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
to->di_flushiter = 0;
memset(to->di_v3_pad, 0, sizeof(to->di_v3_pad));
} else {
to->di_version = 2;
to->di_flushiter = cpu_to_be16(ip->i_flushiter);
memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad));
}

xfs_inode_to_disk_iext_counters(ip, to);
}

static xfs_failaddr_t
Expand Down Expand Up @@ -397,6 +416,24 @@ xfs_dinode_verify_forkoff(
return NULL;
}

static xfs_failaddr_t
xfs_dinode_verify_nextents(
struct xfs_mount *mp,
struct xfs_dinode *dip)
{
if (xfs_dinode_has_nrext64(dip)) {
if (!xfs_has_nrext64(mp))
return __this_address;
if (dip->di_nrext64_pad != 0)
return __this_address;
} else {
if (dip->di_version == 3 && dip->di_big_nextents != 0)
return __this_address;
}

return NULL;
}

xfs_failaddr_t
xfs_dinode_verify(
struct xfs_mount *mp,
Expand Down Expand Up @@ -440,6 +477,10 @@ xfs_dinode_verify(
if ((S_ISLNK(mode) || S_ISDIR(mode)) && di_size == 0)
return __this_address;

fa = xfs_dinode_verify_nextents(mp, dip);
if (fa)
return fa;

nextents = xfs_dfork_data_extents(dip);
nextents += xfs_dfork_attr_extents(dip);
nblocks = be64_to_cpu(dip->di_nblocks);
Expand Down
6 changes: 6 additions & 0 deletions fs/xfs/libxfs/xfs_inode_fork.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -156,13 +156,19 @@ static inline xfs_extnum_t
xfs_dfork_data_extents(
struct xfs_dinode *dip)
{
if (xfs_dinode_has_nrext64(dip))
return be64_to_cpu(dip->di_big_nextents);

return be32_to_cpu(dip->di_nextents);
}

static inline xfs_extnum_t
xfs_dfork_attr_extents(
struct xfs_dinode *dip)
{
if (xfs_dinode_has_nrext64(dip))
return be32_to_cpu(dip->di_big_anextents);

return be16_to_cpu(dip->di_anextents);
}

Expand Down
22 changes: 18 additions & 4 deletions fs/xfs/libxfs/xfs_log_format.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -388,16 +388,30 @@ struct xfs_log_dinode {
uint32_t di_nlink; /* number of links to file */
uint16_t di_projid_lo; /* lower part of owner's project id */
uint16_t di_projid_hi; /* higher part of owner's project id */
uint8_t di_pad[6]; /* unused, zeroed space */
uint16_t di_flushiter; /* incremented on flush */
union {
uint64_t di_big_nextents;/* NREXT64 data extents */
uint8_t di_v3_pad[8]; /* !NREXT64 V3 inode zeroed space */
struct {
uint8_t di_v2_pad[6]; /* V2 inode zeroed space */
uint16_t di_flushiter; /* V2 inode incremented on flush */
};
};
xfs_log_timestamp_t di_atime; /* time last accessed */
xfs_log_timestamp_t di_mtime; /* time last modified */
xfs_log_timestamp_t di_ctime; /* time created/inode modified */
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 */
uint32_t di_nextents; /* number of extents in data fork */
uint16_t di_anextents; /* number of extents in attribute fork*/
union {
struct {
uint32_t di_big_anextents; /* NREXT64 attr extents */
uint16_t di_nrext64_pad; /* NREXT64 unused, zero */
} __packed;
struct {
uint32_t di_nextents; /* !NREXT64 data extents */
uint16_t di_anextents; /* !NREXT64 attr extents */
} __packed;
};
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 */
Expand Down
23 changes: 19 additions & 4 deletions fs/xfs/xfs_inode_item.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -358,6 +358,21 @@ xfs_copy_dm_fields_to_log_dinode(
}
}

static inline void
xfs_inode_to_log_dinode_iext_counters(
struct xfs_inode *ip,
struct xfs_log_dinode *to)
{
if (xfs_inode_has_nrext64(ip)) {
to->di_big_nextents = xfs_ifork_nextents(&ip->i_df);
to->di_big_anextents = xfs_ifork_nextents(ip->i_afp);
to->di_nrext64_pad = 0;
} else {
to->di_nextents = xfs_ifork_nextents(&ip->i_df);
to->di_anextents = xfs_ifork_nextents(ip->i_afp);
}
}

static void
xfs_inode_to_log_dinode(
struct xfs_inode *ip,
Expand All @@ -373,7 +388,6 @@ xfs_inode_to_log_dinode(
to->di_projid_lo = ip->i_projid & 0xffff;
to->di_projid_hi = ip->i_projid >> 16;

memset(to->di_pad, 0, sizeof(to->di_pad));
memset(to->di_pad3, 0, sizeof(to->di_pad3));
to->di_atime = xfs_inode_to_log_dinode_ts(ip, inode->i_atime);
to->di_mtime = xfs_inode_to_log_dinode_ts(ip, inode->i_mtime);
Expand All @@ -385,8 +399,6 @@ xfs_inode_to_log_dinode(
to->di_size = ip->i_disk_size;
to->di_nblocks = ip->i_nblocks;
to->di_extsize = ip->i_extsize;
to->di_nextents = xfs_ifork_nextents(&ip->i_df);
to->di_anextents = xfs_ifork_nextents(ip->i_afp);
to->di_forkoff = ip->i_forkoff;
to->di_aformat = xfs_ifork_format(ip->i_afp);
to->di_flags = ip->i_diflags;
Expand All @@ -406,11 +418,14 @@ xfs_inode_to_log_dinode(
to->di_lsn = lsn;
memset(to->di_pad2, 0, sizeof(to->di_pad2));
uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
to->di_flushiter = 0;
memset(to->di_v3_pad, 0, sizeof(to->di_v3_pad));
} else {
to->di_version = 2;
to->di_flushiter = ip->i_flushiter;
memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad));
}

xfs_inode_to_log_dinode_iext_counters(ip, to);
}

/*
Expand Down
79 changes: 68 additions & 11 deletions fs/xfs/xfs_inode_item_recover.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -148,6 +148,22 @@ static inline bool xfs_log_dinode_has_nrext64(const struct xfs_log_dinode *ld)
(ld->di_flags2 & XFS_DIFLAG2_NREXT64);
}

static inline void
xfs_log_dinode_to_disk_iext_counters(
struct xfs_log_dinode *from,
struct xfs_dinode *to)
{
if (xfs_log_dinode_has_nrext64(from)) {
to->di_big_nextents = cpu_to_be64(from->di_big_nextents);
to->di_big_anextents = cpu_to_be32(from->di_big_anextents);
to->di_nrext64_pad = cpu_to_be16(from->di_nrext64_pad);
} else {
to->di_nextents = cpu_to_be32(from->di_nextents);
to->di_anextents = cpu_to_be16(from->di_anextents);
}

}

STATIC void
xfs_log_dinode_to_disk(
struct xfs_log_dinode *from,
Expand All @@ -164,7 +180,6 @@ xfs_log_dinode_to_disk(
to->di_nlink = cpu_to_be32(from->di_nlink);
to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));

to->di_atime = xfs_log_dinode_to_disk_ts(from, from->di_atime);
to->di_mtime = xfs_log_dinode_to_disk_ts(from, from->di_mtime);
Expand All @@ -173,8 +188,6 @@ xfs_log_dinode_to_disk(
to->di_size = cpu_to_be64(from->di_size);
to->di_nblocks = cpu_to_be64(from->di_nblocks);
to->di_extsize = cpu_to_be32(from->di_extsize);
to->di_nextents = cpu_to_be32(from->di_nextents);
to->di_anextents = cpu_to_be16(from->di_anextents);
to->di_forkoff = from->di_forkoff;
to->di_aformat = from->di_aformat;
to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
Expand All @@ -192,10 +205,13 @@ xfs_log_dinode_to_disk(
to->di_lsn = cpu_to_be64(lsn);
memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
uuid_copy(&to->di_uuid, &from->di_uuid);
to->di_flushiter = 0;
memcpy(to->di_v3_pad, from->di_v3_pad, sizeof(to->di_v3_pad));
} else {
to->di_flushiter = cpu_to_be16(from->di_flushiter);
memcpy(to->di_v2_pad, from->di_v2_pad, sizeof(to->di_v2_pad));
}

xfs_log_dinode_to_disk_iext_counters(from, to);
}

STATIC int
Expand All @@ -209,6 +225,8 @@ xlog_recover_inode_commit_pass2(
struct xfs_mount *mp = log->l_mp;
struct xfs_buf *bp;
struct xfs_dinode *dip;
xfs_extnum_t nextents;
xfs_aextnum_t anextents;
int len;
char *src;
char *dest;
Expand Down Expand Up @@ -348,21 +366,60 @@ xlog_recover_inode_commit_pass2(
goto out_release;
}
}
if (unlikely(ldip->di_nextents + ldip->di_anextents > ldip->di_nblocks)){
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",

if (xfs_log_dinode_has_nrext64(ldip)) {
if (!xfs_has_nrext64(mp) || (ldip->di_nrext64_pad != 0)) {
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
XFS_ERRLEVEL_LOW, mp, ldip,
sizeof(*ldip));
xfs_alert(mp,
"%s: Bad inode log record, rec ptr "PTR_FMT", "
"dino ptr "PTR_FMT", dino bp "PTR_FMT", "
"ino %Ld, xfs_has_nrext64(mp) = %d, "
"ldip->di_nrext64_pad = %u",
__func__, item, dip, bp, in_f->ilf_ino,
xfs_has_nrext64(mp), ldip->di_nrext64_pad);
error = -EFSCORRUPTED;
goto out_release;
}
} else {
if (ldip->di_version == 3 && ldip->di_big_nextents != 0) {
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
XFS_ERRLEVEL_LOW, mp, ldip,
sizeof(*ldip));
xfs_alert(mp,
"%s: Bad inode log record, rec ptr "PTR_FMT", "
"dino ptr "PTR_FMT", dino bp "PTR_FMT", "
"ino %Ld, ldip->di_big_dextcnt = %llu",
__func__, item, dip, bp, in_f->ilf_ino,
ldip->di_big_nextents);
error = -EFSCORRUPTED;
goto out_release;
}
}

if (xfs_log_dinode_has_nrext64(ldip)) {
nextents = ldip->di_big_nextents;
anextents = ldip->di_big_anextents;
} else {
nextents = ldip->di_nextents;
anextents = ldip->di_anextents;
}

if (unlikely(nextents + anextents > ldip->di_nblocks)) {
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
XFS_ERRLEVEL_LOW, mp, ldip,
sizeof(*ldip));
xfs_alert(mp,
"%s: Bad inode log record, rec ptr "PTR_FMT", dino ptr "PTR_FMT", "
"dino bp "PTR_FMT", ino %Ld, total extents = %d, nblocks = %Ld",
"dino bp "PTR_FMT", ino %Ld, total extents = %llu, nblocks = %Ld",
__func__, item, dip, bp, in_f->ilf_ino,
ldip->di_nextents + ldip->di_anextents,
ldip->di_nblocks);
nextents + anextents, ldip->di_nblocks);
error = -EFSCORRUPTED;
goto out_release;
}
if (unlikely(ldip->di_forkoff > mp->m_sb.sb_inodesize)) {
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(8)",
XFS_ERRLEVEL_LOW, mp, ldip,
sizeof(*ldip));
xfs_alert(mp,
Expand All @@ -374,7 +431,7 @@ xlog_recover_inode_commit_pass2(
}
isize = xfs_log_dinode_size(mp);
if (unlikely(item->ri_buf[1].i_len > isize)) {
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(9)",
XFS_ERRLEVEL_LOW, mp, ldip,
sizeof(*ldip));
xfs_alert(mp,
Expand Down

0 comments on commit f12e8b5

Please sign in to comment.