From: "Darrick J. Wong" djwong@kernel.org
mainline-inclusion from mainline-v5.13-rc4 commit 2d53f66baffde66fe72c360e3b9b0c8a2d7ce7c6 category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/I4KIAO CVE: NA
Reference: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?i...
-------------------------------------------------
In preparation for renaming struct xfs_eofblocks to struct xfs_icwalk, change the prefix of the existing XFS_EOF_FLAGS_* flags to XFS_ICWALK_FLAG_ and convert all the existing users. This adds a degree of interface separation between the ioctl definitions and the incore parameters. Since FLAGS_UNION is only used in xfs_icache.c, move it there as a private flag.
Signed-off-by: Darrick J. Wong djwong@kernel.org Reviewed-by: Dave Chinner dchinner@redhat.com Reviewed-by: Carlos Maiolino cmaiolino@redhat.com Signed-off-by: Lihong Kou koulihong@huawei.com Reviewed-by: Zhang Yi yi.zhang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- fs/xfs/xfs_file.c | 4 ++-- fs/xfs/xfs_icache.c | 44 +++++++++++++++++++++++--------------------- fs/xfs/xfs_icache.h | 17 +++++++++++++++-- fs/xfs/xfs_ioctl.c | 13 ++++++++++++- 4 files changed, 52 insertions(+), 26 deletions(-)
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c index 139df7fde2e6..7264b6d11f42 100644 --- a/fs/xfs/xfs_file.c +++ b/fs/xfs/xfs_file.c @@ -701,7 +701,7 @@ xfs_file_buffered_aio_write( */ if (ret == -EDQUOT && !cleared_space) { xfs_iunlock(ip, iolock); - xfs_blockgc_free_quota(ip, XFS_EOF_FLAGS_SYNC); + xfs_blockgc_free_quota(ip, XFS_ICWALK_FLAG_SYNC); cleared_space = true; goto write_retry; } else if (ret == -ENOSPC && !cleared_space) { @@ -711,7 +711,7 @@ xfs_file_buffered_aio_write( xfs_flush_inodes(ip->i_mount);
xfs_iunlock(ip, iolock); - eofb.eof_flags = XFS_EOF_FLAGS_SYNC; + eofb.eof_flags = XFS_ICWALK_FLAG_SYNC; xfs_blockgc_free_space(ip->i_mount, &eofb); goto write_retry; } diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c index 02e837e6234e..986d191b04c5 100644 --- a/fs/xfs/xfs_icache.c +++ b/fs/xfs/xfs_icache.c @@ -62,7 +62,7 @@ static int xfs_icwalk_ag(struct xfs_perag *pag,
/* * Private inode cache walk flags for struct xfs_eofblocks. Must not coincide - * with XFS_EOF_FLAGS_*. + * with XFS_ICWALK_FLAGS_VALID. */ #define XFS_ICWALK_FLAG_DROP_UDQUOT (1U << 31) #define XFS_ICWALK_FLAG_DROP_GDQUOT (1U << 30) @@ -72,12 +72,14 @@ static int xfs_icwalk_ag(struct xfs_perag *pag, #define XFS_ICWALK_FLAG_SCAN_LIMIT (1U << 28)
#define XFS_ICWALK_FLAG_RECLAIM_SICK (1U << 27) +#define XFS_ICWALK_FLAG_UNION (1U << 26) /* union filter algorithm */
#define XFS_ICWALK_PRIVATE_FLAGS (XFS_ICWALK_FLAG_DROP_UDQUOT | \ XFS_ICWALK_FLAG_DROP_GDQUOT | \ XFS_ICWALK_FLAG_DROP_PDQUOT | \ XFS_ICWALK_FLAG_SCAN_LIMIT | \ - XFS_ICWALK_FLAG_RECLAIM_SICK) + XFS_ICWALK_FLAG_RECLAIM_SICK | \ + XFS_ICWALK_FLAG_UNION)
/* * Allocate and initialise an xfs_inode. @@ -1112,15 +1114,15 @@ xfs_inode_match_id( struct xfs_inode *ip, struct xfs_eofblocks *eofb) { - if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) && !uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid)) return false;
- if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) && !gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid)) return false;
- if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) && ip->i_d.di_projid != eofb->eof_prid) return false;
@@ -1136,15 +1138,15 @@ xfs_inode_match_id_union( struct xfs_inode *ip, struct xfs_eofblocks *eofb) { - if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) && uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid)) return true;
- if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) && gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid)) return true;
- if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) && ip->i_d.di_projid == eofb->eof_prid) return true;
@@ -1166,7 +1168,7 @@ xfs_inode_matches_eofb( if (!eofb) return true;
- if (eofb->eof_flags & XFS_EOF_FLAGS_UNION) + if (eofb->eof_flags & XFS_ICWALK_FLAG_UNION) match = xfs_inode_match_id_union(ip, eofb); else match = xfs_inode_match_id(ip, eofb); @@ -1174,7 +1176,7 @@ xfs_inode_matches_eofb( return false;
/* skip the inode if the file size is too small */ - if ((eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE) && + if ((eofb->eof_flags & XFS_ICWALK_FLAG_MINFILESIZE) && XFS_ISIZE(ip) < eofb->eof_min_file_size) return false;
@@ -1206,7 +1208,7 @@ xfs_inode_free_eofblocks( { bool wait;
- wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC); + wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC);
if (!xfs_iflags_test(ip, XFS_IEOFBLOCKS)) return 0; @@ -1370,7 +1372,7 @@ xfs_inode_free_cowblocks( bool wait; int ret = 0;
- wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC); + wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC);
if (!xfs_iflags_test(ip, XFS_ICOWBLOCKS)) return 0; @@ -1560,7 +1562,7 @@ xfs_blockgc_free_space( * scan. * * Callers must not hold any inode's ILOCK. If requesting a synchronous scan - * (XFS_EOF_FLAGS_SYNC), the caller also must not hold any inode's IOLOCK or + * (XFS_ICWALK_FLAG_SYNC), the caller also must not hold any inode's IOLOCK or * MMAPLOCK. */ int @@ -1569,7 +1571,7 @@ xfs_blockgc_free_dquots( struct xfs_dquot *udqp, struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, - unsigned int eof_flags) + unsigned int iwalk_flags) { struct xfs_eofblocks eofb = {0}; bool do_work = false; @@ -1581,23 +1583,23 @@ xfs_blockgc_free_dquots( * Run a scan to free blocks using the union filter to cover all * applicable quotas in a single scan. */ - eofb.eof_flags = XFS_EOF_FLAGS_UNION | eof_flags; + eofb.eof_flags = XFS_ICWALK_FLAG_UNION | iwalk_flags;
if (XFS_IS_UQUOTA_ENFORCED(mp) && udqp && xfs_dquot_lowsp(udqp)) { eofb.eof_uid = make_kuid(mp->m_super->s_user_ns, udqp->q_id); - eofb.eof_flags |= XFS_EOF_FLAGS_UID; + eofb.eof_flags |= XFS_ICWALK_FLAG_UID; do_work = true; }
if (XFS_IS_UQUOTA_ENFORCED(mp) && gdqp && xfs_dquot_lowsp(gdqp)) { eofb.eof_gid = make_kgid(mp->m_super->s_user_ns, gdqp->q_id); - eofb.eof_flags |= XFS_EOF_FLAGS_GID; + eofb.eof_flags |= XFS_ICWALK_FLAG_GID; do_work = true; }
if (XFS_IS_PQUOTA_ENFORCED(mp) && pdqp && xfs_dquot_lowsp(pdqp)) { eofb.eof_prid = pdqp->q_id; - eofb.eof_flags |= XFS_EOF_FLAGS_PRID; + eofb.eof_flags |= XFS_ICWALK_FLAG_PRID; do_work = true; }
@@ -1611,12 +1613,12 @@ xfs_blockgc_free_dquots( int xfs_blockgc_free_quota( struct xfs_inode *ip, - unsigned int eof_flags) + unsigned int iwalk_flags) { return xfs_blockgc_free_dquots(ip->i_mount, xfs_inode_dquot(ip, XFS_DQTYPE_USER), xfs_inode_dquot(ip, XFS_DQTYPE_GROUP), - xfs_inode_dquot(ip, XFS_DQTYPE_PROJ), eof_flags); + xfs_inode_dquot(ip, XFS_DQTYPE_PROJ), iwalk_flags); }
/* XFS Inode Cache Walking Code */ @@ -1836,5 +1838,5 @@ xfs_icwalk( } } return last_error; - BUILD_BUG_ON(XFS_ICWALK_PRIVATE_FLAGS & XFS_EOF_FLAGS_VALID); + BUILD_BUG_ON(XFS_ICWALK_PRIVATE_FLAGS & XFS_ICWALK_FLAGS_VALID); } diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h index 191620a069af..b29048c493b6 100644 --- a/fs/xfs/xfs_icache.h +++ b/fs/xfs/xfs_icache.h @@ -18,6 +18,19 @@ struct xfs_eofblocks { int icw_scan_limit; };
+/* Flags that reflect xfs_fs_eofblocks functionality. */ +#define XFS_ICWALK_FLAG_SYNC (1U << 0) /* sync/wait mode scan */ +#define XFS_ICWALK_FLAG_UID (1U << 1) /* filter by uid */ +#define XFS_ICWALK_FLAG_GID (1U << 2) /* filter by gid */ +#define XFS_ICWALK_FLAG_PRID (1U << 3) /* filter by project id */ +#define XFS_ICWALK_FLAG_MINFILESIZE (1U << 4) /* filter by min file size */ + +#define XFS_ICWALK_FLAGS_VALID (XFS_ICWALK_FLAG_SYNC | \ + XFS_ICWALK_FLAG_UID | \ + XFS_ICWALK_FLAG_GID | \ + XFS_ICWALK_FLAG_PRID | \ + XFS_ICWALK_FLAG_MINFILESIZE) + /* * Flags for xfs_iget() */ @@ -43,8 +56,8 @@ void xfs_inode_mark_reclaimable(struct xfs_inode *ip);
int xfs_blockgc_free_dquots(struct xfs_mount *mp, struct xfs_dquot *udqp, struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, - unsigned int eof_flags); -int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int eof_flags); + unsigned int iwalk_flags); +int xfs_blockgc_free_quota(struct xfs_inode *ip, unsigned int iwalk_flags); int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_eofblocks *eofb);
void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip); diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c index 57cdfac0e7d3..4efb49412afe 100644 --- a/fs/xfs/xfs_ioctl.c +++ b/fs/xfs/xfs_ioctl.c @@ -2038,7 +2038,18 @@ xfs_fs_eofblocks_from_user( memchr_inv(src->pad64, 0, sizeof(src->pad64))) return -EINVAL;
- dst->eof_flags = src->eof_flags; + dst->eof_flags = 0; + if (src->eof_flags & XFS_EOF_FLAGS_SYNC) + dst->eof_flags |= XFS_ICWALK_FLAG_SYNC; + if (src->eof_flags & XFS_EOF_FLAGS_UID) + dst->eof_flags |= XFS_ICWALK_FLAG_UID; + if (src->eof_flags & XFS_EOF_FLAGS_GID) + dst->eof_flags |= XFS_ICWALK_FLAG_GID; + if (src->eof_flags & XFS_EOF_FLAGS_PRID) + dst->eof_flags |= XFS_ICWALK_FLAG_PRID; + if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE) + dst->eof_flags |= XFS_ICWALK_FLAG_MINFILESIZE; + dst->eof_prid = src->eof_prid; dst->eof_min_file_size = src->eof_min_file_size;