xfs_scrub: remove moveon from main program

Replace the moveon returns in xfs_scrub.c to e with a direct integer
error return.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/scrub/phase1.c b/scrub/phase1.c
index 75ae3b00625b3600ffdb55605f13d7b2058cfede..e0382b04501f9e0b6dbfb0182fcbb4dd7abf3807 100644 (file)
--- a/scrub/phase1.c
+++ b/scrub/phase1.c
@@ -206,10 +206,3 @@ _("Unable to find realtime device path."));
        ctx->scrub_setup_succeeded = true;
        return 0;
 }
-
-bool
-xfs_setup_fs(
-       struct scrub_ctx                *ctx)
-{
-       return phase1_func(ctx) == 0;
-}

diff --git a/scrub/phase2.c b/scrub/phase2.c
index 81b2b3dc5a8ccd9a853190f75849caca666fd3ed..45e0d7121afc9867544d71fadebb7e5e45e1d6b8 100644 (file)
--- a/scrub/phase2.c
+++ b/scrub/phase2.c
@@ -179,13 +179,6 @@ out:
        return ret;
 }
 
-bool
-xfs_scan_metadata(
-       struct scrub_ctx        *ctx)
-{
-       return phase2_func(ctx) == 0;
-}
-
 /* Estimate how much work we're going to do. */
 int
 phase2_estimate(
@@ -199,13 +192,3 @@ phase2_estimate(
        *rshift = 0;
        return 0;
 }
-
-bool
-xfs_estimate_metadata_work(
-       struct scrub_ctx        *ctx,
-       uint64_t                *items,
-       unsigned int            *nr_threads,
-       int                     *rshift)
-{
-       return phase2_estimate(ctx, items, nr_threads, rshift) == 0;
-}

diff --git a/scrub/phase3.c b/scrub/phase3.c
index eed8f46f5e52c3fece82f463242f5c6e3234f6b2..223f1caf83b0f018ce76172e84b8a6a7c600f4cc 100644 (file)
--- a/scrub/phase3.c
+++ b/scrub/phase3.c
@@ -194,13 +194,6 @@ free:
        return err;
 }
 
-bool
-xfs_scan_inodes(
-       struct scrub_ctx        *ctx)
-{
-       return phase3_func(ctx) == 0;
-}
-
 /* Estimate how much work we're going to do. */
 int
 phase3_estimate(
@@ -214,13 +207,3 @@ phase3_estimate(
        *rshift = 0;
        return 0;
 }
-
-bool
-xfs_estimate_inodes_work(
-       struct scrub_ctx        *ctx,
-       uint64_t                *items,
-       unsigned int            *nr_threads,
-       int                     *rshift)
-{
-       return phase3_estimate(ctx, items, nr_threads, rshift) == 0;
-}

diff --git a/scrub/phase4.c b/scrub/phase4.c
index f9dcf9c8376837054fac665a847de9af0f0a288a..1c1de906c1d804bc392a34063caf6a216136cdf3 100644 (file)
--- a/scrub/phase4.c
+++ b/scrub/phase4.c
@@ -126,13 +126,6 @@ phase4_func(
        return repair_everything(ctx);
 }
 
-bool
-xfs_repair_fs(
-       struct scrub_ctx        *ctx)
-{
-       return phase4_func(ctx) == 0;
-}
-
 /* Estimate how much work we're going to do. */
 int
 phase4_estimate(
@@ -152,13 +145,3 @@ phase4_estimate(
        *rshift = 0;
        return 0;
 }
-
-bool
-xfs_estimate_repair_work(
-       struct scrub_ctx        *ctx,
-       uint64_t                *items,
-       unsigned int            *nr_threads,
-       int                     *rshift)
-{
-       return phase4_estimate(ctx, items, nr_threads, rshift) == 0;
-}

diff --git a/scrub/phase5.c b/scrub/phase5.c
index 2641a7fb3656489b74198623c5e630b8df4ff920..540b840dc6287d5b8dafede8707f311792309ea3 100644 (file)
--- a/scrub/phase5.c
+++ b/scrub/phase5.c
@@ -406,9 +406,16 @@ _("Filesystem has errors, skipping connectivity checks."));
        return 0;
 }
 
-bool
-xfs_scan_connections(
-       struct scrub_ctx        *ctx)
+/* Estimate how much work we're going to do. */
+int
+phase5_estimate(
+       struct scrub_ctx        *ctx,
+       uint64_t                *items,
+       unsigned int            *nr_threads,
+       int                     *rshift)
 {
-       return phase5_func(ctx) == 0;
+       *items = ctx->mnt_sv.f_files - ctx->mnt_sv.f_ffree;
+       *nr_threads = scrub_nproc(ctx);
+       *rshift = 0;
+       return 0;
 }

