AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

xfs: shorten xfs_repair_ prefix to xrep_

Browse Source 
Shorten all the metadata repair xfs_repair_* symbols to xrep_.
Whitespace damage will be fixed by a subsequent patch.  There are no
functional changes.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
This commit is contained in:
Darrick J. Wong 2018-07-19 12:29:11 -07:00
parent c517b3aa02
commit b5e2196e9c
6 changed files with 168 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/xfs/scrub/agheader_repair.c
View File

@ -28,7 +28,7 @@
/* Repair the superblock. */
int
xfs_repair_superblock(
xrep_superblock(
struct xfs_scrub_context *sc)
{
struct xfs_mount *mp = sc->mp;

2
fs/xfs/scrub/common.c
View File

@ -604,7 +604,7 @@ xchk_setup_fs(
{
uint resblks;
resblks = xfs_repair_calc_ag_resblks(sc);
resblks = xrep_calc_ag_resblks(sc);
return xchk_trans_alloc(sc, resblks);
}

164
fs/xfs/scrub/repair.c
View File

@ -41,21 +41,21 @@
* and will set *fixed to true if it thinks it repaired anything.
*/
int
xfs_repair_attempt(
xrep_attempt(
struct xfs_inode *ip,
struct xfs_scrub_context *sc,
bool *fixed)
{
int error = 0;
trace_xfs_repair_attempt(ip, sc->sm, error);
trace_xrep_attempt(ip, sc->sm, error);
xchk_ag_btcur_free(&sc->sa);
/* Repair whatever's broken. */
ASSERT(sc->ops->repair);
error = sc->ops->repair(sc);
trace_xfs_repair_done(ip, sc->sm, error);
trace_xrep_done(ip, sc->sm, error);
switch (error) {
case 0:
/*
@ -93,7 +93,7 @@ xfs_repair_attempt(
* structure to track rate limiting information.
*/
void
xfs_repair_failure(
xrep_failure(
struct xfs_mount *mp)
{
xfs_alert_ratelimited(mp,
@ -105,7 +105,7 @@ xfs_repair_failure(
* given mountpoint.
*/
int
xfs_repair_probe(
xrep_probe(
struct xfs_scrub_context *sc)
{
int error = 0;
@ -121,7 +121,7 @@ xfs_repair_probe(
* the btree cursors.
*/
int
xfs_repair_roll_ag_trans(
xrep_roll_ag_trans(
struct xfs_scrub_context *sc)
{
int error;
@ -162,7 +162,7 @@ xfs_repair_roll_ag_trans(
* in AG reservations) to construct a whole btree.
*/
bool
xfs_repair_ag_has_space(
xrep_ag_has_space(
struct xfs_perag *pag,
xfs_extlen_t nr_blocks,
enum xfs_ag_resv_type type)
@ -178,7 +178,7 @@ xfs_repair_ag_has_space(
* any type of per-AG btree.
*/
xfs_extlen_t
xfs_repair_calc_ag_resblks(
xrep_calc_ag_resblks(
struct xfs_scrub_context *sc)
{
struct xfs_mount *mp = sc->mp;
@ -231,7 +231,7 @@ xfs_repair_calc_ag_resblks(
}
xfs_perag_put(pag);
trace_xfs_repair_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
trace_xrep_calc_ag_resblks(mp, sm->sm_agno, icount, aglen,
freelen, usedlen);
/*
@ -270,7 +270,7 @@ xfs_repair_calc_ag_resblks(
rmapbt_sz = 0;
}
trace_xfs_repair_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
trace_xrep_calc_ag_resblks_btsize(mp, sm->sm_agno, bnobt_sz,
inobt_sz, rmapbt_sz, refcbt_sz);
return max(max(bnobt_sz, inobt_sz), max(rmapbt_sz, refcbt_sz));
@ -278,7 +278,7 @@ xfs_repair_calc_ag_resblks(
/* Allocate a block in an AG. */
int
xfs_repair_alloc_ag_block(
xrep_alloc_ag_block(
struct xfs_scrub_context *sc,
struct xfs_owner_info *oinfo,
xfs_fsblock_t *fsbno,
@ -329,7 +329,7 @@ xfs_repair_alloc_ag_block(
/* Initialize a new AG btree root block with zero entries. */
int
xfs_repair_init_btblock(
xrep_init_btblock(
struct xfs_scrub_context *sc,
xfs_fsblock_t fsb,
struct xfs_buf **bpp,
@ -340,7 +340,7 @@ xfs_repair_init_btblock(
struct xfs_mount *mp = sc->mp;
struct xfs_buf *bp;
trace_xfs_repair_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
XFS_FSB_TO_AGBNO(mp, fsb), btnum);
ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.agno);
@ -384,19 +384,19 @@ xfs_repair_init_btblock(
/* Collect a dead btree extent for later disposal. */
int
xfs_repair_collect_btree_extent(
xrep_collect_btree_extent(
struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist,
struct xrep_extent_list *exlist,
xfs_fsblock_t fsbno,
xfs_extlen_t len)
{
struct xfs_repair_extent *rex;
struct xrep_extent *rex;
trace_xfs_repair_collect_btree_extent(sc->mp,
trace_xrep_collect_btree_extent(sc->mp,
XFS_FSB_TO_AGNO(sc->mp, fsbno),
XFS_FSB_TO_AGBNO(sc->mp, fsbno), len);
rex = kmem_alloc(sizeof(struct xfs_repair_extent), KM_MAYFAIL);
rex = kmem_alloc(sizeof(struct xrep_extent), KM_MAYFAIL);
if (!rex)
return -ENOMEM;
@ -414,14 +414,14 @@ xfs_repair_collect_btree_extent(
* Therefore, free all the memory associated with the list so we can die.
*/
void
xfs_repair_cancel_btree_extents(
xrep_cancel_btree_extents(
struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist)
struct xrep_extent_list *exlist)
{
struct xfs_repair_extent *rex;
struct xfs_repair_extent *n;
struct xrep_extent *rex;
struct xrep_extent *n;
for_each_xfs_repair_extent_safe(rex, n, exlist) {
for_each_xrep_extent_safe(rex, n, exlist) {
list_del(&rex->list);
kmem_free(rex);
}
@ -429,16 +429,16 @@ xfs_repair_cancel_btree_extents(
/* Compare two btree extents. */
static int
xfs_repair_btree_extent_cmp(
xrep_btree_extent_cmp(
void *priv,
struct list_head *a,
struct list_head *b)
{
struct xfs_repair_extent *ap;
struct xfs_repair_extent *bp;
struct xrep_extent *ap;
struct xrep_extent *bp;
ap = container_of(a, struct xfs_repair_extent, list);
bp = container_of(b, struct xfs_repair_extent, list);
ap = container_of(a, struct xrep_extent, list);
bp = container_of(b, struct xrep_extent, list);
if (ap->fsbno > bp->fsbno)
return 1;
@ -462,15 +462,15 @@ xfs_repair_btree_extent_cmp(
#define LEFT_ALIGNED (1 << 0)
#define RIGHT_ALIGNED (1 << 1)
int
xfs_repair_subtract_extents(
xrep_subtract_extents(
struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist,
struct xfs_repair_extent_list *sublist)
struct xrep_extent_list *exlist,
struct xrep_extent_list *sublist)
{
struct list_head *lp;
struct xfs_repair_extent *ex;
struct xfs_repair_extent *newex;
struct xfs_repair_extent *subex;
struct xrep_extent *ex;
struct xrep_extent *newex;
struct xrep_extent *subex;
xfs_fsblock_t sub_fsb;
xfs_extlen_t sub_len;
int state;
@ -480,8 +480,8 @@ xfs_repair_subtract_extents(
return 0;
ASSERT(!list_empty(&sublist->list));
list_sort(NULL, &exlist->list, xfs_repair_btree_extent_cmp);
list_sort(NULL, &sublist->list, xfs_repair_btree_extent_cmp);
list_sort(NULL, &exlist->list, xrep_btree_extent_cmp);
list_sort(NULL, &sublist->list, xrep_btree_extent_cmp);
/*
* Now that we've sorted both lists, we iterate exlist once, rolling
@ -491,11 +491,11 @@ xfs_repair_subtract_extents(
* list traversal is similar to merge sort, but we're deleting
* instead. In this manner we avoid O(n^2) operations.
*/
subex = list_first_entry(&sublist->list, struct xfs_repair_extent,
subex = list_first_entry(&sublist->list, struct xrep_extent,
list);
lp = exlist->list.next;
while (lp != &exlist->list) {
ex = list_entry(lp, struct xfs_repair_extent, list);
ex = list_entry(lp, struct xrep_extent, list);
/*
* Advance subex and/or ex until we find a pair that
@ -548,7 +548,7 @@ xfs_repair_subtract_extents(
* Deleting from the middle: add the new right extent
* and then shrink the left extent.
*/
newex = kmem_alloc(sizeof(struct xfs_repair_extent),
newex = kmem_alloc(sizeof(struct xrep_extent),
KM_MAYFAIL);
if (!newex) {
error = -ENOMEM;
@ -619,12 +619,12 @@ xfs_repair_subtract_extents(
* is not intended for use with file data repairs; we have bunmapi for that.
*/
int
xfs_repair_invalidate_blocks(
xrep_invalidate_blocks(
struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist)
struct xrep_extent_list *exlist)
{
struct xfs_repair_extent *rex;
struct xfs_repair_extent *n;
struct xrep_extent *rex;
struct xrep_extent *n;
struct xfs_buf *bp;
xfs_fsblock_t fsbno;
xfs_agblock_t i;
@ -637,7 +637,7 @@ xfs_repair_invalidate_blocks(
* because we never own those; and if we can't TRYLOCK the buffer we
* assume it's owned by someone else.
*/
for_each_xfs_repair_extent_safe(rex, n, exlist) {
for_each_xrep_extent_safe(rex, n, exlist) {
for (fsbno = rex->fsbno, i = rex->len; i > 0; fsbno++, i--) {
/* Skip AG headers and post-EOFS blocks */
if (!xfs_verify_fsbno(sc->mp, fsbno))
@ -657,7 +657,7 @@ xfs_repair_invalidate_blocks(
/* Ensure the freelist is the correct size. */
int
xfs_repair_fix_freelist(
xrep_fix_freelist(
struct xfs_scrub_context *sc,
bool can_shrink)
{
@ -677,7 +677,7 @@ xfs_repair_fix_freelist(
* Put a block back on the AGFL.
*/
STATIC int
xfs_repair_put_freelist(
xrep_put_freelist(
struct xfs_scrub_context *sc,
xfs_agblock_t agbno)
{
@ -685,7 +685,7 @@ xfs_repair_put_freelist(
int error;
/* Make sure there's space on the freelist. */
error = xfs_repair_fix_freelist(sc, true);
error = xrep_fix_freelist(sc, true);
if (error)
return error;
@ -713,7 +713,7 @@ xfs_repair_put_freelist(
/* Dispose of a single metadata block. */
STATIC int
xfs_repair_dispose_btree_block(
xrep_dispose_btree_block(
struct xfs_scrub_context *sc,
xfs_fsblock_t fsbno,
struct xfs_owner_info *oinfo,
@ -767,7 +767,7 @@ xfs_repair_dispose_btree_block(
if (has_other_rmap)
error = xfs_rmap_free(sc->tp, agf_bp, agno, agbno, 1, oinfo);
else if (resv == XFS_AG_RESV_AGFL)
error = xfs_repair_put_freelist(sc, agbno);
error = xrep_put_freelist(sc, agbno);
else
error = xfs_free_extent(sc->tp, fsbno, 1, oinfo, resv);
if (agf_bp != sc->sa.agf_bp)
@ -777,7 +777,7 @@ xfs_repair_dispose_btree_block(
if (sc->ip)
return xfs_trans_roll_inode(&sc->tp, sc->ip);
return xfs_repair_roll_ag_trans(sc);
return xrep_roll_ag_trans(sc);
out_free:
if (agf_bp != sc->sa.agf_bp)
@ -787,29 +787,29 @@ xfs_repair_dispose_btree_block(
/* Dispose of btree blocks from an old per-AG btree. */
int
xfs_repair_reap_btree_extents(
xrep_reap_btree_extents(
struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist,
struct xrep_extent_list *exlist,
struct xfs_owner_info *oinfo,
enum xfs_ag_resv_type type)
{
struct xfs_repair_extent *rex;
struct xfs_repair_extent *n;
struct xrep_extent *rex;
struct xrep_extent *n;
int error = 0;
ASSERT(xfs_sb_version_hasrmapbt(&sc->mp->m_sb));
/* Dispose of every block from the old btree. */
for_each_xfs_repair_extent_safe(rex, n, exlist) {
for_each_xrep_extent_safe(rex, n, exlist) {
ASSERT(sc->ip != NULL ||
XFS_FSB_TO_AGNO(sc->mp, rex->fsbno) == sc->sa.agno);
trace_xfs_repair_dispose_btree_extent(sc->mp,
trace_xrep_dispose_btree_extent(sc->mp,
XFS_FSB_TO_AGNO(sc->mp, rex->fsbno),
XFS_FSB_TO_AGBNO(sc->mp, rex->fsbno), rex->len);
for (; rex->len > 0; rex->len--, rex->fsbno++) {
error = xfs_repair_dispose_btree_block(sc, rex->fsbno,
error = xrep_dispose_btree_block(sc, rex->fsbno,
oinfo, type);
if (error)
goto out;
@ -819,7 +819,7 @@ xfs_repair_reap_btree_extents(
}
out:
xfs_repair_cancel_btree_extents(sc, exlist);
xrep_cancel_btree_extents(sc, exlist);
return error;
}
@ -831,12 +831,12 @@ xfs_repair_reap_btree_extents(
* btree roots. This is not guaranteed to work if the AG is heavily damaged
* or the rmap data are corrupt.
*
* Callers of xfs_repair_find_ag_btree_roots must lock the AGF and AGFL
* Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
* buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
* AGI is being rebuilt. It must maintain these locks until it's safe for
* other threads to change the btrees' shapes. The caller provides
* information about the btrees to look for by passing in an array of
* xfs_repair_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
* xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
* The (root, height) fields will be set on return if anything is found. The
* last element of the array should have a NULL buf_ops to mark the end of the
* array.
@ -850,16 +850,16 @@ xfs_repair_reap_btree_extents(
* should be the roots.
*/
struct xfs_repair_findroot {
struct xrep_findroot {
struct xfs_scrub_context *sc;
struct xfs_buf *agfl_bp;
struct xfs_agf *agf;
struct xfs_repair_find_ag_btree *btree_info;
struct xrep_find_ag_btree *btree_info;
};
/* See if our block is in the AGFL. */
STATIC int
xfs_repair_findroot_agfl_walk(
xrep_findroot_agfl_walk(
struct xfs_mount *mp,
xfs_agblock_t bno,
void *priv)
@ -871,9 +871,9 @@ xfs_repair_findroot_agfl_walk(
/* Does this block match the btree information passed in? */
STATIC int
xfs_repair_findroot_block(
struct xfs_repair_findroot *ri,
struct xfs_repair_find_ag_btree *fab,
xrep_findroot_block(
struct xrep_findroot *ri,
struct xrep_find_ag_btree *fab,
uint64_t owner,
xfs_agblock_t agbno,
bool *found_it)
@ -894,7 +894,7 @@ xfs_repair_findroot_block(
*/
if (owner == XFS_RMAP_OWN_AG) {
error = xfs_agfl_walk(mp, ri->agf, ri->agfl_bp,
xfs_repair_findroot_agfl_walk, &agbno);
xrep_findroot_agfl_walk, &agbno);
if (error == XFS_BTREE_QUERY_RANGE_ABORT)
return 0;
if (error)
@ -932,7 +932,7 @@ xfs_repair_findroot_block(
fab->height = xfs_btree_get_level(btblock) + 1;
*found_it = true;
trace_xfs_repair_findroot_block(mp, ri->sc->sa.agno, agbno,
trace_xrep_findroot_block(mp, ri->sc->sa.agno, agbno,
be32_to_cpu(btblock->bb_magic), fab->height - 1);
out:
xfs_trans_brelse(ri->sc->tp, bp);
@ -944,13 +944,13 @@ xfs_repair_findroot_block(
* looking for?
*/
STATIC int
xfs_repair_findroot_rmap(
xrep_findroot_rmap(
struct xfs_btree_cur *cur,
struct xfs_rmap_irec *rec,
void *priv)
{
struct xfs_repair_findroot *ri = priv;
struct xfs_repair_find_ag_btree *fab;
struct xrep_findroot *ri = priv;
struct xrep_find_ag_btree *fab;
xfs_agblock_t b;
bool found_it;
int error = 0;
@ -965,7 +965,7 @@ xfs_repair_findroot_rmap(
for (fab = ri->btree_info; fab->buf_ops; fab++) {
if (rec->rm_owner != fab->rmap_owner)
continue;
error = xfs_repair_findroot_block(ri, fab,
error = xrep_findroot_block(ri, fab,
rec->rm_owner, rec->rm_startblock + b,
&found_it);
if (error)
@ -980,15 +980,15 @@ xfs_repair_findroot_rmap(
/* Find the roots of the per-AG btrees described in btree_info. */
int
xfs_repair_find_ag_btree_roots(
xrep_find_ag_btree_roots(
struct xfs_scrub_context *sc,
struct xfs_buf *agf_bp,
struct xfs_repair_find_ag_btree *btree_info,
struct xrep_find_ag_btree *btree_info,
struct xfs_buf *agfl_bp)
{
struct xfs_mount *mp = sc->mp;
struct xfs_repair_findroot ri;
struct xfs_repair_find_ag_btree *fab;
struct xrep_findroot ri;
struct xrep_find_ag_btree *fab;
struct xfs_btree_cur *cur;
int error;
@ -1007,7 +1007,7 @@ xfs_repair_find_ag_btree_roots(
}
cur = xfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, sc->sa.agno);
error = xfs_rmap_query_all(cur, xfs_repair_findroot_rmap, &ri);
error = xfs_rmap_query_all(cur, xrep_findroot_rmap, &ri);
xfs_btree_del_cursor(cur, error);
return error;
@ -1015,7 +1015,7 @@ xfs_repair_find_ag_btree_roots(
/* Force a quotacheck the next time we mount. */
void
xfs_repair_force_quotacheck(
xrep_force_quotacheck(
struct xfs_scrub_context *sc,
uint dqtype)
{
@ -1043,7 +1043,7 @@ xfs_repair_force_quotacheck(
* repair corruptions in the quota metadata.
*/
int
xfs_repair_ino_dqattach(
xrep_ino_dqattach(
struct xfs_scrub_context *sc)
{
int error;
@ -1057,11 +1057,11 @@ xfs_repair_ino_dqattach(
"inode %llu repair encountered quota error %d, quotacheck forced.",
(unsigned long long)sc->ip->i_ino, error);
if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
xfs_repair_force_quotacheck(sc, XFS_DQ_USER);
xrep_force_quotacheck(sc, XFS_DQ_USER);
if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
xfs_repair_force_quotacheck(sc, XFS_DQ_GROUP);
xrep_force_quotacheck(sc, XFS_DQ_GROUP);
if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
xfs_repair_force_quotacheck(sc, XFS_DQ_PROJ);
xrep_force_quotacheck(sc, XFS_DQ_PROJ);
/* fall through */
case -ESRCH:
error = 0;

74
fs/xfs/scrub/repair.h
View File

@ -6,7 +6,7 @@
#ifndef __XFS_SCRUB_REPAIR_H__
#define __XFS_SCRUB_REPAIR_H__
static inline int xfs_repair_notsupported(struct xfs_scrub_context *sc)
static inline int xrep_notsupported(struct xfs_scrub_context *sc)
{
return -EOPNOTSUPP;
}
@ -15,55 +15,55 @@ static inline int xfs_repair_notsupported(struct xfs_scrub_context *sc)
/* Repair helpers */
int xfs_repair_attempt(struct xfs_inode *ip, struct xfs_scrub_context *sc,
int xrep_attempt(struct xfs_inode *ip, struct xfs_scrub_context *sc,
bool *fixed);
void xfs_repair_failure(struct xfs_mount *mp);
int xfs_repair_roll_ag_trans(struct xfs_scrub_context *sc);
bool xfs_repair_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
void xrep_failure(struct xfs_mount *mp);
int xrep_roll_ag_trans(struct xfs_scrub_context *sc);
bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,
enum xfs_ag_resv_type type);
xfs_extlen_t xfs_repair_calc_ag_resblks(struct xfs_scrub_context *sc);
int xfs_repair_alloc_ag_block(struct xfs_scrub_context *sc,
xfs_extlen_t xrep_calc_ag_resblks(struct xfs_scrub_context *sc);
int xrep_alloc_ag_block(struct xfs_scrub_context *sc,
struct xfs_owner_info *oinfo, xfs_fsblock_t *fsbno,
enum xfs_ag_resv_type resv);
int xfs_repair_init_btblock(struct xfs_scrub_context *sc, xfs_fsblock_t fsb,
int xrep_init_btblock(struct xfs_scrub_context *sc, xfs_fsblock_t fsb,
struct xfs_buf **bpp, xfs_btnum_t btnum,
const struct xfs_buf_ops *ops);
struct xfs_repair_extent {
struct xrep_extent {
struct list_head list;
xfs_fsblock_t fsbno;
xfs_extlen_t len;
};
struct xfs_repair_extent_list {
struct xrep_extent_list {
struct list_head list;
};
static inline void
xfs_repair_init_extent_list(
struct xfs_repair_extent_list *exlist)
xrep_init_extent_list(
struct xrep_extent_list *exlist)
{
INIT_LIST_HEAD(&exlist->list);
}
#define for_each_xfs_repair_extent_safe(rbe, n, exlist) \
#define for_each_xrep_extent_safe(rbe, n, exlist) \
list_for_each_entry_safe((rbe), (n), &(exlist)->list, list)
int xfs_repair_collect_btree_extent(struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *btlist, xfs_fsblock_t fsbno,
int xrep_collect_btree_extent(struct xfs_scrub_context *sc,
struct xrep_extent_list *btlist, xfs_fsblock_t fsbno,
xfs_extlen_t len);
void xfs_repair_cancel_btree_extents(struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *btlist);
int xfs_repair_subtract_extents(struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist,
struct xfs_repair_extent_list *sublist);
int xfs_repair_fix_freelist(struct xfs_scrub_context *sc, bool can_shrink);
int xfs_repair_invalidate_blocks(struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *btlist);
int xfs_repair_reap_btree_extents(struct xfs_scrub_context *sc,
struct xfs_repair_extent_list *exlist,
void xrep_cancel_btree_extents(struct xfs_scrub_context *sc,
struct xrep_extent_list *btlist);
int xrep_subtract_extents(struct xfs_scrub_context *sc,
struct xrep_extent_list *exlist,
struct xrep_extent_list *sublist);
int xrep_fix_freelist(struct xfs_scrub_context *sc, bool can_shrink);
int xrep_invalidate_blocks(struct xfs_scrub_context *sc,
struct xrep_extent_list *btlist);
int xrep_reap_btree_extents(struct xfs_scrub_context *sc,
struct xrep_extent_list *exlist,
struct xfs_owner_info *oinfo, enum xfs_ag_resv_type type);
struct xfs_repair_find_ag_btree {
struct xrep_find_ag_btree {
/* in: rmap owner of the btree we're looking for */
uint64_t rmap_owner;
@ -78,21 +78,21 @@ struct xfs_repair_find_ag_btree {
unsigned int height;
};
int xfs_repair_find_ag_btree_roots(struct xfs_scrub_context *sc,
int xrep_find_ag_btree_roots(struct xfs_scrub_context *sc,
struct xfs_buf *agf_bp,
struct xfs_repair_find_ag_btree *btree_info,
struct xrep_find_ag_btree *btree_info,
struct xfs_buf *agfl_bp);
void xfs_repair_force_quotacheck(struct xfs_scrub_context *sc, uint dqtype);
int xfs_repair_ino_dqattach(struct xfs_scrub_context *sc);
void xrep_force_quotacheck(struct xfs_scrub_context *sc, uint dqtype);
int xrep_ino_dqattach(struct xfs_scrub_context *sc);
/* Metadata repairers */
int xfs_repair_probe(struct xfs_scrub_context *sc);
int xfs_repair_superblock(struct xfs_scrub_context *sc);
int xrep_probe(struct xfs_scrub_context *sc);
int xrep_superblock(struct xfs_scrub_context *sc);
#else
static inline int xfs_repair_attempt(
static inline int xrep_attempt(
struct xfs_inode *ip,
struct xfs_scrub_context *sc,
bool *fixed)
@ -100,18 +100,18 @@ static inline int xfs_repair_attempt(
return -EOPNOTSUPP;
}
static inline void xfs_repair_failure(struct xfs_mount *mp) {}
static inline void xrep_failure(struct xfs_mount *mp) {}
static inline xfs_extlen_t
xfs_repair_calc_ag_resblks(
xrep_calc_ag_resblks(
struct xfs_scrub_context *sc)
{
ASSERT(!(sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR));
return 0;
}
#define xfs_repair_probe xfs_repair_notsupported
#define xfs_repair_superblock xfs_repair_notsupported
#define xrep_probe xrep_notsupported
#define xrep_superblock xrep_notsupported
#endif /* CONFIG_XFS_ONLINE_REPAIR */

54
fs/xfs/scrub/scrub.c
View File

@ -202,150 +202,150 @@ static const struct xchk_meta_ops meta_scrub_ops[] = {
.type = ST_NONE,
.setup = xchk_setup_fs,
.scrub = xchk_probe,
.repair = xfs_repair_probe,
.repair = xrep_probe,
},
[XFS_SCRUB_TYPE_SB] = { /* superblock */
.type = ST_PERAG,
.setup = xchk_setup_fs,
.scrub = xchk_superblock,
.repair = xfs_repair_superblock,
.repair = xrep_superblock,
},
[XFS_SCRUB_TYPE_AGF] = { /* agf */
.type = ST_PERAG,
.setup = xchk_setup_fs,
.scrub = xchk_agf,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_AGFL]= { /* agfl */
.type = ST_PERAG,
.setup = xchk_setup_fs,
.scrub = xchk_agfl,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_AGI] = { /* agi */
.type = ST_PERAG,
.setup = xchk_setup_fs,
.scrub = xchk_agi,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_BNOBT] = { /* bnobt */
.type = ST_PERAG,
.setup = xchk_setup_ag_allocbt,
.scrub = xchk_bnobt,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_CNTBT] = { /* cntbt */
.type = ST_PERAG,
.setup = xchk_setup_ag_allocbt,
.scrub = xchk_cntbt,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_INOBT] = { /* inobt */
.type = ST_PERAG,
.setup = xchk_setup_ag_iallocbt,
.scrub = xchk_inobt,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_FINOBT] = { /* finobt */
.type = ST_PERAG,
.setup = xchk_setup_ag_iallocbt,
.scrub = xchk_finobt,
.has = xfs_sb_version_hasfinobt,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_RMAPBT] = { /* rmapbt */
.type = ST_PERAG,
.setup = xchk_setup_ag_rmapbt,
.scrub = xchk_rmapbt,
.has = xfs_sb_version_hasrmapbt,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_REFCNTBT] = { /* refcountbt */
.type = ST_PERAG,
.setup = xchk_setup_ag_refcountbt,
.scrub = xchk_refcountbt,
.has = xfs_sb_version_hasreflink,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_INODE] = { /* inode record */
.type = ST_INODE,
.setup = xchk_setup_inode,
.scrub = xchk_inode,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_BMBTD] = { /* inode data fork */
.type = ST_INODE,
.setup = xchk_setup_inode_bmap,
.scrub = xchk_bmap_data,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_BMBTA] = { /* inode attr fork */
.type = ST_INODE,
.setup = xchk_setup_inode_bmap,
.scrub = xchk_bmap_attr,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_BMBTC] = { /* inode CoW fork */
.type = ST_INODE,
.setup = xchk_setup_inode_bmap,
.scrub = xchk_bmap_cow,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_DIR] = { /* directory */
.type = ST_INODE,
.setup = xchk_setup_directory,
.scrub = xchk_directory,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_XATTR] = { /* extended attributes */
.type = ST_INODE,
.setup = xchk_setup_xattr,
.scrub = xchk_xattr,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_SYMLINK] = { /* symbolic link */
.type = ST_INODE,
.setup = xchk_setup_symlink,
.scrub = xchk_symlink,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_PARENT] = { /* parent pointers */
.type = ST_INODE,
.setup = xchk_setup_parent,
.scrub = xchk_parent,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_RTBITMAP] = { /* realtime bitmap */
.type = ST_FS,
.setup = xchk_setup_rt,
.scrub = xchk_rtbitmap,
.has = xfs_sb_version_hasrealtime,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_RTSUM] = { /* realtime summary */
.type = ST_FS,
.setup = xchk_setup_rt,
.scrub = xchk_rtsummary,
.has = xfs_sb_version_hasrealtime,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_UQUOTA] = { /* user quota */
.type = ST_FS,
.setup = xchk_setup_quota,
.scrub = xchk_quota,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_GQUOTA] = { /* group quota */
.type = ST_FS,
.setup = xchk_setup_quota,
.scrub = xchk_quota,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
[XFS_SCRUB_TYPE_PQUOTA] = { /* project quota */
.type = ST_FS,
.setup = xchk_setup_quota,
.scrub = xchk_quota,
.repair = xfs_repair_notsupported,
.repair = xrep_notsupported,
},
};
@ -457,7 +457,7 @@ static inline void xchk_postmortem(struct xfs_scrub_context *sc)
if ((sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR) &&
(sc->sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT |
XFS_SCRUB_OFLAG_XCORRUPT)))
xfs_repair_failure(sc->mp);
xrep_failure(sc->mp);
}
#else
static inline void xchk_postmortem(struct xfs_scrub_context *sc)
@ -555,13 +555,13 @@ xfs_scrub_metadata(
* If it's broken, userspace wants us to fix it, and we haven't
* already tried to fix it, then attempt a repair.
*/
error = xfs_repair_attempt(ip, &sc, &already_fixed);
error = xrep_attempt(ip, &sc, &already_fixed);
if (error == -EAGAIN) {
if (sc.try_harder)
try_harder = true;
error = xchk_teardown(&sc, ip, 0);
if (error) {
xfs_repair_failure(mp);
xrep_failure(mp);
goto out;
}
goto retry_op;

40
fs/xfs/scrub/trace.h
View File

@ -55,8 +55,8 @@ DEFINE_EVENT(xchk_class, name, \
DEFINE_SCRUB_EVENT(xchk_start);
DEFINE_SCRUB_EVENT(xchk_done);
DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
DEFINE_SCRUB_EVENT(xfs_repair_attempt);
DEFINE_SCRUB_EVENT(xfs_repair_done);
DEFINE_SCRUB_EVENT(xrep_attempt);
DEFINE_SCRUB_EVENT(xrep_done);
TRACE_EVENT(xchk_op_error,
TP_PROTO(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
@ -483,7 +483,7 @@ TRACE_EVENT(xchk_xref_error,
/* repair tracepoints */
#if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
DECLARE_EVENT_CLASS(xfs_repair_extent_class,
DECLARE_EVENT_CLASS(xrep_extent_class,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
xfs_agblock_t agbno, xfs_extlen_t len),
TP_ARGS(mp, agno, agbno, len),
@ -506,15 +506,15 @@ DECLARE_EVENT_CLASS(xfs_repair_extent_class,
__entry->len)
);
#define DEFINE_REPAIR_EXTENT_EVENT(name) \
DEFINE_EVENT(xfs_repair_extent_class, name, \
DEFINE_EVENT(xrep_extent_class, name, \
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
xfs_agblock_t agbno, xfs_extlen_t len), \
TP_ARGS(mp, agno, agbno, len))
DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_dispose_btree_extent);
DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_collect_btree_extent);
DEFINE_REPAIR_EXTENT_EVENT(xfs_repair_agfl_insert);
DEFINE_REPAIR_EXTENT_EVENT(xrep_dispose_btree_extent);
DEFINE_REPAIR_EXTENT_EVENT(xrep_collect_btree_extent);
DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
DECLARE_EVENT_CLASS(xfs_repair_rmap_class,
DECLARE_EVENT_CLASS(xrep_rmap_class,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
xfs_agblock_t agbno, xfs_extlen_t len,
uint64_t owner, uint64_t offset, unsigned int flags),
@ -547,17 +547,17 @@ DECLARE_EVENT_CLASS(xfs_repair_rmap_class,
__entry->flags)
);
#define DEFINE_REPAIR_RMAP_EVENT(name) \
DEFINE_EVENT(xfs_repair_rmap_class, name, \
DEFINE_EVENT(xrep_rmap_class, name, \
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
xfs_agblock_t agbno, xfs_extlen_t len, \
uint64_t owner, uint64_t offset, unsigned int flags), \
TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
DEFINE_REPAIR_RMAP_EVENT(xfs_repair_alloc_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xfs_repair_ialloc_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xfs_repair_rmap_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xfs_repair_bmap_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xrep_rmap_extent_fn);
DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_extent_fn);
TRACE_EVENT(xfs_repair_refcount_extent_fn,
TRACE_EVENT(xrep_refcount_extent_fn,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
struct xfs_refcount_irec *irec),
TP_ARGS(mp, agno, irec),
@ -583,7 +583,7 @@ TRACE_EVENT(xfs_repair_refcount_extent_fn,
__entry->refcount)
)
TRACE_EVENT(xfs_repair_init_btblock,
TRACE_EVENT(xrep_init_btblock,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
xfs_btnum_t btnum),
TP_ARGS(mp, agno, agbno, btnum),
@ -605,7 +605,7 @@ TRACE_EVENT(xfs_repair_init_btblock,
__entry->agbno,
__entry->btnum)
)
TRACE_EVENT(xfs_repair_findroot_block,
TRACE_EVENT(xrep_findroot_block,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
uint32_t magic, uint16_t level),
TP_ARGS(mp, agno, agbno, magic, level),
@ -630,7 +630,7 @@ TRACE_EVENT(xfs_repair_findroot_block,
__entry->magic,
__entry->level)
)
TRACE_EVENT(xfs_repair_calc_ag_resblks,
TRACE_EVENT(xrep_calc_ag_resblks,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
xfs_agblock_t usedlen),
@ -659,7 +659,7 @@ TRACE_EVENT(xfs_repair_calc_ag_resblks,
__entry->freelen,
__entry->usedlen)
)
TRACE_EVENT(xfs_repair_calc_ag_resblks_btsize,
TRACE_EVENT(xrep_calc_ag_resblks_btsize,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
@ -688,7 +688,7 @@ TRACE_EVENT(xfs_repair_calc_ag_resblks_btsize,
__entry->rmapbt_sz,
__entry->refcbt_sz)
)
TRACE_EVENT(xfs_repair_reset_counters,
TRACE_EVENT(xrep_reset_counters,
TP_PROTO(struct xfs_mount *mp),
TP_ARGS(mp),
TP_STRUCT__entry(
@ -701,7 +701,7 @@ TRACE_EVENT(xfs_repair_reset_counters,
MAJOR(__entry->dev), MINOR(__entry->dev))
)
TRACE_EVENT(xfs_repair_ialloc_insert,
TRACE_EVENT(xrep_ialloc_insert,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
xfs_agino_t startino, uint16_t holemask, uint8_t count,
uint8_t freecount, uint64_t freemask),