mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

xfs: rename struct xfs_eofblocks to xfs_icwalk 

The xfs_eofblocks structure is no longer well-named -- nowadays it
provides optional filtering criteria to any walk of the incore inode
cache.  Only one of the cache walk goals has anything to do with
clearing of speculative post-EOF preallocations, so change the name to
be more appropriate.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
This commit is contained in:
Darrick J. Wong 2021-06-07 09:34:51 -07:00
parent 2d53f66baf
commit b26b2bf14f
5 changed files with 130 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/xfs/xfs_file.c
View File

@ -773,14 +773,14 @@ write_retry:
cleared_space = true; cleared_space = true;
goto write_retry; goto write_retry;
} else if (ret == -ENOSPC && !cleared_space) { } else if (ret == -ENOSPC && !cleared_space) {
struct xfs_eofblocks eofb = {0}; struct xfs_icwalk icw = {0};
cleared_space = true; cleared_space = true;
xfs_flush_inodes(ip->i_mount); xfs_flush_inodes(ip->i_mount);
xfs_iunlock(ip, iolock); xfs_iunlock(ip, iolock);
eofb.eof_flags = XFS_ICWALK_FLAG_SYNC; icw.icw_flags = XFS_ICWALK_FLAG_SYNC;
xfs_blockgc_free_space(ip->i_mount, &eofb); xfs_blockgc_free_space(ip->i_mount, &icw);
goto write_retry; goto write_retry;
} }

164
fs/xfs/xfs_icache.c
View File

