From 7a2eef2b2cede76f4e8c02776c28af37a01f799c Mon Sep 17 00:00:00 2001 From: "Darrick J. Wong" Date: Wed, 6 Nov 2019 17:28:45 -0500 Subject: [PATCH] xfs_scrub: remove moveon from spacemap Replace the moveon returns in the space map iteration code with a direct integer return. Signed-off-by: Darrick J. Wong Reviewed-by: Eric Sandeen Signed-off-by: Eric Sandeen --- scrub/phase6.c | 34 +++++------ scrub/phase7.c | 21 +++---- scrub/spacemap.c | 145 +++++++++++++++++++++++++---------------------- scrub/spacemap.h | 12 ++-- 4 files changed, 108 insertions(+), 104 deletions(-) diff --git a/scrub/phase6.c b/scrub/phase6.c index a0a71ce3b..626297328 100644 --- a/scrub/phase6.c +++ b/scrub/phase6.c @@ -374,10 +374,9 @@ out: } /* Use a fsmap to report metadata lost to a media error. */ -static bool +static int report_ioerr_fsmap( struct scrub_ctx *ctx, - const char *descr, struct fsmap *map, void *arg) { @@ -388,7 +387,7 @@ report_ioerr_fsmap( /* Don't care about unwritten extents. */ if (map->fmr_flags & FMR_OF_PREALLOC) - return true; + return 0; if (err_physical > map->fmr_physical) err_off = err_physical - map->fmr_physical; @@ -420,7 +419,7 @@ report_ioerr_fsmap( * to find the bad file's pathname. */ - return true; + return 0; } /* @@ -434,16 +433,11 @@ report_ioerr( void *arg) { struct fsmap keys[2]; - char descr[DESCR_BUFSZ]; struct disk_ioerr_report *dioerr = arg; dev_t dev; dev = xfs_disk_to_dev(dioerr->ctx, dioerr->disk); - snprintf(descr, DESCR_BUFSZ, -_("dev %d:%d ioerr @ %"PRIu64":%"PRIu64" "), - major(dev), minor(dev), start, length); - /* Go figure out which blocks are bad from the fsmap. */ memset(keys, 0, sizeof(struct fsmap) * 2); keys->fmr_device = dev; @@ -453,9 +447,8 @@ _("dev %d:%d ioerr @ %"PRIu64":%"PRIu64" "), (keys + 1)->fmr_owner = ULLONG_MAX; (keys + 1)->fmr_offset = ULLONG_MAX; (keys + 1)->fmr_flags = UINT_MAX; - xfs_iterate_fsmap(dioerr->ctx, descr, keys, report_ioerr_fsmap, + return scrub_iterate_fsmap(dioerr->ctx, keys, report_ioerr_fsmap, &start); - return 0; } /* Report all the media errors found on a disk. */ @@ -511,10 +504,9 @@ report_all_media_errors( } /* Schedule a read-verify of a (data block) extent. */ -static bool -xfs_check_rmap( +static int +check_rmap( struct scrub_ctx *ctx, - const char *descr, struct fsmap *map, void *arg) { @@ -544,7 +536,7 @@ xfs_check_rmap( */ if (map->fmr_flags & (FMR_OF_PREALLOC | FMR_OF_ATTR_FORK | FMR_OF_EXTENT_MAP | FMR_OF_SPECIAL_OWNER)) - return true; + return 0; /* XXX: Filter out directory data blocks. */ @@ -552,11 +544,11 @@ xfs_check_rmap( ret = read_verify_schedule_io(rvp, map->fmr_physical, map->fmr_length, vs); if (ret) { - str_liberror(ctx, ret, descr); - return false; + str_liberror(ctx, ret, _("scheduling media verify command")); + return ret; } - return true; + return 0; } /* Wait for read/verify actions to finish, then return # bytes checked. */ @@ -669,9 +661,11 @@ xfs_scan_blocks( goto out_logpool; } } - moveon = xfs_scan_all_spacemaps(ctx, xfs_check_rmap, &vs); - if (!moveon) + ret = scrub_scan_all_spacemaps(ctx, check_rmap, &vs); + if (ret) { + moveon = false; goto out_rtpool; + } ret = clean_pool(vs.rvp_data, &ctx->bytes_checked); if (ret) { diff --git a/scrub/phase7.c b/scrub/phase7.c index 6daf75b59..28689eac6 100644 --- a/scrub/phase7.c +++ b/scrub/phase7.c @@ -27,10 +27,9 @@ struct summary_counts { }; /* Record block usage. */ -static bool -xfs_record_block_summary( +static int +count_block_summary( struct scrub_ctx *ctx, - const char *descr, struct fsmap *fsmap, void *arg) { @@ -41,13 +40,13 @@ xfs_record_block_summary( counts = ptvar_get((struct ptvar *)arg, &ret); if (ret) { str_liberror(ctx, ret, _("retrieving summary counts")); - return false; + return ret; } if (fsmap->fmr_device == ctx->fsinfo.fs_logdev) - return true; + return 0; if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) && fsmap->fmr_owner == XFS_FMR_OWN_FREE) - return true; + return 0; len = fsmap->fmr_length; @@ -62,14 +61,14 @@ xfs_record_block_summary( } else { /* Count datadev extents. */ if (counts->next_phys >= fsmap->fmr_physical + len) - return true; + return 0; else if (counts->next_phys > fsmap->fmr_physical) len = counts->next_phys - fsmap->fmr_physical; counts->dbytes += len; counts->next_phys = fsmap->fmr_physical + fsmap->fmr_length; } - return true; + return 0; } /* Add all the summaries in the per-thread counter */ @@ -144,9 +143,11 @@ xfs_scan_summary( } /* Use fsmap to count blocks. */ - moveon = xfs_scan_all_spacemaps(ctx, xfs_record_block_summary, ptvar); - if (!moveon) + error = scrub_scan_all_spacemaps(ctx, count_block_summary, ptvar); + if (error) { + moveon = false; goto out_free; + } error = ptvar_foreach(ptvar, xfs_add_summaries, &totalcount); if (error) { str_liberror(ctx, error, _("counting blocks")); diff --git a/scrub/spacemap.c b/scrub/spacemap.c index 91e8badb7..e56f090d5 100644 --- a/scrub/spacemap.c +++ b/scrub/spacemap.c @@ -31,26 +31,25 @@ #define FSMAP_NR 65536 -/* Iterate all the fs block mappings between the two keys. */ -bool -xfs_iterate_fsmap( +/* + * Iterate all the fs block mappings between the two keys. Returns 0 or a + * positive error number. + */ +int +scrub_iterate_fsmap( struct scrub_ctx *ctx, - const char *descr, struct fsmap *keys, - xfs_fsmap_iter_fn fn, + scrub_fsmap_iter_fn fn, void *arg) { struct fsmap_head *head; struct fsmap *p; - bool moveon = true; int i; int error; head = malloc(fsmap_sizeof(FSMAP_NR)); - if (!head) { - str_errno(ctx, descr); - return false; - } + if (!head) + return errno; memset(head, 0, sizeof(*head)); memcpy(head->fmh_keys, keys, sizeof(struct fsmap) * 2); @@ -60,13 +59,11 @@ xfs_iterate_fsmap( for (i = 0, p = head->fmh_recs; i < head->fmh_entries; i++, p++) { - moveon = fn(ctx, descr, p, arg); - if (!moveon) + error = fn(ctx, p, arg); + if (error) goto out; - if (xfs_scrub_excessive_errors(ctx)) { - moveon = false; + if (xfs_scrub_excessive_errors(ctx)) goto out; - } } if (head->fmh_entries == 0) @@ -76,45 +73,36 @@ xfs_iterate_fsmap( break; fsmap_advance(head); } - - if (error) { - str_errno(ctx, descr); - moveon = false; - } + if (error) + error = errno; out: free(head); - return moveon; + return error; } /* GETFSMAP wrappers routines. */ -struct xfs_scan_blocks { - xfs_fsmap_iter_fn fn; +struct scan_blocks { + scrub_fsmap_iter_fn fn; void *arg; - bool moveon; + bool aborted; }; /* Iterate all the reverse mappings of an AG. */ static void -xfs_scan_ag_blocks( +scan_ag_rmaps( struct workqueue *wq, xfs_agnumber_t agno, void *arg) { struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx; - struct xfs_scan_blocks *sbx = arg; - char descr[DESCR_BUFSZ]; + struct scan_blocks *sbx = arg; struct fsmap keys[2]; off64_t bperag; - bool moveon; + int ret; bperag = (off64_t)ctx->mnt.fsgeom.agblocks * (off64_t)ctx->mnt.fsgeom.blocksize; - snprintf(descr, DESCR_BUFSZ, _("dev %d:%d AG %u fsmap"), - major(ctx->fsinfo.fs_datadev), - minor(ctx->fsinfo.fs_datadev), - agno); - memset(keys, 0, sizeof(struct fsmap) * 2); keys->fmr_device = ctx->fsinfo.fs_datadev; keys->fmr_physical = agno * bperag; @@ -124,25 +112,32 @@ xfs_scan_ag_blocks( (keys + 1)->fmr_offset = ULLONG_MAX; (keys + 1)->fmr_flags = UINT_MAX; - moveon = xfs_iterate_fsmap(ctx, descr, keys, sbx->fn, sbx->arg); - if (!moveon) - sbx->moveon = false; + if (sbx->aborted) + return; + + ret = scrub_iterate_fsmap(ctx, keys, sbx->fn, sbx->arg); + if (ret) { + char descr[DESCR_BUFSZ]; + + snprintf(descr, DESCR_BUFSZ, _("dev %d:%d AG %u fsmap"), + major(ctx->fsinfo.fs_datadev), + minor(ctx->fsinfo.fs_datadev), + agno); + str_liberror(ctx, ret, descr); + sbx->aborted = true; + } } /* Iterate all the reverse mappings of a standalone device. */ static void -xfs_scan_dev_blocks( +scan_dev_rmaps( struct scrub_ctx *ctx, int idx, dev_t dev, - struct xfs_scan_blocks *sbx) + struct scan_blocks *sbx) { struct fsmap keys[2]; - char descr[DESCR_BUFSZ]; - bool moveon; - - snprintf(descr, DESCR_BUFSZ, _("dev %d:%d fsmap"), - major(dev), minor(dev)); + int ret; memset(keys, 0, sizeof(struct fsmap) * 2); keys->fmr_device = dev; @@ -152,79 +147,90 @@ xfs_scan_dev_blocks( (keys + 1)->fmr_offset = ULLONG_MAX; (keys + 1)->fmr_flags = UINT_MAX; - moveon = xfs_iterate_fsmap(ctx, descr, keys, sbx->fn, sbx->arg); - if (!moveon) - sbx->moveon = false; + if (sbx->aborted) + return; + + ret = scrub_iterate_fsmap(ctx, keys, sbx->fn, sbx->arg); + if (ret) { + char descr[DESCR_BUFSZ]; + + snprintf(descr, DESCR_BUFSZ, _("dev %d:%d fsmap"), + major(dev), minor(dev)); + str_liberror(ctx, ret, descr); + sbx->aborted = true; + } } /* Iterate all the reverse mappings of the realtime device. */ static void -xfs_scan_rt_blocks( +scan_rt_rmaps( struct workqueue *wq, xfs_agnumber_t agno, void *arg) { struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx; - xfs_scan_dev_blocks(ctx, agno, ctx->fsinfo.fs_rtdev, arg); + scan_dev_rmaps(ctx, agno, ctx->fsinfo.fs_rtdev, arg); } /* Iterate all the reverse mappings of the log device. */ static void -xfs_scan_log_blocks( +scan_log_rmaps( struct workqueue *wq, xfs_agnumber_t agno, void *arg) { struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx; - xfs_scan_dev_blocks(ctx, agno, ctx->fsinfo.fs_logdev, arg); + scan_dev_rmaps(ctx, agno, ctx->fsinfo.fs_logdev, arg); } -/* Scan all the blocks in a filesystem. */ -bool -xfs_scan_all_spacemaps( +/* + * Scan all the blocks in a filesystem. If errors occur, this function will + * log them and return nonzero. + */ +int +scrub_scan_all_spacemaps( struct scrub_ctx *ctx, - xfs_fsmap_iter_fn fn, + scrub_fsmap_iter_fn fn, void *arg) { struct workqueue wq; - struct xfs_scan_blocks sbx; + struct scan_blocks sbx = { + .fn = fn, + .arg = arg, + }; xfs_agnumber_t agno; int ret; - sbx.moveon = true; - sbx.fn = fn; - sbx.arg = arg; - ret = workqueue_create(&wq, (struct xfs_mount *)ctx, scrub_nproc_workqueue(ctx)); if (ret) { str_liberror(ctx, ret, _("creating fsmap workqueue")); - return false; + return ret; } if (ctx->fsinfo.fs_rt) { - ret = workqueue_add(&wq, xfs_scan_rt_blocks, + ret = workqueue_add(&wq, scan_rt_rmaps, ctx->mnt.fsgeom.agcount + 1, &sbx); if (ret) { - sbx.moveon = false; + sbx.aborted = true; str_liberror(ctx, ret, _("queueing rtdev fsmap work")); goto out; } } if (ctx->fsinfo.fs_log) { - ret = workqueue_add(&wq, xfs_scan_log_blocks, + ret = workqueue_add(&wq, scan_log_rmaps, ctx->mnt.fsgeom.agcount + 2, &sbx); if (ret) { - sbx.moveon = false; + sbx.aborted = true; str_liberror(ctx, ret, _("queueing logdev fsmap work")); goto out; } } for (agno = 0; agno < ctx->mnt.fsgeom.agcount; agno++) { - ret = workqueue_add(&wq, xfs_scan_ag_blocks, agno, &sbx); + ret = workqueue_add(&wq, scan_ag_rmaps, agno, &sbx); if (ret) { - sbx.moveon = false; + sbx.aborted = true; str_liberror(ctx, ret, _("queueing per-AG fsmap work")); break; } @@ -232,10 +238,13 @@ xfs_scan_all_spacemaps( out: ret = workqueue_terminate(&wq); if (ret) { - sbx.moveon = false; + sbx.aborted = true; str_liberror(ctx, ret, _("finishing fsmap work")); } workqueue_destroy(&wq); - return sbx.moveon; + if (!ret && sbx.aborted) + ret = -1; + + return ret; } diff --git a/scrub/spacemap.h b/scrub/spacemap.h index c29c43a51..8a6d1e361 100644 --- a/scrub/spacemap.h +++ b/scrub/spacemap.h @@ -7,15 +7,15 @@ #define XFS_SCRUB_SPACEMAP_H_ /* - * Visit each space mapping in the filesystem. Return true to continue - * iteration or false to stop iterating and return to the caller. + * Visit each space mapping in the filesystem. Return 0 to continue iteration + * or a positive error code to stop iterating and return to the caller. */ -typedef bool (*xfs_fsmap_iter_fn)(struct scrub_ctx *ctx, const char *descr, +typedef int (*scrub_fsmap_iter_fn)(struct scrub_ctx *ctx, struct fsmap *fsr, void *arg); -bool xfs_iterate_fsmap(struct scrub_ctx *ctx, const char *descr, - struct fsmap *keys, xfs_fsmap_iter_fn fn, void *arg); -bool xfs_scan_all_spacemaps(struct scrub_ctx *ctx, xfs_fsmap_iter_fn fn, +int scrub_iterate_fsmap(struct scrub_ctx *ctx, struct fsmap *keys, + scrub_fsmap_iter_fn fn, void *arg); +int scrub_scan_all_spacemaps(struct scrub_ctx *ctx, scrub_fsmap_iter_fn fn, void *arg); #endif /* XFS_SCRUB_SPACEMAP_H_ */ -- 2.39.2