diff --git a/scrub/phase6.c b/scrub/phase6.c
index 020b303dec4bbb9d4c1cc588f526db2e186f098d..88c719b3fd5f10ed36522e926bfad59a38da864d 100644 (file)
--- a/scrub/phase6.c
+++ b/scrub/phase6.c
@@ -707,13 +707,6 @@ out_dbad:
        return ret;
 }
 
-bool
-xfs_scan_blocks(
-       struct scrub_ctx                *ctx)
-{
-       return phase6_func(ctx) == 0;
-}
-
 /* Estimate how much work we're going to do. */
 int
 phase6_estimate(
@@ -743,13 +736,3 @@ phase6_estimate(
        *rshift = 20;
        return 0;
 }
-
-bool
-xfs_estimate_verify_work(
-       struct scrub_ctx        *ctx,
-       uint64_t                *items,
-       unsigned int            *nr_threads,
-       int                     *rshift)
-{
-       return phase6_estimate(ctx, items, nr_threads, rshift) == 0;
-}

diff --git a/scrub/phase7.c b/scrub/phase7.c
index 68912f036fa9a05670ac5f3e4e788da2fadc46bd..191f2e4f0c3eac5705222cf18bd81a86206b7cbf 100644 (file)
--- a/scrub/phase7.c
+++ b/scrub/phase7.c
@@ -270,10 +270,3 @@ out_free:
        ptvar_free(ptvar);
        return error;
 }
-
-bool
-xfs_scan_summary(
-       struct scrub_ctx        *ctx)
-{
-       return phase7_func(ctx) == 0;
-}