@ -56,13 +56,13 @@ xfs_icwalk_tag(enum xfs_icwalk_goal goal)
} }
static int xfs_icwalk(struct xfs_mount *mp, static int xfs_icwalk(struct xfs_mount *mp,
enum xfs_icwalk_goal goal, struct xfs_eofblocks *eofb); enum xfs_icwalk_goal goal, struct xfs_icwalk *icw);
static int xfs_icwalk_ag(struct xfs_perag *pag, static int xfs_icwalk_ag(struct xfs_perag *pag,
enum xfs_icwalk_goal goal, struct xfs_eofblocks *eofb); enum xfs_icwalk_goal goal, struct xfs_icwalk *icw);
/* /*
* Private inode cache walk flags for struct xfs_eofblocks. Must not coincide * Private inode cache walk flags for struct xfs_icwalk. Must not
* with XFS_ICWALK_FLAGS_VALID. * coincide with XFS_ICWALK_FLAGS_VALID.
*/ */
#define XFS_ICWALK_FLAG_DROP_UDQUOT (1U << 31) #define XFS_ICWALK_FLAG_DROP_UDQUOT (1U << 31)
#define XFS_ICWALK_FLAG_DROP_GDQUOT (1U << 30) #define XFS_ICWALK_FLAG_DROP_GDQUOT (1U << 30)
@ -848,21 +848,21 @@ out_unlock:
static void static void
xfs_dqrele_inode( xfs_dqrele_inode(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
if (xfs_iflags_test(ip, XFS_INEW)) if (xfs_iflags_test(ip, XFS_INEW))
xfs_inew_wait(ip); xfs_inew_wait(ip);
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
if (eofb->eof_flags & XFS_ICWALK_FLAG_DROP_UDQUOT) { if (icw->icw_flags & XFS_ICWALK_FLAG_DROP_UDQUOT) {
xfs_qm_dqrele(ip->i_udquot); xfs_qm_dqrele(ip->i_udquot);
ip->i_udquot = NULL; ip->i_udquot = NULL;
} }
if (eofb->eof_flags & XFS_ICWALK_FLAG_DROP_GDQUOT) { if (icw->icw_flags & XFS_ICWALK_FLAG_DROP_GDQUOT) {
xfs_qm_dqrele(ip->i_gdquot); xfs_qm_dqrele(ip->i_gdquot);
ip->i_gdquot = NULL; ip->i_gdquot = NULL;
} }
if (eofb->eof_flags & XFS_ICWALK_FLAG_DROP_PDQUOT) { if (icw->icw_flags & XFS_ICWALK_FLAG_DROP_PDQUOT) {
xfs_qm_dqrele(ip->i_pdquot); xfs_qm_dqrele(ip->i_pdquot);
ip->i_pdquot = NULL; ip->i_pdquot = NULL;
} }
@ -880,16 +880,16 @@ xfs_dqrele_all_inodes(
struct xfs_mount *mp, struct xfs_mount *mp,
unsigned int qflags) unsigned int qflags)
{ {
struct xfs_eofblocks eofb = { .eof_flags = 0 }; struct xfs_icwalk icw = { .icw_flags = 0 };
if (qflags & XFS_UQUOTA_ACCT) if (qflags & XFS_UQUOTA_ACCT)
eofb.eof_flags |= XFS_ICWALK_FLAG_DROP_UDQUOT; icw.icw_flags |= XFS_ICWALK_FLAG_DROP_UDQUOT;
if (qflags & XFS_GQUOTA_ACCT) if (qflags & XFS_GQUOTA_ACCT)
eofb.eof_flags |= XFS_ICWALK_FLAG_DROP_GDQUOT; icw.icw_flags |= XFS_ICWALK_FLAG_DROP_GDQUOT;
if (qflags & XFS_PQUOTA_ACCT) if (qflags & XFS_PQUOTA_ACCT)
eofb.eof_flags |= XFS_ICWALK_FLAG_DROP_PDQUOT; icw.icw_flags |= XFS_ICWALK_FLAG_DROP_PDQUOT;
return xfs_icwalk(mp, XFS_ICWALK_DQRELE, &eofb); return xfs_icwalk(mp, XFS_ICWALK_DQRELE, &icw);
} }
#else #else
# define xfs_dqrele_igrab(ip) (false) # define xfs_dqrele_igrab(ip) (false)
@ -916,7 +916,7 @@ xfs_dqrele_all_inodes(
static bool static bool
xfs_reclaim_igrab( xfs_reclaim_igrab(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
ASSERT(rcu_read_lock_held()); ASSERT(rcu_read_lock_held());
@ -930,7 +930,7 @@ xfs_reclaim_igrab(
/* Don't reclaim a sick inode unless the caller asked for it. */ /* Don't reclaim a sick inode unless the caller asked for it. */
if (ip->i_sick && if (ip->i_sick &&
(!eofb || !(eofb->eof_flags & XFS_ICWALK_FLAG_RECLAIM_SICK))) { (!icw || !(icw->icw_flags & XFS_ICWALK_FLAG_RECLAIM_SICK))) {
spin_unlock(&ip->i_flags_lock); spin_unlock(&ip->i_flags_lock);
return false; return false;
} }
@ -1049,16 +1049,16 @@ void
xfs_reclaim_inodes( xfs_reclaim_inodes(
struct xfs_mount *mp) struct xfs_mount *mp)
{ {
struct xfs_eofblocks eofb = { struct xfs_icwalk icw = {
.eof_flags = 0, .icw_flags = 0,
}; };
if (xfs_want_reclaim_sick(mp)) if (xfs_want_reclaim_sick(mp))
eofb.eof_flags |= XFS_ICWALK_FLAG_RECLAIM_SICK; icw.icw_flags |= XFS_ICWALK_FLAG_RECLAIM_SICK;
while (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) { while (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
xfs_ail_push_all_sync(mp->m_ail); xfs_ail_push_all_sync(mp->m_ail);
xfs_icwalk(mp, XFS_ICWALK_RECLAIM, &eofb); xfs_icwalk(mp, XFS_ICWALK_RECLAIM, &icw);
} }
} }
@ -1074,19 +1074,19 @@ xfs_reclaim_inodes_nr(
struct xfs_mount *mp, struct xfs_mount *mp,
int nr_to_scan) int nr_to_scan)
{ {
struct xfs_eofblocks eofb = { struct xfs_icwalk icw = {
.eof_flags = XFS_ICWALK_FLAG_SCAN_LIMIT, .icw_flags = XFS_ICWALK_FLAG_SCAN_LIMIT,
.icw_scan_limit = nr_to_scan, .icw_scan_limit = nr_to_scan,
}; };
if (xfs_want_reclaim_sick(mp)) if (xfs_want_reclaim_sick(mp))
eofb.eof_flags |= XFS_ICWALK_FLAG_RECLAIM_SICK; icw.icw_flags |= XFS_ICWALK_FLAG_RECLAIM_SICK;
/* kick background reclaimer and push the AIL */ /* kick background reclaimer and push the AIL */
xfs_reclaim_work_queue(mp); xfs_reclaim_work_queue(mp);
xfs_ail_push_all(mp->m_ail); xfs_ail_push_all(mp->m_ail);
xfs_icwalk(mp, XFS_ICWALK_RECLAIM, &eofb); xfs_icwalk(mp, XFS_ICWALK_RECLAIM, &icw);
return 0; return 0;
} }
@ -1111,20 +1111,20 @@ xfs_reclaim_inodes_count(
} }
STATIC bool STATIC bool
xfs_inode_match_id( xfs_icwalk_match_id(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_UID) &&
!uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid)) !uid_eq(VFS_I(ip)->i_uid, icw->icw_uid))
return false; return false;
if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_GID) &&
!gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid)) !gid_eq(VFS_I(ip)->i_gid, icw->icw_gid))
return false; return false;
if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_PRID) &&
ip->i_projid != eofb->eof_prid) ip->i_projid != icw->icw_prid)
return false; return false;
return true; return true;
@ -1135,20 +1135,20 @@ xfs_inode_match_id(
* criteria match. This is for global/internal scans only. * criteria match. This is for global/internal scans only.
*/ */
STATIC bool STATIC bool
xfs_inode_match_id_union( xfs_icwalk_match_id_union(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
if ((eofb->eof_flags & XFS_ICWALK_FLAG_UID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_UID) &&
uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid)) uid_eq(VFS_I(ip)->i_uid, icw->icw_uid))
return true; return true;
if ((eofb->eof_flags & XFS_ICWALK_FLAG_GID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_GID) &&
gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid)) gid_eq(VFS_I(ip)->i_gid, icw->icw_gid))
return true; return true;
if ((eofb->eof_flags & XFS_ICWALK_FLAG_PRID) && if ((icw->icw_flags & XFS_ICWALK_FLAG_PRID) &&
ip->i_projid == eofb->eof_prid) ip->i_projid == icw->icw_prid)
return true; return true;
return false; return false;
@ -1156,29 +1156,29 @@ xfs_inode_match_id_union(
/* /*
* Is this inode @ip eligible for eof/cow block reclamation, given some * Is this inode @ip eligible for eof/cow block reclamation, given some
* filtering parameters @eofb? The inode is eligible if @eofb is null or * filtering parameters @icw? The inode is eligible if @icw is null or
* if the predicate functions match. * if the predicate functions match.
*/ */
static bool static bool
xfs_inode_matches_eofb( xfs_icwalk_match(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
bool match; bool match;
if (!eofb) if (!icw)
return true; return true;
if (eofb->eof_flags & XFS_ICWALK_FLAG_UNION) if (icw->icw_flags & XFS_ICWALK_FLAG_UNION)
match = xfs_inode_match_id_union(ip, eofb); match = xfs_icwalk_match_id_union(ip, icw);
else else
match = xfs_inode_match_id(ip, eofb); match = xfs_icwalk_match_id(ip, icw);
if (!match) if (!match)
return false; return false;
/* skip the inode if the file size is too small */ /* skip the inode if the file size is too small */
if ((eofb->eof_flags & XFS_ICWALK_FLAG_MINFILESIZE) && if ((icw->icw_flags & XFS_ICWALK_FLAG_MINFILESIZE) &&
XFS_ISIZE(ip) < eofb->eof_min_file_size) XFS_ISIZE(ip) < icw->icw_min_file_size)
return false; return false;
return true; return true;
@ -1204,12 +1204,12 @@ xfs_reclaim_worker(
STATIC int STATIC int
xfs_inode_free_eofblocks( xfs_inode_free_eofblocks(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb, struct xfs_icwalk *icw,
unsigned int *lockflags) unsigned int *lockflags)
{ {
bool wait; bool wait;
wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC); wait = icw && (icw->icw_flags & XFS_ICWALK_FLAG_SYNC);
if (!xfs_iflags_test(ip, XFS_IEOFBLOCKS)) if (!xfs_iflags_test(ip, XFS_IEOFBLOCKS))
return 0; return 0;
@ -1221,7 +1221,7 @@ xfs_inode_free_eofblocks(
if (!wait && mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY)) if (!wait && mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY))
return 0; return 0;
if (!xfs_inode_matches_eofb(ip, eofb)) if (!xfs_icwalk_match(ip, icw))
return 0; return 0;
/* /*
@ -1366,13 +1366,13 @@ xfs_prep_free_cowblocks(
STATIC int STATIC int
xfs_inode_free_cowblocks( xfs_inode_free_cowblocks(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb, struct xfs_icwalk *icw,
unsigned int *lockflags) unsigned int *lockflags)
{ {
bool wait; bool wait;
int ret = 0; int ret = 0;
wait = eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SYNC); wait = icw && (icw->icw_flags & XFS_ICWALK_FLAG_SYNC);
if (!xfs_iflags_test(ip, XFS_ICOWBLOCKS)) if (!xfs_iflags_test(ip, XFS_ICOWBLOCKS))
return 0; return 0;
@ -1380,7 +1380,7 @@ xfs_inode_free_cowblocks(
if (!xfs_prep_free_cowblocks(ip)) if (!xfs_prep_free_cowblocks(ip))
return 0; return 0;
if (!xfs_inode_matches_eofb(ip, eofb)) if (!xfs_icwalk_match(ip, icw))
return 0; return 0;
/* /*
@ -1497,16 +1497,16 @@ out_unlock_noent:
static int static int
xfs_blockgc_scan_inode( xfs_blockgc_scan_inode(
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
unsigned int lockflags = 0; unsigned int lockflags = 0;
int error; int error;
error = xfs_inode_free_eofblocks(ip, eofb, &lockflags); error = xfs_inode_free_eofblocks(ip, icw, &lockflags);
if (error) if (error)
goto unlock; goto unlock;
error = xfs_inode_free_cowblocks(ip, eofb, &lockflags); error = xfs_inode_free_cowblocks(ip, icw, &lockflags);
unlock: unlock:
if (lockflags) if (lockflags)
xfs_iunlock(ip, lockflags); xfs_iunlock(ip, lockflags);
@ -1540,11 +1540,11 @@ xfs_blockgc_worker(
int int
xfs_blockgc_free_space( xfs_blockgc_free_space(
struct xfs_mount *mp, struct xfs_mount *mp,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
trace_xfs_blockgc_free_space(mp, eofb, _RET_IP_); trace_xfs_blockgc_free_space(mp, icw, _RET_IP_);
return xfs_icwalk(mp, XFS_ICWALK_BLOCKGC, eofb); return xfs_icwalk(mp, XFS_ICWALK_BLOCKGC, icw);
} }
/* /*
@ -1565,7 +1565,7 @@ xfs_blockgc_free_dquots(
struct xfs_dquot *pdqp, struct xfs_dquot *pdqp,
unsigned int iwalk_flags) unsigned int iwalk_flags)
{ {
struct xfs_eofblocks eofb = {0}; struct xfs_icwalk icw = {0};
bool do_work = false; bool do_work = false;
if (!udqp && !gdqp && !pdqp) if (!udqp && !gdqp && !pdqp)
@ -1575,30 +1575,30 @@ xfs_blockgc_free_dquots(
* Run a scan to free blocks using the union filter to cover all * Run a scan to free blocks using the union filter to cover all
* applicable quotas in a single scan. * applicable quotas in a single scan.
*/ */
eofb.eof_flags = XFS_ICWALK_FLAG_UNION | iwalk_flags; icw.icw_flags = XFS_ICWALK_FLAG_UNION | iwalk_flags;
if (XFS_IS_UQUOTA_ENFORCED(mp) && udqp && xfs_dquot_lowsp(udqp)) { 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); icw.icw_uid = make_kuid(mp->m_super->s_user_ns, udqp->q_id);
eofb.eof_flags |= XFS_ICWALK_FLAG_UID; icw.icw_flags |= XFS_ICWALK_FLAG_UID;
do_work = true; do_work = true;
} }
if (XFS_IS_UQUOTA_ENFORCED(mp) && gdqp && xfs_dquot_lowsp(gdqp)) { 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); icw.icw_gid = make_kgid(mp->m_super->s_user_ns, gdqp->q_id);
eofb.eof_flags |= XFS_ICWALK_FLAG_GID; icw.icw_flags |= XFS_ICWALK_FLAG_GID;
do_work = true; do_work = true;
} }
if (XFS_IS_PQUOTA_ENFORCED(mp) && pdqp && xfs_dquot_lowsp(pdqp)) { if (XFS_IS_PQUOTA_ENFORCED(mp) && pdqp && xfs_dquot_lowsp(pdqp)) {
eofb.eof_prid = pdqp->q_id; icw.icw_prid = pdqp->q_id;
eofb.eof_flags |= XFS_ICWALK_FLAG_PRID; icw.icw_flags |= XFS_ICWALK_FLAG_PRID;
do_work = true; do_work = true;
} }
if (!do_work) if (!do_work)
return 0; return 0;
return xfs_blockgc_free_space(mp, &eofb); return xfs_blockgc_free_space(mp, &icw);
} }
/* Run cow/eofblocks scans on the quotas attached to the inode. */ /* Run cow/eofblocks scans on the quotas attached to the inode. */
@ -1632,7 +1632,7 @@ static inline bool
xfs_icwalk_igrab( xfs_icwalk_igrab(
enum xfs_icwalk_goal goal, enum xfs_icwalk_goal goal,
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
switch (goal) { switch (goal) {
case XFS_ICWALK_DQRELE: case XFS_ICWALK_DQRELE:
@ -1640,7 +1640,7 @@ xfs_icwalk_igrab(
case XFS_ICWALK_BLOCKGC: case XFS_ICWALK_BLOCKGC:
return xfs_blockgc_igrab(ip); return xfs_blockgc_igrab(ip);
case XFS_ICWALK_RECLAIM: case XFS_ICWALK_RECLAIM:
return xfs_reclaim_igrab(ip, eofb); return xfs_reclaim_igrab(ip, icw);
default: default:
return false; return false;
} }
@ -1655,16 +1655,16 @@ xfs_icwalk_process_inode(
enum xfs_icwalk_goal goal, enum xfs_icwalk_goal goal,
struct xfs_inode *ip, struct xfs_inode *ip,
struct xfs_perag *pag, struct xfs_perag *pag,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
int error = 0; int error = 0;
switch (goal) { switch (goal) {
case XFS_ICWALK_DQRELE: case XFS_ICWALK_DQRELE:
xfs_dqrele_inode(ip, eofb); xfs_dqrele_inode(ip, icw);
break; break;
case XFS_ICWALK_BLOCKGC: case XFS_ICWALK_BLOCKGC:
error = xfs_blockgc_scan_inode(ip, eofb); error = xfs_blockgc_scan_inode(ip, icw);
break; break;
case XFS_ICWALK_RECLAIM: case XFS_ICWALK_RECLAIM:
xfs_reclaim_inode(ip, pag); xfs_reclaim_inode(ip, pag);
@ -1681,7 +1681,7 @@ static int
xfs_icwalk_ag( xfs_icwalk_ag(
struct xfs_perag *pag, struct xfs_perag *pag,
enum xfs_icwalk_goal goal, enum xfs_icwalk_goal goal,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
struct xfs_mount *mp = pag->pag_mount; struct xfs_mount *mp = pag->pag_mount;
uint32_t first_index; uint32_t first_index;
@ -1729,7 +1729,7 @@ restart:
for (i = 0; i < nr_found; i++) { for (i = 0; i < nr_found; i++) {
struct xfs_inode *ip = batch[i]; struct xfs_inode *ip = batch[i];
if (done || !xfs_icwalk_igrab(goal, ip, eofb)) if (done || !xfs_icwalk_igrab(goal, ip, icw))
batch[i] = NULL; batch[i] = NULL;
/* /*
@ -1758,7 +1758,7 @@ restart:
if (!batch[i]) if (!batch[i])
continue; continue;
error = xfs_icwalk_process_inode(goal, batch[i], pag, error = xfs_icwalk_process_inode(goal, batch[i], pag,
eofb); icw);
if (error == -EAGAIN) { if (error == -EAGAIN) {
skipped++; skipped++;
continue; continue;
@ -1773,9 +1773,9 @@ restart:
cond_resched(); cond_resched();
if (eofb && (eofb->eof_flags & XFS_ICWALK_FLAG_SCAN_LIMIT)) { if (icw && (icw->icw_flags & XFS_ICWALK_FLAG_SCAN_LIMIT)) {
eofb->icw_scan_limit -= XFS_LOOKUP_BATCH; icw->icw_scan_limit -= XFS_LOOKUP_BATCH;
if (eofb->icw_scan_limit <= 0) if (icw->icw_scan_limit <= 0)
break; break;
} }
} while (nr_found && !done); } while (nr_found && !done);
@ -1812,7 +1812,7 @@ static int
xfs_icwalk( xfs_icwalk(
struct xfs_mount *mp, struct xfs_mount *mp,
enum xfs_icwalk_goal goal, enum xfs_icwalk_goal goal,
struct xfs_eofblocks *eofb) struct xfs_icwalk *icw)
{ {
struct xfs_perag *pag; struct xfs_perag *pag;
int error = 0; int error = 0;
@ -1821,7 +1821,7 @@ xfs_icwalk(
while ((pag = xfs_icwalk_get_perag(mp, agno, goal))) { while ((pag = xfs_icwalk_get_perag(mp, agno, goal))) {
agno = pag->pag_agno + 1; agno = pag->pag_agno + 1;
error = xfs_icwalk_ag(pag, goal, eofb); error = xfs_icwalk_ag(pag, goal, icw);
xfs_perag_put(pag); xfs_perag_put(pag);
if (error) { if (error) {
last_error = error; last_error = error;

14
fs/xfs/xfs_icache.h
View File

@ -9,12 +9,12 @@
struct xfs_mount; struct xfs_mount;
struct xfs_perag; struct xfs_perag;
struct xfs_eofblocks { struct xfs_icwalk {
__u32 eof_flags; __u32 icw_flags;
kuid_t eof_uid; kuid_t icw_uid;
kgid_t eof_gid; kgid_t icw_gid;
prid_t eof_prid; prid_t icw_prid;
__u64 eof_min_file_size; __u64 icw_min_file_size;
int icw_scan_limit; int icw_scan_limit;
}; };
@ -58,7 +58,7 @@ int xfs_blockgc_free_dquots(struct xfs_mount *mp, struct xfs_dquot *udqp,
struct xfs_dquot *gdqp, struct xfs_dquot *pdqp, struct xfs_dquot *gdqp, struct xfs_dquot *pdqp,
unsigned int iwalk_flags); unsigned int iwalk_flags);
int xfs_blockgc_free_quota(struct xfs_inode *ip, 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); int xfs_blockgc_free_space(struct xfs_mount *mp, struct xfs_icwalk *icm);
void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip); void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip); void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);

40
fs/xfs/xfs_ioctl.c
View File

@ -1875,7 +1875,7 @@ out:
static inline int static inline int
xfs_fs_eofblocks_from_user( xfs_fs_eofblocks_from_user(
struct xfs_fs_eofblocks *src, struct xfs_fs_eofblocks *src,
struct xfs_eofblocks *dst) struct xfs_icwalk *dst)
{ {
if (src->eof_version != XFS_EOFBLOCKS_VERSION) if (src->eof_version != XFS_EOFBLOCKS_VERSION)
return -EINVAL; return -EINVAL;
@ -1887,32 +1887,32 @@ xfs_fs_eofblocks_from_user(
memchr_inv(src->pad64, 0, sizeof(src->pad64))) memchr_inv(src->pad64, 0, sizeof(src->pad64)))
return -EINVAL; return -EINVAL;
dst->eof_flags = 0; dst->icw_flags = 0;
if (src->eof_flags & XFS_EOF_FLAGS_SYNC) if (src->eof_flags & XFS_EOF_FLAGS_SYNC)
dst->eof_flags |= XFS_ICWALK_FLAG_SYNC; dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;
if (src->eof_flags & XFS_EOF_FLAGS_UID) if (src->eof_flags & XFS_EOF_FLAGS_UID)
dst->eof_flags |= XFS_ICWALK_FLAG_UID; dst->icw_flags |= XFS_ICWALK_FLAG_UID;
if (src->eof_flags & XFS_EOF_FLAGS_GID) if (src->eof_flags & XFS_EOF_FLAGS_GID)
dst->eof_flags |= XFS_ICWALK_FLAG_GID; dst->icw_flags |= XFS_ICWALK_FLAG_GID;
if (src->eof_flags & XFS_EOF_FLAGS_PRID) if (src->eof_flags & XFS_EOF_FLAGS_PRID)
dst->eof_flags |= XFS_ICWALK_FLAG_PRID; dst->icw_flags |= XFS_ICWALK_FLAG_PRID;
if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE) if (src->eof_flags & XFS_EOF_FLAGS_MINFILESIZE)
dst->eof_flags |= XFS_ICWALK_FLAG_MINFILESIZE; dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;
dst->eof_prid = src->eof_prid; dst->icw_prid = src->eof_prid;
dst->eof_min_file_size = src->eof_min_file_size; dst->icw_min_file_size = src->eof_min_file_size;
dst->eof_uid = INVALID_UID; dst->icw_uid = INVALID_UID;
if (src->eof_flags & XFS_EOF_FLAGS_UID) { if (src->eof_flags & XFS_EOF_FLAGS_UID) {
dst->eof_uid = make_kuid(current_user_ns(), src->eof_uid); dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);
if (!uid_valid(dst->eof_uid)) if (!uid_valid(dst->icw_uid))
return -EINVAL; return -EINVAL;
} }
dst->eof_gid = INVALID_GID; dst->icw_gid = INVALID_GID;
if (src->eof_flags & XFS_EOF_FLAGS_GID) { if (src->eof_flags & XFS_EOF_FLAGS_GID) {
dst->eof_gid = make_kgid(current_user_ns(), src->eof_gid); dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);
if (!gid_valid(dst->eof_gid)) if (!gid_valid(dst->icw_gid))
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
@ -2175,8 +2175,8 @@ xfs_file_ioctl(
return xfs_errortag_clearall(mp); return xfs_errortag_clearall(mp);
case XFS_IOC_FREE_EOFBLOCKS: { case XFS_IOC_FREE_EOFBLOCKS: {
struct xfs_fs_eofblocks eofb; struct xfs_fs_eofblocks eofb;
struct xfs_eofblocks keofb; struct xfs_icwalk icw;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
@ -2187,14 +2187,14 @@ xfs_file_ioctl(
if (copy_from_user(&eofb, arg, sizeof(eofb))) if (copy_from_user(&eofb, arg, sizeof(eofb)))
return -EFAULT; return -EFAULT;
error = xfs_fs_eofblocks_from_user(&eofb, &keofb); error = xfs_fs_eofblocks_from_user(&eofb, &icw);
if (error) if (error)
return error; return error;
trace_xfs_ioc_free_eofblocks(mp, &keofb, _RET_IP_); trace_xfs_ioc_free_eofblocks(mp, &icw, _RET_IP_);
sb_start_write(mp->m_super); sb_start_write(mp->m_super);
error = xfs_blockgc_free_space(mp, &keofb); error = xfs_blockgc_free_space(mp, &icw);
sb_end_write(mp->m_super); sb_end_write(mp->m_super);
return error; return error;
} }

36
fs/xfs/xfs_trace.h
View File

@ -37,7 +37,7 @@ struct xfs_trans_res;
struct xfs_inobt_rec_incore; struct xfs_inobt_rec_incore;
union xfs_btree_ptr; union xfs_btree_ptr;
struct xfs_dqtrx; struct xfs_dqtrx;
struct xfs_eofblocks; struct xfs_icwalk;
#define XFS_ATTR_FILTER_FLAGS \ #define XFS_ATTR_FILTER_FLAGS \
{ XFS_ATTR_ROOT, "ROOT" }, \ { XFS_ATTR_ROOT, "ROOT" }, \
@ -3885,10 +3885,10 @@ DEFINE_EVENT(xfs_timestamp_range_class, name, \
DEFINE_TIMESTAMP_RANGE_EVENT(xfs_inode_timestamp_range); DEFINE_TIMESTAMP_RANGE_EVENT(xfs_inode_timestamp_range);
DEFINE_TIMESTAMP_RANGE_EVENT(xfs_quota_expiry_range); DEFINE_TIMESTAMP_RANGE_EVENT(xfs_quota_expiry_range);
DECLARE_EVENT_CLASS(xfs_eofblocks_class, DECLARE_EVENT_CLASS(xfs_icwalk_class,
TP_PROTO(struct xfs_mount *mp, struct xfs_eofblocks *eofb, TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw,
unsigned long caller_ip), unsigned long caller_ip),
TP_ARGS(mp, eofb, caller_ip), TP_ARGS(mp, icw, caller_ip),
TP_STRUCT__entry( TP_STRUCT__entry(
__field(dev_t, dev) __field(dev_t, dev)
__field(__u32, flags) __field(__u32, flags)
@ -3901,14 +3901,14 @@ DECLARE_EVENT_CLASS(xfs_eofblocks_class,
), ),
TP_fast_assign( TP_fast_assign(
__entry->dev = mp->m_super->s_dev; __entry->dev = mp->m_super->s_dev;
__entry->flags = eofb ? eofb->eof_flags : 0; __entry->flags = icw ? icw->icw_flags : 0;
__entry->uid = eofb ? from_kuid(mp->m_super->s_user_ns, __entry->uid = icw ? from_kuid(mp->m_super->s_user_ns,
eofb->eof_uid) : 0; icw->icw_uid) : 0;
__entry->gid = eofb ? from_kgid(mp->m_super->s_user_ns, __entry->gid = icw ? from_kgid(mp->m_super->s_user_ns,
eofb->eof_gid) : 0; icw->icw_gid) : 0;
__entry->prid = eofb ? eofb->eof_prid : 0; __entry->prid = icw ? icw->icw_prid : 0;
__entry->min_file_size = eofb ? eofb->eof_min_file_size : 0; __entry->min_file_size = icw ? icw->icw_min_file_size : 0;
__entry->scan_limit = eofb ? eofb->icw_scan_limit : 0; __entry->scan_limit = icw ? icw->icw_scan_limit : 0;
__entry->caller_ip = caller_ip; __entry->caller_ip = caller_ip;
), ),
TP_printk("dev %d:%d flags 0x%x uid %u gid %u prid %u minsize %llu scan_limit %d caller %pS", TP_printk("dev %d:%d flags 0x%x uid %u gid %u prid %u minsize %llu scan_limit %d caller %pS",
@ -3921,13 +3921,13 @@ DECLARE_EVENT_CLASS(xfs_eofblocks_class,
__entry->scan_limit, __entry->scan_limit,
(char *)__entry->caller_ip) (char *)__entry->caller_ip)
); );
#define DEFINE_EOFBLOCKS_EVENT(name) \ #define DEFINE_ICWALK_EVENT(name) \
DEFINE_EVENT(xfs_eofblocks_class, name, \ DEFINE_EVENT(xfs_icwalk_class, name, \
TP_PROTO(struct xfs_mount *mp, struct xfs_eofblocks *eofb, \ TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, \
unsigned long caller_ip), \ unsigned long caller_ip), \
TP_ARGS(mp, eofb, caller_ip)) TP_ARGS(mp, icw, caller_ip))
DEFINE_EOFBLOCKS_EVENT(xfs_ioc_free_eofblocks); DEFINE_ICWALK_EVENT(xfs_ioc_free_eofblocks);
DEFINE_EOFBLOCKS_EVENT(xfs_blockgc_free_space); DEFINE_ICWALK_EVENT(xfs_blockgc_free_space);
#endif /* _TRACE_XFS_H */ #endif /* _TRACE_XFS_H */