*/
/*
- * Did we get exactly the inodes we expected? If not, load them one at a
- * time (or fake it) into the bulkstat data.
+ * Run bulkstat on an entire inode allocation group, then check that we got
+ * exactly the inodes we expected. If not, load them one at a time (or fake
+ * it) into the bulkstat data.
*/
static void
-xfs_iterate_inodes_range_check(
+bulkstat_for_inumbers(
struct scrub_ctx *ctx,
- struct xfs_inumbers *inumbers,
- struct xfs_bulkstat *bstat)
+ const char *descr,
+ const struct xfs_inumbers *inumbers,
+ struct xfs_bulkstat_req *breq)
{
+ struct xfs_bulkstat *bstat = breq->bulkstat;
struct xfs_bulkstat *bs;
int i;
int error;
+ /* First we try regular bulkstat, for speed. */
+ breq->hdr.ino = inumbers->xi_startino;
+ breq->hdr.icount = inumbers->xi_alloccount;
+ error = -xfrog_bulkstat(&ctx->mnt, breq);
+ if (error) {
+ char errbuf[DESCR_BUFSZ];
+
+ str_info(ctx, descr, "%s",
+ strerror_r(error, errbuf, DESCR_BUFSZ));
+ }
+
+ /*
+ * Check each of the stats we got back to make sure we got the inodes
+ * we asked for.
+ */
for (i = 0, bs = bstat; i < XFS_INODES_PER_CHUNK; i++) {
if (!(inumbers->xi_allocmask & (1ULL << i)))
continue;
}
/* Load the one inode. */
- error = xfrog_bulkstat_single(&ctx->mnt,
+ error = -xfrog_bulkstat_single(&ctx->mnt,
inumbers->xi_startino + i, 0, bs);
if (error || bs->bs_ino != inumbers->xi_startino + i) {
memset(bs, 0, sizeof(struct xfs_bulkstat));
}
}
+/* BULKSTAT wrapper routines. */
+struct scan_inodes {
+ scrub_inode_iter_fn fn;
+ void *arg;
+ bool aborted;
+};
+
/*
* Call into the filesystem for inode/bulkstat information and call our
* iterator function. We'll try to fill the bulkstat information in batches,
* but we also can detect iget failures.
*/
-static bool
-xfs_iterate_inodes_range(
- struct scrub_ctx *ctx,
- const char *descr,
- void *fshandle,
- uint64_t first_ino,
- uint64_t last_ino,
- xfs_inode_iter_fn fn,
+static void
+scan_ag_inodes(
+ struct workqueue *wq,
+ xfs_agnumber_t agno,
void *arg)
{
struct xfs_handle handle;
+ char descr[DESCR_BUFSZ];
struct xfs_inumbers_req *ireq;
struct xfs_bulkstat_req *breq;
- char idescr[DESCR_BUFSZ];
+ struct scan_inodes *si = arg;
+ struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx;
struct xfs_bulkstat *bs;
struct xfs_inumbers *inumbers;
- bool moveon = true;
int i;
int error;
int stale_count = 0;
- memcpy(&handle.ha_fsid, fshandle, sizeof(handle.ha_fsid));
+ snprintf(descr, DESCR_BUFSZ, _("dev %d:%d AG %u inodes"),
+ major(ctx->fsinfo.fs_datadev),
+ minor(ctx->fsinfo.fs_datadev),
+ agno);
+
+ memcpy(&handle.ha_fsid, ctx->fshandle, sizeof(handle.ha_fsid));
handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
sizeof(handle.ha_fid.fid_len);
handle.ha_fid.fid_pad = 0;
- breq = xfrog_bulkstat_alloc_req(XFS_INODES_PER_CHUNK, 0);
- if (!breq) {
- str_info(ctx, descr, _("Insufficient memory; giving up."));
- return false;
+ error = -xfrog_bulkstat_alloc_req(XFS_INODES_PER_CHUNK, 0, &breq);
+ if (error) {
+ str_liberror(ctx, error, descr);
+ si->aborted = true;
+ return;
}
- ireq = xfrog_inumbers_alloc_req(1, first_ino);
- if (!ireq) {
- str_info(ctx, descr, _("Insufficient memory; giving up."));
+ error = -xfrog_inumbers_alloc_req(1, 0, &ireq);
+ if (error) {
+ str_liberror(ctx, error, descr);
free(breq);
- return false;
+ si->aborted = true;
+ return;
}
inumbers = &ireq->inumbers[0];
+ xfrog_inumbers_set_ag(ireq, agno);
/* Find the inode chunk & alloc mask */
- error = xfrog_inumbers(&ctx->mnt, ireq);
- while (!error && ireq->hdr.ocount > 0) {
+ error = -xfrog_inumbers(&ctx->mnt, ireq);
+ while (!error && !si->aborted && ireq->hdr.ocount > 0) {
/*
* We can have totally empty inode chunks on filesystems where
* there are more than 64 inodes per block. Skip these.
if (inumbers->xi_alloccount == 0)
goto igrp_retry;
- breq->hdr.ino = inumbers->xi_startino;
- breq->hdr.icount = inumbers->xi_alloccount;
- error = xfrog_bulkstat(&ctx->mnt, breq);
- if (error) {
- char errbuf[DESCR_BUFSZ];
-
- str_info(ctx, descr, "%s", strerror_r(error,
- errbuf, DESCR_BUFSZ));
- }
-
- xfs_iterate_inodes_range_check(ctx, inumbers, breq->bulkstat);
+ bulkstat_for_inumbers(ctx, descr, inumbers, breq);
/* Iterate all the inodes. */
for (i = 0, bs = breq->bulkstat;
- i < inumbers->xi_alloccount;
+ !si->aborted && i < inumbers->xi_alloccount;
i++, bs++) {
- if (bs->bs_ino > last_ino)
- goto out;
-
handle.ha_fid.fid_ino = bs->bs_ino;
handle.ha_fid.fid_gen = bs->bs_gen;
- error = fn(ctx, &handle, bs, arg);
+ error = si->fn(ctx, &handle, bs, si->arg);
switch (error) {
case 0:
break;
- case ESTALE:
+ case ESTALE: {
+ char idescr[DESCR_BUFSZ];
+
stale_count++;
if (stale_count < 30) {
ireq->hdr.ino = inumbers->xi_startino;
goto igrp_retry;
}
- snprintf(idescr, DESCR_BUFSZ, "inode %"PRIu64,
- (uint64_t)bs->bs_ino);
+ scrub_render_ino_descr(ctx, idescr, DESCR_BUFSZ,
+ bs->bs_ino, bs->bs_gen, NULL);
str_info(ctx, idescr,
_("Changed too many times during scan; giving up."));
break;
- case XFS_ITERATE_INODES_ABORT:
+ }
+ case ECANCELED:
error = 0;
/* fall thru */
default:
- moveon = false;
- errno = error;
goto err;
}
if (xfs_scrub_excessive_errors(ctx)) {
- moveon = false;
+ si->aborted = true;
goto out;
}
}
stale_count = 0;
igrp_retry:
- error = xfrog_inumbers(&ctx->mnt, ireq);
+ error = -xfrog_inumbers(&ctx->mnt, ireq);
}
err:
if (error) {
str_liberror(ctx, error, descr);
- moveon = false;
+ si->aborted = true;
}
out:
free(ireq);
free(breq);
- return moveon;
-}
-
-/* BULKSTAT wrapper routines. */
-struct xfs_scan_inodes {
- xfs_inode_iter_fn fn;
- void *arg;
- bool moveon;
-};
-
-/* Scan all the inodes in an AG. */
-static void
-xfs_scan_ag_inodes(
- struct workqueue *wq,
- xfs_agnumber_t agno,
- void *arg)
-{
- struct xfs_scan_inodes *si = arg;
- struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx;
- char descr[DESCR_BUFSZ];
- uint64_t ag_ino;
- uint64_t next_ag_ino;
- bool moveon;
-
- snprintf(descr, DESCR_BUFSZ, _("dev %d:%d AG %u inodes"),
- major(ctx->fsinfo.fs_datadev),
- minor(ctx->fsinfo.fs_datadev),
- agno);
-
- ag_ino = cvt_agino_to_ino(&ctx->mnt, agno, 0);
- next_ag_ino = cvt_agino_to_ino(&ctx->mnt, agno + 1, 0);
-
- moveon = xfs_iterate_inodes_range(ctx, descr, ctx->fshandle, ag_ino,
- next_ag_ino - 1, si->fn, si->arg);
- if (!moveon)
- si->moveon = false;
}
-/* Scan all the inodes in a filesystem. */
-bool
-xfs_scan_all_inodes(
+/*
+ * Scan all the inodes in a filesystem. On error, this function will log
+ * an error message and return -1.
+ */
+int
+scrub_scan_all_inodes(
struct scrub_ctx *ctx,
- xfs_inode_iter_fn fn,
+ scrub_inode_iter_fn fn,
void *arg)
{
- struct xfs_scan_inodes si;
+ struct scan_inodes si = {
+ .fn = fn,
+ .arg = arg,
+ };
xfs_agnumber_t agno;
struct workqueue wq;
int ret;
- si.moveon = true;
- si.fn = fn;
- si.arg = arg;
-
- ret = workqueue_create(&wq, (struct xfs_mount *)ctx,
+ ret = -workqueue_create(&wq, (struct xfs_mount *)ctx,
scrub_nproc_workqueue(ctx));
if (ret) {
- str_info(ctx, ctx->mntpoint, _("Could not create workqueue."));
- return false;
+ str_liberror(ctx, ret, _("creating bulkstat workqueue"));
+ return -1;
}
for (agno = 0; agno < ctx->mnt.fsgeom.agcount; agno++) {
- ret = workqueue_add(&wq, xfs_scan_ag_inodes, agno, &si);
+ ret = -workqueue_add(&wq, scan_ag_inodes, agno, &si);
if (ret) {
- si.moveon = false;
- str_info(ctx, ctx->mntpoint,
-_("Could not queue AG %u bulkstat work."), agno);
+ si.aborted = true;
+ str_liberror(ctx, ret, _("queueing bulkstat work"));
break;
}
}
+ ret = -workqueue_terminate(&wq);
+ if (ret) {
+ si.aborted = true;
+ str_liberror(ctx, ret, _("finishing bulkstat work"));
+ }
workqueue_destroy(&wq);
- return si.moveon;
+ return si.aborted ? -1 : 0;
}
-/*
- * Open a file by handle, or return a negative error code.
- */
+/* Open a file by handle, returning either the fd or -1 on error. */
int
-xfs_open_handle(
+scrub_open_handle(
struct xfs_handle *handle)
{
return open_by_fshandle(handle, sizeof(*handle),
projects / thirdparty / xfsprogs-dev.git / blobdiff