From patchwork Wed Jul 18 15:51:58 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Darrick J. Wong" X-Patchwork-Id: 10532729 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 78B25600D0 for ; Wed, 18 Jul 2018 15:52:08 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 5F4FB29264 for ; Wed, 18 Jul 2018 15:52:08 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 533D829046; Wed, 18 Jul 2018 15:52:08 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.8 required=2.0 tests=BAYES_00,DKIM_SIGNED, MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI, T_DKIM_INVALID, UNPARSEABLE_RELAY autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7A655298D9 for ; Wed, 18 Jul 2018 15:52:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728686AbeGRQag (ORCPT ); Wed, 18 Jul 2018 12:30:36 -0400 Received: from aserp2130.oracle.com ([141.146.126.79]:57672 "EHLO aserp2130.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726613AbeGRQag (ORCPT ); Wed, 18 Jul 2018 12:30:36 -0400 Received: from pps.filterd (aserp2130.oracle.com [127.0.0.1]) by aserp2130.oracle.com (8.16.0.22/8.16.0.22) with SMTP id w6IFnJbD003255 for ; Wed, 18 Jul 2018 15:52:00 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=subject : from : to : cc : date : message-id : in-reply-to : references : mime-version : content-type : content-transfer-encoding; s=corp-2018-07-02; bh=TfLWg/L/nHLY3pBMC2K9riHj7dtAw8xKsrvYuLgOQz4=; b=HNF4XcAT9TcfgfTNGF93gZEb4Ro5MzWrx1FY/FFqtWewIf4S+5sQJhUR8Ot1Aw1ouib+ yOfPT5wwzoI2ULVPJPuz65e6C9rIt+U8562yP+UBviRzeIh/iwTtJv8VuhA98L3UWDVN Leu8vbaoKKheZk22TMHexzF+8O6HXjc64uOZWwr36+1VvHnorQubSlgcZibybr3SxSyv rorrTFVR8LjxPL8boQYqL65ajEBeQrpnYGKFQmoOOnG4rTyj8eUfz6ofqlcFRYUEAfTx QmEShcirfQDsY0ghpDBSSCGRqppfgwGw14mjh5HON1rX8qj4HxavG1NZnlR39TlUR5iy Ag== Received: from aserv0021.oracle.com (aserv0021.oracle.com [141.146.126.233]) by aserp2130.oracle.com with ESMTP id 2k7a3t5qxg-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Wed, 18 Jul 2018 15:52:00 +0000 Received: from aserv0121.oracle.com (aserv0121.oracle.com [141.146.126.235]) by aserv0021.oracle.com (8.14.4/8.14.4) with ESMTP id w6IFq0oW026595 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Wed, 18 Jul 2018 15:52:00 GMT Received: from abhmp0007.oracle.com (abhmp0007.oracle.com [141.146.116.13]) by aserv0121.oracle.com (8.14.4/8.13.8) with ESMTP id w6IFq0bc008349 for ; Wed, 18 Jul 2018 15:52:00 GMT Received: from localhost (/67.169.218.210) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Wed, 18 Jul 2018 08:51:59 -0700 Subject: [PATCH 6/8] xfs: shorten xfs_repair_ prefix to xrep_ From: "Darrick J. Wong" To: darrick.wong@oracle.com Cc: linux-xfs@vger.kernel.org Date: Wed, 18 Jul 2018 08:51:58 -0700 Message-ID: <153192911831.31685.9739086364482425982.stgit@magnolia> In-Reply-To: <153192902811.31685.11590100183112248407.stgit@magnolia> References: <153192902811.31685.11590100183112248407.stgit@magnolia> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=nai engine=5900 definitions=8958 signatures=668706 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=4 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1806210000 definitions=main-1807180176 Sender: linux-xfs-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-xfs@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Darrick J. Wong 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 Reviewed-by: Brian Foster --- fs/xfs/scrub/agheader_repair.c | 2 fs/xfs/scrub/common.c | 2 fs/xfs/scrub/repair.c | 164 ++++++++++++++++++++-------------------- fs/xfs/scrub/repair.h | 74 +++++++++--------- fs/xfs/scrub/scrub.c | 54 +++++++------ fs/xfs/scrub/trace.h | 40 +++++----- 6 files changed, 168 insertions(+), 168 deletions(-) -- To unsubscribe from this list: send the line "unsubscribe linux-xfs" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c index 117eedac53df..631940f3ca4d 100644 --- a/fs/xfs/scrub/agheader_repair.c +++ b/fs/xfs/scrub/agheader_repair.c @@ -28,7 +28,7 @@ /* Repair the superblock. */ int -xfs_repair_superblock( +xrep_superblock( struct xfs_scrub_context *sc) { struct xfs_mount *mp = sc->mp; diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c index a4004a06f482..fa1c16063d17 100644 --- a/fs/xfs/scrub/common.c +++ b/fs/xfs/scrub/common.c @@ -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); } diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c index 5eccd89c64a8..7e6a56a5f59d 100644 --- a/fs/xfs/scrub/repair.c +++ b/fs/xfs/scrub/repair.c @@ -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; diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h index ef47826b6725..60d81294797b 100644 --- a/fs/xfs/scrub/repair.h +++ b/fs/xfs/scrub/repair.h @@ -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 */ diff --git a/fs/xfs/scrub/scrub.c b/fs/xfs/scrub/scrub.c index ead97ab91a3c..a6efede6e430 100644 --- a/fs/xfs/scrub/scrub.c +++ b/fs/xfs/scrub/scrub.c @@ -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; diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h index 11967d3942ac..96f3edda3e91 100644 --- a/fs/xfs/scrub/trace.h +++ b/fs/xfs/scrub/trace.h @@ -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),