diff --git a/scrub/xfs_scrub.c b/scrub/xfs_scrub.c
index 5030a7faeecc15eddd408e350c5b06f641089908..a792768c5de559762c0606199a0c67313ce115b3 100644 (file)
--- a/scrub/xfs_scrub.c
+++ b/scrub/xfs_scrub.c
@@ -245,14 +245,14 @@ struct phase_rusage {
 #define REPAIR_DUMMY_FN                ((void *)2)
 struct phase_ops {
        char            *descr;
-       bool            (*fn)(struct scrub_ctx *);
-       bool            (*estimate_work)(struct scrub_ctx *, uint64_t *,
-                                        unsigned int *, int *);
+       int             (*fn)(struct scrub_ctx *ctx);
+       int             (*estimate_work)(struct scrub_ctx *ctx, uint64_t *items,
+                                        unsigned int *threads, int *rshift);
        bool            must_run;
 };
 
 /* Start tracking resource usage for a phase. */
-static bool
+static int
 phase_start(
        struct phase_rusage     *pi,
        unsigned int            phase,
@@ -264,14 +264,14 @@ phase_start(
        error = scrub_getrusage(&pi->ruse);
        if (error) {
                perror(_("getrusage"));
-               return false;
+               return error;
        }
        pi->brk_start = sbrk(0);
 
        error = gettimeofday(&pi->time, NULL);
        if (error) {
                perror(_("gettimeofday"));
-               return false;
+               return error;
        }
 
        pi->descr = descr;
@@ -279,11 +279,11 @@ phase_start(
                fprintf(stdout, _("Phase %u: %s\n"), phase, descr);
                fflush(stdout);
        }
-       return true;
+       return error;
 }
 
 /* Report usage stats. */
-static bool
+static int
 phase_end(
        struct phase_rusage     *pi,
        unsigned int            phase)
@@ -303,19 +303,19 @@ phase_end(
        int                     error;
 
        if (!display_rusage)
-               return true;
+               return 0;
 
        error = gettimeofday(&time_now, NULL);
        if (error) {
                perror(_("gettimeofday"));
-               return false;
+               return error;
        }
        dt = timeval_subtract(&time_now, &pi->time);
 
        error = scrub_getrusage(&ruse_now);
        if (error) {
                perror(_("getrusage"));
-               return false;
+               return error;
        }
 
        if (phase)
@@ -366,7 +366,7 @@ _("%sI/O rate: %.1f%s/s in, %.1f%s/s out, %.1f%s/s tot\n"),
        }
        fflush(stdout);
 
-       return true;
+       return 0;
 }
 
 /* Run all the phases of the scrubber. */
@@ -379,37 +379,37 @@ run_scrub_phases(
        {
                {
                        .descr = _("Find filesystem geometry."),
-                       .fn = xfs_setup_fs,
+                       .fn = phase1_func,
                        .must_run = true,
                },
                {
                        .descr = _("Check internal metadata."),
-                       .fn = xfs_scan_metadata,
-                       .estimate_work = xfs_estimate_metadata_work,
+                       .fn = phase2_func,
+                       .estimate_work = phase2_estimate,
                },
                {
                        .descr = _("Scan all inodes."),
-                       .fn = xfs_scan_inodes,
-                       .estimate_work = xfs_estimate_inodes_work,
+                       .fn = phase3_func,
+                       .estimate_work = phase3_estimate,
                },
                {
                        .descr = _("Defer filesystem repairs."),
                        .fn = REPAIR_DUMMY_FN,
-                       .estimate_work = xfs_estimate_repair_work,
+                       .estimate_work = phase4_estimate,
                },
                {
                        .descr = _("Check directory tree."),
-                       .fn = xfs_scan_connections,
-                       .estimate_work = xfs_estimate_inodes_work,
+                       .fn = phase5_func,
+                       .estimate_work = phase5_estimate,
                },
                {
                        .descr = _("Verify data file integrity."),
                        .fn = DATASCAN_DUMMY_FN,
-                       .estimate_work = xfs_estimate_verify_work,
+                       .estimate_work = phase6_estimate,
                },
                {
                        .descr = _("Check summary counters."),
-                       .fn = xfs_scan_summary,
+                       .fn = phase7_func,
                        .must_run = true,
                },
                {
@@ -419,7 +419,6 @@ run_scrub_phases(
        struct phase_rusage     pi;
        struct phase_ops        *sp;
        uint64_t                max_work;
-       bool                    moveon = true;
        unsigned int            debug_phase = 0;
        unsigned int            phase;
        int                     rshift;
@@ -432,11 +431,11 @@ run_scrub_phases(
        for (phase = 1, sp = phases; sp->fn; sp++, phase++) {
                /* Turn on certain phases if user said to. */
                if (sp->fn == DATASCAN_DUMMY_FN && scrub_data) {
-                       sp->fn = xfs_scan_blocks;
+                       sp->fn = phase6_func;
                } else if (sp->fn == REPAIR_DUMMY_FN &&
                           ctx->mode == SCRUB_MODE_REPAIR) {
                        sp->descr = _("Repair filesystem.");
-                       sp->fn = xfs_repair_fs;
+                       sp->fn = phase4_func;
                        sp->must_run = true;
                }
 
@@ -450,15 +449,15 @@ run_scrub_phases(
                        continue;
 
                /* Run this phase. */
-               moveon = phase_start(&pi, phase, sp->descr);
-               if (!moveon)
+               ret = phase_start(&pi, phase, sp->descr);
+               if (ret)
                        break;
                if (sp->estimate_work) {
                        unsigned int            work_threads;
 
-                       moveon = sp->estimate_work(ctx, &max_work,
+                       ret = sp->estimate_work(ctx, &max_work,
                                        &work_threads, &rshift);
-                       if (!moveon)
+                       if (ret)
                                break;
 
                        /*
@@ -469,23 +468,19 @@ run_scrub_phases(
                        work_threads++;
                        ret = progress_init_phase(ctx, progress_fp, phase,
                                        max_work, rshift, work_threads);
-                       if (ret) {
-                               moveon = false;
+                       if (ret)
                                break;
-                       }
-                       moveon = descr_init_phase(ctx, work_threads) == 0;
+                       ret = descr_init_phase(ctx, work_threads);
                } else {
                        ret = progress_init_phase(ctx, NULL, phase, 0, 0, 0);
-                       if (ret) {
-                               moveon = false;
+                       if (ret)
                                break;
-                       }
-                       moveon = descr_init_phase(ctx, 1) == 0;
+                       ret = descr_init_phase(ctx, 1);
                }
-               if (!moveon)
+               if (ret)
                        break;
-               moveon = sp->fn(ctx);
-               if (!moveon) {
+               ret = sp->fn(ctx);
+               if (ret) {
                        str_info(ctx, ctx->mntpoint,
 _("Scrub aborted after phase %d."),
                                        phase);
@@ -493,17 +488,18 @@ _("Scrub aborted after phase %d."),
                }
                progress_end_phase();
                descr_end_phase();
-               moveon = phase_end(&pi, phase);
-               if (!moveon)
+               ret = phase_end(&pi, phase);
+               if (ret)
                        break;
 
                /* Too many errors? */
-               moveon = !xfs_scrub_excessive_errors(ctx);
-               if (!moveon)
+               if (xfs_scrub_excessive_errors(ctx)) {
+                       ret = ECANCELED;
                        break;
+               }
        }
 
-       return moveon;
+       return ret;
 }
 
 static void
@@ -596,7 +592,6 @@ main(
        char                    *mtab = NULL;
        FILE                    *progress_fp = NULL;
        struct fs_path          *fsp;
-       bool                    moveon = true;
        int                     c;
        int                     fd;
        int                     ret = SCRUB_RET_SUCCESS;
@@ -711,8 +706,8 @@ main(
                is_service = true;
 
        /* Initialize overall phase stats. */
-       moveon = phase_start(&all_pi, 0, NULL);
-       if (!moveon)
+       error = phase_start(&all_pi, 0, NULL);
+       if (error)
                return SCRUB_RET_OPERROR;
 
        /* Find the mount record for the passed-in argument. */
@@ -759,8 +754,8 @@ main(
                ctx.mode = SCRUB_MODE_REPAIR;
 
        /* Scrub a filesystem. */
-       moveon = run_scrub_phases(&ctx, progress_fp);
-       if (!moveon && ctx.runtime_errors == 0)
+       error = run_scrub_phases(&ctx, progress_fp);
+       if (error && ctx.runtime_errors == 0)
                ctx.runtime_errors++;
 
        /*

diff --git a/scrub/xfs_scrub.h b/scrub/xfs_scrub.h
index 1068341600d0a0b64d98342e36941b0b224b557a..f6712d368c6b4117818f250c2a5a372b836bb30b 100644 (file)
--- a/scrub/xfs_scrub.h
+++ b/scrub/xfs_scrub.h
@@ -88,24 +88,25 @@ struct scrub_ctx {
 /* Phase helper functions */
 void xfs_shutdown_fs(struct scrub_ctx *ctx);
 int scrub_cleanup(struct scrub_ctx *ctx);
-bool xfs_setup_fs(struct scrub_ctx *ctx);
-bool xfs_scan_metadata(struct scrub_ctx *ctx);
-bool xfs_scan_inodes(struct scrub_ctx *ctx);
-bool xfs_scan_connections(struct scrub_ctx *ctx);
-bool xfs_scan_blocks(struct scrub_ctx *ctx);
-bool xfs_scan_summary(struct scrub_ctx *ctx);
-bool xfs_repair_fs(struct scrub_ctx *ctx);
+int phase1_func(struct scrub_ctx *ctx);
+int phase2_func(struct scrub_ctx *ctx);
+int phase3_func(struct scrub_ctx *ctx);
+int phase4_func(struct scrub_ctx *ctx);
+int phase5_func(struct scrub_ctx *ctx);
+int phase6_func(struct scrub_ctx *ctx);
+int phase7_func(struct scrub_ctx *ctx);
 
 /* Progress estimator functions */
-uint64_t xfs_estimate_inodes(struct scrub_ctx *ctx);
 unsigned int scrub_estimate_ag_work(struct scrub_ctx *ctx);
-bool xfs_estimate_metadata_work(struct scrub_ctx *ctx, uint64_t *items,
-                               unsigned int *nr_threads, int *rshift);
-bool xfs_estimate_inodes_work(struct scrub_ctx *ctx, uint64_t *items,
-                             unsigned int *nr_threads, int *rshift);
-bool xfs_estimate_repair_work(struct scrub_ctx *ctx, uint64_t *items,
-                             unsigned int *nr_threads, int *rshift);
-bool xfs_estimate_verify_work(struct scrub_ctx *ctx, uint64_t *items,
-                             unsigned int *nr_threads, int *rshift);
+int phase2_estimate(struct scrub_ctx *ctx, uint64_t *items,
+                   unsigned int *nr_threads, int *rshift);
+int phase3_estimate(struct scrub_ctx *ctx, uint64_t *items,
+                   unsigned int *nr_threads, int *rshift);
+int phase4_estimate(struct scrub_ctx *ctx, uint64_t *items,
+                   unsigned int *nr_threads, int *rshift);
+int phase5_estimate(struct scrub_ctx *ctx, uint64_t *items,
+                   unsigned int *nr_threads, int *rshift);
+int phase6_estimate(struct scrub_ctx *ctx, uint64_t *items,
+                   unsigned int *nr_threads, int *rshift);
 
 #endif /* XFS_SCRUB_XFS_SCRUB_H_ */