libfrog: fix per-thread variable error communication problems

Convert all the per-thread variable functions away from the libc-style
indirect errno return to return error values directly to callers.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
[sandeen: initialize ret in ptvar_foreach]
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/libfrog/ptvar.c b/libfrog/ptvar.c
index c9296835440405508cf668d10d60e62d28849709..b8e4d4f0e8bb1f89a8da9480b5050c75082a9a2b 100644 (file)
--- a/libfrog/ptvar.c
+++ b/libfrog/ptvar.c
@@ -33,11 +33,12 @@ struct ptvar {
 };
 #define PTVAR_SIZE(nr, sz) (sizeof(struct ptvar) + ((nr) * (size)))
 
-/* Initialize per-thread counter. */
-struct ptvar *
-ptvar_init(
+/* Allocate a new per-thread counter. */
+int
+ptvar_alloc(
        size_t          nr,
-       size_t          size)
+       size_t          size,
+       struct ptvar    **pptv)
 {
        struct ptvar    *ptv;
        int             ret;
@@ -49,7 +50,7 @@ ptvar_init(
 
        ptv = malloc(PTVAR_SIZE(nr, size));
        if (!ptv)
-               return NULL;
+               return errno;
        ptv->data_size = size;
        ptv->nr_counters = nr;
        ptv->nr_used = 0;
@@ -60,13 +61,14 @@ ptvar_init(
        ret = pthread_key_create(&ptv->key, NULL);
        if (ret)
                goto out_mutex;
-       return ptv;
 
+       *pptv = ptv;
+       return 0;
 out_mutex:
        pthread_mutex_destroy(&ptv->lock);
 out:
        free(ptv);
-       return NULL;
+       return ret;
 }
 
 /* Free per-thread counter. */
@@ -82,7 +84,8 @@ ptvar_free(
 /* Get a reference to this thread's variable. */
 void *
 ptvar_get(
-       struct ptvar    *ptv)
+       struct ptvar    *ptv,
+       int             *retp)
 {
        void            *p;
 
@@ -94,23 +97,24 @@ ptvar_get(
                pthread_setspecific(ptv->key, p);
                pthread_mutex_unlock(&ptv->lock);
        }
+       *retp = 0;
        return p;
 }
 
 /* Iterate all of the per-thread variables. */
-bool
+int
 ptvar_foreach(
        struct ptvar    *ptv,
        ptvar_iter_fn   fn,
        void            *foreach_arg)
 {
        size_t          i;
-       bool            ret = true;
+       int             ret = 0;
 
        pthread_mutex_lock(&ptv->lock);
        for (i = 0; i < ptv->nr_used; i++) {
                ret = fn(ptv, &ptv->data[i * ptv->data_size], foreach_arg);
-               if (!ret)
+               if (ret)
                        break;
        }
        pthread_mutex_unlock(&ptv->lock);

diff --git a/libfrog/ptvar.h b/libfrog/ptvar.h
index a8803c64116370bc7e546ec67ab1001de18f6a40..42865c0b2fd3e3f6538e81094756064d3052376a 100644 (file)
--- a/libfrog/ptvar.h
+++ b/libfrog/ptvar.h
@@ -8,11 +8,11 @@
 
 struct ptvar;
 
-typedef bool (*ptvar_iter_fn)(struct ptvar *ptv, void *data, void *foreach_arg);
+typedef int (*ptvar_iter_fn)(struct ptvar *ptv, void *data, void *foreach_arg);
 
-struct ptvar *ptvar_init(size_t nr, size_t size);
+int ptvar_alloc(size_t nr, size_t size, struct ptvar **pptv);
 void ptvar_free(struct ptvar *ptv);
-void *ptvar_get(struct ptvar *ptv);
-bool ptvar_foreach(struct ptvar *ptv, ptvar_iter_fn fn, void *foreach_arg);
+void *ptvar_get(struct ptvar *ptv, int *ret);
+int ptvar_foreach(struct ptvar *ptv, ptvar_iter_fn fn, void *foreach_arg);
 
 #endif /* __LIBFROG_PTVAR_H__ */

diff --git a/scrub/counter.c b/scrub/counter.c
index 4344492763c13f02aeec81436af0a7a046f9d556..49ffbfea290210b95e0a276ee0f0a253ae680b0b 100644 (file)
--- a/scrub/counter.c
+++ b/scrub/counter.c
@@ -32,12 +32,13 @@ ptcounter_init(
        size_t                  nr)
 {
        struct ptcounter        *p;
+       int                     ret;
 
        p = malloc(sizeof(struct ptcounter));
        if (!p)
                return NULL;
-       p->var = ptvar_init(nr, sizeof(uint64_t));
-       if (!p->var) {
+       ret = ptvar_alloc(nr, sizeof(uint64_t), &p->var);
+       if (ret) {
                free(p);
                return NULL;
        }
@@ -60,12 +61,14 @@ ptcounter_add(
        int64_t                 nr)
 {
        uint64_t                *p;
+       int                     ret;
 
-       p = ptvar_get(ptc->var);
+       p = ptvar_get(ptc->var, &ret);
+       assert(ret == 0);
        *p += nr;
 }
 
-static bool
+static int
 ptcounter_val_helper(
        struct ptvar            *ptv,
        void                    *data,
@@ -75,7 +78,7 @@ ptcounter_val_helper(
        uint64_t                *count = data;
 
        *sum += *count;
-       return true;
+       return 0;
 }
 
 /* Return the approximate value of this counter. */

diff --git a/scrub/phase7.c b/scrub/phase7.c
index 308b8bb3072696c7428841ae61b94bfa17ec6a81..bc959f5b093da031a700ce9702b4c4c16e01a061 100644 (file)
--- a/scrub/phase7.c
+++ b/scrub/phase7.c
@@ -36,8 +36,13 @@ xfs_record_block_summary(
 {
        struct summary_counts   *counts;
        unsigned long long      len;
+       int                     ret;
 
-       counts = ptvar_get((struct ptvar *)arg);
+       counts = ptvar_get((struct ptvar *)arg, &ret);
+       if (ret) {
+               str_liberror(ctx, ret, _("retrieving summary counts"));
+               return false;
+       }
        if (fsmap->fmr_device == ctx->fsinfo.fs_logdev)
                return true;
        if ((fsmap->fmr_flags & FMR_OF_SPECIAL_OWNER) &&
@@ -68,7 +73,7 @@ xfs_record_block_summary(
 }
 
 /* Add all the summaries in the per-thread counter */
-static bool
+static int
 xfs_add_summaries(
        struct ptvar            *ptv,
        void                    *data,
@@ -80,7 +85,7 @@ xfs_add_summaries(
        total->dbytes += item->dbytes;
        total->rbytes += item->rbytes;
        total->agbytes += item->agbytes;
-       return true;
+       return 0;
 }
 
 /*
@@ -131,9 +136,10 @@ xfs_scan_summary(
                return false;
        }
 
-       ptvar = ptvar_init(scrub_nproc(ctx), sizeof(struct summary_counts));
-       if (!ptvar) {
-               str_errno(ctx, ctx->mntpoint);
+       error = ptvar_alloc(scrub_nproc(ctx), sizeof(struct summary_counts),
+                       &ptvar);
+       if (error) {
+               str_liberror(ctx, error, _("setting up block counter"));
                return false;
        }
 
@@ -141,9 +147,11 @@ xfs_scan_summary(
        moveon = xfs_scan_all_spacemaps(ctx, xfs_record_block_summary, ptvar);
        if (!moveon)
                goto out_free;
-       moveon = ptvar_foreach(ptvar, xfs_add_summaries, &totalcount);
-       if (!moveon)
+       error = ptvar_foreach(ptvar, xfs_add_summaries, &totalcount);
+       if (error) {
+               str_liberror(ctx, error, _("counting blocks"));
                goto out_free;
+       }
        ptvar_free(ptvar);
 
        /* Scan the whole fs. */

diff --git a/scrub/read_verify.c b/scrub/read_verify.c
index e59d3e670c52c93376d03eabdc20bcf53cfe0a3a..95987a9bab3f45be4ceda3d41eb590df58ece792 100644 (file)
--- a/scrub/read_verify.c
+++ b/scrub/read_verify.c
@@ -91,9 +91,9 @@ read_verify_pool_init(
        rvp->ctx = ctx;
        rvp->disk = disk;
        rvp->ioerr_fn = ioerr_fn;
-       rvp->rvstate = ptvar_init(submitter_threads,
-                       sizeof(struct read_verify));
-       if (rvp->rvstate == NULL)
+       error = ptvar_alloc(submitter_threads, sizeof(struct read_verify),
+                       &rvp->rvstate);
+       if (error)
                goto out_counter;
        /* Run in the main thread if we only want one thread. */
        if (nproc == 1)
@@ -220,9 +220,12 @@ read_verify_schedule_io(
        struct read_verify              *rv;
        uint64_t                        req_end;
        uint64_t                        rv_end;
+       int                             ret;
 
        assert(rvp->readbuf);
-       rv = ptvar_get(rvp->rvstate);
+       rv = ptvar_get(rvp->rvstate, &ret);
+       if (ret)
+               return false;
        req_end = start + length;
        rv_end = rv->io_start + rv->io_length;
 
@@ -259,9 +262,12 @@ read_verify_force_io(
 {
        struct read_verify              *rv;
        bool                            moveon;
+       int                             ret;
 
        assert(rvp->readbuf);
-       rv = ptvar_get(rvp->rvstate);
+       rv = ptvar_get(rvp->rvstate, &ret);
+       if (ret)
+               return false;
        if (rv->io_length == 0)
                return true;