libgfapi: introduce bit flags for pthread mutex and cond variables

At present stage, the initialization and destroy of conditional
and mutex variables of glfs struct happen in different places and
there is no uniform way of destroying these variables incase
there is a failure when initializing these. The fs mutex and
conditional variables are getting destroyed from glfs_free_from_ctx().
However this destroy is not done by a conditional check inside destroy
function. By introducing bit flags in glfs object, we can make use of the
same (if there is a failure in initialization) in glfs_fini()
which is evolving as one and only function to free fs and ctx resources.
This patch introduce the flags field and set the flags according
to the initialization flow of the mutex and conditional variables
of struct glfs members. Without this patch we are compelled to use
the goto lables and other hacks in init functions to make sure
the resources are freed if there is an error path.

Change-Id: I86e2719fb7ce437419a05699b4f06c14b02d0e69
BUG: 1208482
Signed-off-by: Humble Devassy Chirammal <hchiramm@redhat.com>
Signed-off-by: Poornima G <pgurusid@redhat.com>
Reviewed-on: http://review.gluster.org/10120
Reviewed-by: Niels de Vos <ndevos@redhat.com>
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Tested-by: NetBSD Build System
Reviewed-by: Shyamsundar Ranganathan <srangana@redhat.com>

1 files changed, 50 insertions, 73 deletions

diff --git a/api/src/glfs.c b/api/src/glfs.c
index 897d3eab80..5653f4d46c 100644
--- a/api/src/glfs.c
+++ b/api/src/glfs.c
@@ -581,12 +581,42 @@ glfs_poller (void *data)
 	return NULL;
 }
 
-/*
- * please note all the variable initializations done here probably
- * need to be added in 'glfs_new_from_ctx()' as well, so that,
- * we do not miss out while adding new members in 'fs'.
-*/
+static struct glfs *
+glfs_new_fs (const char *volname)
+{
+        struct glfs     *fs             = NULL;
+
+        fs = CALLOC (1, sizeof (*fs));
+        if (!fs)
+                return NULL;
+
+        INIT_LIST_HEAD (&fs->openfds);
+        INIT_LIST_HEAD (&fs->upcall_list);
+
+        PTHREAD_MUTEX_INIT (&fs->mutex, NULL, fs->pthread_flags,
+                            GLFS_INIT_MUTEX, err);
+
+        PTHREAD_COND_INIT (&fs->cond, NULL, fs->pthread_flags,
+                           GLFS_INIT_COND, err);
+
+        PTHREAD_COND_INIT (&fs->child_down_cond, NULL, fs->pthread_flags,
+                           GLFS_INIT_COND_CHILD, err);
+
+        PTHREAD_MUTEX_INIT (&fs->upcall_list_mutex, NULL, fs->pthread_flags,
+                            GLFS_INIT_MUTEX_UPCALL, err);
+
+        fs->volname = strdup (volname);
+        if (!fs->volname)
+                goto err;
+
+        fs->pin_refcnt = 0;
 
+        return fs;
+
+err:
+        glfs_free_from_ctx (fs);
+        return NULL;
+}
 
 struct glfs *
 pub_glfs_new (const char *volname)
@@ -601,26 +631,10 @@ pub_glfs_new (const char *volname)
                 return NULL;
         }
 
-        fs = CALLOC (1, sizeof (*fs));
+        fs = glfs_new_fs (volname);
         if (!fs)
                 return NULL;
 
-        ret = pthread_mutex_init (&fs->mutex, NULL);
-        if (ret != 0)
-                goto freefs;
-
-        ret = pthread_cond_init (&fs->cond, NULL);
-        if (ret != 0)
-                goto mutex_destroy;
-
-        ret = pthread_cond_init (&fs->child_down_cond, NULL);
-        if (ret != 0)
-                goto cond_destroy;
-
-        ret = pthread_mutex_init (&fs->upcall_list_mutex, NULL);
-        if (ret != 0)
-                goto cond_child_destroy;
-
         ctx = glusterfs_ctx_new ();
         if (!ctx)
                 goto fini;
@@ -654,39 +668,9 @@ pub_glfs_new (const char *volname)
         if (!(fs->ctx->cmd_args.volfile_id))
                 goto fini;
 
-        fs->volname = strdup (volname);
-        if (!fs->volname)
-                goto fini;
-
-        INIT_LIST_HEAD (&fs->openfds);
-        INIT_LIST_HEAD (&fs->upcall_list);
-
-        fs->pin_refcnt = 0;
-
         goto out;
 
-cond_child_destroy:
-        pthread_cond_destroy (&fs->child_down_cond);
-
-cond_destroy:
-        pthread_cond_destroy (&fs->cond);
-
-mutex_destroy:
-        pthread_mutex_destroy (&fs->mutex);
-
-freefs:
-        FREE (fs);
-        fs = NULL;
-        goto out;
 fini:
-        /*
-         * When pthread_*init() fails there is no way for other cleanup
-         * funtions (glfs_fini/glfs_free_from_ctx) to know which of them succeded
-         * and which did not(unless there is a flag). Hence pthread cleanup is done
-         * in this funtion.Anything that fails after pthread_*_init() succeeds, should
-         * directly call glfs_fini() to cleanup the resources.
-         */
-
          glfs_fini (fs);
          fs = NULL;
 out:
@@ -705,25 +689,15 @@ priv_glfs_new_from_ctx (glusterfs_ctx_t *ctx)
         struct glfs    *fs = NULL;
 
         if (!ctx)
-                return NULL;
+                goto out;
 
-        fs = CALLOC (1, sizeof (*fs));
+        fs = glfs_new_fs ("");
         if (!fs)
-                return NULL;
-        fs->ctx = ctx;
-
-        (void) pthread_cond_init (&fs->cond, NULL);
-        (void) pthread_cond_init (&fs->child_down_cond, NULL);
-
-        (void) pthread_mutex_init (&fs->mutex, NULL);
-
-        INIT_LIST_HEAD (&fs->openfds);
-
-        INIT_LIST_HEAD (&fs->upcall_list);
-        pthread_mutex_init (&fs->upcall_list_mutex, NULL);
+                goto out;
 
-        fs->pin_refcnt = 0;
+        fs->ctx = ctx;
 
+out:
         return fs;
 }
 
@@ -747,15 +721,18 @@ priv_glfs_free_from_ctx (struct glfs *fs)
                 GF_FREE (u_list->upcall_data.data);
                 GF_FREE (u_list);
         }
-        (void) pthread_mutex_destroy (&fs->upcall_list_mutex);
 
-        (void) pthread_cond_destroy (&fs->cond);
-        (void) pthread_cond_destroy (&fs->child_down_cond);
+        PTHREAD_MUTEX_DESTROY (&fs->mutex, fs->pthread_flags, GLFS_INIT_MUTEX);
+
+        PTHREAD_COND_DESTROY (&fs->cond, fs->pthread_flags, GLFS_INIT_COND);
+
+        PTHREAD_COND_DESTROY (&fs->child_down_cond, fs->pthread_flags,
+                              GLFS_INIT_COND_CHILD);
 
-        (void) pthread_mutex_destroy (&fs->mutex);
+        PTHREAD_MUTEX_DESTROY (&fs->upcall_list_mutex, fs->pthread_flags,
+                               GLFS_INIT_MUTEX_UPCALL);
 
-        if (fs->volname)
-                FREE (fs->volname);
+        FREE (fs->volname);
 
         FREE (fs);
 }