![Dave Chinner](/assets/img/avatar_default.png)
Remove the verbose license text from XFS files and replace them with SPDX tags. This does not change the license of any of the code, merely refers to the common, up-to-date license files in LICENSES/ This change was mostly scripted. fs/xfs/Makefile and fs/xfs/libxfs/xfs_fs.h were modified by hand, the rest were detected and modified by the following command: for f in `git grep -l "GNU General" fs/xfs/` ; do echo $f cat $f | awk -f hdr.awk > $f.new mv -f $f.new $f done And the hdr.awk script that did the modification (including detecting the difference between GPL-2.0 and GPL-2.0+ licenses) is as follows: $ cat hdr.awk BEGIN { hdr = 1.0 tag = "GPL-2.0" str = "" } /^ \* This program is free software/ { hdr = 2.0; next } /any later version./ { tag = "GPL-2.0+" next } /^ \*\// { if (hdr > 0.0) { print "// SPDX-License-Identifier: " tag print str print $0 str="" hdr = 0.0 next } print $0 next } /^ \* / { if (hdr > 1.0) next if (hdr > 0.0) { if (str != "") str = str "\n" str = str $0 next } print $0 next } /^ \*/ { if (hdr > 0.0) next print $0 next } // { if (hdr > 0.0) { if (str != "") str = str "\n" str = str $0 next } print $0 } END { } $ Signed-off-by: Dave Chinner <dchinner@redhat.com> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
887 lines
22 KiB
C
887 lines
22 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2017 Oracle. All Rights Reserved.
|
|
* Author: Darrick J. Wong <darrick.wong@oracle.com>
|
|
*/
|
|
#include "xfs.h"
|
|
#include "xfs_fs.h"
|
|
#include "xfs_shared.h"
|
|
#include "xfs_format.h"
|
|
#include "xfs_trans_resv.h"
|
|
#include "xfs_mount.h"
|
|
#include "xfs_defer.h"
|
|
#include "xfs_btree.h"
|
|
#include "xfs_bit.h"
|
|
#include "xfs_log_format.h"
|
|
#include "xfs_trans.h"
|
|
#include "xfs_sb.h"
|
|
#include "xfs_inode.h"
|
|
#include "xfs_icache.h"
|
|
#include "xfs_itable.h"
|
|
#include "xfs_alloc.h"
|
|
#include "xfs_alloc_btree.h"
|
|
#include "xfs_bmap.h"
|
|
#include "xfs_bmap_btree.h"
|
|
#include "xfs_ialloc.h"
|
|
#include "xfs_ialloc_btree.h"
|
|
#include "xfs_refcount.h"
|
|
#include "xfs_refcount_btree.h"
|
|
#include "xfs_rmap.h"
|
|
#include "xfs_rmap_btree.h"
|
|
#include "xfs_log.h"
|
|
#include "xfs_trans_priv.h"
|
|
#include "xfs_attr.h"
|
|
#include "xfs_reflink.h"
|
|
#include "scrub/xfs_scrub.h"
|
|
#include "scrub/scrub.h"
|
|
#include "scrub/common.h"
|
|
#include "scrub/trace.h"
|
|
#include "scrub/btree.h"
|
|
#include "scrub/repair.h"
|
|
|
|
/* Common code for the metadata scrubbers. */
|
|
|
|
/*
|
|
* Handling operational errors.
|
|
*
|
|
* The *_process_error() family of functions are used to process error return
|
|
* codes from functions called as part of a scrub operation.
|
|
*
|
|
* If there's no error, we return true to tell the caller that it's ok
|
|
* to move on to the next check in its list.
|
|
*
|
|
* For non-verifier errors (e.g. ENOMEM) we return false to tell the
|
|
* caller that something bad happened, and we preserve *error so that
|
|
* the caller can return the *error up the stack to userspace.
|
|
*
|
|
* Verifier errors (EFSBADCRC/EFSCORRUPTED) are recorded by setting
|
|
* OFLAG_CORRUPT in sm_flags and the *error is cleared. In other words,
|
|
* we track verifier errors (and failed scrub checks) via OFLAG_CORRUPT,
|
|
* not via return codes. We return false to tell the caller that
|
|
* something bad happened. Since the error has been cleared, the caller
|
|
* will (presumably) return that zero and scrubbing will move on to
|
|
* whatever's next.
|
|
*
|
|
* ftrace can be used to record the precise metadata location and the
|
|
* approximate code location of the failed operation.
|
|
*/
|
|
|
|
/* Check for operational errors. */
|
|
static bool
|
|
__xfs_scrub_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_agnumber_t agno,
|
|
xfs_agblock_t bno,
|
|
int *error,
|
|
__u32 errflag,
|
|
void *ret_ip)
|
|
{
|
|
switch (*error) {
|
|
case 0:
|
|
return true;
|
|
case -EDEADLOCK:
|
|
/* Used to restart an op with deadlock avoidance. */
|
|
trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
|
|
break;
|
|
case -EFSBADCRC:
|
|
case -EFSCORRUPTED:
|
|
/* Note the badness but don't abort. */
|
|
sc->sm->sm_flags |= errflag;
|
|
*error = 0;
|
|
/* fall through */
|
|
default:
|
|
trace_xfs_scrub_op_error(sc, agno, bno, *error,
|
|
ret_ip);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
xfs_scrub_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_agnumber_t agno,
|
|
xfs_agblock_t bno,
|
|
int *error)
|
|
{
|
|
return __xfs_scrub_process_error(sc, agno, bno, error,
|
|
XFS_SCRUB_OFLAG_CORRUPT, __return_address);
|
|
}
|
|
|
|
bool
|
|
xfs_scrub_xref_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_agnumber_t agno,
|
|
xfs_agblock_t bno,
|
|
int *error)
|
|
{
|
|
return __xfs_scrub_process_error(sc, agno, bno, error,
|
|
XFS_SCRUB_OFLAG_XFAIL, __return_address);
|
|
}
|
|
|
|
/* Check for operational errors for a file offset. */
|
|
static bool
|
|
__xfs_scrub_fblock_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset,
|
|
int *error,
|
|
__u32 errflag,
|
|
void *ret_ip)
|
|
{
|
|
switch (*error) {
|
|
case 0:
|
|
return true;
|
|
case -EDEADLOCK:
|
|
/* Used to restart an op with deadlock avoidance. */
|
|
trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
|
|
break;
|
|
case -EFSBADCRC:
|
|
case -EFSCORRUPTED:
|
|
/* Note the badness but don't abort. */
|
|
sc->sm->sm_flags |= errflag;
|
|
*error = 0;
|
|
/* fall through */
|
|
default:
|
|
trace_xfs_scrub_file_op_error(sc, whichfork, offset, *error,
|
|
ret_ip);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
xfs_scrub_fblock_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset,
|
|
int *error)
|
|
{
|
|
return __xfs_scrub_fblock_process_error(sc, whichfork, offset, error,
|
|
XFS_SCRUB_OFLAG_CORRUPT, __return_address);
|
|
}
|
|
|
|
bool
|
|
xfs_scrub_fblock_xref_process_error(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset,
|
|
int *error)
|
|
{
|
|
return __xfs_scrub_fblock_process_error(sc, whichfork, offset, error,
|
|
XFS_SCRUB_OFLAG_XFAIL, __return_address);
|
|
}
|
|
|
|
/*
|
|
* Handling scrub corruption/optimization/warning checks.
|
|
*
|
|
* The *_set_{corrupt,preen,warning}() family of functions are used to
|
|
* record the presence of metadata that is incorrect (corrupt), could be
|
|
* optimized somehow (preen), or should be flagged for administrative
|
|
* review but is not incorrect (warn).
|
|
*
|
|
* ftrace can be used to record the precise metadata location and
|
|
* approximate code location of the failed check.
|
|
*/
|
|
|
|
/* Record a block which could be optimized. */
|
|
void
|
|
xfs_scrub_block_set_preen(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_buf *bp)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
|
|
trace_xfs_scrub_block_preen(sc, bp->b_bn, __return_address);
|
|
}
|
|
|
|
/*
|
|
* Record an inode which could be optimized. The trace data will
|
|
* include the block given by bp if bp is given; otherwise it will use
|
|
* the block location of the inode record itself.
|
|
*/
|
|
void
|
|
xfs_scrub_ino_set_preen(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_ino_t ino)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
|
|
trace_xfs_scrub_ino_preen(sc, ino, __return_address);
|
|
}
|
|
|
|
/* Record a corrupt block. */
|
|
void
|
|
xfs_scrub_block_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_buf *bp)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
|
trace_xfs_scrub_block_error(sc, bp->b_bn, __return_address);
|
|
}
|
|
|
|
/* Record a corruption while cross-referencing. */
|
|
void
|
|
xfs_scrub_block_xref_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_buf *bp)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
|
|
trace_xfs_scrub_block_error(sc, bp->b_bn, __return_address);
|
|
}
|
|
|
|
/*
|
|
* Record a corrupt inode. The trace data will include the block given
|
|
* by bp if bp is given; otherwise it will use the block location of the
|
|
* inode record itself.
|
|
*/
|
|
void
|
|
xfs_scrub_ino_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_ino_t ino)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
|
trace_xfs_scrub_ino_error(sc, ino, __return_address);
|
|
}
|
|
|
|
/* Record a corruption while cross-referencing with an inode. */
|
|
void
|
|
xfs_scrub_ino_xref_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_ino_t ino)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
|
|
trace_xfs_scrub_ino_error(sc, ino, __return_address);
|
|
}
|
|
|
|
/* Record corruption in a block indexed by a file fork. */
|
|
void
|
|
xfs_scrub_fblock_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
|
trace_xfs_scrub_fblock_error(sc, whichfork, offset, __return_address);
|
|
}
|
|
|
|
/* Record a corruption while cross-referencing a fork block. */
|
|
void
|
|
xfs_scrub_fblock_xref_set_corrupt(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
|
|
trace_xfs_scrub_fblock_error(sc, whichfork, offset, __return_address);
|
|
}
|
|
|
|
/*
|
|
* Warn about inodes that need administrative review but is not
|
|
* incorrect.
|
|
*/
|
|
void
|
|
xfs_scrub_ino_set_warning(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_ino_t ino)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
|
|
trace_xfs_scrub_ino_warning(sc, ino, __return_address);
|
|
}
|
|
|
|
/* Warn about a block indexed by a file fork that needs review. */
|
|
void
|
|
xfs_scrub_fblock_set_warning(
|
|
struct xfs_scrub_context *sc,
|
|
int whichfork,
|
|
xfs_fileoff_t offset)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
|
|
trace_xfs_scrub_fblock_warning(sc, whichfork, offset, __return_address);
|
|
}
|
|
|
|
/* Signal an incomplete scrub. */
|
|
void
|
|
xfs_scrub_set_incomplete(
|
|
struct xfs_scrub_context *sc)
|
|
{
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_INCOMPLETE;
|
|
trace_xfs_scrub_incomplete(sc, __return_address);
|
|
}
|
|
|
|
/*
|
|
* rmap scrubbing -- compute the number of blocks with a given owner,
|
|
* at least according to the reverse mapping data.
|
|
*/
|
|
|
|
struct xfs_scrub_rmap_ownedby_info {
|
|
struct xfs_owner_info *oinfo;
|
|
xfs_filblks_t *blocks;
|
|
};
|
|
|
|
STATIC int
|
|
xfs_scrub_count_rmap_ownedby_irec(
|
|
struct xfs_btree_cur *cur,
|
|
struct xfs_rmap_irec *rec,
|
|
void *priv)
|
|
{
|
|
struct xfs_scrub_rmap_ownedby_info *sroi = priv;
|
|
bool irec_attr;
|
|
bool oinfo_attr;
|
|
|
|
irec_attr = rec->rm_flags & XFS_RMAP_ATTR_FORK;
|
|
oinfo_attr = sroi->oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK;
|
|
|
|
if (rec->rm_owner != sroi->oinfo->oi_owner)
|
|
return 0;
|
|
|
|
if (XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) || irec_attr == oinfo_attr)
|
|
(*sroi->blocks) += rec->rm_blockcount;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Calculate the number of blocks the rmap thinks are owned by something.
|
|
* The caller should pass us an rmapbt cursor.
|
|
*/
|
|
int
|
|
xfs_scrub_count_rmap_ownedby_ag(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_btree_cur *cur,
|
|
struct xfs_owner_info *oinfo,
|
|
xfs_filblks_t *blocks)
|
|
{
|
|
struct xfs_scrub_rmap_ownedby_info sroi;
|
|
|
|
sroi.oinfo = oinfo;
|
|
*blocks = 0;
|
|
sroi.blocks = blocks;
|
|
|
|
return xfs_rmap_query_all(cur, xfs_scrub_count_rmap_ownedby_irec,
|
|
&sroi);
|
|
}
|
|
|
|
/*
|
|
* AG scrubbing
|
|
*
|
|
* These helpers facilitate locking an allocation group's header
|
|
* buffers, setting up cursors for all btrees that are present, and
|
|
* cleaning everything up once we're through.
|
|
*/
|
|
|
|
/* Decide if we want to return an AG header read failure. */
|
|
static inline bool
|
|
want_ag_read_header_failure(
|
|
struct xfs_scrub_context *sc,
|
|
unsigned int type)
|
|
{
|
|
/* Return all AG header read failures when scanning btrees. */
|
|
if (sc->sm->sm_type != XFS_SCRUB_TYPE_AGF &&
|
|
sc->sm->sm_type != XFS_SCRUB_TYPE_AGFL &&
|
|
sc->sm->sm_type != XFS_SCRUB_TYPE_AGI)
|
|
return true;
|
|
/*
|
|
* If we're scanning a given type of AG header, we only want to
|
|
* see read failures from that specific header. We'd like the
|
|
* other headers to cross-check them, but this isn't required.
|
|
*/
|
|
if (sc->sm->sm_type == type)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Grab all the headers for an AG.
|
|
*
|
|
* The headers should be released by xfs_scrub_ag_free, but as a fail
|
|
* safe we attach all the buffers we grab to the scrub transaction so
|
|
* they'll all be freed when we cancel it.
|
|
*/
|
|
int
|
|
xfs_scrub_ag_read_headers(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_agnumber_t agno,
|
|
struct xfs_buf **agi,
|
|
struct xfs_buf **agf,
|
|
struct xfs_buf **agfl)
|
|
{
|
|
struct xfs_mount *mp = sc->mp;
|
|
int error;
|
|
|
|
error = xfs_ialloc_read_agi(mp, sc->tp, agno, agi);
|
|
if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGI))
|
|
goto out;
|
|
|
|
error = xfs_alloc_read_agf(mp, sc->tp, agno, 0, agf);
|
|
if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGF))
|
|
goto out;
|
|
|
|
error = xfs_alloc_read_agfl(mp, sc->tp, agno, agfl);
|
|
if (error && want_ag_read_header_failure(sc, XFS_SCRUB_TYPE_AGFL))
|
|
goto out;
|
|
error = 0;
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
/* Release all the AG btree cursors. */
|
|
void
|
|
xfs_scrub_ag_btcur_free(
|
|
struct xfs_scrub_ag *sa)
|
|
{
|
|
if (sa->refc_cur)
|
|
xfs_btree_del_cursor(sa->refc_cur, XFS_BTREE_ERROR);
|
|
if (sa->rmap_cur)
|
|
xfs_btree_del_cursor(sa->rmap_cur, XFS_BTREE_ERROR);
|
|
if (sa->fino_cur)
|
|
xfs_btree_del_cursor(sa->fino_cur, XFS_BTREE_ERROR);
|
|
if (sa->ino_cur)
|
|
xfs_btree_del_cursor(sa->ino_cur, XFS_BTREE_ERROR);
|
|
if (sa->cnt_cur)
|
|
xfs_btree_del_cursor(sa->cnt_cur, XFS_BTREE_ERROR);
|
|
if (sa->bno_cur)
|
|
xfs_btree_del_cursor(sa->bno_cur, XFS_BTREE_ERROR);
|
|
|
|
sa->refc_cur = NULL;
|
|
sa->rmap_cur = NULL;
|
|
sa->fino_cur = NULL;
|
|
sa->ino_cur = NULL;
|
|
sa->bno_cur = NULL;
|
|
sa->cnt_cur = NULL;
|
|
}
|
|
|
|
/* Initialize all the btree cursors for an AG. */
|
|
int
|
|
xfs_scrub_ag_btcur_init(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_scrub_ag *sa)
|
|
{
|
|
struct xfs_mount *mp = sc->mp;
|
|
xfs_agnumber_t agno = sa->agno;
|
|
|
|
if (sa->agf_bp) {
|
|
/* Set up a bnobt cursor for cross-referencing. */
|
|
sa->bno_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
|
|
agno, XFS_BTNUM_BNO);
|
|
if (!sa->bno_cur)
|
|
goto err;
|
|
|
|
/* Set up a cntbt cursor for cross-referencing. */
|
|
sa->cnt_cur = xfs_allocbt_init_cursor(mp, sc->tp, sa->agf_bp,
|
|
agno, XFS_BTNUM_CNT);
|
|
if (!sa->cnt_cur)
|
|
goto err;
|
|
}
|
|
|
|
/* Set up a inobt cursor for cross-referencing. */
|
|
if (sa->agi_bp) {
|
|
sa->ino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
|
|
agno, XFS_BTNUM_INO);
|
|
if (!sa->ino_cur)
|
|
goto err;
|
|
}
|
|
|
|
/* Set up a finobt cursor for cross-referencing. */
|
|
if (sa->agi_bp && xfs_sb_version_hasfinobt(&mp->m_sb)) {
|
|
sa->fino_cur = xfs_inobt_init_cursor(mp, sc->tp, sa->agi_bp,
|
|
agno, XFS_BTNUM_FINO);
|
|
if (!sa->fino_cur)
|
|
goto err;
|
|
}
|
|
|
|
/* Set up a rmapbt cursor for cross-referencing. */
|
|
if (sa->agf_bp && xfs_sb_version_hasrmapbt(&mp->m_sb)) {
|
|
sa->rmap_cur = xfs_rmapbt_init_cursor(mp, sc->tp, sa->agf_bp,
|
|
agno);
|
|
if (!sa->rmap_cur)
|
|
goto err;
|
|
}
|
|
|
|
/* Set up a refcountbt cursor for cross-referencing. */
|
|
if (sa->agf_bp && xfs_sb_version_hasreflink(&mp->m_sb)) {
|
|
sa->refc_cur = xfs_refcountbt_init_cursor(mp, sc->tp,
|
|
sa->agf_bp, agno, NULL);
|
|
if (!sa->refc_cur)
|
|
goto err;
|
|
}
|
|
|
|
return 0;
|
|
err:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Release the AG header context and btree cursors. */
|
|
void
|
|
xfs_scrub_ag_free(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_scrub_ag *sa)
|
|
{
|
|
xfs_scrub_ag_btcur_free(sa);
|
|
if (sa->agfl_bp) {
|
|
xfs_trans_brelse(sc->tp, sa->agfl_bp);
|
|
sa->agfl_bp = NULL;
|
|
}
|
|
if (sa->agf_bp) {
|
|
xfs_trans_brelse(sc->tp, sa->agf_bp);
|
|
sa->agf_bp = NULL;
|
|
}
|
|
if (sa->agi_bp) {
|
|
xfs_trans_brelse(sc->tp, sa->agi_bp);
|
|
sa->agi_bp = NULL;
|
|
}
|
|
if (sa->pag) {
|
|
xfs_perag_put(sa->pag);
|
|
sa->pag = NULL;
|
|
}
|
|
sa->agno = NULLAGNUMBER;
|
|
}
|
|
|
|
/*
|
|
* For scrub, grab the AGI and the AGF headers, in that order. Locking
|
|
* order requires us to get the AGI before the AGF. We use the
|
|
* transaction to avoid deadlocking on crosslinked metadata buffers;
|
|
* either the caller passes one in (bmap scrub) or we have to create a
|
|
* transaction ourselves.
|
|
*/
|
|
int
|
|
xfs_scrub_ag_init(
|
|
struct xfs_scrub_context *sc,
|
|
xfs_agnumber_t agno,
|
|
struct xfs_scrub_ag *sa)
|
|
{
|
|
int error;
|
|
|
|
sa->agno = agno;
|
|
error = xfs_scrub_ag_read_headers(sc, agno, &sa->agi_bp,
|
|
&sa->agf_bp, &sa->agfl_bp);
|
|
if (error)
|
|
return error;
|
|
|
|
return xfs_scrub_ag_btcur_init(sc, sa);
|
|
}
|
|
|
|
/*
|
|
* Grab the per-ag structure if we haven't already gotten it. Teardown of the
|
|
* xfs_scrub_ag will release it for us.
|
|
*/
|
|
void
|
|
xfs_scrub_perag_get(
|
|
struct xfs_mount *mp,
|
|
struct xfs_scrub_ag *sa)
|
|
{
|
|
if (!sa->pag)
|
|
sa->pag = xfs_perag_get(mp, sa->agno);
|
|
}
|
|
|
|
/* Per-scrubber setup functions */
|
|
|
|
/*
|
|
* Grab an empty transaction so that we can re-grab locked buffers if
|
|
* one of our btrees turns out to be cyclic.
|
|
*
|
|
* If we're going to repair something, we need to ask for the largest possible
|
|
* log reservation so that we can handle the worst case scenario for metadata
|
|
* updates while rebuilding a metadata item. We also need to reserve as many
|
|
* blocks in the head transaction as we think we're going to need to rebuild
|
|
* the metadata object.
|
|
*/
|
|
int
|
|
xfs_scrub_trans_alloc(
|
|
struct xfs_scrub_context *sc,
|
|
uint resblks)
|
|
{
|
|
if (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR)
|
|
return xfs_trans_alloc(sc->mp, &M_RES(sc->mp)->tr_itruncate,
|
|
resblks, 0, 0, &sc->tp);
|
|
|
|
return xfs_trans_alloc_empty(sc->mp, &sc->tp);
|
|
}
|
|
|
|
/* Set us up with a transaction and an empty context. */
|
|
int
|
|
xfs_scrub_setup_fs(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_inode *ip)
|
|
{
|
|
uint resblks;
|
|
|
|
resblks = xfs_repair_calc_ag_resblks(sc);
|
|
return xfs_scrub_trans_alloc(sc, resblks);
|
|
}
|
|
|
|
/* Set us up with AG headers and btree cursors. */
|
|
int
|
|
xfs_scrub_setup_ag_btree(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_inode *ip,
|
|
bool force_log)
|
|
{
|
|
struct xfs_mount *mp = sc->mp;
|
|
int error;
|
|
|
|
/*
|
|
* If the caller asks us to checkpont the log, do so. This
|
|
* expensive operation should be performed infrequently and only
|
|
* as a last resort. Any caller that sets force_log should
|
|
* document why they need to do so.
|
|
*/
|
|
if (force_log) {
|
|
error = xfs_scrub_checkpoint_log(mp);
|
|
if (error)
|
|
return error;
|
|
}
|
|
|
|
error = xfs_scrub_setup_fs(sc, ip);
|
|
if (error)
|
|
return error;
|
|
|
|
return xfs_scrub_ag_init(sc, sc->sm->sm_agno, &sc->sa);
|
|
}
|
|
|
|
/* Push everything out of the log onto disk. */
|
|
int
|
|
xfs_scrub_checkpoint_log(
|
|
struct xfs_mount *mp)
|
|
{
|
|
int error;
|
|
|
|
error = xfs_log_force(mp, XFS_LOG_SYNC);
|
|
if (error)
|
|
return error;
|
|
xfs_ail_push_all_sync(mp->m_ail);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Given an inode and the scrub control structure, grab either the
|
|
* inode referenced in the control structure or the inode passed in.
|
|
* The inode is not locked.
|
|
*/
|
|
int
|
|
xfs_scrub_get_inode(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_inode *ip_in)
|
|
{
|
|
struct xfs_imap imap;
|
|
struct xfs_mount *mp = sc->mp;
|
|
struct xfs_inode *ip = NULL;
|
|
int error;
|
|
|
|
/* We want to scan the inode we already had opened. */
|
|
if (sc->sm->sm_ino == 0 || sc->sm->sm_ino == ip_in->i_ino) {
|
|
sc->ip = ip_in;
|
|
return 0;
|
|
}
|
|
|
|
/* Look up the inode, see if the generation number matches. */
|
|
if (xfs_internal_inum(mp, sc->sm->sm_ino))
|
|
return -ENOENT;
|
|
error = xfs_iget(mp, NULL, sc->sm->sm_ino,
|
|
XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE, 0, &ip);
|
|
switch (error) {
|
|
case -ENOENT:
|
|
/* Inode doesn't exist, just bail out. */
|
|
return error;
|
|
case 0:
|
|
/* Got an inode, continue. */
|
|
break;
|
|
case -EINVAL:
|
|
/*
|
|
* -EINVAL with IGET_UNTRUSTED could mean one of several
|
|
* things: userspace gave us an inode number that doesn't
|
|
* correspond to fs space, or doesn't have an inobt entry;
|
|
* or it could simply mean that the inode buffer failed the
|
|
* read verifiers.
|
|
*
|
|
* Try just the inode mapping lookup -- if it succeeds, then
|
|
* the inode buffer verifier failed and something needs fixing.
|
|
* Otherwise, we really couldn't find it so tell userspace
|
|
* that it no longer exists.
|
|
*/
|
|
error = xfs_imap(sc->mp, sc->tp, sc->sm->sm_ino, &imap,
|
|
XFS_IGET_UNTRUSTED | XFS_IGET_DONTCACHE);
|
|
if (error)
|
|
return -ENOENT;
|
|
error = -EFSCORRUPTED;
|
|
/* fall through */
|
|
default:
|
|
trace_xfs_scrub_op_error(sc,
|
|
XFS_INO_TO_AGNO(mp, sc->sm->sm_ino),
|
|
XFS_INO_TO_AGBNO(mp, sc->sm->sm_ino),
|
|
error, __return_address);
|
|
return error;
|
|
}
|
|
if (VFS_I(ip)->i_generation != sc->sm->sm_gen) {
|
|
iput(VFS_I(ip));
|
|
return -ENOENT;
|
|
}
|
|
|
|
sc->ip = ip;
|
|
return 0;
|
|
}
|
|
|
|
/* Set us up to scrub a file's contents. */
|
|
int
|
|
xfs_scrub_setup_inode_contents(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_inode *ip,
|
|
unsigned int resblks)
|
|
{
|
|
int error;
|
|
|
|
error = xfs_scrub_get_inode(sc, ip);
|
|
if (error)
|
|
return error;
|
|
|
|
/* Got the inode, lock it and we're ready to go. */
|
|
sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
|
|
xfs_ilock(sc->ip, sc->ilock_flags);
|
|
error = xfs_scrub_trans_alloc(sc, resblks);
|
|
if (error)
|
|
goto out;
|
|
sc->ilock_flags |= XFS_ILOCK_EXCL;
|
|
xfs_ilock(sc->ip, XFS_ILOCK_EXCL);
|
|
|
|
out:
|
|
/* scrub teardown will unlock and release the inode for us */
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* Predicate that decides if we need to evaluate the cross-reference check.
|
|
* If there was an error accessing the cross-reference btree, just delete
|
|
* the cursor and skip the check.
|
|
*/
|
|
bool
|
|
xfs_scrub_should_check_xref(
|
|
struct xfs_scrub_context *sc,
|
|
int *error,
|
|
struct xfs_btree_cur **curpp)
|
|
{
|
|
/* No point in xref if we already know we're corrupt. */
|
|
if (xfs_scrub_skip_xref(sc->sm))
|
|
return false;
|
|
|
|
if (*error == 0)
|
|
return true;
|
|
|
|
if (curpp) {
|
|
/* If we've already given up on xref, just bail out. */
|
|
if (!*curpp)
|
|
return false;
|
|
|
|
/* xref error, delete cursor and bail out. */
|
|
xfs_btree_del_cursor(*curpp, XFS_BTREE_ERROR);
|
|
*curpp = NULL;
|
|
}
|
|
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XFAIL;
|
|
trace_xfs_scrub_xref_error(sc, *error, __return_address);
|
|
|
|
/*
|
|
* Errors encountered during cross-referencing with another
|
|
* data structure should not cause this scrubber to abort.
|
|
*/
|
|
*error = 0;
|
|
return false;
|
|
}
|
|
|
|
/* Run the structure verifiers on in-memory buffers to detect bad memory. */
|
|
void
|
|
xfs_scrub_buffer_recheck(
|
|
struct xfs_scrub_context *sc,
|
|
struct xfs_buf *bp)
|
|
{
|
|
xfs_failaddr_t fa;
|
|
|
|
if (bp->b_ops == NULL) {
|
|
xfs_scrub_block_set_corrupt(sc, bp);
|
|
return;
|
|
}
|
|
if (bp->b_ops->verify_struct == NULL) {
|
|
xfs_scrub_set_incomplete(sc);
|
|
return;
|
|
}
|
|
fa = bp->b_ops->verify_struct(bp);
|
|
if (!fa)
|
|
return;
|
|
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
|
trace_xfs_scrub_block_error(sc, bp->b_bn, fa);
|
|
}
|
|
|
|
/*
|
|
* Scrub the attr/data forks of a metadata inode. The metadata inode must be
|
|
* pointed to by sc->ip and the ILOCK must be held.
|
|
*/
|
|
int
|
|
xfs_scrub_metadata_inode_forks(
|
|
struct xfs_scrub_context *sc)
|
|
{
|
|
__u32 smtype;
|
|
bool shared;
|
|
int error;
|
|
|
|
if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
|
|
return 0;
|
|
|
|
/* Metadata inodes don't live on the rt device. */
|
|
if (sc->ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
|
|
xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
|
|
return 0;
|
|
}
|
|
|
|
/* They should never participate in reflink. */
|
|
if (xfs_is_reflink_inode(sc->ip)) {
|
|
xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
|
|
return 0;
|
|
}
|
|
|
|
/* They also should never have extended attributes. */
|
|
if (xfs_inode_hasattr(sc->ip)) {
|
|
xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
|
|
return 0;
|
|
}
|
|
|
|
/* Invoke the data fork scrubber. */
|
|
smtype = sc->sm->sm_type;
|
|
sc->sm->sm_type = XFS_SCRUB_TYPE_BMBTD;
|
|
error = xfs_scrub_bmap_data(sc);
|
|
sc->sm->sm_type = smtype;
|
|
if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
|
|
return error;
|
|
|
|
/* Look for incorrect shared blocks. */
|
|
if (xfs_sb_version_hasreflink(&sc->mp->m_sb)) {
|
|
error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
|
|
&shared);
|
|
if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0,
|
|
&error))
|
|
return error;
|
|
if (shared)
|
|
xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* Try to lock an inode in violation of the usual locking order rules. For
|
|
* example, trying to get the IOLOCK while in transaction context, or just
|
|
* plain breaking AG-order or inode-order inode locking rules. Either way,
|
|
* the only way to avoid an ABBA deadlock is to use trylock and back off if
|
|
* we can't.
|
|
*/
|
|
int
|
|
xfs_scrub_ilock_inverted(
|
|
struct xfs_inode *ip,
|
|
uint lock_mode)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 20; i++) {
|
|
if (xfs_ilock_nowait(ip, lock_mode))
|
|
return 0;
|
|
delay(1);
|
|
}
|
|
return -EDEADLOCK;
|
|
}
|