From patchwork Fri Dec 30 22:17:22 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Darrick J. Wong" X-Patchwork-Id: 13085049 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8BE7CC4332F for ; Sat, 31 Dec 2022 00:06:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235717AbiLaAGd (ORCPT ); Fri, 30 Dec 2022 19:06:33 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53652 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235621AbiLaAGc (ORCPT ); Fri, 30 Dec 2022 19:06:32 -0500 Received: from ams.source.kernel.org (ams.source.kernel.org [IPv6:2604:1380:4601:e00::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 503E71B1D4 for ; Fri, 30 Dec 2022 16:06:32 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 0CBD6B81DEC for ; Sat, 31 Dec 2022 00:06:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C21E6C433EF; Sat, 31 Dec 2022 00:06:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1672445189; bh=NTBaJAE/DOH61sX9qllU7ErApPpj3Y9xTzqaF5QenSI=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=sulNfqEJJap8Yfkt05ljU9uIRayGkLYd/GYYSVSt9UnPizwZsJGcq5e3LFnA/nQwL RvvLneArc8UxgjJc9+626Z57zT0akUhCcfepes1aaKcmmFeh0EjX0ijBwD9gFdtvb/ 0LSqRXnxw5pUYgc/GA+UuOLro76C9UkJXsMNVn71OLv0JTzhepDWWJzNb7AnWgNDql TF8ftBIZghdzeIczkbdp+i7gFjOWzuPisrTNeGauu67ywwCwY9D6ArmF6Jkk7V4aWS Df67mo4XUtFXaRIylFRgMjzAraIy40X61icTTxinzLkQUxUGrorMNaa8xGYybmZ9PW Ch3ZVdD0zjBWg== Subject: [PATCH 1/3] xfs: allow userspace to rebuild metadata structures From: "Darrick J. Wong" To: cem@kernel.org, djwong@kernel.org Cc: linux-xfs@vger.kernel.org Date: Fri, 30 Dec 2022 14:17:22 -0800 Message-ID: <167243864265.707991.3461580373977289965.stgit@magnolia> In-Reply-To: <167243864252.707991.14471233385651088983.stgit@magnolia> References: <167243864252.707991.14471233385651088983.stgit@magnolia> User-Agent: StGit/0.19 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-xfs@vger.kernel.org From: Darrick J. Wong Add a new (superuser-only) flag to the online metadata repair ioctl to force it to rebuild structures, even if they're not broken. We will use this to move metadata structures out of the way during a free space defragmentation operation. Signed-off-by: Darrick J. Wong --- libxfs/xfs_fs.h | 6 +++++- man/man2/ioctl_xfs_scrub_metadata.2 | 5 +++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/libxfs/xfs_fs.h b/libxfs/xfs_fs.h index 1cfd5bc6520..920fd4513fc 100644 --- a/libxfs/xfs_fs.h +++ b/libxfs/xfs_fs.h @@ -741,7 +741,11 @@ struct xfs_scrub_metadata { */ #define XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED (1u << 7) -#define XFS_SCRUB_FLAGS_IN (XFS_SCRUB_IFLAG_REPAIR) +/* i: Rebuild the data structure. */ +#define XFS_SCRUB_IFLAG_FORCE_REBUILD (1 << 31) + +#define XFS_SCRUB_FLAGS_IN (XFS_SCRUB_IFLAG_REPAIR | \ + XFS_SCRUB_IFLAG_FORCE_REBUILD) #define XFS_SCRUB_FLAGS_OUT (XFS_SCRUB_OFLAG_CORRUPT | \ XFS_SCRUB_OFLAG_PREEN | \ XFS_SCRUB_OFLAG_XFAIL | \ diff --git a/man/man2/ioctl_xfs_scrub_metadata.2 b/man/man2/ioctl_xfs_scrub_metadata.2 index 046e3e3657b..42bf1e1cac5 100644 --- a/man/man2/ioctl_xfs_scrub_metadata.2 +++ b/man/man2/ioctl_xfs_scrub_metadata.2 @@ -216,6 +216,11 @@ The checker was unable to complete its check of all records. The checker encountered a metadata object with potentially problematic records. However, the records were not obviously corrupt. +.TP +.B XFS_SCRUB_IFLAG_FORCE_REBUILD +Force the kernel to rebuild the specified piece of metadata, even if it's +healthy. +This can only be specified by the system administrator. .RE .PP For metadata checkers that operate on inodes or inode metadata, the fields From patchwork Fri Dec 30 22:17:22 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Darrick J. Wong" X-Patchwork-Id: 13085050 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F1FD5C4332F for ; Sat, 31 Dec 2022 00:06:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235850AbiLaAGt (ORCPT ); Fri, 30 Dec 2022 19:06:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53674 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235621AbiLaAGt (ORCPT ); Fri, 30 Dec 2022 19:06:49 -0500 Received: from ams.source.kernel.org (ams.source.kernel.org [145.40.68.75]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0091F1CB3E for ; Fri, 30 Dec 2022 16:06:47 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id A8187B81DEE for ; Sat, 31 Dec 2022 00:06:46 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 55F9BC433D2; Sat, 31 Dec 2022 00:06:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1672445205; bh=vOamtiEnmON4NcN0z0Dilr2Z+wQCu3i84dOmjmfD3kU=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=RZONyqm+/Mh63d12NrYDpQfmHCizqgswukHp9XdNo3RuCS4ZbiHCn7daBOpGxxspr Ac8Rn4UsUMF+JTHvh6PmkaLI38UF5TdE8PHDeTYWkVIew8uNubqNR4M8/rCFIQ60tJ b4rHjLjBDnLzT4og5CilIhCUcHng0u1cwxJeBd1gpnPKlOwGVS0mac/kmihl4E7XV6 BjQs7+BqiBAZA2uQ3psraljIwuYhP9n8LetD3GGJ6nD1Qu8QREZGBDaDs93uRLgtvm OfLrJHJesD7FDO77ByZjmYt9udlUfIOfxuUxOfRottov+J795U47nPs0/i2LttVw2z OPn9kHVQCJCDw== Subject: [PATCH 2/3] xfs_io: support passing the FORCE_REBUILD flag to online repair From: "Darrick J. Wong" To: cem@kernel.org, djwong@kernel.org Cc: linux-xfs@vger.kernel.org Date: Fri, 30 Dec 2022 14:17:22 -0800 Message-ID: <167243864278.707991.18074766242840502279.stgit@magnolia> In-Reply-To: <167243864252.707991.14471233385651088983.stgit@magnolia> References: <167243864252.707991.14471233385651088983.stgit@magnolia> User-Agent: StGit/0.19 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-xfs@vger.kernel.org From: Darrick J. Wong Add CLI options to the scrubv and repair commands so that the user can pass FORCE_REBUILD to force the kernel to rebuild metadata. Signed-off-by: Darrick J. Wong --- io/scrub.c | 22 +++++++++++++++------- man/man8/xfs_io.8 | 3 +++ 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/io/scrub.c b/io/scrub.c index fc22ba49f8b..a74e65fbe8d 100644 --- a/io/scrub.c +++ b/io/scrub.c @@ -46,7 +46,8 @@ scrub_ioctl( int fd, int type, uint64_t control, - uint32_t control2) + uint32_t control2, + uint32_t flags) { struct xfs_scrub_metadata meta; const struct xfrog_scrub_descr *sc; @@ -69,7 +70,7 @@ scrub_ioctl( /* no control parameters */ break; } - meta.sm_flags = 0; + meta.sm_flags = flags; error = ioctl(fd, XFS_IOC_SCRUB_METADATA, &meta); if (error) @@ -91,17 +92,21 @@ parse_args( int argc, char **argv, struct cmdinfo *cmdinfo, - void (*fn)(int, int, uint64_t, uint32_t)) + void (*fn)(int, int, uint64_t, uint32_t, uint32_t)) { char *p; int type = -1; int i, c; uint64_t control = 0; uint32_t control2 = 0; + uint32_t flags = 0; const struct xfrog_scrub_descr *d = NULL; - while ((c = getopt(argc, argv, "")) != EOF) { + while ((c = getopt(argc, argv, "R")) != EOF) { switch (c) { + case 'R': + flags |= XFS_SCRUB_IFLAG_FORCE_REBUILD; + break; default: return command_usage(cmdinfo); } @@ -173,7 +178,7 @@ parse_args( ASSERT(0); break; } - fn(file->fd, type, control, control2); + fn(file->fd, type, control, control2, flags); return 0; } @@ -216,6 +221,8 @@ repair_help(void) " or (optionally) take an inode number and generation number to act upon as\n" " the second and third parameters.\n" "\n" +" Flags are -R to rebuild metadata.\n" +"\n" " Example:\n" " 'repair inobt 3' - repairs the inode btree in AG 3.\n" " 'repair bmapbtd 128 13525' - repairs the extent map of inode 128 gen 13525.\n" @@ -231,7 +238,8 @@ repair_ioctl( int fd, int type, uint64_t control, - uint32_t control2) + uint32_t control2, + uint32_t flags) { struct xfs_scrub_metadata meta; const struct xfrog_scrub_descr *sc; @@ -254,7 +262,7 @@ repair_ioctl( /* no control parameters */ break; } - meta.sm_flags = XFS_SCRUB_IFLAG_REPAIR; + meta.sm_flags = flags | XFS_SCRUB_IFLAG_REPAIR; error = ioctl(fd, XFS_IOC_SCRUB_METADATA, &meta); if (error) diff --git a/man/man8/xfs_io.8 b/man/man8/xfs_io.8 index 223b5152314..ae8d0245d87 100644 --- a/man/man8/xfs_io.8 +++ b/man/man8/xfs_io.8 @@ -1340,6 +1340,9 @@ parameter specifies which type of metadata to repair. For AG metadata, one AG number must be specified. For file metadata, the repair is applied to the open file unless the inode number and generation number are specified. +The +.B -R +option can be specified to force rebuilding of a metadata structure. .TP .BI "label" " " "[ -c | -s " label " ] " On filesystems that support online label manipulation, get, set, or clear the From patchwork Fri Dec 30 22:17:22 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Darrick J. Wong" X-Patchwork-Id: 13085051 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DC279C4332F for ; Sat, 31 Dec 2022 00:07:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235858AbiLaAHD (ORCPT ); Fri, 30 Dec 2022 19:07:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53690 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235857AbiLaAHC (ORCPT ); Fri, 30 Dec 2022 19:07:02 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DFF051CB3E for ; Fri, 30 Dec 2022 16:07:01 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 7C10E61CCB for ; Sat, 31 Dec 2022 00:07:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id D8CE7C433D2; Sat, 31 Dec 2022 00:07:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1672445220; bh=b2ddQ74c6Gybd/iP2TXajKwOqTiJdTClBpW4FRLFcgk=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=LqWkhs1qIyZU1VqTw13oBXsHiOO0J88Ddb+bVN/mYnXqUH8bykRnQa2LLa27h9dwh NnTxPh+iZav01iakAZJAsNVks8eqGjKon5ZnWA7bbDiGPBNRJIsWQQCAhNoMhzLdlB 5R2sOya9IGqYO/oeAbLqOjlKjW3s2Ew3jf+S0dHkDyoF52LUAWuBBiMCdKFDBglBKe 1goqJZVKYaenfKdPuSNu1zl+MU3sE/xBTWXd+/SuoQRzuLXcCWa+H2J2VLwLTpAj2N 5E4Qq5VTdLRrIv/JCCnDWv5uqAdi4tkO7AhDPcDGG07ibQE5xOQ/PUT59ig0qAuvtV ps17uRN54k4tg== Subject: [PATCH 3/3] xfs_scrub: try to use XFS_SCRUB_IFLAG_FORCE_REBUILD From: "Darrick J. Wong" To: cem@kernel.org, djwong@kernel.org Cc: linux-xfs@vger.kernel.org Date: Fri, 30 Dec 2022 14:17:22 -0800 Message-ID: <167243864291.707991.12856124083468099734.stgit@magnolia> In-Reply-To: <167243864252.707991.14471233385651088983.stgit@magnolia> References: <167243864252.707991.14471233385651088983.stgit@magnolia> User-Agent: StGit/0.19 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-xfs@vger.kernel.org From: Darrick J. Wong Now that we have a FORCE_REBUILD flag to the scrub ioctl, try to use that over the (much noisier) error injection knob, which may or may not even be enabled in the kernel config. Signed-off-by: Darrick J. Wong --- scrub/phase1.c | 28 ++++++++++++++++++++++++++++ scrub/scrub.c | 45 +++++++++++++++++++++++---------------------- scrub/scrub.h | 1 + scrub/xfs_scrub.c | 3 +++ scrub/xfs_scrub.h | 1 + 5 files changed, 56 insertions(+), 22 deletions(-) diff --git a/scrub/phase1.c b/scrub/phase1.c index fd1050c9202..2daf5c7bb38 100644 --- a/scrub/phase1.c +++ b/scrub/phase1.c @@ -27,6 +27,7 @@ #include "scrub.h" #include "repair.h" #include "libfrog/fsgeom.h" +#include "xfs_errortag.h" /* Phase 1: Find filesystem geometry (and clean up after) */ @@ -68,6 +69,27 @@ scrub_cleanup( return error; } +/* Decide if we're using FORCE_REBUILD or injecting FORCE_REPAIR. */ +static int +enable_force_repair( + struct scrub_ctx *ctx) +{ + struct xfs_error_injection inject = { + .fd = ctx->mnt.fd, + .errtag = XFS_ERRTAG_FORCE_SCRUB_REPAIR, + }; + int error; + + use_force_rebuild = can_force_rebuild(ctx); + if (use_force_rebuild) + return 0; + + error = ioctl(ctx->mnt.fd, XFS_IOC_ERROR_INJECTION, &inject); + if (error) + str_errno(ctx, _("force_repair")); + return error; +} + /* * Bind to the mountpoint, read the XFS geometry, bind to the block devices. * Anything we've already built will be cleaned up by scrub_cleanup. @@ -156,6 +178,12 @@ _("Kernel metadata repair facility is not available. Use -n to scrub.")); return ECANCELED; } + if (debug_tweak_on("XFS_SCRUB_FORCE_REPAIR")) { + error = enable_force_repair(ctx); + if (error) + return error; + } + /* Did we find the log and rt devices, if they're present? */ if (ctx->mnt.fsgeom.logstart == 0 && ctx->fsinfo.fs_log == NULL) { str_error(ctx, ctx->mntpoint, diff --git a/scrub/scrub.c b/scrub/scrub.c index e83d0d9ce99..d899f75a92f 100644 --- a/scrub/scrub.c +++ b/scrub/scrub.c @@ -18,7 +18,6 @@ #include "common.h" #include "progress.h" #include "scrub.h" -#include "xfs_errortag.h" #include "repair.h" #include "descr.h" @@ -500,26 +499,16 @@ static bool __scrub_test( struct scrub_ctx *ctx, unsigned int type, - bool repair) + unsigned int flags) { struct xfs_scrub_metadata meta = {0}; - struct xfs_error_injection inject; - static bool injected; int error; if (debug_tweak_on("XFS_SCRUB_NO_KERNEL")) return false; - if (debug_tweak_on("XFS_SCRUB_FORCE_REPAIR") && !injected) { - inject.fd = ctx->mnt.fd; - inject.errtag = XFS_ERRTAG_FORCE_SCRUB_REPAIR; - error = ioctl(ctx->mnt.fd, XFS_IOC_ERROR_INJECTION, &inject); - if (error == 0) - injected = true; - } meta.sm_type = type; - if (repair) - meta.sm_flags |= XFS_SCRUB_IFLAG_REPAIR; + meta.sm_flags = flags; error = -xfrog_scrub_metadata(&ctx->mnt, &meta); switch (error) { case 0: @@ -532,13 +521,15 @@ _("Filesystem is mounted read-only; cannot proceed.")); str_info(ctx, ctx->mntpoint, _("Filesystem is mounted norecovery; cannot proceed.")); return false; + case EINVAL: case EOPNOTSUPP: case ENOTTY: if (debug || verbose) str_info(ctx, ctx->mntpoint, _("Kernel %s %s facility not detected."), _(xfrog_scrubbers[type].descr), - repair ? _("repair") : _("scrub")); + (flags & XFS_SCRUB_IFLAG_REPAIR) ? + _("repair") : _("scrub")); return false; case ENOENT: /* Scrubber says not present on this fs; that's fine. */ @@ -553,56 +544,64 @@ bool can_scrub_fs_metadata( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_PROBE, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_PROBE, 0); } bool can_scrub_inode( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_INODE, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_INODE, 0); } bool can_scrub_bmap( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_BMBTD, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_BMBTD, 0); } bool can_scrub_dir( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_DIR, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_DIR, 0); } bool can_scrub_attr( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_XATTR, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_XATTR, 0); } bool can_scrub_symlink( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_SYMLINK, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_SYMLINK, 0); } bool can_scrub_parent( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_PARENT, false); + return __scrub_test(ctx, XFS_SCRUB_TYPE_PARENT, 0); } bool xfs_can_repair( struct scrub_ctx *ctx) { - return __scrub_test(ctx, XFS_SCRUB_TYPE_PROBE, true); + return __scrub_test(ctx, XFS_SCRUB_TYPE_PROBE, XFS_SCRUB_IFLAG_REPAIR); +} + +bool +can_force_rebuild( + struct scrub_ctx *ctx) +{ + return __scrub_test(ctx, XFS_SCRUB_TYPE_PROBE, + XFS_SCRUB_IFLAG_REPAIR | XFS_SCRUB_IFLAG_FORCE_REBUILD); } /* General repair routines. */ @@ -624,6 +623,8 @@ xfs_repair_metadata( assert(!debug_tweak_on("XFS_SCRUB_NO_KERNEL")); meta.sm_type = aitem->type; meta.sm_flags = aitem->flags | XFS_SCRUB_IFLAG_REPAIR; + if (use_force_rebuild) + meta.sm_flags |= XFS_SCRUB_IFLAG_FORCE_REBUILD; switch (xfrog_scrubbers[aitem->type].type) { case XFROG_SCRUB_TYPE_AGHEADER: case XFROG_SCRUB_TYPE_PERAG: diff --git a/scrub/scrub.h b/scrub/scrub.h index fccd82f2155..023069ee066 100644 --- a/scrub/scrub.h +++ b/scrub/scrub.h @@ -33,6 +33,7 @@ bool can_scrub_attr(struct scrub_ctx *ctx); bool can_scrub_symlink(struct scrub_ctx *ctx); bool can_scrub_parent(struct scrub_ctx *ctx); bool xfs_can_repair(struct scrub_ctx *ctx); +bool can_force_rebuild(struct scrub_ctx *ctx); int scrub_file(struct scrub_ctx *ctx, int fd, const struct xfs_bulkstat *bstat, unsigned int type, struct action_list *alist); diff --git a/scrub/xfs_scrub.c b/scrub/xfs_scrub.c index 7a0411b0cc8..597be59f9f9 100644 --- a/scrub/xfs_scrub.c +++ b/scrub/xfs_scrub.c @@ -157,6 +157,9 @@ bool stdout_isatty; */ bool is_service; +/* Set to true if the kernel supports XFS_SCRUB_IFLAG_FORCE_REBUILD */ +bool use_force_rebuild; + #define SCRUB_RET_SUCCESS (0) /* no problems left behind */ #define SCRUB_RET_CORRUPT (1) /* corruption remains on fs */ #define SCRUB_RET_UNOPTIMIZED (2) /* fs could be optimized */ diff --git a/scrub/xfs_scrub.h b/scrub/xfs_scrub.h index f6712d368c6..0d6b9dad2c9 100644 --- a/scrub/xfs_scrub.h +++ b/scrub/xfs_scrub.h @@ -21,6 +21,7 @@ extern bool want_fstrim; extern bool stderr_isatty; extern bool stdout_isatty; extern bool is_service; +extern bool use_force_rebuild; enum scrub_mode { SCRUB_MODE_DRY_RUN,