Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

1 files changed, 3190 insertions, 3236 deletions

diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c
index f3d7def64d0..f0d8aff999f 100644
--- a/xlators/nfs/server/src/mount3.c
+++ b/xlators/nfs/server/src/mount3.c
@@ -36,119 +36,121 @@
 #include <sys/socket.h>
 #include <sys/uio.h>
 
-
 /* This macro will assist in freeing up entire link list
  * of host_auth_spec structure.
  */
-#define FREE_HOSTSPEC(exp) do {                                 \
-                struct host_auth_spec *host= exp->hostspec;     \
-                while (NULL != host){                           \
-                        struct host_auth_spec* temp = host;     \
-                        host = host->next;                      \
-                        if (NULL != temp->host_addr) {          \
-                                GF_FREE (temp->host_addr);      \
-                        }                                       \
-                        GF_FREE (temp);                         \
-                }                                               \
-                exp->hostspec = NULL;                           \
-        } while (0)
+#define FREE_HOSTSPEC(exp)                                                     \
+    do {                                                                       \
+        struct host_auth_spec *host = exp->hostspec;                           \
+        while (NULL != host) {                                                 \
+            struct host_auth_spec *temp = host;                                \
+            host = host->next;                                                 \
+            if (NULL != temp->host_addr) {                                     \
+                GF_FREE(temp->host_addr);                                      \
+            }                                                                  \
+            GF_FREE(temp);                                                     \
+        }                                                                      \
+        exp->hostspec = NULL;                                                  \
+    } while (0)
 
 /* Paths for export and netgroup files */
-const char *exports_file_path   = GLUSTERD_DEFAULT_WORKDIR "/nfs/exports";
+const char *exports_file_path = GLUSTERD_DEFAULT_WORKDIR "/nfs/exports";
 const char *netgroups_file_path = GLUSTERD_DEFAULT_WORKDIR "/nfs/netgroups";
 
-typedef ssize_t (*mnt3_serializer) (struct iovec outmsg, void *args);
+typedef ssize_t (*mnt3_serializer)(struct iovec outmsg, void *args);
 
 extern void *
-mount3udp_thread (void *argv);
+mount3udp_thread(void *argv);
 
 static void
-mnt3_export_free (struct mnt3_export *exp)
+mnt3_export_free(struct mnt3_export *exp)
 {
-        if (!exp)
-                return;
-
-        if (exp->exptype == MNT3_EXPTYPE_DIR)
-                FREE_HOSTSPEC (exp);
-        GF_FREE (exp->expname);
-        GF_FREE (exp->fullpath);
-        GF_FREE (exp);
+    if (!exp)
+        return;
+
+    if (exp->exptype == MNT3_EXPTYPE_DIR)
+        FREE_HOSTSPEC(exp);
+    GF_FREE(exp->expname);
+    GF_FREE(exp->fullpath);
+    GF_FREE(exp);
 }
 
 /* Generic reply function for MOUNTv3 specific replies. */
 int
-mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc)
+mnt3svc_submit_reply(rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc)
 {
-        struct iovec            outmsg  = {0, };
-        struct iobuf            *iob    = NULL;
-        struct mount3_state     *ms     = NULL;
-        int                     ret     = -1;
-        ssize_t                 msglen  = 0;
-        struct iobref           *iobref = NULL;
-
-        if (!req)
-                return -1;
-
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found");
-                goto ret;
-        }
-
-        /* First, get the io buffer into which the reply in arg will
-         * be serialized.
-         */
-        /* TODO: use 'xdrproc_t' instead of 'sfunc' to get the xdr-size */
-        iob = iobuf_get (ms->iobpool);
-        if (!iob) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobuf");
-                goto ret;
-        }
-
-        iobuf_to_iovec (iob, &outmsg);
-        /* Use the given serializer to translate the give C structure in arg
-         * to XDR format which will be written into the buffer in outmsg.
-         */
-        msglen = sfunc (outmsg, arg);
-        if (msglen < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_MSG_FAIL,
-                        "Failed to encode message");
-                goto ret;
-        }
-        outmsg.iov_len = msglen;
-
-        iobref = iobref_new ();
-        if (iobref == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobref");
-                goto ret;
-        }
-
-        ret = iobref_add (iobref, iob);
-        if (ret) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to add iob to iobref");
-                goto ret;
-        }
-
-        /* Then, submit the message for transmission. */
-        ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref);
-        if (ret == -1) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
-                        "Reply submission failed");
-                goto ret;
-        }
+    struct iovec outmsg = {
+        0,
+    };
+    struct iobuf *iob = NULL;
+    struct mount3_state *ms = NULL;
+    int ret = -1;
+    ssize_t msglen = 0;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        return -1;
 
-        ret = 0;
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "mount state not found");
+        goto ret;
+    }
+
+    /* First, get the io buffer into which the reply in arg will
+     * be serialized.
+     */
+    /* TODO: use 'xdrproc_t' instead of 'sfunc' to get the xdr-size */
+    iob = iobuf_get(ms->iobpool);
+    if (!iob) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobuf");
+        goto ret;
+    }
+
+    iobuf_to_iovec(iob, &outmsg);
+    /* Use the given serializer to translate the give C structure in arg
+     * to XDR format which will be written into the buffer in outmsg.
+     */
+    msglen = sfunc(outmsg, arg);
+    if (msglen < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_MSG_FAIL,
+               "Failed to encode message");
+        goto ret;
+    }
+    outmsg.iov_len = msglen;
+
+    iobref = iobref_new();
+    if (iobref == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobref");
+        goto ret;
+    }
+
+    ret = iobref_add(iobref, iob);
+    if (ret) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to add iob to iobref");
+        goto ret;
+    }
+
+    /* Then, submit the message for transmission. */
+    ret = rpcsvc_submit_message(req, &outmsg, 1, NULL, 0, iobref);
+    if (ret == -1) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
+               "Reply submission failed");
+        goto ret;
+    }
+
+    ret = 0;
 ret:
-        if (NULL != iob)
-                iobuf_unref (iob);
-        if (NULL != iobref)
-                iobref_unref (iobref);
+    if (NULL != iob)
+        iobuf_unref(iob);
+    if (NULL != iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 /**
  * __mountdict_insert -- Insert a mount entry into the mount state
@@ -159,39 +161,38 @@ ret:
  * Not for external use.
  */
 void
-__mountdict_insert (struct mount3_state *ms, struct mountentry *me)
+__mountdict_insert(struct mount3_state *ms, struct mountentry *me)
 {
-        char   *exname = NULL;
-        char   *fpath  = NULL;
-        data_t *medata = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_MNT, ms, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT, me, out);
-
-        /* We don't want export names with leading slashes */
-        exname = me->exname;
-        while (exname[0] == '/')
-                exname++;
-
-        /* Get the fullpath for the export */
-        fpath = me->fullpath;
-        if (me->has_full_path) {
-                while (fpath[0] == '/')
-                        fpath++;
-
-                /* Export names can either be just volumes or paths inside that
-                 * volume. */
-                exname = fpath;
-        }
-
-        snprintf (me->hashkey, sizeof (me->hashkey), "%s:%s", exname,
-                  me->hostname);
-
-        medata = bin_to_data (me, sizeof (*me));
-        dict_set (ms->mountdict, me->hashkey, medata);
-        gf_msg_trace (GF_MNT, 0, "Inserted into mountdict: %s", me->hashkey);
+    char *exname = NULL;
+    char *fpath = NULL;
+    data_t *medata = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_MNT, ms, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT, me, out);
+
+    /* We don't want export names with leading slashes */
+    exname = me->exname;
+    while (exname[0] == '/')
+        exname++;
+
+    /* Get the fullpath for the export */
+    fpath = me->fullpath;
+    if (me->has_full_path) {
+        while (fpath[0] == '/')
+            fpath++;
+
+        /* Export names can either be just volumes or paths inside that
+         * volume. */
+        exname = fpath;
+    }
+
+    snprintf(me->hashkey, sizeof(me->hashkey), "%s:%s", exname, me->hostname);
+
+    medata = bin_to_data(me, sizeof(*me));
+    dict_set(ms->mountdict, me->hashkey, medata);
+    gf_msg_trace(GF_MNT, 0, "Inserted into mountdict: %s", me->hashkey);
 out:
-        return;
+    return;
 }
 
 /**
@@ -203,91 +204,90 @@ out:
  * Not for external use.
  */
 void
-__mountdict_remove (struct mount3_state *ms, struct mountentry *me)
+__mountdict_remove(struct mount3_state *ms, struct mountentry *me)
 {
-        dict_del (ms->mountdict, me->hashkey);
+    dict_del(ms->mountdict, me->hashkey);
 }
 
 /* Generic error reply function, just pass the err status
  * and it will do the rest, including transmission.
  */
 int
-mnt3svc_mnt_error_reply (rpcsvc_request_t *req, int mntstat)
+mnt3svc_mnt_error_reply(rpcsvc_request_t *req, int mntstat)
 {
-        mountres3       res;
+    mountres3 res;
 
-        if (!req)
-                return -1;
+    if (!req)
+        return -1;
 
-        res.fhs_status = mntstat;
-        mnt3svc_submit_reply (req, (void *)&res,
-                              (mnt3_serializer)xdr_serialize_mountres3);
+    res.fhs_status = mntstat;
+    mnt3svc_submit_reply(req, (void *)&res,
+                         (mnt3_serializer)xdr_serialize_mountres3);
 
-        return 0;
+    return 0;
 }
 
-
 mountstat3
-mnt3svc_errno_to_mnterr (int32_t errnum)
+mnt3svc_errno_to_mnterr(int32_t errnum)
 {
-        mountstat3      stat;
-
-        switch (errnum) {
-
-                case 0:
-                        stat = MNT3_OK;
-                        break;
-                case ENOENT:
-                        stat = MNT3ERR_NOENT;
-                        break;
-                case EPERM:
-                        stat = MNT3ERR_PERM;
-                        break;
-                case EIO:
-                        stat = MNT3ERR_IO;
-                        break;
-                case EACCES:
-                        stat = MNT3ERR_ACCES;
-                        break;
-                case ENOTDIR:
-                        stat = MNT3ERR_NOTDIR;
-                        break;
-                case EINVAL:
-                        stat = MNT3ERR_INVAL;
-                        break;
-                case ENOSYS:
-                        stat = MNT3ERR_NOTSUPP;
-                        break;
-                case ENOMEM:
-                        stat = MNT3ERR_SERVERFAULT;
-                        break;
-                default:
-                        stat = MNT3ERR_SERVERFAULT;
-                        break;
-        }
+    mountstat3 stat;
+
+    switch (errnum) {
+        case 0:
+            stat = MNT3_OK;
+            break;
+        case ENOENT:
+            stat = MNT3ERR_NOENT;
+            break;
+        case EPERM:
+            stat = MNT3ERR_PERM;
+            break;
+        case EIO:
+            stat = MNT3ERR_IO;
+            break;
+        case EACCES:
+            stat = MNT3ERR_ACCES;
+            break;
+        case ENOTDIR:
+            stat = MNT3ERR_NOTDIR;
+            break;
+        case EINVAL:
+            stat = MNT3ERR_INVAL;
+            break;
+        case ENOSYS:
+            stat = MNT3ERR_NOTSUPP;
+            break;
+        case ENOMEM:
+            stat = MNT3ERR_SERVERFAULT;
+            break;
+        default:
+            stat = MNT3ERR_SERVERFAULT;
+            break;
+    }
 
-        return stat;
+    return stat;
 }
 
-
 mountres3
-mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, int *authflavor,
-                       u_int aflen)
+mnt3svc_set_mountres3(mountstat3 stat, struct nfs3_fh *fh, int *authflavor,
+                      u_int aflen)
 {
-        mountres3       res = {0, };
-        uint32_t        fhlen = 0;
+    mountres3 res = {
+        0,
+    };
+    uint32_t fhlen = 0;
 
-        res.fhs_status = stat;
+    res.fhs_status = stat;
 
-        if (fh)
-                fhlen = nfs3_fh_compute_size ();
+    if (fh)
+        fhlen = nfs3_fh_compute_size();
 
-        res.mountres3_u.mountinfo.fhandle.fhandle3_len = fhlen;
-        res.mountres3_u.mountinfo.fhandle.fhandle3_val = (char *)fh;
-        res.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = authflavor;
-        res.mountres3_u.mountinfo.auth_flavors.auth_flavors_len = aflen;
+    res.mountres3_u.mountinfo.fhandle.fhandle3_len = fhlen;
+    res.mountres3_u.mountinfo.fhandle.fhandle3_val = (char *)fh;
+    res.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = authflavor;
+    res.mountres3_u.mountinfo.auth_flavors.auth_flavors_len = aflen;
 
-        return res;
+    return res;
 }
 
 /* Read the rmtab from the store_handle and append (or not) the entries to the
@@ -296,81 +296,82 @@ mnt3svc_set_mountres3 (mountstat3 stat, struct nfs3_fh *fh, int *authflavor,
  * Requires the store_handle to be locked.
  */
 static int
-__mount_read_rmtab (gf_store_handle_t *sh, struct list_head *mountlist,
-                    gf_boolean_t append)
+__mount_read_rmtab(gf_store_handle_t *sh, struct list_head *mountlist,
+                   gf_boolean_t append)
 {
-        int                     ret = 0;
-        unsigned int            idx = 0;
-        struct mountentry       *me = NULL, *tmp = NULL;
-                                /* me->hostname is a char[MNTPATHLEN] */
-        char                    key[MNTPATHLEN + 11];
-
-        GF_ASSERT (sh && mountlist);
-
-        if (!gf_store_locked_local (sh)) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_READ_LOCKED,
-                        "Not reading unlocked %s", sh->path);
-                return -1;
-        }
+    int ret = 0;
+    unsigned int idx = 0;
+    struct mountentry *me = NULL, *tmp = NULL;
+    /* me->hostname is a char[MNTPATHLEN] */
+    char key[MNTPATHLEN + 11];
 
-        if (!append) {
-                list_for_each_entry_safe (me, tmp, mountlist, mlist) {
-                        list_del (&me->mlist);
-                        GF_FREE (me);
-                }
-                me = NULL;
-        }
+    GF_ASSERT(sh && mountlist);
 
-        for (;;) {
-                char *value = NULL;
-
-                if (me && append) {
-                        /* do not add duplicates */
-                        list_for_each_entry (tmp, mountlist, mlist) {
-                                if (!strcmp(tmp->hostname, me->hostname) &&
-                                    !strcmp(tmp->exname, me->exname)) {
-                                        GF_FREE (me);
-                                        goto dont_add;
-                                }
-                        }
-                        list_add_tail (&me->mlist, mountlist);
-                } else if (me) {
-                        list_add_tail (&me->mlist, mountlist);
-                }
+    if (!gf_store_locked_local(sh)) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_READ_LOCKED,
+               "Not reading unlocked %s", sh->path);
+        return -1;
+    }
 
-dont_add:
-                me = GF_CALLOC (1, sizeof (*me), gf_nfs_mt_mountentry);
-                if (!me) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Out of memory");
-                        ret = -1;
-                        goto out;
+    if (!append) {
+        list_for_each_entry_safe(me, tmp, mountlist, mlist)
+        {
+            list_del(&me->mlist);
+            GF_FREE(me);
+        }
+        me = NULL;
+    }
+
+    for (;;) {
+        char *value = NULL;
+
+        if (me && append) {
+            /* do not add duplicates */
+            list_for_each_entry(tmp, mountlist, mlist)
+            {
+                if (!strcmp(tmp->hostname, me->hostname) &&
+                    !strcmp(tmp->exname, me->exname)) {
+                    GF_FREE(me);
+                    goto dont_add;
                 }
-
-                INIT_LIST_HEAD (&me->mlist);
-
-                snprintf (key, 9 + MNTPATHLEN, "hostname-%d", idx);
-                ret = gf_store_retrieve_value (sh, key, &value);
-                if (ret)
-                        break;
-                snprintf (me->hostname, MNTPATHLEN, "%s", value);
-                GF_FREE (value);
-
-                snprintf (key, 11 + MNTPATHLEN, "mountpoint-%d", idx);
-                ret = gf_store_retrieve_value (sh, key, &value);
-                if (ret)
-                        break;
-                snprintf (me->exname, MNTPATHLEN, "%s", value);
-                GF_FREE (value);
-
-                idx++;
-                gf_msg_trace (GF_MNT, 0, "Read entries %s:%s",
-                              me->hostname, me->exname);
-        }
-        gf_msg_debug (GF_MNT, 0, "Read %d entries from '%s'", idx, sh->path);
-        GF_FREE (me);
+            }
+            list_add_tail(&me->mlist, mountlist);
+        } else if (me) {
+            list_add_tail(&me->mlist, mountlist);
+        }
+
+    dont_add:
+        me = GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry);
+        if (!me) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Out of memory");
+            ret = -1;
+            goto out;
+        }
+
+        INIT_LIST_HEAD(&me->mlist);
+
+        snprintf(key, 9 + MNTPATHLEN, "hostname-%d", idx);
+        ret = gf_store_retrieve_value(sh, key, &value);
+        if (ret)
+            break;
+        snprintf(me->hostname, MNTPATHLEN, "%s", value);
+        GF_FREE(value);
+
+        snprintf(key, 11 + MNTPATHLEN, "mountpoint-%d", idx);
+        ret = gf_store_retrieve_value(sh, key, &value);
+        if (ret)
+            break;
+        snprintf(me->exname, MNTPATHLEN, "%s", value);
+        GF_FREE(value);
+
+        idx++;
+        gf_msg_trace(GF_MNT, 0, "Read entries %s:%s", me->hostname, me->exname);
+    }
+    gf_msg_debug(GF_MNT, 0, "Read %d entries from '%s'", idx, sh->path);
+    GF_FREE(me);
 out:
-        return ret;
+    return ret;
 }
 
 /* Overwrite the contents of the rwtab with the in-memory client list.
@@ -379,98 +380,97 @@ out:
 static void
 __mount_rewrite_rmtab(struct mount3_state *ms, gf_store_handle_t *sh)
 {
-        struct mountentry       *me = NULL;
-        char                    key[16];
-        int                     fd, ret;
-        unsigned int            idx = 0;
-
-        if (!gf_store_locked_local (sh)) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_MODIFY_LOCKED,
-                        "Not modifying unlocked %s", sh->path);
-                return;
-        }
+    struct mountentry *me = NULL;
+    char key[16];
+    int fd, ret;
+    unsigned int idx = 0;
+
+    if (!gf_store_locked_local(sh)) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_MODIFY_LOCKED,
+               "Not modifying unlocked %s", sh->path);
+        return;
+    }
 
-        fd = gf_store_mkstemp (sh);
-        if (fd == -1) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Failed to open %s", sh->path);
-                return;
-        }
+    fd = gf_store_mkstemp(sh);
+    if (fd == -1) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Failed to open %s", sh->path);
+        return;
+    }
 
-        list_for_each_entry (me, &ms->mountlist, mlist) {
-                snprintf (key, 16, "hostname-%d", idx);
-                ret = gf_store_save_value (fd, key, me->hostname);
-                if (ret)
-                        goto fail;
+    list_for_each_entry(me, &ms->mountlist, mlist)
+    {
+        snprintf(key, 16, "hostname-%d", idx);
+        ret = gf_store_save_value(fd, key, me->hostname);
+        if (ret)
+            goto fail;
 
-                snprintf (key, 16, "mountpoint-%d", idx);
-                ret = gf_store_save_value (fd, key, me->exname);
-                if (ret)
-                        goto fail;
+        snprintf(key, 16, "mountpoint-%d", idx);
+        ret = gf_store_save_value(fd, key, me->exname);
+        if (ret)
+            goto fail;
 
-                idx++;
-        }
+        idx++;
+    }
 
-        gf_msg_debug (GF_MNT, 0, "Updated rmtab with %d entries", idx);
+    gf_msg_debug(GF_MNT, 0, "Updated rmtab with %d entries", idx);
 
-        if (gf_store_rename_tmppath (sh))
-                gf_msg (GF_MNT, GF_LOG_ERROR, errno,
-                        NFS_MSG_RWTAB_OVERWRITE_FAIL,
-                        "Failed to overwrite rwtab %s", sh->path);
+    if (gf_store_rename_tmppath(sh))
+        gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_RWTAB_OVERWRITE_FAIL,
+               "Failed to overwrite rwtab %s", sh->path);
 
-        return;
+    return;
 
 fail:
-        gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_UPDATE_FAIL,
-                "Failed to update %s", sh->path);
-        gf_store_unlink_tmppath (sh);
+    gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_UPDATE_FAIL,
+           "Failed to update %s", sh->path);
+    gf_store_unlink_tmppath(sh);
 }
 
 static gf_boolean_t
-mount_open_rmtab (const char *rmtab, gf_store_handle_t **sh)
+mount_open_rmtab(const char *rmtab, gf_store_handle_t **sh)
 {
-        int ret = -1;
+    int ret = -1;
 
-        /* updating the rmtab is disabled, use in-memory only */
-        if (!rmtab || rmtab[0] == '\0')
-                return _gf_false;
+    /* updating the rmtab is disabled, use in-memory only */
+    if (!rmtab || rmtab[0] == '\0')
+        return _gf_false;
 
-        ret = gf_store_handle_new (rmtab, sh);
-        if (ret) {
-                gf_log (GF_MNT, GF_LOG_WARNING, "Failed to open '%s'", rmtab);
-                return _gf_false;
-        }
+    ret = gf_store_handle_new(rmtab, sh);
+    if (ret) {
+        gf_log(GF_MNT, GF_LOG_WARNING, "Failed to open '%s'", rmtab);
+        return _gf_false;
+    }
 
-        return _gf_true;
+    return _gf_true;
 }
 
-
 /* Read the rmtab into a clean ms->mountlist.
  */
 static void
-mount_read_rmtab (struct mount3_state *ms)
+mount_read_rmtab(struct mount3_state *ms)
 {
-        gf_store_handle_t       *sh = NULL;
-        struct nfs_state        *nfs = NULL;
-        gf_boolean_t            read_rmtab = _gf_false;
+    gf_store_handle_t *sh = NULL;
+    struct nfs_state *nfs = NULL;
+    gf_boolean_t read_rmtab = _gf_false;
 
-        nfs = (struct nfs_state *)ms->nfsx->private;
+    nfs = (struct nfs_state *)ms->nfsx->private;
 
-        read_rmtab = mount_open_rmtab (nfs->rmtab, &sh);
-        if (!read_rmtab)
-                return;
+    read_rmtab = mount_open_rmtab(nfs->rmtab, &sh);
+    if (!read_rmtab)
+        return;
 
-        if (gf_store_lock (sh)) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL,
-                        "Failed to lock '%s'", nfs->rmtab);
-                goto out;
-        }
+    if (gf_store_lock(sh)) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL,
+               "Failed to lock '%s'", nfs->rmtab);
+        goto out;
+    }
 
-        __mount_read_rmtab (sh, &ms->mountlist, _gf_false);
-        gf_store_unlock (sh);
+    __mount_read_rmtab(sh, &ms->mountlist, _gf_false);
+    gf_store_unlock(sh);
 
 out:
-        gf_store_handle_destroy (sh);
+    gf_store_handle_destroy(sh);
 }
 
 /* Write the ms->mountlist to the rmtab.
@@ -491,77 +491,75 @@ out:
  * 9. releases the store_handle lock of the old rmtab
  */
 void
-mount_rewrite_rmtab (struct mount3_state *ms, char *new_rmtab)
+mount_rewrite_rmtab(struct mount3_state *ms, char *new_rmtab)
 {
-        gf_store_handle_t       *sh = NULL, *nsh = NULL;
-        struct nfs_state        *nfs = NULL;
-        int                     ret;
-        char                    *rmtab = NULL;
-        gf_boolean_t            got_old_rmtab = _gf_false;
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-
-        got_old_rmtab = mount_open_rmtab (nfs->rmtab, &sh);
-        if (!got_old_rmtab && !new_rmtab)
-                return;
-
-        if (got_old_rmtab && gf_store_lock (sh)) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR,
-                        "Not rewriting '%s'", nfs->rmtab);
-                goto free_sh;
-        }
+    gf_store_handle_t *sh = NULL, *nsh = NULL;
+    struct nfs_state *nfs = NULL;
+    int ret;
+    char *rmtab = NULL;
+    gf_boolean_t got_old_rmtab = _gf_false;
 
-        if (new_rmtab) {
-                ret = gf_store_handle_new (new_rmtab, &nsh);
-                if (ret) {
-                        gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_OPEN_FAIL,
-                                "Failed to open '%s'", new_rmtab);
-                        goto unlock_sh;
-                }
+    nfs = (struct nfs_state *)ms->nfsx->private;
 
-                if (gf_store_lock (nsh)) {
-                        gf_msg (GF_MNT, GF_LOG_WARNING, 0,
-                                NFS_MSG_REWRITE_ERROR,
-                                "Not rewriting '%s'", new_rmtab);
-                        goto free_nsh;
-                }
+    got_old_rmtab = mount_open_rmtab(nfs->rmtab, &sh);
+    if (!got_old_rmtab && !new_rmtab)
+        return;
+
+    if (got_old_rmtab && gf_store_lock(sh)) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR,
+               "Not rewriting '%s'", nfs->rmtab);
+        goto free_sh;
+    }
+
+    if (new_rmtab) {
+        ret = gf_store_handle_new(new_rmtab, &nsh);
+        if (ret) {
+            gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_OPEN_FAIL,
+                   "Failed to open '%s'", new_rmtab);
+            goto unlock_sh;
         }
 
-        /* always read the currently used rmtab */
-        if (got_old_rmtab)
-                __mount_read_rmtab (sh, &ms->mountlist, _gf_true);
-
-        if (new_rmtab) {
-                /* read the new rmtab and write changes to the new location */
-                __mount_read_rmtab (nsh, &ms->mountlist, _gf_true);
-                __mount_rewrite_rmtab (ms, nsh);
-
-                /* replace the nfs->rmtab reference to the new rmtab */
-                rmtab = gf_strdup(new_rmtab);
-                if (rmtab == NULL) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_NO_MEMORY,
-                                "Out of memory, keeping %s as rmtab",
-                                nfs->rmtab);
-                } else {
-                        GF_FREE (nfs->rmtab);
-                        nfs->rmtab = rmtab;
-                }
+        if (gf_store_lock(nsh)) {
+            gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR,
+                   "Not rewriting '%s'", new_rmtab);
+            goto free_nsh;
+        }
+    }
+
+    /* always read the currently used rmtab */
+    if (got_old_rmtab)
+        __mount_read_rmtab(sh, &ms->mountlist, _gf_true);
+
+    if (new_rmtab) {
+        /* read the new rmtab and write changes to the new location */
+        __mount_read_rmtab(nsh, &ms->mountlist, _gf_true);
+        __mount_rewrite_rmtab(ms, nsh);
 
-                gf_store_unlock (nsh);
+        /* replace the nfs->rmtab reference to the new rmtab */
+        rmtab = gf_strdup(new_rmtab);
+        if (rmtab == NULL) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_NO_MEMORY,
+                   "Out of memory, keeping %s as rmtab", nfs->rmtab);
         } else {
-                /* rewrite the current (unchanged location) rmtab */
-                __mount_rewrite_rmtab (ms, sh);
+            GF_FREE(nfs->rmtab);
+            nfs->rmtab = rmtab;
         }
 
+        gf_store_unlock(nsh);
+    } else {
+        /* rewrite the current (unchanged location) rmtab */
+        __mount_rewrite_rmtab(ms, sh);
+    }
+
 free_nsh:
-        if (new_rmtab)
-                gf_store_handle_destroy (nsh);
+    if (new_rmtab)
+        gf_store_handle_destroy(nsh);
 unlock_sh:
-        if (got_old_rmtab)
-                gf_store_unlock (sh);
+    if (got_old_rmtab)
+        gf_store_unlock(sh);
 free_sh:
-        if (got_old_rmtab)
-                gf_store_handle_destroy (sh);
+    if (got_old_rmtab)
+        gf_store_handle_destroy(sh);
 }
 
 /* Add a new NFS-client to the ms->mountlist and update the rmtab if we can.
@@ -576,374 +574,375 @@ free_sh:
  * common issue for all(?) NFS-servers.
  */
 int
-mnt3svc_update_mountlist (struct mount3_state *ms, rpcsvc_request_t *req,
-                          const char *expname, const char *fullpath)
+mnt3svc_update_mountlist(struct mount3_state *ms, rpcsvc_request_t *req,
+                         const char *expname, const char *fullpath)
 {
-        struct mountentry       *me = NULL;
-        struct mountentry       *cur = NULL;
-        int                     ret = -1;
-        char                    *colon = NULL;
-        struct nfs_state        *nfs = NULL;
-        gf_store_handle_t       *sh = NULL;
-        gf_boolean_t            update_rmtab = _gf_false;
-
-        if ((!ms) || (!req) || (!expname))
-                return -1;
-
-        me = (struct mountentry *)GF_CALLOC (1, sizeof (*me),
-                                             gf_nfs_mt_mountentry);
-        if (!me)
-                return -1;
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-
-        update_rmtab = mount_open_rmtab (nfs->rmtab, &sh);
+    struct mountentry *me = NULL;
+    struct mountentry *cur = NULL;
+    int ret = -1;
+    char *colon = NULL;
+    struct nfs_state *nfs = NULL;
+    gf_store_handle_t *sh = NULL;
+    gf_boolean_t update_rmtab = _gf_false;
+
+    if ((!ms) || (!req) || (!expname))
+        return -1;
 
-        snprintf (me->exname, MNTPATHLEN, "%s", expname);
-        /* Sometimes we don't care about the full path
-         * so a NULL value for fullpath is valid.
-         */
-        if (fullpath) {
-                if (strlen (fullpath) < MNTPATHLEN) {
-                        strcpy (me->fullpath, fullpath);
-                        me->has_full_path = _gf_true;
-                }
-        }
+    me = (struct mountentry *)GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry);
+    if (!me)
+        return -1;
 
+    nfs = (struct nfs_state *)ms->nfsx->private;
 
-        INIT_LIST_HEAD (&me->mlist);
-        /* Must get the IP or hostname of the client so we
-         * can map it into the mount entry.
-         */
-        ret = rpcsvc_transport_peername (req->trans, me->hostname, MNTPATHLEN);
-        if (ret == -1)
-                goto free_err;
+    update_rmtab = mount_open_rmtab(nfs->rmtab, &sh);
 
-        colon = strrchr (me->hostname, ':');
-        if (colon) {
-                *colon = '\0';
+    snprintf(me->exname, MNTPATHLEN, "%s", expname);
+    /* Sometimes we don't care about the full path
+     * so a NULL value for fullpath is valid.
+     */
+    if (fullpath) {
+        if (strlen(fullpath) < MNTPATHLEN) {
+            strcpy(me->fullpath, fullpath);
+            me->has_full_path = _gf_true;
         }
-        LOCK (&ms->mountlock);
-        {
-                /* in case locking fails, we just don't write the rmtab */
-                if (update_rmtab && gf_store_lock (sh)) {
-                        gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL,
-                                "Failed to lock '%s', changes will not be "
-                                "written", nfs->rmtab);
-                } else if (update_rmtab) {
-                        __mount_read_rmtab (sh, &ms->mountlist, _gf_false);
-                }
+    }
 
-                /* do not add duplicates */
-                list_for_each_entry (cur, &ms->mountlist, mlist) {
-                        if (!strcmp(cur->hostname, me->hostname) &&
-                            !strcmp(cur->exname, me->exname)) {
-                                GF_FREE (me);
-                                goto dont_add;
-                        }
-                }
-                list_add_tail (&me->mlist, &ms->mountlist);
-                __mountdict_insert (ms, me);
+    INIT_LIST_HEAD(&me->mlist);
+    /* Must get the IP or hostname of the client so we
+     * can map it into the mount entry.
+     */
+    ret = rpcsvc_transport_peername(req->trans, me->hostname, MNTPATHLEN);
+    if (ret == -1)
+        goto free_err;
 
-                /* only write the rmtab in case it was locked */
-                if (update_rmtab && gf_store_locked_local (sh))
-                        __mount_rewrite_rmtab (ms, sh);
-        }
+    colon = strrchr(me->hostname, ':');
+    if (colon) {
+        *colon = '\0';
+    }
+    LOCK(&ms->mountlock);
+    {
+        /* in case locking fails, we just don't write the rmtab */
+        if (update_rmtab && gf_store_lock(sh)) {
+            gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL,
+                   "Failed to lock '%s', changes will not be "
+                   "written",
+                   nfs->rmtab);
+        } else if (update_rmtab) {
+            __mount_read_rmtab(sh, &ms->mountlist, _gf_false);
+        }
+
+        /* do not add duplicates */
+        list_for_each_entry(cur, &ms->mountlist, mlist)
+        {
+            if (!strcmp(cur->hostname, me->hostname) &&
+                !strcmp(cur->exname, me->exname)) {
+                GF_FREE(me);
+                goto dont_add;
+            }
+        }
+        list_add_tail(&me->mlist, &ms->mountlist);
+        __mountdict_insert(ms, me);
+
+        /* only write the rmtab in case it was locked */
+        if (update_rmtab && gf_store_locked_local(sh))
+            __mount_rewrite_rmtab(ms, sh);
+    }
 dont_add:
-        if (update_rmtab && gf_store_locked_local (sh))
-                gf_store_unlock (sh);
+    if (update_rmtab && gf_store_locked_local(sh))
+        gf_store_unlock(sh);
 
-        UNLOCK (&ms->mountlock);
+    UNLOCK(&ms->mountlock);
 
 free_err:
-        if (update_rmtab)
-                gf_store_handle_destroy (sh);
+    if (update_rmtab)
+        gf_store_handle_destroy(sh);
 
-        if (ret == -1)
-                GF_FREE (me);
+    if (ret == -1)
+        GF_FREE(me);
 
-        return ret;
+    return ret;
 }
 
-
 int
-__mnt3_get_volume_id (struct mount3_state *ms, xlator_t *mntxl,
-                      uuid_t volumeid)
+__mnt3_get_volume_id(struct mount3_state *ms, xlator_t *mntxl, uuid_t volumeid)
 {
-        int                     ret = -1;
-        struct mnt3_export      *exp = NULL;
-
-        if ((!ms) || (!mntxl))
-                return ret;
-
-        LOCK (&ms->mountlock);
-        list_for_each_entry (exp, &ms->exportlist, explist) {
-                if (exp->vol == mntxl) {
-                        gf_uuid_copy (volumeid, exp->volumeid);
-                        ret = 0;
-                        goto out;
-                }
+    int ret = -1;
+    struct mnt3_export *exp = NULL;
+
+    if ((!ms) || (!mntxl))
+        return ret;
+
+    LOCK(&ms->mountlock);
+    list_for_each_entry(exp, &ms->exportlist, explist)
+    {
+        if (exp->vol == mntxl) {
+            gf_uuid_copy(volumeid, exp->volumeid);
+            ret = 0;
+            goto out;
         }
+    }
 
 out:
-        UNLOCK (&ms->mountlock);
-        return ret;
+    UNLOCK(&ms->mountlock);
+    return ret;
 }
 
 int
-__mnt3_build_mountid_from_path (const char *path, uuid_t mountid)
+__mnt3_build_mountid_from_path(const char *path, uuid_t mountid)
 {
-        uint32_t hashed_path = 0;
-        int      ret = -1;
+    uint32_t hashed_path = 0;
+    int ret = -1;
 
-        if (!path)
-                goto out;
+    if (!path)
+        goto out;
 
-        while (strlen (path) > 0 && path[0] == '/')
-                path++;
+    while (strlen(path) > 0 && path[0] == '/')
+        path++;
 
-        /* Clear the mountid */
-        gf_uuid_clear (mountid);
+    /* Clear the mountid */
+    gf_uuid_clear(mountid);
 
-        hashed_path = SuperFastHash (path,  strlen (path));
-        if (hashed_path == 1) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_PATH_FAIL,
-                        "failed to hash path: %s", path);
-                goto out;
-        }
+    hashed_path = SuperFastHash(path, strlen(path));
+    if (hashed_path == 1) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_PATH_FAIL,
+               "failed to hash path: %s", path);
+        goto out;
+    }
 
-        memcpy (mountid, &hashed_path, sizeof (hashed_path));
-        ret = 0;
+    memcpy(mountid, &hashed_path, sizeof(hashed_path));
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-__mnt3_get_mount_id (xlator_t *mntxl, uuid_t mountid)
+__mnt3_get_mount_id(xlator_t *mntxl, uuid_t mountid)
 {
-        int ret = -1;
-        uint32_t hashed_path = 0;
+    int ret = -1;
+    uint32_t hashed_path = 0;
 
+    /* first clear the mountid */
+    gf_uuid_clear(mountid);
 
-        /* first clear the mountid */
-        gf_uuid_clear (mountid);
+    hashed_path = SuperFastHash(mntxl->name, strlen(mntxl->name));
+    if (hashed_path == 1) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_XLATOR_FAIL,
+               "failed to hash xlator name: %s", mntxl->name);
+        goto out;
+    }
 
-        hashed_path = SuperFastHash (mntxl->name, strlen (mntxl->name));
-        if (hashed_path == 1) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_XLATOR_FAIL,
-                        "failed to hash xlator name: %s", mntxl->name);
-                goto out;
-        }
-
-        memcpy (mountid, &hashed_path, sizeof (hashed_path));
-        ret = 0;
+    memcpy(mountid, &hashed_path, sizeof(hashed_path));
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-mnt3svc_lookup_mount_cbk (call_frame_t *frame, void  *cookie,
-                          xlator_t *this, int32_t op_ret, int32_t op_errno,
-                          inode_t *inode, struct iatt *buf, dict_t *xattr,
-                          struct iatt *postparent)
+mnt3svc_lookup_mount_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, inode_t *inode,
+                         struct iatt *buf, dict_t *xattr,
+                         struct iatt *postparent)
 {
-        mountres3               res = {0, };
-        rpcsvc_request_t        *req = NULL;
-        struct nfs3_fh          fh = {{0}, };
-        struct mount3_state     *ms = NULL;
-        mountstat3              status = 0;
-        int                     autharr[10];
-        int                     autharrlen = 0;
-        rpcsvc_t                *svc = NULL;
-        xlator_t                *mntxl = NULL;
-        uuid_t                  volumeid = {0, };
-        char                    *path = NULL;
-        uuid_t                  mountid = {1, };
-        char                    fhstr[1536];
-        int                     alloclen = 0;
-
-        req = (rpcsvc_request_t *)frame->local;
-
-        if (!req)
-                return -1;
-
-        mntxl = (xlator_t *)cookie;
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND,
-                        "mount state not found");
-                op_ret = -1;
-                op_errno = EINVAL;
-        }
-
-        if (op_ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, op_errno,
-                        NFS_MSG_LOOKUP_MNT_ERROR, "error=%s",
-                        strerror (op_errno));
-                status = mnt3svc_errno_to_mnterr (op_errno);
-        }
-        if (status != MNT3_OK)
-                goto xmit_res;
-
-        alloclen = strlen(mntxl->name) + 2;
-        path = GF_MALLOC (alloclen, gf_nfs_mt_char);
-        if (!path) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                        NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed.");
-                goto xmit_res;
-        }
-
-        snprintf (path, alloclen, "/%s", mntxl->name);
-        mnt3svc_update_mountlist (ms, req, path, NULL);
-        GF_FREE (path);
-        if (gf_nfs_dvm_off (nfs_state (ms->nfsx))) {
-                fh = nfs3_fh_build_indexed_root_fh (ms->nfsx->children, mntxl);
-                goto xmit_res;
-        }
+    mountres3 res = {
+        0,
+    };
+    rpcsvc_request_t *req = NULL;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    struct mount3_state *ms = NULL;
+    mountstat3 status = 0;
+    int autharr[10];
+    int autharrlen = 0;
+    rpcsvc_t *svc = NULL;
+    xlator_t *mntxl = NULL;
+    uuid_t volumeid = {
+        0,
+    };
+    char *path = NULL;
+    uuid_t mountid = {
+        1,
+    };
+    char fhstr[1536];
+    int alloclen = 0;
+
+    req = (rpcsvc_request_t *)frame->local;
+
+    if (!req)
+        return -1;
 
-        __mnt3_get_mount_id (mntxl, mountid);
-        __mnt3_get_volume_id (ms, mntxl, volumeid);
-        fh = nfs3_fh_build_uuid_root_fh (volumeid, mountid);
+    mntxl = (xlator_t *)cookie;
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "mount state not found");
+        op_ret = -1;
+        op_errno = EINVAL;
+    }
+
+    if (op_ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_MNT_ERROR,
+               "error=%s", strerror(op_errno));
+        status = mnt3svc_errno_to_mnterr(op_errno);
+    }
+    if (status != MNT3_OK)
+        goto xmit_res;
+
+    alloclen = strlen(mntxl->name) + 2;
+    path = GF_MALLOC(alloclen, gf_nfs_mt_char);
+    if (!path) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed.");
+        goto xmit_res;
+    }
+
+    snprintf(path, alloclen, "/%s", mntxl->name);
+    mnt3svc_update_mountlist(ms, req, path, NULL);
+    GF_FREE(path);
+    if (gf_nfs_dvm_off(nfs_state(ms->nfsx))) {
+        fh = nfs3_fh_build_indexed_root_fh(ms->nfsx->children, mntxl);
+        goto xmit_res;
+    }
+
+    __mnt3_get_mount_id(mntxl, mountid);
+    __mnt3_get_volume_id(ms, mntxl, volumeid);
+    fh = nfs3_fh_build_uuid_root_fh(volumeid, mountid);
 
 xmit_res:
-        nfs3_fh_to_str (&fh, fhstr, sizeof (fhstr));
-        gf_msg_debug (GF_MNT, 0, "MNT reply: fh %s, status: %d", fhstr,
-                      status);
-        if (op_ret == 0) {
-                svc = rpcsvc_request_service (req);
-                autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr,
-                                                10);
-        }
-
-        res = mnt3svc_set_mountres3 (status, &fh, autharr, autharrlen);
-        mnt3svc_submit_reply (req, (void *)&res,
-                              (mnt3_serializer)xdr_serialize_mountres3);
-
-        return 0;
+    nfs3_fh_to_str(&fh, fhstr, sizeof(fhstr));
+    gf_msg_debug(GF_MNT, 0, "MNT reply: fh %s, status: %d", fhstr, status);
+    if (op_ret == 0) {
+        svc = rpcsvc_request_service(req);
+        autharrlen = rpcsvc_auth_array(svc, mntxl->name, autharr, 10);
+    }
+
+    res = mnt3svc_set_mountres3(status, &fh, autharr, autharrlen);
+    mnt3svc_submit_reply(req, (void *)&res,
+                         (mnt3_serializer)xdr_serialize_mountres3);
+
+    return 0;
 }
 
-
 int
-mnt3_match_dirpath_export (const char *expname, const char *dirpath,
-                           gf_boolean_t export_parsing_match)
+mnt3_match_dirpath_export(const char *expname, const char *dirpath,
+                          gf_boolean_t export_parsing_match)
 {
-        int     ret = 0;
-        size_t  dlen;
-        char    *fullpath = NULL;
-        char    *second_slash = NULL;
-        char    *dirdup = NULL;
+    int ret = 0;
+    size_t dlen;
+    char *fullpath = NULL;
+    char *second_slash = NULL;
+    char *dirdup = NULL;
 
-        if ((!expname) || (!dirpath))
-                return 0;
+    if ((!expname) || (!dirpath))
+        return 0;
 
-        dirdup = strdupa (dirpath);
+    dirdup = strdupa(dirpath);
 
-        /* Some clients send a dirpath for mount that includes the slash at the
-         * end. String compare for searching the export will fail because our
-         * exports list does not include that slash. Remove the slash to
-         * compare.
-         */
-        dlen = strlen (dirdup);
-        if (dlen && dirdup[dlen - 1] == '/')
-                dirdup[dlen - 1] = '\0';
+    /* Some clients send a dirpath for mount that includes the slash at the
+     * end. String compare for searching the export will fail because our
+     * exports list does not include that slash. Remove the slash to
+     * compare.
+     */
+    dlen = strlen(dirdup);
+    if (dlen && dirdup[dlen - 1] == '/')
+        dirdup[dlen - 1] = '\0';
 
-        /* Here we try to match fullpaths with export names */
-        fullpath = dirdup;
+    /* Here we try to match fullpaths with export names */
+    fullpath = dirdup;
 
-        if (export_parsing_match) {
-                if (dirdup[0] == '/')
-                        fullpath = dirdup + 1;
+    if (export_parsing_match) {
+        if (dirdup[0] == '/')
+            fullpath = dirdup + 1;
 
-                second_slash = strchr (fullpath, '/');
-                if (second_slash)
-                        *second_slash = '\0';
-        }
+        second_slash = strchr(fullpath, '/');
+        if (second_slash)
+            *second_slash = '\0';
+    }
 
-        /* The export name begins with a slash so move it forward by one
-         * to ignore the slash when we want to compare the fullpath and
-         * export.
-         */
-        if (fullpath[0] != '/')
-                expname++;
+    /* The export name begins with a slash so move it forward by one
+     * to ignore the slash when we want to compare the fullpath and
+     * export.
+     */
+    if (fullpath[0] != '/')
+        expname++;
 
-        if (strcmp (expname, fullpath) == 0)
-                ret = 1;
+    if (strcmp(expname, fullpath) == 0)
+        ret = 1;
 
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_mount_inode (rpcsvc_request_t *req, struct mount3_state *ms,
-                     xlator_t * xl, inode_t *exportinode)
+mnt3svc_mount_inode(rpcsvc_request_t *req, struct mount3_state *ms,
+                    xlator_t *xl, inode_t *exportinode)
 {
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-        loc_t           exportloc = {0, };
-
-        if ((!req) || (!xl) || (!ms) || (!exportinode))
-                return ret;
-
-        ret = nfs_inode_loc_fill (exportinode, &exportloc, NFS_RESOLVE_EXIST);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_INODE_LOC_FILL_ERROR,
-                        "Loc fill failed for export inode"
-                        ": gfid %s, volume: %s",
-                        uuid_utoa (exportinode->gfid), xl->name);
-                goto err;
-        }
-
-        /* To service the mount request, all we need to do
-         * is to send a lookup fop that returns the stat
-         * for the root of the child volume. This is
-         * used to build the root fh sent to the client.
-         */
-        nfs_request_user_init (&nfu, req);
-        ret = nfs_lookup (ms->nfsx, xl, &nfu, &exportloc,
-                          mnt3svc_lookup_mount_cbk, (void *)req);
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    loc_t exportloc = {
+        0,
+    };
+
+    if ((!req) || (!xl) || (!ms) || (!exportinode))
+        return ret;
 
-        nfs_loc_wipe (&exportloc);
+    ret = nfs_inode_loc_fill(exportinode, &exportloc, NFS_RESOLVE_EXIST);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_INODE_LOC_FILL_ERROR,
+               "Loc fill failed for export inode"
+               ": gfid %s, volume: %s",
+               uuid_utoa(exportinode->gfid), xl->name);
+        goto err;
+    }
+
+    /* To service the mount request, all we need to do
+     * is to send a lookup fop that returns the stat
+     * for the root of the child volume. This is
+     * used to build the root fh sent to the client.
+     */
+    nfs_request_user_init(&nfu, req);
+    ret = nfs_lookup(ms->nfsx, xl, &nfu, &exportloc, mnt3svc_lookup_mount_cbk,
+                     (void *)req);
+
+    nfs_loc_wipe(&exportloc);
 err:
-        return ret;
+    return ret;
 }
 
-
 /* For a volume mount request, we just have to create loc on the root inode,
  * and send a lookup. In the lookup callback the mount reply is send along with
  * the file handle.
  */
 int
-mnt3svc_volume_mount (rpcsvc_request_t *req, struct mount3_state *ms,
-                      struct mnt3_export *exp)
+mnt3svc_volume_mount(rpcsvc_request_t *req, struct mount3_state *ms,
+                     struct mnt3_export *exp)
 {
-        inode_t         *exportinode = NULL;
-        int             ret = -EFAULT;
-        uuid_t          rootgfid = {0, };
-
-        if ((!req) || (!exp) || (!ms))
-                return ret;
-
-        rootgfid[15] = 1;
-        exportinode = inode_find (exp->vol->itable, rootgfid);
-        if (!exportinode) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT,
-                        NFS_MSG_GET_ROOT_INODE_FAIL,
-                        "Failed to get root inode");
-                ret = -ENOENT;
-                goto err;
-        }
+    inode_t *exportinode = NULL;
+    int ret = -EFAULT;
+    uuid_t rootgfid = {
+        0,
+    };
+
+    if ((!req) || (!exp) || (!ms))
+        return ret;
+
+    rootgfid[15] = 1;
+    exportinode = inode_find(exp->vol->itable, rootgfid);
+    if (!exportinode) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOENT, NFS_MSG_GET_ROOT_INODE_FAIL,
+               "Failed to get root inode");
+        ret = -ENOENT;
+        goto err;
+    }
 
-        ret = mnt3svc_mount_inode (req, ms, exp->vol, exportinode);
-        inode_unref (exportinode);
+    ret = mnt3svc_mount_inode(req, ms, exp->vol, exportinode);
+    inode_unref(exportinode);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 /* The catch with directory exports is that the first component of the export
  * name will be the name of the volume.
  * Any lookup that needs to be performed to build the directory's file handle
@@ -951,280 +950,280 @@ err:
  * we need to strip out the volume name first.
  */
 char *
-mnt3_get_volume_subdir (char *dirpath, char **volname)
+mnt3_get_volume_subdir(char *dirpath, char **volname)
 {
-        /* subdir points to the first / after the volume name while dirpath
-         * points to the first char of the volume name.
-         */
-        char          *subdir        = NULL;
-        int            volname_len   = 0;
-        static char   *root          = "/";
-
-        /* all callers are expected to pass a valid *dirpath */
-        GF_ASSERT (dirpath);
-
-        if (dirpath[0] == '/')
-                dirpath++;
-
-        subdir = index (dirpath, (int)'/');
-        if (!subdir) {
-                subdir = root;
-                volname_len = strlen (dirpath);
-        } else {
-                volname_len = subdir - dirpath;
-        }
-
-        if (!volname)
-                goto out;
-
-        if (!*volname)
-                goto out;
-
-        strncpy (*volname, dirpath, volname_len);
-        *(*volname + volname_len) = '\0';
+    /* subdir points to the first / after the volume name while dirpath
+     * points to the first char of the volume name.
+     */
+    char *subdir = NULL;
+    int volname_len = 0;
+    static char *root = "/";
+
+    /* all callers are expected to pass a valid *dirpath */
+    GF_ASSERT(dirpath);
+
+    if (dirpath[0] == '/')
+        dirpath++;
+
+    subdir = index(dirpath, (int)'/');
+    if (!subdir) {
+        subdir = root;
+        volname_len = strlen(dirpath);
+    } else {
+        volname_len = subdir - dirpath;
+    }
+
+    if (!volname)
+        goto out;
+
+    if (!*volname)
+        goto out;
+
+    strncpy(*volname, dirpath, volname_len);
+    *(*volname + volname_len) = '\0';
 out:
-        return subdir;
+    return subdir;
 }
 
-
 void
-mnt3_resolve_state_wipe (mnt3_resolve_t *mres)
+mnt3_resolve_state_wipe(mnt3_resolve_t *mres)
 {
-        if (!mres)
-                return;
-
-        nfs_loc_wipe (&mres->resolveloc);
-        GF_FREE (mres);
+    if (!mres)
+        return;
 
+    nfs_loc_wipe(&mres->resolveloc);
+    GF_FREE(mres);
 }
 
-
 /* Sets up the component argument to contain the next component in the path and
  * sets up path as an absolute path starting from the next component.
  */
 static char *
-setup_next_component (char *path, size_t plen, char *component, size_t clen)
+setup_next_component(char *path, size_t plen, char *component, size_t clen)
 {
-        char    *comp = NULL;
-        char    *nextcomp = NULL;
-
-        if ((!path) || (!component))
-                return NULL;
-
-        strncpy (component, path, clen);
-        comp = index (component, (int)'/');
-        if (!comp)
-                goto err;
-
-        comp++;
-        nextcomp = index (comp, (int)'/');
-        if (nextcomp) {
-                strncpy (path, nextcomp, plen);
-                *nextcomp = '\0';
-        } else
-                path[0] = '\0';
+    char *comp = NULL;
+    char *nextcomp = NULL;
+
+    if ((!path) || (!component))
+        return NULL;
+
+    strncpy(component, path, clen);
+    comp = index(component, (int)'/');
+    if (!comp)
+        goto err;
+
+    comp++;
+    nextcomp = index(comp, (int)'/');
+    if (nextcomp) {
+        strncpy(path, nextcomp, plen);
+        *nextcomp = '\0';
+    } else
+        path[0] = '\0';
 
 err:
-        return comp;
+    return comp;
 }
 
 int32_t
-mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, inode_t *inode,
-                         struct iatt *buf, dict_t *xattr,
-                         struct iatt *postparent);
+mnt3_resolve_subdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, inode_t *inode,
+                        struct iatt *buf, dict_t *xattr,
+                        struct iatt *postparent);
 
 int32_t
-mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, const char *path,
-                   struct iatt *buf, dict_t *xdata);
+mnt3_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, const char *path,
+                  struct iatt *buf, dict_t *xdata);
 
 /* There are multiple components in the directory export path and each one
  * needs to be looked up one after the other.
  */
 int
-__mnt3_resolve_export_subdir_comp (mnt3_resolve_t *mres)
+__mnt3_resolve_export_subdir_comp(mnt3_resolve_t *mres)
 {
-        char            dupsubdir[MNTPATHLEN];
-        char            *nextcomp = NULL;
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-        uuid_t          gfid = {0, };
-
-        if (!mres)
-                return ret;
-
-        nextcomp = setup_next_component (mres->remainingdir,
-                                         sizeof (mres->remainingdir),
-                                         dupsubdir, sizeof (dupsubdir));
-        if (!nextcomp)
-                goto err;
-
-        /* Wipe the contents of the previous component */
-        gf_uuid_copy (gfid, mres->resolveloc.inode->gfid);
-        nfs_loc_wipe (&mres->resolveloc);
-        ret = nfs_entry_loc_fill (mres->mstate->nfsx, mres->exp->vol->itable,
-                                  gfid, nextcomp, &mres->resolveloc,
-                                  NFS_RESOLVE_CREATE, NULL);
-        if ((ret < 0) && (ret != -2)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT,
-                        NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and "
-                        "create inode: parent gfid %s, entry %s",
-                        uuid_utoa (gfid), nextcomp);
-                ret = -EFAULT;
-                goto err;
-        }
+    char dupsubdir[MNTPATHLEN];
+    char *nextcomp = NULL;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    uuid_t gfid = {
+        0,
+    };
+
+    if (!mres)
+        return ret;
 
-        nfs_request_user_init (&nfu, mres->req);
-        if (IA_ISLNK (mres->resolveloc.inode->ia_type)) {
-                ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu,
-                                    &mres->resolveloc, mnt3_readlink_cbk, mres);
-                gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve"
-                              " into directory handle");
-                goto err;
-        }
-        ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu,
-                          &mres->resolveloc, mnt3_resolve_subdir_cbk, mres);
+    nextcomp = setup_next_component(mres->remainingdir,
+                                    sizeof(mres->remainingdir), dupsubdir,
+                                    sizeof(dupsubdir));
+    if (!nextcomp)
+        goto err;
+
+    /* Wipe the contents of the previous component */
+    gf_uuid_copy(gfid, mres->resolveloc.inode->gfid);
+    nfs_loc_wipe(&mres->resolveloc);
+    ret = nfs_entry_loc_fill(mres->mstate->nfsx, mres->exp->vol->itable, gfid,
+                             nextcomp, &mres->resolveloc, NFS_RESOLVE_CREATE,
+                             NULL);
+    if ((ret < 0) && (ret != -2)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_RESOLVE_INODE_FAIL,
+               "Failed to resolve and "
+               "create inode: parent gfid %s, entry %s",
+               uuid_utoa(gfid), nextcomp);
+        ret = -EFAULT;
+        goto err;
+    }
+
+    nfs_request_user_init(&nfu, mres->req);
+    if (IA_ISLNK(mres->resolveloc.inode->ia_type)) {
+        ret = nfs_readlink(mres->mstate->nfsx, mres->exp->vol, &nfu,
+                           &mres->resolveloc, mnt3_readlink_cbk, mres);
+        gf_msg_debug(GF_MNT, 0,
+                     "Symlink found , need to resolve"
+                     " into directory handle");
+        goto err;
+    }
+    ret = nfs_lookup(mres->mstate->nfsx, mres->exp->vol, &nfu,
+                     &mres->resolveloc, mnt3_resolve_subdir_cbk, mres);
 
 err:
-        return ret;
+    return ret;
 }
 
-int __mnt3_resolve_subdir (mnt3_resolve_t *mres);
+int
+__mnt3_resolve_subdir(mnt3_resolve_t *mres);
 
 /*
  * Per the AFR2 comments, this function performs the "fresh" lookup
  * by deleting the inode from cache and calling __mnt3_resolve_subdir
  * again.
  */
-int __mnt3_fresh_lookup (mnt3_resolve_t *mres) {
-        inode_unlink (mres->resolveloc.inode,
-                mres->resolveloc.parent, mres->resolveloc.name);
-        strncpy (mres->remainingdir, mres->resolveloc.path,
-                strlen(mres->resolveloc.path));
-        nfs_loc_wipe (&mres->resolveloc);
-        return __mnt3_resolve_subdir (mres);
+int
+__mnt3_fresh_lookup(mnt3_resolve_t *mres)
+{
+    inode_unlink(mres->resolveloc.inode, mres->resolveloc.parent,
+                 mres->resolveloc.name);
+    strncpy(mres->remainingdir, mres->resolveloc.path,
+            strlen(mres->resolveloc.path));
+    nfs_loc_wipe(&mres->resolveloc);
+    return __mnt3_resolve_subdir(mres);
 }
 
 int32_t
-mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, inode_t *inode,
-                         struct iatt *buf, dict_t *xattr,
-                         struct iatt *postparent)
+mnt3_resolve_subdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, inode_t *inode,
+                        struct iatt *buf, dict_t *xattr,
+                        struct iatt *postparent)
 {
-        mnt3_resolve_t          *mres = NULL;
-        mountstat3              mntstat = MNT3ERR_SERVERFAULT;
-        struct nfs3_fh          fh = {{0}, };
-        int                     autharr[10];
-        int                     autharrlen = 0;
-        rpcsvc_t                *svc = NULL;
-        mountres3               res = {0, };
-        xlator_t                *mntxl = NULL;
-        char                    *path = NULL;
-        struct mount3_state     *ms = NULL;
-        int                     authcode = 0;
-        char                    *authorized_host = NULL;
-        char                    *authorized_path = NULL;
-        inode_t                 *linked_inode = NULL;
-
-        mres = frame->local;
-        ms = mres->mstate;
-        mntxl = (xlator_t *)cookie;
-        if (op_ret == -1 && op_errno == ESTALE) {
-                /* Nuke inode from cache and try the LOOKUP
-                 * request again. */
-                return __mnt3_fresh_lookup (mres);
-        } else if (op_ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, op_errno,
-                        NFS_MSG_RESOLVE_SUBDIR_FAIL, "path=%s (%s)",
-                        mres->resolveloc.path, strerror (op_errno));
-                mntstat = mnt3svc_errno_to_mnterr (op_errno);
-                goto err;
+    mnt3_resolve_t *mres = NULL;
+    mountstat3 mntstat = MNT3ERR_SERVERFAULT;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    int autharr[10];
+    int autharrlen = 0;
+    rpcsvc_t *svc = NULL;
+    mountres3 res = {
+        0,
+    };
+    xlator_t *mntxl = NULL;
+    char *path = NULL;
+    struct mount3_state *ms = NULL;
+    int authcode = 0;
+    char *authorized_host = NULL;
+    char *authorized_path = NULL;
+    inode_t *linked_inode = NULL;
+
+    mres = frame->local;
+    ms = mres->mstate;
+    mntxl = (xlator_t *)cookie;
+    if (op_ret == -1 && op_errno == ESTALE) {
+        /* Nuke inode from cache and try the LOOKUP
+         * request again. */
+        return __mnt3_fresh_lookup(mres);
+    } else if (op_ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, op_errno, NFS_MSG_RESOLVE_SUBDIR_FAIL,
+               "path=%s (%s)", mres->resolveloc.path, strerror(op_errno));
+        mntstat = mnt3svc_errno_to_mnterr(op_errno);
+        goto err;
+    }
+
+    linked_inode = inode_link(mres->resolveloc.inode, mres->resolveloc.parent,
+                              mres->resolveloc.name, buf);
+
+    if (linked_inode)
+        nfs_fix_generation(this, linked_inode);
+
+    nfs3_fh_build_child_fh(&mres->parentfh, buf, &fh);
+    if (strlen(mres->remainingdir) <= 0) {
+        int alloclen;
+        op_ret = -1;
+        mntstat = MNT3_OK;
+
+        /* Construct the full path */
+        int resolveloc_path_len = strlen(mres->resolveloc.path);
+        alloclen = strlen(mres->exp->expname) + resolveloc_path_len + 1;
+        mres->exp->fullpath = GF_MALLOC(alloclen, gf_nfs_mt_char);
+        if (!mres->exp->fullpath) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed.");
+            goto err;
+        }
+        snprintf(mres->exp->fullpath, alloclen, "%s%s", mres->exp->expname,
+                 mres->resolveloc.path);
+
+        /* Check if this path is authorized to be mounted */
+        authcode = mnt3_authenticate_request(
+            ms, mres->req, NULL, NULL, mres->exp->fullpath, &authorized_path,
+            &authorized_host, FALSE);
+        if (authcode != 0) {
+            mntstat = MNT3ERR_ACCES;
+            gf_msg_debug(GF_MNT, 0, "Client mount not allowed");
+            op_ret = -1;
+            goto err;
         }
 
-        linked_inode = inode_link (mres->resolveloc.inode,
-                                   mres->resolveloc.parent,
-                                   mres->resolveloc.name, buf);
-
-        if (linked_inode)
-                nfs_fix_generation (this, linked_inode);
-
-        nfs3_fh_build_child_fh (&mres->parentfh, buf, &fh);
-        if (strlen (mres->remainingdir) <= 0) {
-                int alloclen;
-                op_ret = -1;
-                mntstat = MNT3_OK;
-
-                /* Construct the full path */
-                int resolveloc_path_len = strlen(mres->resolveloc.path);
-                alloclen = strlen (mres->exp->expname) +
-                                   resolveloc_path_len + 1;
-                mres->exp->fullpath = GF_MALLOC (alloclen, gf_nfs_mt_char);
-                if (!mres->exp->fullpath) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "Memory allocation failed.");
-                        goto err;
-                }
-                snprintf (mres->exp->fullpath, alloclen, "%s%s",
-                                mres->exp->expname, mres->resolveloc.path);
-
-                /* Check if this path is authorized to be mounted */
-                authcode = mnt3_authenticate_request (ms, mres->req, NULL, NULL,
-                                                      mres->exp->fullpath,
-                                                      &authorized_path,
-                                                      &authorized_host,
-                                                      FALSE);
-                if (authcode != 0) {
-                        mntstat = MNT3ERR_ACCES;
-                        gf_msg_debug (GF_MNT, 0, "Client mount not allowed");
-                        op_ret = -1;
-                        goto err;
-                }
-
-                alloclen = strlen (mres->exp->vol->name) +
-                                   resolveloc_path_len + 2;
-                path = GF_MALLOC (alloclen, gf_nfs_mt_char);
-                if (!path) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "Memory allocation failed");
-                        goto err;
-                }
-                /* Build mountid from the authorized path and stick it in the
-                 * filehandle that will get passed back to the client
-                 */
-                __mnt3_build_mountid_from_path (authorized_path, fh.mountid);
-
-                snprintf (path, alloclen, "/%s%s", mres->exp->vol->name,
-                         mres->resolveloc.path);
-
-                mnt3svc_update_mountlist (mres->mstate, mres->req,
-                                          path, mres->exp->fullpath);
-                GF_FREE (path);
-        } else {
-                mres->parentfh = fh;
-                op_ret = __mnt3_resolve_export_subdir_comp (mres);
-                if (op_ret < 0)
-                        mntstat = mnt3svc_errno_to_mnterr (-op_ret);
+        alloclen = strlen(mres->exp->vol->name) + resolveloc_path_len + 2;
+        path = GF_MALLOC(alloclen, gf_nfs_mt_char);
+        if (!path) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto err;
         }
+        /* Build mountid from the authorized path and stick it in the
+         * filehandle that will get passed back to the client
+         */
+        __mnt3_build_mountid_from_path(authorized_path, fh.mountid);
+
+        snprintf(path, alloclen, "/%s%s", mres->exp->vol->name,
+                 mres->resolveloc.path);
+
+        mnt3svc_update_mountlist(mres->mstate, mres->req, path,
+                                 mres->exp->fullpath);
+        GF_FREE(path);
+    } else {
+        mres->parentfh = fh;
+        op_ret = __mnt3_resolve_export_subdir_comp(mres);
+        if (op_ret < 0)
+            mntstat = mnt3svc_errno_to_mnterr(-op_ret);
+    }
 err:
-        if (op_ret == -1) {
-                gf_msg_debug (GF_MNT, 0, "Mount reply status: %d", mntstat);
-                svc = rpcsvc_request_service (mres->req);
-                autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr,
-                                                10);
-
-                res = mnt3svc_set_mountres3 (mntstat, &fh, autharr, autharrlen);
-                mnt3svc_submit_reply (mres->req, (void *)&res,
-                                      (mnt3_serializer)xdr_serialize_mountres3);
-                mnt3_resolve_state_wipe (mres);
-        }
+    if (op_ret == -1) {
+        gf_msg_debug(GF_MNT, 0, "Mount reply status: %d", mntstat);
+        svc = rpcsvc_request_service(mres->req);
+        autharrlen = rpcsvc_auth_array(svc, mntxl->name, autharr, 10);
 
-        GF_FREE (authorized_path);
-        GF_FREE (authorized_host);
+        res = mnt3svc_set_mountres3(mntstat, &fh, autharr, autharrlen);
+        mnt3svc_submit_reply(mres->req, (void *)&res,
+                             (mnt3_serializer)xdr_serialize_mountres3);
+        mnt3_resolve_state_wipe(mres);
+    }
 
-        return 0;
+    GF_FREE(authorized_path);
+    GF_FREE(authorized_host);
+
+    return 0;
 }
 
 /* This function resolves symbolic link into directory path from
@@ -1251,105 +1250,106 @@ err:
  *            similar to udp
  */
 int32_t
-mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, const char *path,
-                   struct iatt *buf, dict_t *xdata)
+mnt3_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, const char *path,
+                  struct iatt *buf, dict_t *xdata)
 {
-        mnt3_resolve_t           *mres            = NULL;
-        int                      ret              = -EFAULT;
-        char                     *real_loc        = NULL;
-        size_t                   path_len         = 0;
-        size_t                   parent_path_len  = 0;
-        char                     *parent_path     = NULL;
-        char                     *absolute_path   = NULL;
-        char                     *relative_path   = NULL;
-        int                      mntstat          = 0;
-
-        GF_ASSERT (frame);
-
-        mres = frame->local;
-        if (!mres || !path || (path[0] == '/') || (op_ret < 0))
-                goto mnterr;
-
-        /* Finding current location of symlink */
-        parent_path_len = strlen (mres->resolveloc.path) - strlen (mres->resolveloc.name);
-        parent_path = gf_strndup (mres->resolveloc.path, parent_path_len);
-        if (!parent_path) {
-                ret = -ENOMEM;
-                goto mnterr;
-        }
-
-        relative_path = gf_strdup (path);
-        if (!relative_path) {
-                ret = -ENOMEM;
-                goto mnterr;
-        }
-        /* Resolving into absolute path */
-        ret = gf_build_absolute_path (parent_path, relative_path, &absolute_path);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                        NFS_MSG_RESOLVE_SYMLINK_ERROR,
-                        "Cannot resolve symlink, path is out of boundary "
-                        "from current location %s and with relative path "
-                        "%s pointed by symlink", parent_path, relative_path);
-
-                goto mnterr;
-        }
-
-        /* Building the actual mount path to be mounted */
-        path_len = strlen (mres->exp->vol->name) +  strlen (absolute_path)
-                   + strlen (mres->remainingdir) + 1;
-        real_loc = GF_MALLOC (path_len, gf_nfs_mt_char);
-        if (!real_loc) {
-                ret = -ENOMEM;
-                goto mnterr;
-        }
-        snprintf (real_loc, path_len, "%s%s", mres->exp->vol->name, absolute_path);
-        gf_path_strip_trailing_slashes (real_loc);
-
-        /* There may entries after symlink in the mount path,
-         * we should include remaining entries too */
-        if (strlen (mres->remainingdir) > 0)
-                strcat (real_loc, mres->remainingdir);
-
-        gf_msg_debug (GF_MNT, 0, "Resolved path is : %s%s "
-                      "and actual mount path is %s",
-                      absolute_path, mres->remainingdir, real_loc);
-
-        /* After the resolving the symlink , parsing should be done
-         * for the populated mount path
-         */
-        ret = mnt3_parse_dir_exports (mres->req, mres->mstate, real_loc,
-                                      _gf_true);
-
-        if (ret) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_ERROR,
-                        "Resolved into an unknown path %s%s "
-                        "from the current location of symlink %s",
-                         absolute_path, mres->remainingdir, parent_path);
-        }
-
-        GF_FREE (real_loc);
-        GF_FREE (absolute_path);
-        GF_FREE (parent_path);
-        GF_FREE (relative_path);
-
-        return ret;
+    mnt3_resolve_t *mres = NULL;
+    int ret = -EFAULT;
+    char *real_loc = NULL;
+    size_t path_len = 0;
+    size_t parent_path_len = 0;
+    char *parent_path = NULL;
+    char *absolute_path = NULL;
+    char *relative_path = NULL;
+    int mntstat = 0;
+
+    GF_ASSERT(frame);
+
+    mres = frame->local;
+    if (!mres || !path || (path[0] == '/') || (op_ret < 0))
+        goto mnterr;
+
+    /* Finding current location of symlink */
+    parent_path_len = strlen(mres->resolveloc.path) -
+                      strlen(mres->resolveloc.name);
+    parent_path = gf_strndup(mres->resolveloc.path, parent_path_len);
+    if (!parent_path) {
+        ret = -ENOMEM;
+        goto mnterr;
+    }
+
+    relative_path = gf_strdup(path);
+    if (!relative_path) {
+        ret = -ENOMEM;
+        goto mnterr;
+    }
+    /* Resolving into absolute path */
+    ret = gf_build_absolute_path(parent_path, relative_path, &absolute_path);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SYMLINK_ERROR,
+               "Cannot resolve symlink, path is out of boundary "
+               "from current location %s and with relative path "
+               "%s pointed by symlink",
+               parent_path, relative_path);
+
+        goto mnterr;
+    }
+
+    /* Building the actual mount path to be mounted */
+    path_len = strlen(mres->exp->vol->name) + strlen(absolute_path) +
+               strlen(mres->remainingdir) + 1;
+    real_loc = GF_MALLOC(path_len, gf_nfs_mt_char);
+    if (!real_loc) {
+        ret = -ENOMEM;
+        goto mnterr;
+    }
+    snprintf(real_loc, path_len, "%s%s", mres->exp->vol->name, absolute_path);
+    gf_path_strip_trailing_slashes(real_loc);
+
+    /* There may entries after symlink in the mount path,
+     * we should include remaining entries too */
+    if (strlen(mres->remainingdir) > 0)
+        strcat(real_loc, mres->remainingdir);
+
+    gf_msg_debug(GF_MNT, 0,
+                 "Resolved path is : %s%s "
+                 "and actual mount path is %s",
+                 absolute_path, mres->remainingdir, real_loc);
+
+    /* After the resolving the symlink , parsing should be done
+     * for the populated mount path
+     */
+    ret = mnt3_parse_dir_exports(mres->req, mres->mstate, real_loc, _gf_true);
+
+    if (ret) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_ERROR,
+               "Resolved into an unknown path %s%s "
+               "from the current location of symlink %s",
+               absolute_path, mres->remainingdir, parent_path);
+    }
+
+    GF_FREE(real_loc);
+    GF_FREE(absolute_path);
+    GF_FREE(parent_path);
+    GF_FREE(relative_path);
+
+    return ret;
 
 mnterr:
-        if (mres) {
-                mntstat = mnt3svc_errno_to_mnterr (-ret);
-                mnt3svc_mnt_error_reply (mres->req, mntstat);
-        } else
-                gf_msg (GF_MNT, GF_LOG_CRITICAL, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "mres == NULL, this should *never* happen");
-        if (absolute_path)
-                GF_FREE (absolute_path);
-        if (parent_path)
-                GF_FREE (parent_path);
-        if (relative_path)
-                GF_FREE (relative_path);
-        return ret;
+    if (mres) {
+        mntstat = mnt3svc_errno_to_mnterr(-ret);
+        mnt3svc_mnt_error_reply(mres->req, mntstat);
+    } else
+        gf_msg(GF_MNT, GF_LOG_CRITICAL, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "mres == NULL, this should *never* happen");
+    if (absolute_path)
+        GF_FREE(absolute_path);
+    if (parent_path)
+        GF_FREE(parent_path);
+    if (relative_path)
+        GF_FREE(relative_path);
+    return ret;
 }
 
 /* We will always have to perform a hard lookup on all the components of a
@@ -1364,69 +1364,72 @@ mnterr:
  * of the exported directory can be built.
  */
 int
-__mnt3_resolve_subdir (mnt3_resolve_t *mres)
+__mnt3_resolve_subdir(mnt3_resolve_t *mres)
 {
-        char            dupsubdir[MNTPATHLEN];
-        char            *firstcomp = NULL;
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-        uuid_t          rootgfid = {0, };
-
-        if (!mres)
-                return ret;
-
-        firstcomp = setup_next_component (mres->remainingdir,
-                                          sizeof (mres->remainingdir),
-                                          dupsubdir, sizeof (dupsubdir));
-        if (!firstcomp)
-                goto err;
-
-        rootgfid[15] = 1;
-        ret = nfs_entry_loc_fill (mres->mstate->nfsx, mres->exp->vol->itable,
-                                  rootgfid, firstcomp, &mres->resolveloc,
-                                  NFS_RESOLVE_CREATE, NULL);
-        if ((ret < 0) && (ret != -2)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT,
-                        NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and "
-                        "create inode for volume root: %s",
-                        mres->exp->vol->name);
-                ret = -EFAULT;
-                goto err;
-        }
+    char dupsubdir[MNTPATHLEN];
+    char *firstcomp = NULL;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    uuid_t rootgfid = {
+        0,
+    };
+
+    if (!mres)
+        return ret;
 
-        nfs_request_user_init (&nfu, mres->req);
-        if (IA_ISLNK (mres->resolveloc.inode->ia_type)) {
-                ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu,
-                                    &mres->resolveloc, mnt3_readlink_cbk, mres);
-                gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve "
-                              "into directory handle");
-                goto err;
-        }
-        ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu,
-                          &mres->resolveloc, mnt3_resolve_subdir_cbk, mres);
+    firstcomp = setup_next_component(mres->remainingdir,
+                                     sizeof(mres->remainingdir), dupsubdir,
+                                     sizeof(dupsubdir));
+    if (!firstcomp)
+        goto err;
+
+    rootgfid[15] = 1;
+    ret = nfs_entry_loc_fill(mres->mstate->nfsx, mres->exp->vol->itable,
+                             rootgfid, firstcomp, &mres->resolveloc,
+                             NFS_RESOLVE_CREATE, NULL);
+    if ((ret < 0) && (ret != -2)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_RESOLVE_INODE_FAIL,
+               "Failed to resolve and "
+               "create inode for volume root: %s",
+               mres->exp->vol->name);
+        ret = -EFAULT;
+        goto err;
+    }
+
+    nfs_request_user_init(&nfu, mres->req);
+    if (IA_ISLNK(mres->resolveloc.inode->ia_type)) {
+        ret = nfs_readlink(mres->mstate->nfsx, mres->exp->vol, &nfu,
+                           &mres->resolveloc, mnt3_readlink_cbk, mres);
+        gf_msg_debug(GF_MNT, 0,
+                     "Symlink found , need to resolve "
+                     "into directory handle");
+        goto err;
+    }
+    ret = nfs_lookup(mres->mstate->nfsx, mres->exp->vol, &nfu,
+                     &mres->resolveloc, mnt3_resolve_subdir_cbk, mres);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 static gf_boolean_t
-mnt3_match_subnet_v4 (struct addrinfo *ai, uint32_t saddr, uint32_t mask)
+mnt3_match_subnet_v4(struct addrinfo *ai, uint32_t saddr, uint32_t mask)
 {
-        for (; ai; ai = ai->ai_next) {
-                struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr;
+    for (; ai; ai = ai->ai_next) {
+        struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr;
 
-                if (sin->sin_family != AF_INET)
-                        continue;
+        if (sin->sin_family != AF_INET)
+            continue;
 
-                if (mask_match (saddr, sin->sin_addr.s_addr, mask))
-                        return _gf_true;
-        }
+        if (mask_match(saddr, sin->sin_addr.s_addr, mask))
+            return _gf_true;
+    }
 
-        return _gf_false;
+    return _gf_false;
 }
 
-
 /**
  * This function will verify if the client is allowed to mount
  * the directory or not. Client's IP address will be compared with
@@ -1440,446 +1443,448 @@ mnt3_match_subnet_v4 (struct addrinfo *ai, uint32_t saddr, uint32_t mask)
  * TODO: Support IPv6 subnetwork
  */
 int
-mnt3_verify_auth (struct sockaddr_in *client_addr, struct mnt3_export *export)
+mnt3_verify_auth(struct sockaddr_in *client_addr, struct mnt3_export *export)
 {
-        int                     retvalue = -EACCES;
-        int                     ret = 0;
-        struct host_auth_spec   *host = NULL;
-        struct sockaddr_in      *allowed_addr = NULL;
-        struct addrinfo         *allowed_addrinfo = NULL;
-
-        struct addrinfo         hint = {
-                .ai_family      = AF_INET,
-                .ai_protocol    = (int)IPPROTO_TCP,
-                .ai_flags       = AI_CANONNAME,
-        };
-
-        /* Sanity check */
-        if ((NULL == client_addr) ||
-            (NULL == export) ||
-            (NULL == export->hostspec)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument");
-                return retvalue;
-        }
-
-        host = export->hostspec;
-
-        /*
-         * Currently IPv4 subnetwork is supported i.e. AF_INET.
-         * TODO: IPv6 subnetwork i.e. AF_INET6.
-         */
-        if (client_addr->sin_family != AF_INET) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EAFNOSUPPORT,
-                        NFS_MSG_UNSUPPORTED_VERSION,
-                        "Only IPv4 is supported for subdir-auth");
-                return retvalue;
-        }
+    int retvalue = -EACCES;
+    int ret = 0;
+    struct host_auth_spec *host = NULL;
+    struct sockaddr_in *allowed_addr = NULL;
+    struct addrinfo *allowed_addrinfo = NULL;
+
+    struct addrinfo hint = {
+        .ai_family = AF_INET,
+        .ai_protocol = (int)IPPROTO_TCP,
+        .ai_flags = AI_CANONNAME,
+    };
+
+    /* Sanity check */
+    if ((NULL == client_addr) || (NULL == export) ||
+        (NULL == export->hostspec)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument");
+        return retvalue;
+    }
 
-        /* Try to see if the client IP matches the allowed IP list.*/
-        while (NULL != host){
-                GF_ASSERT (host->host_addr);
+    host = export->hostspec;
 
-                if (NULL != allowed_addrinfo) {
-                        freeaddrinfo (allowed_addrinfo);
-                        allowed_addrinfo = NULL;
-                }
+    /*
+     * Currently IPv4 subnetwork is supported i.e. AF_INET.
+     * TODO: IPv6 subnetwork i.e. AF_INET6.
+     */
+    if (client_addr->sin_family != AF_INET) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EAFNOSUPPORT, NFS_MSG_UNSUPPORTED_VERSION,
+               "Only IPv4 is supported for subdir-auth");
+        return retvalue;
+    }
 
-                /* Get the addrinfo for the allowed host (host_addr). */
-                ret = getaddrinfo (host->host_addr, NULL,
-                                   &hint, &allowed_addrinfo);
-                if (0 != ret){
-                        /*
-                         * getaddrinfo() FAILED for the host IP addr. Continue
-                         * to search other allowed hosts in the  hostspec list.
-                         */
-                        gf_msg_debug (GF_MNT, 0, "getaddrinfo: %s\n",
-                                      gai_strerror (ret));
-                        host = host->next;
-                        continue;
-                }
+    /* Try to see if the client IP matches the allowed IP list.*/
+    while (NULL != host) {
+        GF_ASSERT(host->host_addr);
 
-                allowed_addr = (struct sockaddr_in *)(allowed_addrinfo->ai_addr);
-                if (NULL == allowed_addr) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                                NFS_MSG_INVALID_ENTRY, "Invalid structure");
-                        break;
-                }
+        if (NULL != allowed_addrinfo) {
+            freeaddrinfo(allowed_addrinfo);
+            allowed_addrinfo = NULL;
+        }
 
-                /* Check if the network addr of both IPv4 socket match */
-                if (mnt3_match_subnet_v4 (allowed_addrinfo,
-                                          client_addr->sin_addr.s_addr,
-                                          host->netmask)) {
-                        retvalue = 0;
-                        break;
-                }
+        /* Get the addrinfo for the allowed host (host_addr). */
+        ret = getaddrinfo(host->host_addr, NULL, &hint, &allowed_addrinfo);
+        if (0 != ret) {
+            /*
+             * getaddrinfo() FAILED for the host IP addr. Continue
+             * to search other allowed hosts in the  hostspec list.
+             */
+            gf_msg_debug(GF_MNT, 0, "getaddrinfo: %s\n", gai_strerror(ret));
+            host = host->next;
+            continue;
+        }
 
-                /* No match yet, continue the search */
-               host = host->next;
+        allowed_addr = (struct sockaddr_in *)(allowed_addrinfo->ai_addr);
+        if (NULL == allowed_addr) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+                   "Invalid structure");
+            break;
         }
 
-        /* FREE the dynamic memory allocated by getaddrinfo() */
-        if (NULL != allowed_addrinfo) {
-               freeaddrinfo (allowed_addrinfo);
+        /* Check if the network addr of both IPv4 socket match */
+        if (mnt3_match_subnet_v4(allowed_addrinfo, client_addr->sin_addr.s_addr,
+                                 host->netmask)) {
+            retvalue = 0;
+            break;
         }
 
-        return retvalue;
+        /* No match yet, continue the search */
+        host = host->next;
+    }
+
+    /* FREE the dynamic memory allocated by getaddrinfo() */
+    if (NULL != allowed_addrinfo) {
+        freeaddrinfo(allowed_addrinfo);
+    }
+
+    return retvalue;
 }
 
 int
-mnt3_resolve_subdir (rpcsvc_request_t *req, struct mount3_state *ms,
-                     struct mnt3_export *exp, char *subdir,
-                     gf_boolean_t send_reply)
+mnt3_resolve_subdir(rpcsvc_request_t *req, struct mount3_state *ms,
+                    struct mnt3_export *exp, char *subdir,
+                    gf_boolean_t send_reply)
 {
-        mnt3_resolve_t        *mres = NULL;
-        int                   ret = -EFAULT;
-        struct nfs3_fh        pfh = GF_NFS3FH_STATIC_INITIALIZER;
-        struct sockaddr_in    *sin = NULL;
-
-        if ((!req) || (!ms) || (!exp) || (!subdir))
-                return ret;
-
-        sin = (struct sockaddr_in *)(&(req->trans->peerinfo.sockaddr));
-
-        /* Need to check AUTH */
-        if (NULL != exp->hostspec) {
-                ret = mnt3_verify_auth (sin, exp);
-                if (0 != ret) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, EACCES,
-                                NFS_MSG_AUTH_VERIFY_FAILED,
-                                "AUTH verification failed");
-                        return ret;
-                }
-        }
+    mnt3_resolve_t *mres = NULL;
+    int ret = -EFAULT;
+    struct nfs3_fh pfh = GF_NFS3FH_STATIC_INITIALIZER;
+    struct sockaddr_in *sin = NULL;
 
-        /* no reply is needed (WebNFS permissions checking), just return */
-        if (!send_reply)
-                return 0; /* no error, mnt3_verify_auth() allowed it */
+    if ((!req) || (!ms) || (!exp) || (!subdir))
+        return ret;
 
-        mres = GF_CALLOC (1, sizeof (mnt3_resolve_t), gf_nfs_mt_mnt3_resolve);
-        if (!mres) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                goto err;
+    sin = (struct sockaddr_in *)(&(req->trans->peerinfo.sockaddr));
+
+    /* Need to check AUTH */
+    if (NULL != exp->hostspec) {
+        ret = mnt3_verify_auth(sin, exp);
+        if (0 != ret) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, EACCES, NFS_MSG_AUTH_VERIFY_FAILED,
+                   "AUTH verification failed");
+            return ret;
         }
+    }
+
+    /* no reply is needed (WebNFS permissions checking), just return */
+    if (!send_reply)
+        return 0; /* no error, mnt3_verify_auth() allowed it */
 
-        mres->exp = exp;
-        mres->mstate = ms;
-        mres->req = req;
+    mres = GF_CALLOC(1, sizeof(mnt3_resolve_t), gf_nfs_mt_mnt3_resolve);
+    if (!mres) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        goto err;
+    }
 
-        snprintf (mres->remainingdir, MNTPATHLEN, "%s", subdir);
-        gf_path_strip_trailing_slashes (mres->remainingdir);
+    mres->exp = exp;
+    mres->mstate = ms;
+    mres->req = req;
 
-        if (gf_nfs_dvm_off (nfs_state (ms->nfsx)))
-                pfh = nfs3_fh_build_indexed_root_fh (
-                                            mres->mstate->nfsx->children,
+    snprintf(mres->remainingdir, MNTPATHLEN, "%s", subdir);
+    gf_path_strip_trailing_slashes(mres->remainingdir);
+
+    if (gf_nfs_dvm_off(nfs_state(ms->nfsx)))
+        pfh = nfs3_fh_build_indexed_root_fh(mres->mstate->nfsx->children,
                                             mres->exp->vol);
-        else
-                pfh = nfs3_fh_build_uuid_root_fh (exp->volumeid, exp->mountid);
+    else
+        pfh = nfs3_fh_build_uuid_root_fh(exp->volumeid, exp->mountid);
 
-        mres->parentfh = pfh;
-        ret = __mnt3_resolve_subdir (mres);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
-                        "Failed to resolve export dir: %s", mres->exp->expname);
-                GF_FREE (mres);
-        }
+    mres->parentfh = pfh;
+    ret = __mnt3_resolve_subdir(mres);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
+               "Failed to resolve export dir: %s", mres->exp->expname);
+        GF_FREE(mres);
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3_resolve_export_subdir (rpcsvc_request_t *req, struct mount3_state *ms,
-                            struct mnt3_export *exp)
+mnt3_resolve_export_subdir(rpcsvc_request_t *req, struct mount3_state *ms,
+                           struct mnt3_export *exp)
 {
-        char            *volume_subdir = NULL;
-        int             ret = -EFAULT;
+    char *volume_subdir = NULL;
+    int ret = -EFAULT;
 
-        if ((!req) || (!ms) || (!exp))
-                return ret;
+    if ((!req) || (!ms) || (!exp))
+        return ret;
 
-        volume_subdir = mnt3_get_volume_subdir (exp->expname, NULL);
+    volume_subdir = mnt3_get_volume_subdir(exp->expname, NULL);
 
-        ret = mnt3_resolve_subdir (req, ms, exp, volume_subdir, _gf_true);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
-                        "Failed to resolve export dir: %s", exp->expname);
-                goto err;
-        }
+    ret = mnt3_resolve_subdir(req, ms, exp, volume_subdir, _gf_true);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
+               "Failed to resolve export dir: %s", exp->expname);
+        goto err;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_mount (rpcsvc_request_t *req, struct mount3_state *ms,
-               struct mnt3_export *exp)
+mnt3svc_mount(rpcsvc_request_t *req, struct mount3_state *ms,
+              struct mnt3_export *exp)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!req) || (!ms) || (!exp))
-                return ret;
+    if ((!req) || (!ms) || (!exp))
+        return ret;
 
-        if (exp->exptype == MNT3_EXPTYPE_VOLUME)
-                ret = mnt3svc_volume_mount (req, ms, exp);
-        else if (exp->exptype == MNT3_EXPTYPE_DIR)
-                ret = mnt3_resolve_export_subdir (req, ms, exp);
+    if (exp->exptype == MNT3_EXPTYPE_VOLUME)
+        ret = mnt3svc_volume_mount(req, ms, exp);
+    else if (exp->exptype == MNT3_EXPTYPE_DIR)
+        ret = mnt3_resolve_export_subdir(req, ms, exp);
 
-        return ret;
+    return ret;
 }
 
-
 /* mnt3_mntpath_to_xlator sets this to 1 if the mount is for a full
-* volume or 2 for a subdir in the volume.
-*
-* The parameter 'export_parsing_match' indicates whether this function
-* is being called by an exports parser or whether it is being called
-* during mount. The behavior is different since we don't have to resolve
-* the path when doing the parse.
-*/
+ * volume or 2 for a subdir in the volume.
+ *
+ * The parameter 'export_parsing_match' indicates whether this function
+ * is being called by an exports parser or whether it is being called
+ * during mount. The behavior is different since we don't have to resolve
+ * the path when doing the parse.
+ */
 struct mnt3_export *
-mnt3_mntpath_to_export (struct mount3_state *ms, const char *dirpath,
-                        gf_boolean_t export_parsing_match)
+mnt3_mntpath_to_export(struct mount3_state *ms, const char *dirpath,
+                       gf_boolean_t export_parsing_match)
 {
-        struct mnt3_export      *exp = NULL;
-        struct mnt3_export      *found = NULL;
-
-        if ((!ms) || (!dirpath))
-                return NULL;
-
-        LOCK (&ms->mountlock);
-        list_for_each_entry (exp, &ms->exportlist, explist) {
-
-                /* Search for the an exact match with the volume */
-                if (mnt3_match_dirpath_export (exp->expname, dirpath,
-                                               export_parsing_match)) {
-                        found = exp;
-                        gf_msg_debug (GF_MNT, 0, "Found export volume: "
-                                      "%s", exp->vol->name);
-                        goto foundexp;
-                }
-        }
+    struct mnt3_export *exp = NULL;
+    struct mnt3_export *found = NULL;
 
-        gf_msg_debug (GF_MNT, 0, "Export not found");
+    if ((!ms) || (!dirpath))
+        return NULL;
+
+    LOCK(&ms->mountlock);
+    list_for_each_entry(exp, &ms->exportlist, explist)
+    {
+        /* Search for the an exact match with the volume */
+        if (mnt3_match_dirpath_export(exp->expname, dirpath,
+                                      export_parsing_match)) {
+            found = exp;
+            gf_msg_debug(GF_MNT, 0,
+                         "Found export volume: "
+                         "%s",
+                         exp->vol->name);
+            goto foundexp;
+        }
+    }
+
+    gf_msg_debug(GF_MNT, 0, "Export not found");
 foundexp:
-        UNLOCK (&ms->mountlock);
-        return found;
+    UNLOCK(&ms->mountlock);
+    return found;
 }
 
-
 static int
-mnt3_check_client_net_check (rpcsvc_t *svc, char *expvol,
-                             char *ipaddr, uint16_t port)
+mnt3_check_client_net_check(rpcsvc_t *svc, char *expvol, char *ipaddr,
+                            uint16_t port)
 {
-        int ret = RPCSVC_AUTH_REJECT;
-
-        if ((!svc) || (!expvol) || (!ipaddr))
-                goto err;
-
-        ret = rpcsvc_auth_check (svc, expvol, ipaddr);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PEER_NOT_ALLOWED,
-                        "Peer %s  not allowed", ipaddr);
-                goto err;
-        }
-
-        ret = rpcsvc_transport_privport_check (svc, expvol, port);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                gf_msg (GF_MNT, GF_LOG_INFO, errno, NFS_MSG_PEER_NOT_ALLOWED,
-                        "Peer %s rejected. Unprivileged "
-                        "port %d not allowed", ipaddr, port);
-                goto err;
-        }
-
-        ret = RPCSVC_AUTH_ACCEPT;
+    int ret = RPCSVC_AUTH_REJECT;
+
+    if ((!svc) || (!expvol) || (!ipaddr))
+        goto err;
+
+    ret = rpcsvc_auth_check(svc, expvol, ipaddr);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PEER_NOT_ALLOWED,
+               "Peer %s  not allowed", ipaddr);
+        goto err;
+    }
+
+    ret = rpcsvc_transport_privport_check(svc, expvol, port);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        gf_msg(GF_MNT, GF_LOG_INFO, errno, NFS_MSG_PEER_NOT_ALLOWED,
+               "Peer %s rejected. Unprivileged "
+               "port %d not allowed",
+               ipaddr, port);
+        goto err;
+    }
+
+    ret = RPCSVC_AUTH_ACCEPT;
 err:
-        return ret;
+    return ret;
 }
 
 int
-mnt3_check_client_net_tcp (rpcsvc_request_t *req, char *volname)
+mnt3_check_client_net_tcp(rpcsvc_request_t *req, char *volname)
 {
-        rpcsvc_t                *svc = NULL;
-        rpc_transport_t         *trans = NULL;
-        union gf_sock_union     sock_union;
-        socklen_t               socksize = sizeof (struct sockaddr_in);
-        char                    peer[RPCSVC_PEER_STRLEN] = {0,};
-        char                    *ipaddr = NULL;
-        uint16_t                port = 0;
-        int                     ret = RPCSVC_AUTH_REJECT;
-
-        if ((!req) || (!volname))
-                goto err;
-
-        svc = rpcsvc_request_service (req);
-        trans = rpcsvc_request_transport (req);
-        if ((!svc) || (!trans))
-                goto err;
-
-        ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN,
-                                         &sock_union.storage, socksize);
-        if (ret != 0) {
-                gf_msg (GF_MNT, GF_LOG_WARNING, ENOENT,
-                        NFS_MSG_GET_PEER_ADDR_FAIL, "Failed to get peer "
-                        "addr: %s", gai_strerror (ret));
-                ret = RPCSVC_AUTH_REJECT;
-                goto err;
-        }
-
-        /* peer[] gets IP:PORT formar, slash the port out */
-        if (!get_host_name ((char *)peer, &ipaddr))
-                ipaddr = peer;
-
-        port = ntohs (sock_union.sin.sin_port);
-
-        ret = mnt3_check_client_net_check (svc, volname, ipaddr, port);
+    rpcsvc_t *svc = NULL;
+    rpc_transport_t *trans = NULL;
+    union gf_sock_union sock_union;
+    socklen_t socksize = sizeof(struct sockaddr_in);
+    char peer[RPCSVC_PEER_STRLEN] = {
+        0,
+    };
+    char *ipaddr = NULL;
+    uint16_t port = 0;
+    int ret = RPCSVC_AUTH_REJECT;
+
+    if ((!req) || (!volname))
+        goto err;
+
+    svc = rpcsvc_request_service(req);
+    trans = rpcsvc_request_transport(req);
+    if ((!svc) || (!trans))
+        goto err;
+
+    ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN,
+                                    &sock_union.storage, socksize);
+    if (ret != 0) {
+        gf_msg(GF_MNT, GF_LOG_WARNING, ENOENT, NFS_MSG_GET_PEER_ADDR_FAIL,
+               "Failed to get peer "
+               "addr: %s",
+               gai_strerror(ret));
+        ret = RPCSVC_AUTH_REJECT;
+        goto err;
+    }
+
+    /* peer[] gets IP:PORT formar, slash the port out */
+    if (!get_host_name((char *)peer, &ipaddr))
+        ipaddr = peer;
+
+    port = ntohs(sock_union.sin.sin_port);
+
+    ret = mnt3_check_client_net_check(svc, volname, ipaddr, port);
 err:
-        return ret;
+    return ret;
 }
 
 static int
-mnt3_check_client_net_udp (struct svc_req *req, char *volname, xlator_t *nfsx)
+mnt3_check_client_net_udp(struct svc_req *req, char *volname, xlator_t *nfsx)
 {
-        rpcsvc_t                *svc = NULL;
-        struct sockaddr_in      *sin = NULL;
-        char                    ipaddr[INET_ADDRSTRLEN + 1] = {0, };
-        uint16_t                port = 0;
-        int                     ret = RPCSVC_AUTH_REJECT;
-        struct nfs_state        *nfs = NULL;
-
-        if ((!req) || (!volname) || (!nfsx))
-                goto err;
+    rpcsvc_t *svc = NULL;
+    struct sockaddr_in *sin = NULL;
+    char ipaddr[INET_ADDRSTRLEN + 1] = {
+        0,
+    };
+    uint16_t port = 0;
+    int ret = RPCSVC_AUTH_REJECT;
+    struct nfs_state *nfs = NULL;
+
+    if ((!req) || (!volname) || (!nfsx))
+        goto err;
 
 #if !defined(_TIRPC_SVC_H)
-        sin = svc_getcaller (req->rq_xprt);
+    sin = svc_getcaller(req->rq_xprt);
 #else
-        sin = (struct sockaddr_in *)svc_getcaller (req->rq_xprt);
-        /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even
-         * though it might actually be an IPv4 address. It ought return a
-         * struct sockaddr and make the caller upcast it to the proper
-         * address family. Sigh.
-         */
+    sin = (struct sockaddr_in *)svc_getcaller(req->rq_xprt);
+    /* TIRPC's svc_getcaller() returns a pointer to a sockaddr_in6, even
+     * though it might actually be an IPv4 address. It ought return a
+     * struct sockaddr and make the caller upcast it to the proper
+     * address family. Sigh.
+     */
 #endif
-        if (!sin)
-                goto err;
-        /* And let's make sure that it's actually an IPv4 address. */
+    if (!sin)
+        goto err;
+    /* And let's make sure that it's actually an IPv4 address. */
 
-        GF_ASSERT (sin->sin_family == AF_INET);
+    GF_ASSERT(sin->sin_family == AF_INET);
 
-        (void) inet_ntop (AF_INET, &sin->sin_addr, ipaddr, INET_ADDRSTRLEN);
+    (void)inet_ntop(AF_INET, &sin->sin_addr, ipaddr, INET_ADDRSTRLEN);
 
-        port = ntohs (sin->sin_port);
+    port = ntohs(sin->sin_port);
 
-        nfs = (struct nfs_state *)nfsx->private;
-        if (nfs != NULL)
-                svc = nfs->rpcsvc;
+    nfs = (struct nfs_state *)nfsx->private;
+    if (nfs != NULL)
+        svc = nfs->rpcsvc;
 
-        ret = mnt3_check_client_net_check (svc, volname, ipaddr, port);
+    ret = mnt3_check_client_net_check(svc, volname, ipaddr, port);
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3_parse_dir_exports (rpcsvc_request_t *req, struct mount3_state *ms,
-                        char *path, gf_boolean_t send_reply)
+mnt3_parse_dir_exports(rpcsvc_request_t *req, struct mount3_state *ms,
+                       char *path, gf_boolean_t send_reply)
 {
-        char                    volname[1024] = {0, };
-        struct mnt3_export      *exp = NULL;
-        char                    *volname_ptr = NULL;
-        char                    *subdir = NULL;
-        int                     ret = -ENOENT;
-        struct nfs_state        *nfs = NULL;
-
-        if ((!ms) || (!path))
-                return -1;
-
-        volname_ptr = volname;
-        subdir = mnt3_get_volume_subdir (path, &volname_ptr);
+    char volname[1024] = {
+        0,
+    };
+    struct mnt3_export *exp = NULL;
+    char *volname_ptr = NULL;
+    char *subdir = NULL;
+    int ret = -ENOENT;
+    struct nfs_state *nfs = NULL;
+
+    if ((!ms) || (!path))
+        return -1;
 
-        /* first try to match the full export/subdir */
-        exp = mnt3_mntpath_to_export (ms, path, _gf_false);
+    volname_ptr = volname;
+    subdir = mnt3_get_volume_subdir(path, &volname_ptr);
+
+    /* first try to match the full export/subdir */
+    exp = mnt3_mntpath_to_export(ms, path, _gf_false);
+    if (!exp) {
+        gf_msg_trace(GF_MNT, 0,
+                     "Could not find exact matching export "
+                     "for path=%s",
+                     path);
+        /* if no exact match is found, look for a fallback */
+        exp = mnt3_mntpath_to_export(ms, volname, _gf_true);
         if (!exp) {
-                gf_msg_trace (GF_MNT, 0, "Could not find exact matching export "
-                              "for path=%s", path);
-                /* if no exact match is found, look for a fallback */
-                exp = mnt3_mntpath_to_export (ms, volname, _gf_true);
-                if (!exp) {
-                        gf_msg_trace (GF_MNT, 0, "Could not find export for "
-                                      "volume %s", volname);
-                        goto err;
-                }
-        }
-        gf_msg_trace (GF_MNT, 0, "volume %s and export %s will be used for "
-                      "path %s", exp->vol->name, exp->expname, path);
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-        if (!nfs)
-                goto err;
-
-        if (!nfs_subvolume_started (nfs, exp->vol)) {
-                gf_msg_debug (GF_MNT, 0, "Volume %s not started",
-                              exp->vol->name);
-                goto err;
-        }
-
-        ret = mnt3_check_client_net_tcp (req, exp->vol->name);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                gf_msg_debug (GF_MNT, 0, "Client mount not allowed");
-                ret = -EACCES;
-                goto err;
-        }
-
-        ret = mnt3_resolve_subdir (req, ms, exp, subdir, send_reply);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
-                        "Failed to resolve export dir: %s", subdir);
-                goto err;
-        }
+            gf_msg_trace(GF_MNT, 0,
+                         "Could not find export for "
+                         "volume %s",
+                         volname);
+            goto err;
+        }
+    }
+    gf_msg_trace(GF_MNT, 0,
+                 "volume %s and export %s will be used for "
+                 "path %s",
+                 exp->vol->name, exp->expname, path);
+
+    nfs = (struct nfs_state *)ms->nfsx->private;
+    if (!nfs)
+        goto err;
+
+    if (!nfs_subvolume_started(nfs, exp->vol)) {
+        gf_msg_debug(GF_MNT, 0, "Volume %s not started", exp->vol->name);
+        goto err;
+    }
+
+    ret = mnt3_check_client_net_tcp(req, exp->vol->name);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        gf_msg_debug(GF_MNT, 0, "Client mount not allowed");
+        ret = -EACCES;
+        goto err;
+    }
+
+    ret = mnt3_resolve_subdir(req, ms, exp, subdir, send_reply);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL,
+               "Failed to resolve export dir: %s", subdir);
+        goto err;
+    }
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3_find_export (rpcsvc_request_t *req, char *path, struct mnt3_export **e)
+mnt3_find_export(rpcsvc_request_t *req, char *path, struct mnt3_export **e)
 {
-        int                     ret = -EFAULT;
-        struct mount3_state     *ms = NULL;
-        struct mnt3_export      *exp = NULL;
-
-        if ((!req) || (!path) || (!e))
-                return -1;
-
-        ms = (struct mount3_state *) rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                goto err;
-        }
+    int ret = -EFAULT;
+    struct mount3_state *ms = NULL;
+    struct mnt3_export *exp = NULL;
 
-        gf_msg_debug (GF_MNT, 0, "dirpath: %s", path);
-        exp = mnt3_mntpath_to_export (ms, path, _gf_false);
-        if (exp) {
-                ret = 0;
-                *e = exp;
-                goto err;
-        }
+    if ((!req) || (!path) || (!e))
+        return -1;
 
-        if (!gf_mnt3_export_dirs(ms)) {
-                ret = -1;
-                goto err;
-        }
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "Mount state not present");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        goto err;
+    }
+
+    gf_msg_debug(GF_MNT, 0, "dirpath: %s", path);
+    exp = mnt3_mntpath_to_export(ms, path, _gf_false);
+    if (exp) {
+        ret = 0;
+        *e = exp;
+        goto err;
+    }
 
-        ret = mnt3_parse_dir_exports (req, ms, path, _gf_true);
+    if (!gf_mnt3_export_dirs(ms)) {
+        ret = -1;
+        goto err;
+    }
+
+    ret = mnt3_parse_dir_exports(req, ms, path, _gf_true);
 
 err:
-        return ret;
+    return ret;
 }
 
 /**
@@ -1892,25 +1897,29 @@ err:
  *          failure: NULL
  */
 char *
-_mnt3_get_peer_addr (const rpcsvc_request_t *req)
+_mnt3_get_peer_addr(const rpcsvc_request_t *req)
 {
-        rpc_transport_t         *trans = NULL;
-        struct sockaddr_storage sastorage = {0, };
-        char                    peer[RPCSVC_PEER_STRLEN] = {0, };
-        char                    *peerdup = NULL;
-        int                     ret = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, req, out);
-
-        trans = rpcsvc_request_transport (req);
-        ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN,
-                                         &sastorage, sizeof (sastorage));
-        if (ret != 0)
-                goto out;
-
-        peerdup = gf_strdup (peer);
+    rpc_transport_t *trans = NULL;
+    struct sockaddr_storage sastorage = {
+        0,
+    };
+    char peer[RPCSVC_PEER_STRLEN] = {
+        0,
+    };
+    char *peerdup = NULL;
+    int ret = 0;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, req, out);
+
+    trans = rpcsvc_request_transport(req);
+    ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN, &sastorage,
+                                    sizeof(sastorage));
+    if (ret != 0)
+        goto out;
+
+    peerdup = gf_strdup(peer);
 out:
-        return peerdup;
+    return peerdup;
 }
 
 /**
@@ -1925,27 +1934,27 @@ out:
  *
  */
 char *
-_mnt3_get_host_from_peer (const char *peer_addr)
+_mnt3_get_host_from_peer(const char *peer_addr)
 {
-        char   *part       = NULL;
-        size_t host_len    = 0;
-        char   *colon      = NULL;
-
-        colon = strrchr (peer_addr, ':');
-        if (!colon) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_BAD_PEER,
-                        "Bad peer %s", peer_addr);
-                goto out;
-        }
-
-        host_len = colon - peer_addr;
-        if (host_len < RPCSVC_PEER_STRLEN)
-                part = gf_strndup (peer_addr, host_len);
-        else
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PEER_TOO_LONG,
-                        "Peer too long %s", peer_addr);
+    char *part = NULL;
+    size_t host_len = 0;
+    char *colon = NULL;
+
+    colon = strrchr(peer_addr, ':');
+    if (!colon) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_BAD_PEER, "Bad peer %s",
+               peer_addr);
+        goto out;
+    }
+
+    host_len = colon - peer_addr;
+    if (host_len < RPCSVC_PEER_STRLEN)
+        part = gf_strndup(peer_addr, host_len);
+    else
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PEER_TOO_LONG,
+               "Peer too long %s", peer_addr);
 out:
-        return part;
+    return part;
 }
 
 /**
@@ -1956,13 +1965,13 @@ out:
  *
  */
 int
-mnt3_check_cached_fh (struct mount3_state *ms, struct nfs3_fh *fh,
-                      const char *host_addr, gf_boolean_t is_write_op)
+mnt3_check_cached_fh(struct mount3_state *ms, struct nfs3_fh *fh,
+                     const char *host_addr, gf_boolean_t is_write_op)
 {
-        if (!is_write_op)
-                return is_nfs_fh_cached (ms->authcache, fh, host_addr);
+    if (!is_write_op)
+        return is_nfs_fh_cached(ms->authcache, fh, host_addr);
 
-        return is_nfs_fh_cached_and_writeable (ms->authcache, fh, host_addr);
+    return is_nfs_fh_cached_and_writeable(ms->authcache, fh, host_addr);
 }
 
 /**
@@ -1984,109 +1993,103 @@ mnt3_check_cached_fh (struct mount3_state *ms, struct nfs3_fh *fh,
  *          -EROFS  for unauthorized write operations (rm, mkdir, write)
  */
 int
-_mnt3_authenticate_req (struct mount3_state *ms, rpcsvc_request_t *req,
-                        struct nfs3_fh *fh, const char *path,
-                        char **authorized_export, char **authorized_host,
-                        gf_boolean_t is_write_op)
+_mnt3_authenticate_req(struct mount3_state *ms, rpcsvc_request_t *req,
+                       struct nfs3_fh *fh, const char *path,
+                       char **authorized_export, char **authorized_host,
+                       gf_boolean_t is_write_op)
 {
-        char                    *peer_addr       = NULL;
-        char                    *host_addr_ip    = NULL;
-        char                    *host_addr_fqdn  = NULL;
-        int                     auth_status_code = -EACCES;
-        char                    *pathdup         = NULL;
-        size_t                  dlen             = 0;
-        char                    *auth_host       = NULL;
-        gf_boolean_t            fh_cached        = _gf_false;
-        struct export_item      *expitem         = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_MNT, ms, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT, req, out);
-
-        peer_addr    = _mnt3_get_peer_addr (req);
-
-        if (!peer_addr)
-                goto free_and_out;
-
-        host_addr_ip = _mnt3_get_host_from_peer (peer_addr);
-
-        if (!host_addr_ip)
-                goto free_and_out;
-
-        if (path) {
-                /* Need to strip out trailing '/' */
-                pathdup = strdupa (path);
-                dlen = strlen (pathdup);
-                if (dlen > 0 && pathdup[dlen-1] == '/')
-                        pathdup[dlen-1] = '\0';
-        }
-
-        /* Check if the filehandle is cached */
-        fh_cached = mnt3_check_cached_fh (ms, fh, host_addr_ip, is_write_op);
-        if (fh_cached) {
-                gf_msg_trace (GF_MNT, 0, "Found cached FH for %s",
-                              host_addr_ip);
-                auth_status_code = 0;
-                goto free_and_out;
-        }
-
-        /* Check if the IP is authorized */
-        auth_status_code = mnt3_auth_host (ms->auth_params, host_addr_ip,
-                                           fh, pathdup, is_write_op, &expitem);
-
-        gf_msg_debug (GF_MNT, 0, "access from IP %s is %s", host_addr_ip,
-                      auth_status_code ? "denied" : "allowed");
-
-        if (auth_status_code != 0) {
-                /* If not, check if the FQDN is authorized */
-                host_addr_fqdn = gf_rev_dns_lookup (host_addr_ip);
-                auth_status_code = mnt3_auth_host (ms->auth_params,
-                                                   host_addr_fqdn,
-                                                   fh, pathdup, is_write_op,
-                                                   &expitem);
-
-                gf_msg_debug (GF_MNT, 0, "access from FQDN %s is %s",
-                              host_addr_fqdn, auth_status_code ? "denied" :
-                                                                 "allowed");
-
-                if (auth_status_code == 0)
-                        auth_host = host_addr_fqdn;
-        } else
-                auth_host = host_addr_ip;
-
-        /* Skip the lines that set authorized export &
-         * host if they are null.
-         */
-        if (!authorized_export || !authorized_host) {
-                /* Cache the file handle if it was authorized */
-                if (fh && auth_status_code == 0)
-                        cache_nfs_fh (ms->authcache, fh, host_addr_ip, expitem);
-
-                goto free_and_out;
-        }
-
-        if (!fh && auth_status_code == 0) {
-                *authorized_export = gf_strdup (pathdup);
-                if (!*authorized_export)
-                        gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "Allocation error when copying "
-                                "authorized path");
-
-                *authorized_host = gf_strdup (auth_host);
-                if (!*authorized_host)
-                        gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "Allocation error when copying "
-                                "authorized host");
-        }
+    char *peer_addr = NULL;
+    char *host_addr_ip = NULL;
+    char *host_addr_fqdn = NULL;
+    int auth_status_code = -EACCES;
+    char *pathdup = NULL;
+    size_t dlen = 0;
+    char *auth_host = NULL;
+    gf_boolean_t fh_cached = _gf_false;
+    struct export_item *expitem = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_MNT, ms, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT, req, out);
+
+    peer_addr = _mnt3_get_peer_addr(req);
+
+    if (!peer_addr)
+        goto free_and_out;
+
+    host_addr_ip = _mnt3_get_host_from_peer(peer_addr);
+
+    if (!host_addr_ip)
+        goto free_and_out;
+
+    if (path) {
+        /* Need to strip out trailing '/' */
+        pathdup = strdupa(path);
+        dlen = strlen(pathdup);
+        if (dlen > 0 && pathdup[dlen - 1] == '/')
+            pathdup[dlen - 1] = '\0';
+    }
+
+    /* Check if the filehandle is cached */
+    fh_cached = mnt3_check_cached_fh(ms, fh, host_addr_ip, is_write_op);
+    if (fh_cached) {
+        gf_msg_trace(GF_MNT, 0, "Found cached FH for %s", host_addr_ip);
+        auth_status_code = 0;
+        goto free_and_out;
+    }
+
+    /* Check if the IP is authorized */
+    auth_status_code = mnt3_auth_host(ms->auth_params, host_addr_ip, fh,
+                                      pathdup, is_write_op, &expitem);
+
+    gf_msg_debug(GF_MNT, 0, "access from IP %s is %s", host_addr_ip,
+                 auth_status_code ? "denied" : "allowed");
+
+    if (auth_status_code != 0) {
+        /* If not, check if the FQDN is authorized */
+        host_addr_fqdn = gf_rev_dns_lookup(host_addr_ip);
+        auth_status_code = mnt3_auth_host(ms->auth_params, host_addr_fqdn, fh,
+                                          pathdup, is_write_op, &expitem);
+
+        gf_msg_debug(GF_MNT, 0, "access from FQDN %s is %s", host_addr_fqdn,
+                     auth_status_code ? "denied" : "allowed");
+
+        if (auth_status_code == 0)
+            auth_host = host_addr_fqdn;
+    } else
+        auth_host = host_addr_ip;
+
+    /* Skip the lines that set authorized export &
+     * host if they are null.
+     */
+    if (!authorized_export || !authorized_host) {
+        /* Cache the file handle if it was authorized */
+        if (fh && auth_status_code == 0)
+            cache_nfs_fh(ms->authcache, fh, host_addr_ip, expitem);
+
+        goto free_and_out;
+    }
+
+    if (!fh && auth_status_code == 0) {
+        *authorized_export = gf_strdup(pathdup);
+        if (!*authorized_export)
+            gf_msg(GF_MNT, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Allocation error when copying "
+                   "authorized path");
+
+        *authorized_host = gf_strdup(auth_host);
+        if (!*authorized_host)
+            gf_msg(GF_MNT, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Allocation error when copying "
+                   "authorized host");
+    }
 
 free_and_out:
-        /* Free allocated strings after doing the auth */
-        GF_FREE (peer_addr);
-        GF_FREE (host_addr_fqdn);
-        GF_FREE (host_addr_ip);
+    /* Free allocated strings after doing the auth */
+    GF_FREE(peer_addr);
+    GF_FREE(host_addr_fqdn);
+    GF_FREE(host_addr_ip);
 out:
-        return auth_status_code;
+    return auth_status_code;
 }
 
 /**
@@ -2114,827 +2117,810 @@ out:
  *          -EROFS  for unauthorized write operations (rm, mkdir, write)
  */
 int
-mnt3_authenticate_request (struct mount3_state *ms, rpcsvc_request_t *req,
-                           struct nfs3_fh *fh, const char *volname,
-                           const char *path, char **authorized_path,
-                           char **authorized_host, gf_boolean_t is_write_op)
+mnt3_authenticate_request(struct mount3_state *ms, rpcsvc_request_t *req,
+                          struct nfs3_fh *fh, const char *volname,
+                          const char *path, char **authorized_path,
+                          char **authorized_host, gf_boolean_t is_write_op)
 {
-        int          auth_status_code       = -EACCES;
-        char         *parent_path = NULL;
-        const char   *parent_old  = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_MNT, ms, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT, req, out);
-
-        /* If this option is not set, just allow it through */
-        if (!ms->nfs->exports_auth) {
-                /* This function is called in a variety of use-cases (mount
-                 * + each fop) so path/authorized_path are not always present.
-                 * For the cases which it _is_ present we need to populate the
-                 * authorized_path. */
-                if (path && authorized_path)
-                        *authorized_path = gf_strdup (path);
-
-                auth_status_code = 0;
-                goto out;
-        }
-
-        /* First check if the path is allowed */
-        auth_status_code = _mnt3_authenticate_req (ms, req, fh, path,
-                                                   authorized_path,
-                                                   authorized_host,
-                                                   is_write_op);
-
-        /* If the filehandle is set, just exit since we have to make only
-         * one call to the function above
-         */
-        if (fh)
-                goto out;
-
-        parent_old = path;
-        while (auth_status_code != 0) {
-                /* Get the path's parent */
-                parent_path = gf_resolve_path_parent (parent_old);
-                if (!parent_path) /* Nothing left in the path to resolve */
-                        goto out;
-
-                /* Authenticate it */
-                auth_status_code = _mnt3_authenticate_req (ms, req, fh,
-                                                           parent_path,
-                                                           authorized_path,
-                                                           authorized_host,
-                                                           is_write_op);
-
-                parent_old = strdupa (parent_path); /* Copy the parent onto the
-                                                     * stack.
-                                                     */
-
-                GF_FREE (parent_path); /* Free the allocated parent string */
-        }
+    int auth_status_code = -EACCES;
+    char *parent_path = NULL;
+    const char *parent_old = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_MNT, ms, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT, req, out);
+
+    /* If this option is not set, just allow it through */
+    if (!ms->nfs->exports_auth) {
+        /* This function is called in a variety of use-cases (mount
+         * + each fop) so path/authorized_path are not always present.
+         * For the cases which it _is_ present we need to populate the
+         * authorized_path. */
+        if (path && authorized_path)
+            *authorized_path = gf_strdup(path);
+
+        auth_status_code = 0;
+        goto out;
+    }
+
+    /* First check if the path is allowed */
+    auth_status_code = _mnt3_authenticate_req(
+        ms, req, fh, path, authorized_path, authorized_host, is_write_op);
+
+    /* If the filehandle is set, just exit since we have to make only
+     * one call to the function above
+     */
+    if (fh)
+        goto out;
+
+    parent_old = path;
+    while (auth_status_code != 0) {
+        /* Get the path's parent */
+        parent_path = gf_resolve_path_parent(parent_old);
+        if (!parent_path) /* Nothing left in the path to resolve */
+            goto out;
+
+        /* Authenticate it */
+        auth_status_code = _mnt3_authenticate_req(ms, req, fh, parent_path,
+                                                  authorized_path,
+                                                  authorized_host, is_write_op);
+
+        parent_old = strdupa(parent_path); /* Copy the parent onto the
+                                            * stack.
+                                            */
+
+        GF_FREE(parent_path); /* Free the allocated parent string */
+    }
 
 out:
-        return auth_status_code;
+    return auth_status_code;
 }
 
 int
-mnt3svc_mnt (rpcsvc_request_t *req)
+mnt3svc_mnt(rpcsvc_request_t *req)
 {
-        struct iovec            pvec = {0, };
-        char                    path[MNTPATHLEN];
-        int                     ret = -1;
-        struct mount3_state     *ms = NULL;
-        mountstat3              mntstat = MNT3ERR_SERVERFAULT;
-        struct mnt3_export      *exp = NULL;
-        struct nfs_state        *nfs = NULL;
-        int                     authcode = 0;
-
-        if (!req)
-                return -1;
-
-        pvec.iov_base = path;
-        pvec.iov_len = MNTPATHLEN;
-        ret = xdr_to_mountpath (pvec, req->msg[0]);
-        if (ret == -1) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Failed to decode args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND,
-                        "Mount state not present");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = -1;
-                goto rpcerr;
-        }
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-        gf_msg_debug (GF_MNT, 0, "dirpath: %s", path);
-        ret = mnt3_find_export (req, path, &exp);
-        if (ret < 0) {
-                mntstat = mnt3svc_errno_to_mnterr (-ret);
-                goto mnterr;
-        } else if (!exp) {
-                /*
-                 * SPECIAL CASE: exp is NULL if "path" is subdir in
-                 * call to mnt3_find_export().
-                 *
-                 * This is subdir mount, we are already DONE!
-                 * nfs_subvolume_started() and mnt3_check_client_net_tcp()
-                 * validation are done in mnt3_parse_dir_exports()
-                 * which is invoked through mnt3_find_export().
-                 *
-                 * TODO: All mount should happen thorugh mnt3svc_mount()
-                 *       It needs more clean up.
-                 */
-                return (0);
-        }
-
-        if (!nfs_subvolume_started (nfs, exp->vol)) {
-                gf_msg_debug (GF_MNT, 0, "Volume %s not started",
-                              exp->vol->name);
-                ret = -1;
-                mntstat = MNT3ERR_NOENT;
-                goto mnterr;
-        }
-
-        ret = mnt3_check_client_net_tcp (req, exp->vol->name);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                mntstat = MNT3ERR_ACCES;
-                gf_msg_debug (GF_MNT, 0, "Client mount not allowed");
-                ret = -1;
-                goto mnterr;
-        }
+    struct iovec pvec = {
+        0,
+    };
+    char path[MNTPATHLEN];
+    int ret = -1;
+    struct mount3_state *ms = NULL;
+    mountstat3 mntstat = MNT3ERR_SERVERFAULT;
+    struct mnt3_export *exp = NULL;
+    struct nfs_state *nfs = NULL;
+    int authcode = 0;
+
+    if (!req)
+        return -1;
 
-        /* The second authentication check is the exports/netgroups
-         * check.
+    pvec.iov_base = path;
+    pvec.iov_len = MNTPATHLEN;
+    ret = xdr_to_mountpath(pvec, req->msg[0]);
+    if (ret == -1) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Failed to decode args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "Mount state not present");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = -1;
+        goto rpcerr;
+    }
+
+    nfs = (struct nfs_state *)ms->nfsx->private;
+    gf_msg_debug(GF_MNT, 0, "dirpath: %s", path);
+    ret = mnt3_find_export(req, path, &exp);
+    if (ret < 0) {
+        mntstat = mnt3svc_errno_to_mnterr(-ret);
+        goto mnterr;
+    } else if (!exp) {
+        /*
+         * SPECIAL CASE: exp is NULL if "path" is subdir in
+         * call to mnt3_find_export().
+         *
+         * This is subdir mount, we are already DONE!
+         * nfs_subvolume_started() and mnt3_check_client_net_tcp()
+         * validation are done in mnt3_parse_dir_exports()
+         * which is invoked through mnt3_find_export().
+         *
+         * TODO: All mount should happen thorugh mnt3svc_mount()
+         *       It needs more clean up.
          */
-        authcode = mnt3_authenticate_request (ms, req, NULL, NULL, path, NULL,
-                                              NULL, _gf_false);
-        if (authcode != 0) {
-                mntstat = MNT3ERR_ACCES;
-                gf_msg_debug (GF_MNT, 0, "Client mount not allowed");
-                ret = -1;
-                goto mnterr;
-        }
-
-        ret = mnt3svc_mount (req, ms, exp);
-
-        if (ret < 0)
-                mntstat = mnt3svc_errno_to_mnterr (-ret);
+        return (0);
+    }
+
+    if (!nfs_subvolume_started(nfs, exp->vol)) {
+        gf_msg_debug(GF_MNT, 0, "Volume %s not started", exp->vol->name);
+        ret = -1;
+        mntstat = MNT3ERR_NOENT;
+        goto mnterr;
+    }
+
+    ret = mnt3_check_client_net_tcp(req, exp->vol->name);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        mntstat = MNT3ERR_ACCES;
+        gf_msg_debug(GF_MNT, 0, "Client mount not allowed");
+        ret = -1;
+        goto mnterr;
+    }
+
+    /* The second authentication check is the exports/netgroups
+     * check.
+     */
+    authcode = mnt3_authenticate_request(ms, req, NULL, NULL, path, NULL, NULL,
+                                         _gf_false);
+    if (authcode != 0) {
+        mntstat = MNT3ERR_ACCES;
+        gf_msg_debug(GF_MNT, 0, "Client mount not allowed");
+        ret = -1;
+        goto mnterr;
+    }
+
+    ret = mnt3svc_mount(req, ms, exp);
+
+    if (ret < 0)
+        mntstat = mnt3svc_errno_to_mnterr(-ret);
 mnterr:
-        if (ret < 0) {
-                mnt3svc_mnt_error_reply (req, mntstat);
-                ret = 0;
-        }
+    if (ret < 0) {
+        mnt3svc_mnt_error_reply(req, mntstat);
+        ret = 0;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_null (rpcsvc_request_t *req)
+mnt3svc_null(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
+    struct iovec dummyvec = {
+        0,
+    };
 
-        if (!req) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Got NULL request!");
-                return 0;
-        }
-        rpcsvc_submit_generic (req, &dummyvec, 1,  NULL, 0, NULL);
+    if (!req) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Got NULL request!");
         return 0;
+    }
+    rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL);
+    return 0;
 }
 
-
 mountlist
-__build_mountlist (struct mount3_state *ms, int *count)
+__build_mountlist(struct mount3_state *ms, int *count)
 {
-        struct mountbody        *mlist = NULL;
-        struct mountbody        *prev = NULL;
-        struct mountbody        *first = NULL;
-        size_t                  namelen = 0;
-        int                     ret = -1;
-        struct mountentry       *me = NULL;
-
-        if ((!ms) || (!count))
-                return NULL;
-
-        /* read rmtab, other peers might have updated it */
-        mount_read_rmtab(ms);
-
-        *count = 0;
-        gf_msg_debug (GF_MNT, 0, "Building mount list:");
-        list_for_each_entry (me, &ms->mountlist, mlist) {
-                namelen = strlen (me->exname);
-                mlist = GF_CALLOC (1, sizeof (*mlist), gf_nfs_mt_mountbody);
-                if (!mlist) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Memory allocation failed");
-                        goto free_list;
-                }
-                if (!first)
-                        first = mlist;
-
-                mlist->ml_directory = GF_MALLOC (namelen + 2,
-                                                 gf_nfs_mt_char);
-                if (!mlist->ml_directory) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Memory allocation failed");
-                        goto free_list;
-                }
+    struct mountbody *mlist = NULL;
+    struct mountbody *prev = NULL;
+    struct mountbody *first = NULL;
+    size_t namelen = 0;
+    int ret = -1;
+    struct mountentry *me = NULL;
+
+    if ((!ms) || (!count))
+        return NULL;
 
-                strcpy (mlist->ml_directory, me->exname);
+    /* read rmtab, other peers might have updated it */
+    mount_read_rmtab(ms);
 
-                namelen = strlen (me->hostname);
-                mlist->ml_hostname = GF_MALLOC (namelen + 2,
-                                                gf_nfs_mt_char);
-                if (!mlist->ml_hostname) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Memory allocation failed");
-                        goto free_list;
-                }
+    *count = 0;
+    gf_msg_debug(GF_MNT, 0, "Building mount list:");
+    list_for_each_entry(me, &ms->mountlist, mlist)
+    {
+        namelen = strlen(me->exname);
+        mlist = GF_CALLOC(1, sizeof(*mlist), gf_nfs_mt_mountbody);
+        if (!mlist) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto free_list;
+        }
+        if (!first)
+            first = mlist;
 
-                strcat (mlist->ml_hostname, me->hostname);
+        mlist->ml_directory = GF_MALLOC(namelen + 2, gf_nfs_mt_char);
+        if (!mlist->ml_directory) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto free_list;
+        }
 
-                gf_msg_debug (GF_MNT, 0, "mount entry: dir: %s, host: %s",
-                              mlist->ml_directory, mlist->ml_hostname);
-                if (prev) {
-                        prev->ml_next = mlist;
-                        prev = mlist;
-                } else
-                        prev = mlist;
+        strcpy(mlist->ml_directory, me->exname);
 
-                (*count)++;
+        namelen = strlen(me->hostname);
+        mlist->ml_hostname = GF_MALLOC(namelen + 2, gf_nfs_mt_char);
+        if (!mlist->ml_hostname) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto free_list;
         }
 
-        ret = 0;
+        strcat(mlist->ml_hostname, me->hostname);
+
+        gf_msg_debug(GF_MNT, 0, "mount entry: dir: %s, host: %s",
+                     mlist->ml_directory, mlist->ml_hostname);
+        if (prev) {
+            prev->ml_next = mlist;
+            prev = mlist;
+        } else
+            prev = mlist;
+
+        (*count)++;
+    }
+
+    ret = 0;
 
 free_list:
-        if (ret == -1) {
-                xdr_free_mountlist (first);
-                first = NULL;
-        }
+    if (ret == -1) {
+        xdr_free_mountlist(first);
+        first = NULL;
+    }
 
-        return first;
+    return first;
 }
 
-
 mountlist
-mnt3svc_build_mountlist (struct mount3_state *ms, int *count)
+mnt3svc_build_mountlist(struct mount3_state *ms, int *count)
 {
-        struct mountbody        *first = NULL;
+    struct mountbody *first = NULL;
 
-        LOCK (&ms->mountlock);
-        {
-                first = __build_mountlist (ms, count);
-        }
-        UNLOCK (&ms->mountlock);
+    LOCK(&ms->mountlock);
+    {
+        first = __build_mountlist(ms, count);
+    }
+    UNLOCK(&ms->mountlock);
 
-        return first;
+    return first;
 }
 
-
 int
-mnt3svc_dump (rpcsvc_request_t *req)
+mnt3svc_dump(rpcsvc_request_t *req)
 {
-        int                     ret = -1;
-        struct mount3_state     *ms = NULL;
-        mountlist               mlist;
-        mountstat3              mstat = 0;
-        mnt3_serializer         sfunc = NULL;
-        void                    *arg = NULL;
-
-
-        if (!req)
-                return -1;
+    int ret = -1;
+    struct mount3_state *ms = NULL;
+    mountlist mlist;
+    mountstat3 mstat = 0;
+    mnt3_serializer sfunc = NULL;
+    void *arg = NULL;
+
+    if (!req)
+        return -1;
 
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                goto rpcerr;
-        }
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        goto rpcerr;
+    }
 
-        sfunc = (mnt3_serializer)xdr_serialize_mountlist;
-        mlist = mnt3svc_build_mountlist (ms, &ret);
-        arg = &mlist;
+    sfunc = (mnt3_serializer)xdr_serialize_mountlist;
+    mlist = mnt3svc_build_mountlist(ms, &ret);
+    arg = &mlist;
 
-        if (!mlist) {
-                if (ret != 0) {
-                        rpcsvc_request_seterr (req, SYSTEM_ERR);
-                        ret = -1;
-                        goto rpcerr;
-                } else {
-                        arg = &mstat;
-                        sfunc = (mnt3_serializer)xdr_serialize_mountstat3;
-                }
+    if (!mlist) {
+        if (ret != 0) {
+            rpcsvc_request_seterr(req, SYSTEM_ERR);
+            ret = -1;
+            goto rpcerr;
+        } else {
+            arg = &mstat;
+            sfunc = (mnt3_serializer)xdr_serialize_mountstat3;
         }
+    }
 
-        mnt3svc_submit_reply (req, arg, sfunc);
+    mnt3svc_submit_reply(req, arg, sfunc);
 
-        xdr_free_mountlist (mlist);
-        ret = 0;
+    xdr_free_mountlist(mlist);
+    ret = 0;
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_umount (struct mount3_state *ms, char *dirpath, char *hostname)
+mnt3svc_umount(struct mount3_state *ms, char *dirpath, char *hostname)
 {
-        struct mountentry       *me = NULL;
-        int                     ret = -1;
-        gf_store_handle_t       *sh = NULL;
-        struct nfs_state        *nfs = NULL;
-        gf_boolean_t            update_rmtab = _gf_false;
-
-        if ((!ms) || (!dirpath) || (!hostname))
-                return -1;
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-
-        update_rmtab = mount_open_rmtab (nfs->rmtab, &sh);
-        if (update_rmtab) {
-                ret = gf_store_lock (sh);
-                if (ret)
-                        goto out_free;
-        }
-
-        LOCK (&ms->mountlock);
-        {
-                if (update_rmtab)
-                        __mount_read_rmtab (sh, &ms->mountlist, _gf_false);
+    struct mountentry *me = NULL;
+    int ret = -1;
+    gf_store_handle_t *sh = NULL;
+    struct nfs_state *nfs = NULL;
+    gf_boolean_t update_rmtab = _gf_false;
 
-                if (list_empty (&ms->mountlist)) {
-                        ret = 0;
-                        goto out_unlock;
-                }
+    if ((!ms) || (!dirpath) || (!hostname))
+        return -1;
 
-                ret = -1;
-                list_for_each_entry (me, &ms->mountlist, mlist) {
-                       if ((strcmp (me->exname, dirpath) == 0) &&
-                            (strcmp (me->hostname, hostname) == 0)) {
-                               ret = 0;
-                               break;
-                       }
-                }
+    nfs = (struct nfs_state *)ms->nfsx->private;
 
-                /* Need this check here because at the end of the search me
-                 * might still be pointing to the last entry, which may not be
-                 * the one we're looking for.
-                 */
-                if (ret == -1)  {/* Not found in list. */
-                        gf_msg_trace (GF_MNT, 0, "Export not found");
-                        goto out_unlock;
-                }
+    update_rmtab = mount_open_rmtab(nfs->rmtab, &sh);
+    if (update_rmtab) {
+        ret = gf_store_lock(sh);
+        if (ret)
+            goto out_free;
+    }
 
-                if (!me)
-                        goto out_unlock;
+    LOCK(&ms->mountlock);
+    {
+        if (update_rmtab)
+            __mount_read_rmtab(sh, &ms->mountlist, _gf_false);
 
-                gf_msg_debug (GF_MNT, 0, "Unmounting: dir %s, host: %s",
-                              me->exname, me->hostname);
+        if (list_empty(&ms->mountlist)) {
+            ret = 0;
+            goto out_unlock;
+        }
 
-                list_del (&me->mlist);
-                GF_FREE (me);
+        ret = -1;
+        list_for_each_entry(me, &ms->mountlist, mlist)
+        {
+            if ((strcmp(me->exname, dirpath) == 0) &&
+                (strcmp(me->hostname, hostname) == 0)) {
+                ret = 0;
+                break;
+            }
+        }
 
-                if (update_rmtab)
-                        __mount_rewrite_rmtab (ms, sh);
+        /* Need this check here because at the end of the search me
+         * might still be pointing to the last entry, which may not be
+         * the one we're looking for.
+         */
+        if (ret == -1) { /* Not found in list. */
+            gf_msg_trace(GF_MNT, 0, "Export not found");
+            goto out_unlock;
         }
-out_unlock:
-        UNLOCK (&ms->mountlock);
+
+        if (!me)
+            goto out_unlock;
+
+        gf_msg_debug(GF_MNT, 0, "Unmounting: dir %s, host: %s", me->exname,
+                     me->hostname);
+
+        list_del(&me->mlist);
+        GF_FREE(me);
 
         if (update_rmtab)
-                gf_store_unlock (sh);
+            __mount_rewrite_rmtab(ms, sh);
+    }
+out_unlock:
+    UNLOCK(&ms->mountlock);
+
+    if (update_rmtab)
+        gf_store_unlock(sh);
 
 out_free:
-        if (update_rmtab)
-                gf_store_handle_destroy (sh);
+    if (update_rmtab)
+        gf_store_handle_destroy(sh);
 
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_umnt (rpcsvc_request_t *req)
+mnt3svc_umnt(rpcsvc_request_t *req)
 {
-        char                    hostname[MNTPATHLEN];
-        char                    dirpath[MNTPATHLEN];
-        struct iovec            pvec = {0, };
-        int                     ret = -1;
-        struct mount3_state     *ms = NULL;
-        mountstat3              mstat = MNT3_OK;
-        char                    *colon = NULL;
-
-        if (!req)
-                return -1;
-
-        /* Remove the mount point from the exports list. */
-        pvec.iov_base = dirpath;
-        pvec.iov_len = MNTPATHLEN;
-        ret = xdr_to_mountpath (pvec, req->msg[0]);
-        if (ret == -1) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Failed decode args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = -1;
-                goto rpcerr;
-        }
-
-        ret = rpcsvc_transport_peername (req->trans, hostname, MNTPATHLEN);
-        if (ret != 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT,
-                        NFS_MSG_GET_REMOTE_NAME_FAIL,
-                        "Failed to get remote name: %s", gai_strerror (ret));
-                goto rpcerr;
-        }
+    char hostname[MNTPATHLEN];
+    char dirpath[MNTPATHLEN];
+    struct iovec pvec = {
+        0,
+    };
+    int ret = -1;
+    struct mount3_state *ms = NULL;
+    mountstat3 mstat = MNT3_OK;
+    char *colon = NULL;
+
+    if (!req)
+        return -1;
 
-        colon = strrchr (hostname, ':');
-        if (colon) {
-                *colon= '\0';
-        }
-        gf_path_strip_trailing_slashes (dirpath);
-        gf_msg_debug (GF_MNT, 0, "dirpath: %s, hostname: %s", dirpath,
-                      hostname);
-        ret = mnt3svc_umount (ms, dirpath, hostname);
+    /* Remove the mount point from the exports list. */
+    pvec.iov_base = dirpath;
+    pvec.iov_len = MNTPATHLEN;
+    ret = xdr_to_mountpath(pvec, req->msg[0]);
+    if (ret == -1) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Failed decode args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "Mount state not present");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = -1;
+        goto rpcerr;
+    }
+
+    ret = rpcsvc_transport_peername(req->trans, hostname, MNTPATHLEN);
+    if (ret != 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOENT, NFS_MSG_GET_REMOTE_NAME_FAIL,
+               "Failed to get remote name: %s", gai_strerror(ret));
+        goto rpcerr;
+    }
+
+    colon = strrchr(hostname, ':');
+    if (colon) {
+        *colon = '\0';
+    }
+    gf_path_strip_trailing_slashes(dirpath);
+    gf_msg_debug(GF_MNT, 0, "dirpath: %s, hostname: %s", dirpath, hostname);
+    ret = mnt3svc_umount(ms, dirpath, hostname);
 
-        if (ret == -1) {
-                ret = 0;
-                mstat = MNT3ERR_NOENT;
-        }
-        /* FIXME: also take care of the corner case where the
-         * client was resolvable at mount but not at the umount - vice-versa.
-         */
-        mnt3svc_submit_reply (req, &mstat,
-                              (mnt3_serializer)xdr_serialize_mountstat3);
+    if (ret == -1) {
+        ret = 0;
+        mstat = MNT3ERR_NOENT;
+    }
+    /* FIXME: also take care of the corner case where the
+     * client was resolvable at mount but not at the umount - vice-versa.
+     */
+    mnt3svc_submit_reply(req, &mstat,
+                         (mnt3_serializer)xdr_serialize_mountstat3);
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-__mnt3svc_umountall (struct mount3_state *ms)
+__mnt3svc_umountall(struct mount3_state *ms)
 {
-        struct mountentry       *me = NULL;
-        struct mountentry       *tmp = NULL;
+    struct mountentry *me = NULL;
+    struct mountentry *tmp = NULL;
 
-        if (!ms)
-                return -1;
+    if (!ms)
+        return -1;
 
-        if (list_empty (&ms->mountlist))
-                return 0;
+    if (list_empty(&ms->mountlist))
+        return 0;
 
-        list_for_each_entry_safe (me, tmp, &ms->mountlist, mlist) {
-                list_del (&me->mlist);       /* Remove from the mount list */
-                __mountdict_remove (ms, me); /* Remove from the mount dict */
-                GF_FREE (me);
-        }
+    list_for_each_entry_safe(me, tmp, &ms->mountlist, mlist)
+    {
+        list_del(&me->mlist);       /* Remove from the mount list */
+        __mountdict_remove(ms, me); /* Remove from the mount dict */
+        GF_FREE(me);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-mnt3svc_umountall (struct mount3_state *ms)
+mnt3svc_umountall(struct mount3_state *ms)
 {
-        int     ret = -1;
-        if (!ms)
-                return -1;
+    int ret = -1;
+    if (!ms)
+        return -1;
 
-        LOCK (&ms->mountlock);
-        {
-               ret = __mnt3svc_umountall (ms);
-        }
-        UNLOCK (&ms->mountlock);
+    LOCK(&ms->mountlock);
+    {
+        ret = __mnt3svc_umountall(ms);
+    }
+    UNLOCK(&ms->mountlock);
 
-        return ret;
+    return ret;
 }
 
-
 int
-mnt3svc_umntall (rpcsvc_request_t *req)
+mnt3svc_umntall(rpcsvc_request_t *req)
 {
-        int                     ret = RPCSVC_ACTOR_ERROR;
-        struct mount3_state     *ms = NULL;
-        mountstat3              mstat = MNT3_OK;
-
-        if (!req)
-                return ret;
-
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                goto rpcerr;
-        }
+    int ret = RPCSVC_ACTOR_ERROR;
+    struct mount3_state *ms = NULL;
+    mountstat3 mstat = MNT3_OK;
+
+    if (!req)
+        return ret;
+
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "Mount state not present");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        goto rpcerr;
+    }
 
-        mnt3svc_umountall (ms);
-        mnt3svc_submit_reply (req, &mstat,
-                              (mnt3_serializer)xdr_serialize_mountstat3);
+    mnt3svc_umountall(ms);
+    mnt3svc_submit_reply(req, &mstat,
+                         (mnt3_serializer)xdr_serialize_mountstat3);
 
-        ret = RPCSVC_ACTOR_SUCCESS;
+    ret = RPCSVC_ACTOR_SUCCESS;
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 exports
-mnt3_xlchildren_to_exports (rpcsvc_t *svc, struct mount3_state *ms)
+mnt3_xlchildren_to_exports(rpcsvc_t *svc, struct mount3_state *ms)
 {
-        struct exportnode       *elist = NULL;
-        struct exportnode       *prev = NULL;
-        struct exportnode       *first = NULL;
-        size_t                  namelen = 0;
-        int                     ret = -1;
-        char                    *addrstr = NULL;
-        struct mnt3_export      *ent = NULL;
-        struct nfs_state        *nfs = NULL;
-
-        if ((!ms) || (!svc))
-                return NULL;
-
-        nfs = (struct nfs_state *)ms->nfsx->private;
-        if (!nfs)
-                return NULL;
-
-        LOCK (&ms->mountlock);
-        list_for_each_entry(ent, &ms->exportlist, explist) {
-
-                /* If volume is not started yet, do not list it for tools like
-                 * showmount.
-                 */
-                if (!nfs_subvolume_started (nfs, ent->vol))
-                        continue;
-
-                elist = GF_CALLOC (1, sizeof (*elist), gf_nfs_mt_exportnode);
-                if (!elist) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Memory allocation failed");
-                        goto free_list;
-                }
-                 if (!first)
-                         first = elist;
-                namelen = strlen (ent->expname);
-                elist->ex_dir = GF_MALLOC (namelen + 2,
-                                           gf_nfs_mt_char);
-                if (!elist->ex_dir) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Memory allocation failed");
-                        goto free_list;
+    struct exportnode *elist = NULL;
+    struct exportnode *prev = NULL;
+    struct exportnode *first = NULL;
+    size_t namelen = 0;
+    int ret = -1;
+    char *addrstr = NULL;
+    struct mnt3_export *ent = NULL;
+    struct nfs_state *nfs = NULL;
+
+    if ((!ms) || (!svc))
+        return NULL;
+
+    nfs = (struct nfs_state *)ms->nfsx->private;
+    if (!nfs)
+        return NULL;
+
+    LOCK(&ms->mountlock);
+    list_for_each_entry(ent, &ms->exportlist, explist)
+    {
+        /* If volume is not started yet, do not list it for tools like
+         * showmount.
+         */
+        if (!nfs_subvolume_started(nfs, ent->vol))
+            continue;
+
+        elist = GF_CALLOC(1, sizeof(*elist), gf_nfs_mt_exportnode);
+        if (!elist) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto free_list;
+        }
+        if (!first)
+            first = elist;
+        namelen = strlen(ent->expname);
+        elist->ex_dir = GF_MALLOC(namelen + 2, gf_nfs_mt_char);
+        if (!elist->ex_dir) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto free_list;
+        }
+        strcpy(elist->ex_dir, ent->expname);
+
+        addrstr = rpcsvc_volume_allowed(svc->options, ent->vol->name);
+        if (addrstr) {
+            /* create a groupnode per allowed client */
+            char *pos = NULL;
+            char *addr = NULL;
+            char *addrs = NULL;
+            struct groupnode *group = NULL;
+            struct groupnode *prev_group = NULL;
+
+            /* strtok_r() modifies the string, dup it */
+            addrs = gf_strdup(addrstr);
+            if (!addrs)
+                goto free_list;
+
+            while (1) {
+                /* only pass addrs on the 1st call */
+                addr = strtok_r(group ? NULL : addrs, ",", &pos);
+                if (addr == NULL)
+                    /* no mode clients */
+                    break;
+
+                group = GF_CALLOC(1, sizeof(struct groupnode),
+                                  gf_nfs_mt_groupnode);
+                if (!group) {
+                    gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                           "Memory "
+                           "allocation failed");
+                    GF_FREE(addrs);
+                    goto free_list;
                 }
-                strcpy (elist->ex_dir, ent->expname);
-
-                addrstr = rpcsvc_volume_allowed (svc->options, ent->vol->name);
-                if (addrstr) {
-                        /* create a groupnode per allowed client */
-                        char             *pos        = NULL;
-                        char             *addr       = NULL;
-                        char             *addrs      = NULL;
-                        struct groupnode *group      = NULL;
-                        struct groupnode *prev_group = NULL;
-
-                        /* strtok_r() modifies the string, dup it */
-                        addrs = gf_strdup (addrstr);
-                        if (!addrs)
-                                goto free_list;
-
-                        while (1) {
-                                /* only pass addrs on the 1st call */
-                                addr = strtok_r (group ? NULL : addrs, ",",
-                                                 &pos);
-                                if (addr == NULL)
-                                        /* no mode clients */
-                                        break;
-
-                                group = GF_CALLOC (1, sizeof (struct groupnode),
-                                                   gf_nfs_mt_groupnode);
-                                if (!group) {
-                                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                                NFS_MSG_NO_MEMORY, "Memory "
-                                                "allocation failed");
-                                        GF_FREE (addrs);
-                                        goto free_list;
-                                }
-
-                                group->gr_name = gf_strdup (addr);
-                                if (!group->gr_name) {
-                                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                                NFS_MSG_NO_MEMORY, "Memory "
-                                                "allocation failed");
-                                        GF_FREE (group);
-                                        GF_FREE (addrs);
-                                        goto free_list;
-                                }
-
-                                /* chain the groups together */
-                                if (!elist->ex_groups)
-                                        elist->ex_groups = group;
-                                else if (!prev_group->gr_next)
-                                        prev_group->gr_next = group;
-                                prev_group = group;
-                        }
-
-                        GF_FREE (addrs);
-                } else {
-                        elist->ex_groups = GF_CALLOC (1,
-                                                      sizeof (struct groupnode),
-                                                      gf_nfs_mt_groupnode);
-                        if (!elist->ex_groups) {
-                                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                        NFS_MSG_NO_MEMORY, "Memory allocation "
-                                        "failed");
-                                goto free_list;
-                        }
-
-                        addrstr = gf_strdup ("No Access");
-                        if (!addrstr)
-                                goto free_list;
-
-                        elist->ex_groups->gr_name = addrstr;
+
+                group->gr_name = gf_strdup(addr);
+                if (!group->gr_name) {
+                    gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                           "Memory "
+                           "allocation failed");
+                    GF_FREE(group);
+                    GF_FREE(addrs);
+                    goto free_list;
                 }
 
-                if (prev) {
-                        prev->ex_next = elist;
-                        prev = elist;
-                } else
-                        prev = elist;
+                /* chain the groups together */
+                if (!elist->ex_groups)
+                    elist->ex_groups = group;
+                else if (!prev_group->gr_next)
+                    prev_group->gr_next = group;
+                prev_group = group;
+            }
+
+            GF_FREE(addrs);
+        } else {
+            elist->ex_groups = GF_CALLOC(1, sizeof(struct groupnode),
+                                         gf_nfs_mt_groupnode);
+            if (!elist->ex_groups) {
+                gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                       "Memory allocation "
+                       "failed");
+                goto free_list;
+            }
+
+            addrstr = gf_strdup("No Access");
+            if (!addrstr)
+                goto free_list;
+
+            elist->ex_groups->gr_name = addrstr;
         }
 
-        ret = 0;
+        if (prev) {
+            prev->ex_next = elist;
+            prev = elist;
+        } else
+            prev = elist;
+    }
+
+    ret = 0;
 
 free_list:
-        UNLOCK (&ms->mountlock);
-        if (ret == -1) {
-                xdr_free_exports_list (first);
-                first = NULL;
-        }
+    UNLOCK(&ms->mountlock);
+    if (ret == -1) {
+        xdr_free_exports_list(first);
+        first = NULL;
+    }
 
-        return first;
+    return first;
 }
 
-
 int
-mnt3svc_export (rpcsvc_request_t *req)
+mnt3svc_export(rpcsvc_request_t *req)
 {
-        struct mount3_state     *ms = NULL;
-        exports                 elist = NULL;
-        int                     ret = -1;
-
-        if (!req)
-                return -1;
-
-        ms = (struct mount3_state *)rpcsvc_request_program_private (req);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                goto err;
-        }
+    struct mount3_state *ms = NULL;
+    exports elist = NULL;
+    int ret = -1;
 
-        /* Using the children translator names, build the export list */
-        elist = mnt3_xlchildren_to_exports (rpcsvc_request_service (req),
-                                            ms);
-        /* Do not return error when exports list is empty. An exports list can
-         * be empty when no subvolumes have come up. No point returning error
-         * and confusing the user.
-        if (!elist) {
-                gf_log (GF_MNT, GF_LOG_ERROR, "Failed to build exports list");
-                nfs_rpcsvc_request_seterr (req, SYSTEM_ERR);
-                goto err;
-        }
-        */
-
-        /* Note how the serializer is passed to the generic reply function. */
-        mnt3svc_submit_reply (req, &elist,
-                              (mnt3_serializer)xdr_serialize_exports);
+    if (!req)
+        return -1;
 
-        xdr_free_exports_list (elist);
-        ret = 0;
+    ms = (struct mount3_state *)rpcsvc_request_program_private(req);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_NOT_FOUND,
+               "mount state not found");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        goto err;
+    }
+
+    /* Using the children translator names, build the export list */
+    elist = mnt3_xlchildren_to_exports(rpcsvc_request_service(req), ms);
+    /* Do not return error when exports list is empty. An exports list can
+     * be empty when no subvolumes have come up. No point returning error
+     * and confusing the user.
+    if (!elist) {
+            gf_log (GF_MNT, GF_LOG_ERROR, "Failed to build exports list");
+            nfs_rpcsvc_request_seterr (req, SYSTEM_ERR);
+            goto err;
+    }
+    */
+
+    /* Note how the serializer is passed to the generic reply function. */
+    mnt3svc_submit_reply(req, &elist, (mnt3_serializer)xdr_serialize_exports);
+
+    xdr_free_exports_list(elist);
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 /*
  * __mnt3udp_get_mstate() Fetches mount3_state from xlator
  * Linkage: Static
  * Usage: Used only for UDP MOUNT codepath
  */
 static struct mount3_state *
-__mnt3udp_get_mstate (xlator_t *nfsx)
+__mnt3udp_get_mstate(xlator_t *nfsx)
 {
-        struct nfs_state        *nfs = NULL;
-        struct mount3_state     *ms = NULL;
+    struct nfs_state *nfs = NULL;
+    struct mount3_state *ms = NULL;
 
-        if (nfsx == NULL)
-                return NULL;
+    if (nfsx == NULL)
+        return NULL;
 
-        nfs = (struct nfs_state *)nfsx->private;
-        if (nfs == NULL)
-                return NULL;
+    nfs = (struct nfs_state *)nfsx->private;
+    if (nfs == NULL)
+        return NULL;
 
-        ms = (struct mount3_state *)nfs->mstate;
-        return ms;
+    ms = (struct mount3_state *)nfs->mstate;
+    return ms;
 }
 
 extern int
-glfs_resolve_at (struct glfs *, xlator_t *, inode_t *,
-                 const char *, loc_t *, struct iatt *, int, int);
+glfs_resolve_at(struct glfs *, xlator_t *, inode_t *, const char *, loc_t *,
+                struct iatt *, int, int);
 
 extern struct glfs *
-glfs_new_from_ctx (glusterfs_ctx_t *);
+glfs_new_from_ctx(glusterfs_ctx_t *);
 
 extern void
-glfs_free_from_ctx (struct glfs *);
+glfs_free_from_ctx(struct glfs *);
 
 static inode_t *
-__mnt3udp_get_export_subdir_inode (struct svc_req *req, char *subdir,
-                                   char *expname, /* OUT */
-                                   struct mnt3_export *exp)
+__mnt3udp_get_export_subdir_inode(struct svc_req *req, char *subdir,
+                                  char *expname, /* OUT */
+                                  struct mnt3_export *exp)
 {
-        inode_t                 *inode = NULL;
-        loc_t                   loc = {0, };
-        struct iatt             buf = {0, };
-        int                     ret = -1;
-        glfs_t                  *fs = NULL;
-
-        if ((!req) || (!subdir) || (!expname) || (!exp))
-                return NULL;
+    inode_t *inode = NULL;
+    loc_t loc = {
+        0,
+    };
+    struct iatt buf = {
+        0,
+    };
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    if ((!req) || (!subdir) || (!expname) || (!exp))
+        return NULL;
 
-        /* AUTH check for subdir i.e. nfs.export-dir */
-        if (exp->hostspec) {
-                struct sockaddr_in *sin = NULL;
+    /* AUTH check for subdir i.e. nfs.export-dir */
+    if (exp->hostspec) {
+        struct sockaddr_in *sin = NULL;
 
 #if !defined(_TIRPC_SVC_H)
-                sin = svc_getcaller (req->rq_xprt);
+        sin = svc_getcaller(req->rq_xprt);
 #else
-                sin = (struct sockaddr_in *)svc_getcaller (req->rq_xprt);
-                /* TIRPC's svc_getcaller() returns a pointer to a
-                 * sockaddr_in6, even though it might actually be an
-                 * IPv4 address. It ought return a struct sockaddr and
-                 * make the caller upcast it to the proper address family.
-                 */
+        sin = (struct sockaddr_in *)svc_getcaller(req->rq_xprt);
+        /* TIRPC's svc_getcaller() returns a pointer to a
+         * sockaddr_in6, even though it might actually be an
+         * IPv4 address. It ought return a struct sockaddr and
+         * make the caller upcast it to the proper address family.
+         */
 #endif
-                /* And let's make sure that it's actually an IPv4 address. */
-                GF_ASSERT (sin->sin_family == AF_INET);
-
-                ret = mnt3_verify_auth (sin, exp);
-                if (ret) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, EACCES,
-                                NFS_MSG_AUTH_VERIFY_FAILED,
-                                "AUTH(nfs.export-dir) verification failed");
-                        errno = EACCES;
-                        return NULL;
-                }
-        }
+        /* And let's make sure that it's actually an IPv4 address. */
+        GF_ASSERT(sin->sin_family == AF_INET);
 
-        /*
-         * IMP: glfs_t fs object is not used by glfs_resolve_at (). The main
-         * purpose is to not change the ABI of glfs_resolve_at () and not to
-         * pass a NULL object.
-         *
-         * TODO: Instead of linking against libgfapi.so, just for one API
-         * i.e. glfs_resolve_at(), It would be cleaner if PATH name to
-         * inode resolution code can be moved to libglusterfs.so or so.
-         * refer bugzilla for more details :
-         * https://bugzilla.redhat.com/show_bug.cgi?id=1161573
-         */
-        fs = glfs_new_from_ctx (exp->vol->ctx);
-        if (!fs)
-                return NULL;
+        ret = mnt3_verify_auth(sin, exp);
+        if (ret) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, EACCES, NFS_MSG_AUTH_VERIFY_FAILED,
+                   "AUTH(nfs.export-dir) verification failed");
+            errno = EACCES;
+            return NULL;
+        }
+    }
+
+    /*
+     * IMP: glfs_t fs object is not used by glfs_resolve_at (). The main
+     * purpose is to not change the ABI of glfs_resolve_at () and not to
+     * pass a NULL object.
+     *
+     * TODO: Instead of linking against libgfapi.so, just for one API
+     * i.e. glfs_resolve_at(), It would be cleaner if PATH name to
+     * inode resolution code can be moved to libglusterfs.so or so.
+     * refer bugzilla for more details :
+     * https://bugzilla.redhat.com/show_bug.cgi?id=1161573
+     */
+    fs = glfs_new_from_ctx(exp->vol->ctx);
+    if (!fs)
+        return NULL;
 
-        ret = glfs_resolve_at (fs, exp->vol, NULL, subdir,
-                               &loc, &buf, 1 /* Follow link */,
-                               0 /* Hard lookup */);
+    ret = glfs_resolve_at(fs, exp->vol, NULL, subdir, &loc, &buf,
+                          1 /* Follow link */, 0 /* Hard lookup */);
 
-        glfs_free_from_ctx (fs);
+    glfs_free_from_ctx(fs);
 
-        if (ret != 0) {
-                loc_wipe (&loc);
-                return NULL;
-        }
+    if (ret != 0) {
+        loc_wipe(&loc);
+        return NULL;
+    }
 
-        inode = inode_ref (loc.inode);
-        snprintf (expname, PATH_MAX, "/%s%s", exp->vol->name, loc.path);
+    inode = inode_ref(loc.inode);
+    snprintf(expname, PATH_MAX, "/%s%s", exp->vol->name, loc.path);
 
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return inode;
+    return inode;
 }
 
 static inode_t *
-__mnt3udp_get_export_volume_inode (struct svc_req *req, char *volpath,
-                                   char *expname, /* OUT */
-                                   struct mnt3_export *exp)
+__mnt3udp_get_export_volume_inode(struct svc_req *req, char *volpath,
+                                  char *expname, /* OUT */
+                                  struct mnt3_export *exp)
 {
-        char                    *rpath = NULL;
-        inode_t                 *inode = NULL;
+    char *rpath = NULL;
+    inode_t *inode = NULL;
 
-        if ((!req) || (!volpath) || (!expname) || (!exp))
-                return NULL;
+    if ((!req) || (!volpath) || (!expname) || (!exp))
+        return NULL;
 
-        rpath = strchr (volpath, '/');
-        if (rpath == NULL)
-                rpath = "/";
+    rpath = strchr(volpath, '/');
+    if (rpath == NULL)
+        rpath = "/";
 
-        inode = inode_from_path (exp->vol->itable, rpath);
-        snprintf (expname, PATH_MAX, "/%s", exp->vol->name);
+    inode = inode_from_path(exp->vol->itable, rpath);
+    snprintf(expname, PATH_MAX, "/%s", exp->vol->name);
 
-        return inode;
+    return inode;
 }
 
 /*
@@ -2943,162 +2929,161 @@ __mnt3udp_get_export_volume_inode (struct svc_req *req, char *volpath,
  * when nfs.mount-udp is ENABLED (set to TRUE/ON).
  */
 struct nfs3_fh *
-nfs3_rootfh (struct svc_req *req, xlator_t *nfsx,
-             char *path, char *expname /* OUT */)
+nfs3_rootfh(struct svc_req *req, xlator_t *nfsx, char *path,
+            char *expname /* OUT */)
 {
-        struct nfs3_fh          *fh = NULL;
-        inode_t                 *inode = NULL;
-        struct mnt3_export      *exp = NULL;
-        struct mount3_state     *ms = NULL;
-        struct nfs_state        *nfs = NULL;
-        int                     mnt3type = MNT3_EXPTYPE_DIR;
-        int                     ret = RPCSVC_AUTH_REJECT;
-
-        if ((!req) || (!nfsx) || (!path) || (!expname)) {
-                errno = EFAULT;
-                return NULL;
-        }
-
-        /*
-         * 1. First check if the MOUNT is for whole volume.
-         *      i.e. __mnt3udp_get_export_volume_inode ()
-         * 2. If NOT, then TRY for SUBDIR MOUNT.
-         *      i.e. __mnt3udp_get_export_subdir_inode ()
-         * 3. If a subdir is exported using nfs.export-dir,
-         *      then the mount type would be MNT3_EXPTYPE_DIR,
-         *      so make sure to find the proper path to be
-         *      resolved using mnt3_get_volume_subdir()
-         * 3. Make sure subdir export is allowed.
-         */
-        ms = __mnt3udp_get_mstate(nfsx);
-        if (!ms) {
-                errno = EFAULT;
-                return NULL;
-        }
-
-        exp = mnt3_mntpath_to_export (ms, path , _gf_false);
-        if (exp != NULL)
-                mnt3type = exp->exptype;
+    struct nfs3_fh *fh = NULL;
+    inode_t *inode = NULL;
+    struct mnt3_export *exp = NULL;
+    struct mount3_state *ms = NULL;
+    struct nfs_state *nfs = NULL;
+    int mnt3type = MNT3_EXPTYPE_DIR;
+    int ret = RPCSVC_AUTH_REJECT;
+
+    if ((!req) || (!nfsx) || (!path) || (!expname)) {
+        errno = EFAULT;
+        return NULL;
+    }
+
+    /*
+     * 1. First check if the MOUNT is for whole volume.
+     *      i.e. __mnt3udp_get_export_volume_inode ()
+     * 2. If NOT, then TRY for SUBDIR MOUNT.
+     *      i.e. __mnt3udp_get_export_subdir_inode ()
+     * 3. If a subdir is exported using nfs.export-dir,
+     *      then the mount type would be MNT3_EXPTYPE_DIR,
+     *      so make sure to find the proper path to be
+     *      resolved using mnt3_get_volume_subdir()
+     * 3. Make sure subdir export is allowed.
+     */
+    ms = __mnt3udp_get_mstate(nfsx);
+    if (!ms) {
+        errno = EFAULT;
+        return NULL;
+    }
 
-        if (mnt3type == MNT3_EXPTYPE_DIR) {
-                char    volname [MNTPATHLEN] = {0, };
-                char    *volptr = volname;
+    exp = mnt3_mntpath_to_export(ms, path, _gf_false);
+    if (exp != NULL)
+        mnt3type = exp->exptype;
 
-                /* Subdir export (nfs3.export-dirs) check */
-                if (!gf_mnt3_export_dirs(ms)) {
-                        errno = EACCES;
-                        return NULL;
-                }
+    if (mnt3type == MNT3_EXPTYPE_DIR) {
+        char volname[MNTPATHLEN] = {
+            0,
+        };
+        char *volptr = volname;
 
-                path = mnt3_get_volume_subdir (path, &volptr);
-                if (exp == NULL)
-                        exp = mnt3_mntpath_to_export (ms, volname , _gf_false);
+        /* Subdir export (nfs3.export-dirs) check */
+        if (!gf_mnt3_export_dirs(ms)) {
+            errno = EACCES;
+            return NULL;
         }
 
-        if (exp == NULL) {
-                errno = ENOENT;
-                return NULL;
-        }
+        path = mnt3_get_volume_subdir(path, &volptr);
+        if (exp == NULL)
+            exp = mnt3_mntpath_to_export(ms, volname, _gf_false);
+    }
 
-        nfs = (struct nfs_state *)nfsx->private;
-        if (!nfs_subvolume_started (nfs, exp->vol)) {
-                errno = ENOENT;
-                return NULL;
-        }
+    if (exp == NULL) {
+        errno = ENOENT;
+        return NULL;
+    }
 
-        /* AUTH check: respect nfs.rpc-auth-allow/reject */
-        ret = mnt3_check_client_net_udp (req, exp->vol->name, nfsx);
-        if (ret == RPCSVC_AUTH_REJECT) {
-                errno = EACCES;
-                return NULL;
-        }
+    nfs = (struct nfs_state *)nfsx->private;
+    if (!nfs_subvolume_started(nfs, exp->vol)) {
+        errno = ENOENT;
+        return NULL;
+    }
 
-        switch (mnt3type) {
+    /* AUTH check: respect nfs.rpc-auth-allow/reject */
+    ret = mnt3_check_client_net_udp(req, exp->vol->name, nfsx);
+    if (ret == RPCSVC_AUTH_REJECT) {
+        errno = EACCES;
+        return NULL;
+    }
 
+    switch (mnt3type) {
         case MNT3_EXPTYPE_VOLUME:
-                inode = __mnt3udp_get_export_volume_inode (req, path,
-                                                           expname, exp);
-                break;
+            inode = __mnt3udp_get_export_volume_inode(req, path, expname, exp);
+            break;
 
         case MNT3_EXPTYPE_DIR:
-                inode = __mnt3udp_get_export_subdir_inode (req, path,
-                                                           expname, exp);
-                break;
+            inode = __mnt3udp_get_export_subdir_inode(req, path, expname, exp);
+            break;
 
         default:
-                /* Never reachable */
-                gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_UNKNOWN_MNT_TYPE,
-                        "Unknown MOUNT3 type");
-                errno = EFAULT;
-                goto err;
-        }
-
-        if (inode == NULL) {
-                /* Don't over-write errno */
-                if (!errno)
-                        errno = ENOENT;
-                goto err;
-        }
-
-        /* Build the inode from FH */
-        fh = GF_CALLOC (1, sizeof(*fh), gf_nfs_mt_nfs3_fh);
-        if (fh == NULL) {
-                errno = ENOMEM;
-                goto err;
-        }
-
-        (void) nfs3_build_fh (inode, exp->volumeid, fh);
+            /* Never reachable */
+            gf_msg(GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_UNKNOWN_MNT_TYPE,
+                   "Unknown MOUNT3 type");
+            errno = EFAULT;
+            goto err;
+    }
+
+    if (inode == NULL) {
+        /* Don't over-write errno */
+        if (!errno)
+            errno = ENOENT;
+        goto err;
+    }
+
+    /* Build the inode from FH */
+    fh = GF_CALLOC(1, sizeof(*fh), gf_nfs_mt_nfs3_fh);
+    if (fh == NULL) {
+        errno = ENOMEM;
+        goto err;
+    }
+
+    (void)nfs3_build_fh(inode, exp->volumeid, fh);
 
 err:
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        return fh;
+    return fh;
 }
 
 int
-mount3udp_add_mountlist (xlator_t *nfsx, char *host, char *export)
+mount3udp_add_mountlist(xlator_t *nfsx, char *host, char *export)
 {
-        struct mountentry       *me = NULL;
-        struct mount3_state     *ms = NULL;
+    struct mountentry *me = NULL;
+    struct mount3_state *ms = NULL;
 
-        if ((!host) || (!export) || (!nfsx))
-                return -1;
+    if ((!host) || (!export) || (!nfsx))
+        return -1;
 
-        ms = __mnt3udp_get_mstate (nfsx);
-        if (!ms)
-                return -1;
+    ms = __mnt3udp_get_mstate(nfsx);
+    if (!ms)
+        return -1;
 
-        me = GF_CALLOC (1, sizeof (*me), gf_nfs_mt_mountentry);
-        if (!me)
-                return -1;
+    me = GF_CALLOC(1, sizeof(*me), gf_nfs_mt_mountentry);
+    if (!me)
+        return -1;
 
-        snprintf (me->exname, MNTPATHLEN, "%s", export);
-        snprintf (me->hostname, MNTPATHLEN, "%s", host);
-        INIT_LIST_HEAD (&me->mlist);
-        LOCK (&ms->mountlock);
-        {
-                list_add_tail (&me->mlist, &ms->mountlist);
-                mount_rewrite_rmtab(ms, NULL);
-        }
-        UNLOCK (&ms->mountlock);
-        return 0;
+    snprintf(me->exname, MNTPATHLEN, "%s", export);
+    snprintf(me->hostname, MNTPATHLEN, "%s", host);
+    INIT_LIST_HEAD(&me->mlist);
+    LOCK(&ms->mountlock);
+    {
+        list_add_tail(&me->mlist, &ms->mountlist);
+        mount_rewrite_rmtab(ms, NULL);
+    }
+    UNLOCK(&ms->mountlock);
+    return 0;
 }
 
 int
-mount3udp_delete_mountlist (xlator_t *nfsx, char *hostname, char *export)
+mount3udp_delete_mountlist(xlator_t *nfsx, char *hostname, char *export)
 {
-        struct mount3_state     *ms = NULL;
+    struct mount3_state *ms = NULL;
 
-        if ((!hostname) || (!export) || (!nfsx))
-                return -1;
+    if ((!hostname) || (!export) || (!nfsx))
+        return -1;
 
-        ms = __mnt3udp_get_mstate (nfsx);
-        if (!ms)
-                return -1;
+    ms = __mnt3udp_get_mstate(nfsx);
+    if (!ms)
+        return -1;
 
-        mnt3svc_umount (ms, export, hostname);
-        return 0;
+    mnt3svc_umount(ms, export, hostname);
+    return 0;
 }
 
 /**
@@ -3113,90 +3098,88 @@ mount3udp_delete_mountlist (xlator_t *nfsx, char *hostname, char *export)
  * NB: This does not support IPv6 currently.
  */
 int
-mnt3_export_fill_hostspec (struct host_auth_spec* hostspec, const char* hostip)
+mnt3_export_fill_hostspec(struct host_auth_spec *hostspec, const char *hostip)
 {
-        char     *ipdupstr = NULL;
-        char     *savptr = NULL;
-        char     *endptr = NULL;
-        char     *ip = NULL;
-        char     *token = NULL;
-        int      ret = -1;
-        long     prefixlen = IPv4_ADDR_SIZE; /* default */
-        uint32_t shiftbits = 0;
-        size_t   length = 0;
-
-        /* Create copy of the string so that the source won't change
-         */
-        ipdupstr = gf_strdup (hostip);
-        if (NULL == ipdupstr) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                goto err;
-        }
-
-        ip = strtok_r (ipdupstr, "/", &savptr);
-        /* Validate the Hostname or IPv4 address
-         * TODO: IPv6 support for subdir auth.
-         */
-        length = strlen (ip);
-        if ((!valid_ipv4_address (ip, (int)length, _gf_false)) &&
-            (!valid_host_name (ip, (int)length))) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid hostname or IPv4 address: %s", ip);
-                goto err;
-        }
-
-        hostspec->host_addr = gf_strdup (ip);
-        if (NULL == hostspec->host_addr) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                goto err;
-        }
-
-        /**
-         * User provided CIDR address (xx.xx.xx.xx/n format) is split
-         * into HOST (IP addr or hostname) and network prefix(n) from
-         * which netmask would be calculated. This CIDR address may
-         * denote a single, distinct interface address or the beginning
-         * address of an entire network.
-         *
-         * e.g. the IPv4 block 192.168.100.0/24 represents the 256
-         * IPv4 addresses from 192.168.100.0 to 192.168.100.255.
-         * Therefore to check if an IP matches 192.168.100.0/24
-         * we should mask the IP with FFFFFF00 and compare it with
-         * host address part of CIDR.
-         *
-         * Refer: mask_match() in common-utils.c.
-         */
-        token = strtok_r (NULL, "/", &savptr);
-        if (token != NULL) {
-              prefixlen = strtol (token, &endptr, 10);
-              if ((errno != 0) || (*endptr != '\0') ||
-                  (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) {
-                        gf_msg (THIS->name, GF_LOG_WARNING, EINVAL,
-                                NFS_MSG_INVALID_ENTRY,
-                                "Invalid IPv4 subnetwork mask");
-                      goto err;
-              }
-        }
-
-        /*
-         * 1. Calculate the network mask address.
-         * 2. Convert it into Big-Endian format.
-         * 3. Store it in hostspec netmask.
-         */
-        shiftbits = IPv4_ADDR_SIZE - prefixlen;
-        hostspec->netmask = htonl ((uint32_t)~0 << shiftbits);
-
-        ret = 0; /* SUCCESS */
+    char *ipdupstr = NULL;
+    char *savptr = NULL;
+    char *endptr = NULL;
+    char *ip = NULL;
+    char *token = NULL;
+    int ret = -1;
+    long prefixlen = IPv4_ADDR_SIZE; /* default */
+    uint32_t shiftbits = 0;
+    size_t length = 0;
+
+    /* Create copy of the string so that the source won't change
+     */
+    ipdupstr = gf_strdup(hostip);
+    if (NULL == ipdupstr) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        goto err;
+    }
+
+    ip = strtok_r(ipdupstr, "/", &savptr);
+    /* Validate the Hostname or IPv4 address
+     * TODO: IPv6 support for subdir auth.
+     */
+    length = strlen(ip);
+    if ((!valid_ipv4_address(ip, (int)length, _gf_false)) &&
+        (!valid_host_name(ip, (int)length))) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid hostname or IPv4 address: %s", ip);
+        goto err;
+    }
+
+    hostspec->host_addr = gf_strdup(ip);
+    if (NULL == hostspec->host_addr) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        goto err;
+    }
+
+    /**
+     * User provided CIDR address (xx.xx.xx.xx/n format) is split
+     * into HOST (IP addr or hostname) and network prefix(n) from
+     * which netmask would be calculated. This CIDR address may
+     * denote a single, distinct interface address or the beginning
+     * address of an entire network.
+     *
+     * e.g. the IPv4 block 192.168.100.0/24 represents the 256
+     * IPv4 addresses from 192.168.100.0 to 192.168.100.255.
+     * Therefore to check if an IP matches 192.168.100.0/24
+     * we should mask the IP with FFFFFF00 and compare it with
+     * host address part of CIDR.
+     *
+     * Refer: mask_match() in common-utils.c.
+     */
+    token = strtok_r(NULL, "/", &savptr);
+    if (token != NULL) {
+        prefixlen = strtol(token, &endptr, 10);
+        if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) ||
+            (prefixlen > IPv4_ADDR_SIZE)) {
+            gf_msg(THIS->name, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY,
+                   "Invalid IPv4 subnetwork mask");
+            goto err;
+        }
+    }
+
+    /*
+     * 1. Calculate the network mask address.
+     * 2. Convert it into Big-Endian format.
+     * 3. Store it in hostspec netmask.
+     */
+    shiftbits = IPv4_ADDR_SIZE - prefixlen;
+    hostspec->netmask = htonl((uint32_t)~0 << shiftbits);
+
+    ret = 0; /* SUCCESS */
 err:
-        if (NULL != ipdupstr) {
-                GF_FREE (ipdupstr);
-        }
-        return ret;
+    if (NULL != ipdupstr) {
+        GF_FREE(ipdupstr);
+    }
+    return ret;
 }
 
-
 /**
  * This function will parse the AUTH parameter passed along with
  * "export-dir" option. If AUTH parameter is present then it will be
@@ -3210,80 +3193,75 @@ err:
  * @return This function will return 0 on success and -1 on failure.
  */
 int
-mnt3_export_parse_auth_param (struct mnt3_export* exp, char* exportpath)
+mnt3_export_parse_auth_param(struct mnt3_export *exp, char *exportpath)
 {
-        char *token = NULL;
-        char *savPtr = NULL;
-        char *hostip = NULL;
-        struct host_auth_spec *host = NULL;
-        int ret = 0;
-
-        /* Using exportpath directly in strtok_r because we want
-         * to strip off AUTH parameter from exportpath. */
-        token = strtok_r (exportpath, "(", &savPtr);
-
-        /* Get the next token, which will be the AUTH parameter. */
-        token = strtok_r (NULL, ")", &savPtr);
-
-        if (NULL == token) {
-                /* If AUTH is not present then we should return success. */
-                return 0;
-        }
+    char *token = NULL;
+    char *savPtr = NULL;
+    char *hostip = NULL;
+    struct host_auth_spec *host = NULL;
+    int ret = 0;
 
-        /* Free any previously allocated hostspec structure. */
-        if (NULL != exp->hostspec) {
-                GF_FREE (exp->hostspec);
-                exp->hostspec = NULL;
-        }
+    /* Using exportpath directly in strtok_r because we want
+     * to strip off AUTH parameter from exportpath. */
+    token = strtok_r(exportpath, "(", &savPtr);
 
-        exp->hostspec = GF_CALLOC (1,
-                        sizeof (*(exp->hostspec)),
-                        gf_nfs_mt_auth_spec);
-        if (NULL == exp->hostspec){
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                return -1;
-        }
+    /* Get the next token, which will be the AUTH parameter. */
+    token = strtok_r(NULL, ")", &savPtr);
 
-        /* AUTH parameter can have multiple entries. For each entry
-         * a host_auth_spec structure is created. */
-        host = exp->hostspec;
+    if (NULL == token) {
+        /* If AUTH is not present then we should return success. */
+        return 0;
+    }
+
+    /* Free any previously allocated hostspec structure. */
+    if (NULL != exp->hostspec) {
+        GF_FREE(exp->hostspec);
+        exp->hostspec = NULL;
+    }
+
+    exp->hostspec = GF_CALLOC(1, sizeof(*(exp->hostspec)), gf_nfs_mt_auth_spec);
+    if (NULL == exp->hostspec) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        return -1;
+    }
 
-        hostip = strtok_r (token, "|", &savPtr);
+    /* AUTH parameter can have multiple entries. For each entry
+     * a host_auth_spec structure is created. */
+    host = exp->hostspec;
 
-        /* Parse all AUTH parameters separated by '|' */
-        while (NULL != hostip){
-                ret = mnt3_export_fill_hostspec (host, hostip);
-                if (0 != ret) {
-                        gf_msg (GF_MNT, GF_LOG_WARNING, 0,
-                                NFS_MSG_PARSE_HOSTSPEC_FAIL,
-                                "Failed to parse hostspec: %s", hostip);
-                        goto err;
-                }
+    hostip = strtok_r(token, "|", &savPtr);
 
-                hostip = strtok_r (NULL, "|", &savPtr);
-                if (NULL == hostip) {
-                        break;
-                }
+    /* Parse all AUTH parameters separated by '|' */
+    while (NULL != hostip) {
+        ret = mnt3_export_fill_hostspec(host, hostip);
+        if (0 != ret) {
+            gf_msg(GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_PARSE_HOSTSPEC_FAIL,
+                   "Failed to parse hostspec: %s", hostip);
+            goto err;
+        }
 
-                host->next = GF_CALLOC (1, sizeof (*(host)),
-                                gf_nfs_mt_auth_spec);
-                if (NULL == host->next){
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "Memory allocation failed");
-                        goto err;
-                }
-                host = host->next;
+        hostip = strtok_r(NULL, "|", &savPtr);
+        if (NULL == hostip) {
+            break;
         }
 
-        /* In case of success return from here */
-        return 0;
+        host->next = GF_CALLOC(1, sizeof(*(host)), gf_nfs_mt_auth_spec);
+        if (NULL == host->next) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Memory allocation failed");
+            goto err;
+        }
+        host = host->next;
+    }
+
+    /* In case of success return from here */
+    return 0;
 err:
-        /* In case of failure free up hostspec structure.  */
-        FREE_HOSTSPEC (exp);
+    /* In case of failure free up hostspec structure.  */
+    FREE_HOSTSPEC(exp);
 
-        return -1;
+    return -1;
 }
 
 /**
@@ -3292,419 +3270,410 @@ err:
  * exportpath format: <abspath>[(hostdesc[|hostspec|...])]
  */
 struct mnt3_export *
-mnt3_init_export_ent (struct mount3_state *ms, xlator_t *xl, char *exportpath,
-                      uuid_t volumeid)
+mnt3_init_export_ent(struct mount3_state *ms, xlator_t *xl, char *exportpath,
+                     uuid_t volumeid)
 {
-        struct mnt3_export      *exp = NULL;
-        int                     alloclen = 0;
-        int                     ret = -1;
-
-        if ((!ms) || (!xl))
-                return NULL;
-
-        exp = GF_CALLOC (1, sizeof (*exp), gf_nfs_mt_mnt3_export);
-        if (!exp) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                return NULL;
-        }
-
-        if (NULL != exportpath) {
-                /* If exportpath is not NULL then we should check if AUTH
-                 * parameter is present or not. If AUTH parameter is present
-                 * then it will be stripped and stored in mnt3_export (exp)
-                 * structure.
-                 */
-                if (0 != mnt3_export_parse_auth_param (exp, exportpath)){
-                        gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                NFS_MSG_PARSE_AUTH_PARAM_FAIL,
-                                "Failed to parse auth param");
-                        goto err;
-                }
-        }
-
+    struct mnt3_export *exp = NULL;
+    int alloclen = 0;
+    int ret = -1;
 
-        INIT_LIST_HEAD (&exp->explist);
-        if (exportpath)
-                alloclen = strlen (xl->name) + 2 + strlen (exportpath);
-        else
-                alloclen = strlen (xl->name) + 2;
+    if ((!ms) || (!xl))
+        return NULL;
 
-        exp->expname = GF_MALLOC (alloclen, gf_nfs_mt_char);
-        if (!exp->expname) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                goto err;
-        }
+    exp = GF_CALLOC(1, sizeof(*exp), gf_nfs_mt_mnt3_export);
+    if (!exp) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        return NULL;
+    }
 
-        if (exportpath) {
-                gf_msg_trace (GF_MNT, 0, "Initing dir export: %s:%s",
-                              xl->name, exportpath);
-                exp->exptype = MNT3_EXPTYPE_DIR;
-                ret = snprintf (exp->expname, alloclen, "/%s%s", xl->name,
-                                exportpath);
-        } else {
-                gf_msg_trace (GF_MNT, 0, "Initing volume export: %s",
-                              xl->name);
-                exp->exptype = MNT3_EXPTYPE_VOLUME;
-                ret = snprintf (exp->expname, alloclen, "/%s", xl->name);
-        }
-        if (ret < 0) {
-                gf_msg (xl->name, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_FAIL,
-                        "Failed to set the export name");
-                goto err;
-        }
-        /* Just copy without discrimination, we'll determine whether to
-         * actually use it when a mount request comes in and a file handle
-         * needs to be built.
+    if (NULL != exportpath) {
+        /* If exportpath is not NULL then we should check if AUTH
+         * parameter is present or not. If AUTH parameter is present
+         * then it will be stripped and stored in mnt3_export (exp)
+         * structure.
          */
-        gf_uuid_copy (exp->volumeid, volumeid);
-        exp->vol = xl;
-
-        /* On success we should return from here*/
-        return exp;
+        if (0 != mnt3_export_parse_auth_param(exp, exportpath)) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PARSE_AUTH_PARAM_FAIL,
+                   "Failed to parse auth param");
+            goto err;
+        }
+    }
+
+    INIT_LIST_HEAD(&exp->explist);
+    if (exportpath)
+        alloclen = strlen(xl->name) + 2 + strlen(exportpath);
+    else
+        alloclen = strlen(xl->name) + 2;
+
+    exp->expname = GF_MALLOC(alloclen, gf_nfs_mt_char);
+    if (!exp->expname) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        goto err;
+    }
+
+    if (exportpath) {
+        gf_msg_trace(GF_MNT, 0, "Initing dir export: %s:%s", xl->name,
+                     exportpath);
+        exp->exptype = MNT3_EXPTYPE_DIR;
+        ret = snprintf(exp->expname, alloclen, "/%s%s", xl->name, exportpath);
+    } else {
+        gf_msg_trace(GF_MNT, 0, "Initing volume export: %s", xl->name);
+        exp->exptype = MNT3_EXPTYPE_VOLUME;
+        ret = snprintf(exp->expname, alloclen, "/%s", xl->name);
+    }
+    if (ret < 0) {
+        gf_msg(xl->name, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_FAIL,
+               "Failed to set the export name");
+        goto err;
+    }
+    /* Just copy without discrimination, we'll determine whether to
+     * actually use it when a mount request comes in and a file handle
+     * needs to be built.
+     */
+    gf_uuid_copy(exp->volumeid, volumeid);
+    exp->vol = xl;
+
+    /* On success we should return from here*/
+    return exp;
 err:
-        /* On failure free exp and it's members.*/
-        if (NULL != exp) {
-                mnt3_export_free (exp);
-                exp = NULL;
-        }
+    /* On failure free exp and it's members.*/
+    if (NULL != exp) {
+        mnt3_export_free(exp);
+        exp = NULL;
+    }
 
-        return exp;
+    return exp;
 }
 
-
 int
-__mnt3_init_volume_direxports (struct mount3_state *ms, xlator_t *xlator,
-                               char *optstr, uuid_t volumeid)
+__mnt3_init_volume_direxports(struct mount3_state *ms, xlator_t *xlator,
+                              char *optstr, uuid_t volumeid)
 {
-        struct mnt3_export      *newexp = NULL;
-        int                     ret = -1;
-        char                    *savptr = NULL;
-        char                    *dupopt = NULL;
-        char                    *token = NULL;
-
-        if ((!ms) || (!xlator) || (!optstr))
-                return -1;
-
-        dupopt = strdupa (optstr);
-
-        token = strtok_r (dupopt, ",", &savptr);
-        while (token) {
-                newexp = mnt3_init_export_ent (ms, xlator, token, volumeid);
-                if (!newexp) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                NFS_MSG_INIT_DIR_EXP_FAIL, "Failed to init dir "
-                                "export: %s", token);
-                        ret = -1;
-                        goto err;
-                }
+    struct mnt3_export *newexp = NULL;
+    int ret = -1;
+    char *savptr = NULL;
+    char *dupopt = NULL;
+    char *token = NULL;
 
-                list_add_tail (&newexp->explist, &ms->exportlist);
-                token = strtok_r (NULL, ",", &savptr);
+    if ((!ms) || (!xlator) || (!optstr))
+        return -1;
+
+    dupopt = strdupa(optstr);
+
+    token = strtok_r(dupopt, ",", &savptr);
+    while (token) {
+        newexp = mnt3_init_export_ent(ms, xlator, token, volumeid);
+        if (!newexp) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_INIT_DIR_EXP_FAIL,
+                   "Failed to init dir "
+                   "export: %s",
+                   token);
+            ret = -1;
+            goto err;
         }
 
-        ret = 0;
+        list_add_tail(&newexp->explist, &ms->exportlist);
+        token = strtok_r(NULL, ",", &savptr);
+    }
+
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-__mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator)
+__mnt3_init_volume(struct mount3_state *ms, dict_t *opts, xlator_t *xlator)
 {
-        struct mnt3_export      *newexp = NULL;
-        int                     ret = -1;
-        char                    searchstr[1024];
-        char                    *optstr  = NULL;
-        uuid_t                  volumeid = {0, };
+    struct mnt3_export *newexp = NULL;
+    int ret = -1;
+    char searchstr[1024];
+    char *optstr = NULL;
+    uuid_t volumeid = {
+        0,
+    };
+
+    if ((!ms) || (!xlator) || (!opts))
+        return -1;
 
-        if ((!ms) || (!xlator) || (!opts))
-                return -1;
+    gf_uuid_clear(volumeid);
+    if (gf_nfs_dvm_off(nfs_state(ms->nfsx)))
+        goto no_dvm;
 
-        gf_uuid_clear (volumeid);
-        if (gf_nfs_dvm_off (nfs_state (ms->nfsx)))
-                goto no_dvm;
+    ret = snprintf(searchstr, 1024, "nfs3.%s.volume-id", xlator->name);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
 
-        ret = snprintf (searchstr, 1024, "nfs3.%s.volume-id", xlator->name);
+    if (dict_get(opts, searchstr)) {
+        ret = dict_get_str(opts, searchstr, &optstr);
         if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
-        }
-
-        if (dict_get (opts, searchstr)) {
-                ret = dict_get_str (opts, searchstr, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                                NFS_MSG_DICT_GET_FAILED, "Failed to read "
-                                "option: %s", searchstr);
-                        ret = -1;
-                        goto err;
-                }
-        } else {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING,
-                        "DVM is on but volume-id not "
-                        "given for volume: %s", xlator->name);
-                ret = -1;
-                goto err;
-        }
-
-        if (optstr) {
-                ret = gf_uuid_parse (optstr, volumeid);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                                NFS_MSG_PARSE_VOL_UUID_FAIL, "Failed to parse "
-                                "volume UUID");
-                        ret = -1;
-                        goto err;
-                }
+            gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
+                   "Failed to read "
+                   "option: %s",
+                   searchstr);
+            ret = -1;
+            goto err;
+        }
+    } else {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING,
+               "DVM is on but volume-id not "
+               "given for volume: %s",
+               xlator->name);
+        ret = -1;
+        goto err;
+    }
+
+    if (optstr) {
+        ret = gf_uuid_parse(optstr, volumeid);
+        if (ret < 0) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_PARSE_VOL_UUID_FAIL,
+                   "Failed to parse "
+                   "volume UUID");
+            ret = -1;
+            goto err;
         }
+    }
 
 no_dvm:
-        ret = snprintf (searchstr, 1024, "nfs3.%s.export-dir", xlator->name);
+    ret = snprintf(searchstr, 1024, "nfs3.%s.export-dir", xlator->name);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    if (dict_get(opts, searchstr)) {
+        ret = dict_get_str(opts, searchstr, &optstr);
         if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
+            gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
+                   "Failed to read "
+                   "option: %s",
+                   searchstr);
+            ret = -1;
+            goto err;
         }
 
-        if (dict_get (opts, searchstr)) {
-                ret = dict_get_str (opts, searchstr, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                                NFS_MSG_DICT_GET_FAILED, "Failed to read "
-                                "option: %s", searchstr);
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = __mnt3_init_volume_direxports (ms, xlator, optstr,
-                                                     volumeid);
-                if (ret == -1) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                NFS_MSG_DIR_EXP_SETUP_FAIL, "Dir export "
-                                "setup failed for volume: %s", xlator->name);
-                        goto err;
-                }
+        ret = __mnt3_init_volume_direxports(ms, xlator, optstr, volumeid);
+        if (ret == -1) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_DIR_EXP_SETUP_FAIL,
+                   "Dir export "
+                   "setup failed for volume: %s",
+                   xlator->name);
+            goto err;
         }
+    }
 
-        if (ms->export_volumes) {
-                newexp = mnt3_init_export_ent (ms, xlator, NULL, volumeid);
-                if (!newexp) {
-                        ret = -1;
-                        goto err;
-                }
-
-                list_add_tail (&newexp->explist, &ms->exportlist);
+    if (ms->export_volumes) {
+        newexp = mnt3_init_export_ent(ms, xlator, NULL, volumeid);
+        if (!newexp) {
+            ret = -1;
+            goto err;
         }
-        ret = 0;
 
+        list_add_tail(&newexp->explist, &ms->exportlist);
+    }
+    ret = 0;
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-__mnt3_init_volume_export (struct mount3_state *ms, dict_t *opts)
+__mnt3_init_volume_export(struct mount3_state *ms, dict_t *opts)
 {
-        int                     ret = -1;
-        char                    *optstr  = NULL;
-        /* On by default. */
-        gf_boolean_t            boolt = _gf_true;
-
-        if ((!ms) || (!opts))
-                return -1;
-
-        if (!dict_get (opts, "nfs3.export-volumes")) {
-                ret = 0;
-                goto err;
-        }
+    int ret = -1;
+    char *optstr = NULL;
+    /* On by default. */
+    gf_boolean_t boolt = _gf_true;
 
-        ret = dict_get_str (opts, "nfs3.export-volumes", &optstr);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
-                        "Failed to read option: nfs3.export-volumes");
-                ret = -1;
-                goto err;
-        }
+    if ((!ms) || (!opts))
+        return -1;
 
-        ret = gf_string2boolean (optstr, &boolt);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL,
-                        "Failed to convert string to boolean");
-        }
+    if (!dict_get(opts, "nfs3.export-volumes")) {
+        ret = 0;
+        goto err;
+    }
+
+    ret = dict_get_str(opts, "nfs3.export-volumes", &optstr);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
+               "Failed to read option: nfs3.export-volumes");
+        ret = -1;
+        goto err;
+    }
+
+    ret = gf_string2boolean(optstr, &boolt);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL,
+               "Failed to convert string to boolean");
+    }
 
 err:
-        if (boolt == _gf_false) {
-                gf_msg_trace (GF_MNT, 0, "Volume exports disabled");
-                ms->export_volumes = 0;
-        } else {
-                gf_msg_trace (GF_MNT, 0, "Volume exports enabled");
-                ms->export_volumes = 1;
-        }
-
-        return ret;
+    if (boolt == _gf_false) {
+        gf_msg_trace(GF_MNT, 0, "Volume exports disabled");
+        ms->export_volumes = 0;
+    } else {
+        gf_msg_trace(GF_MNT, 0, "Volume exports enabled");
+        ms->export_volumes = 1;
+    }
+
+    return ret;
 }
 
-
 int
-__mnt3_init_dir_export (struct mount3_state *ms, dict_t *opts)
+__mnt3_init_dir_export(struct mount3_state *ms, dict_t *opts)
 {
-        int                     ret = -1;
-        char                    *optstr  = NULL;
-        /* On by default. */
-        gf_boolean_t            boolt = _gf_true;
-
-        if ((!ms) || (!opts))
-                return -1;
+    int ret = -1;
+    char *optstr = NULL;
+    /* On by default. */
+    gf_boolean_t boolt = _gf_true;
 
-        if (!dict_get (opts, "nfs3.export-dirs")) {
-                ret = 0;
-                goto err;
-        }
-
-        ret = dict_get_str (opts, "nfs3.export-dirs", &optstr);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
-                        "Failed to read option: nfs3.export-dirs");
-                ret = -1;
-                goto err;
-        }
+    if ((!ms) || (!opts))
+        return -1;
 
-        ret = gf_string2boolean (optstr, &boolt);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL,
-                        "Failed to convert string to boolean");
-         }
+    if (!dict_get(opts, "nfs3.export-dirs")) {
+        ret = 0;
+        goto err;
+    }
+
+    ret = dict_get_str(opts, "nfs3.export-dirs", &optstr);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED,
+               "Failed to read option: nfs3.export-dirs");
+        ret = -1;
+        goto err;
+    }
+
+    ret = gf_string2boolean(optstr, &boolt);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL,
+               "Failed to convert string to boolean");
+    }
 
 err:
-        if (boolt == _gf_false) {
-                gf_msg_trace (GF_MNT, 0, "Dir exports disabled");
-                ms->export_dirs = 0;
-        } else {
-                gf_msg_trace (GF_MNT, 0, "Dir exports enabled");
-                ms->export_dirs = 1;
-        }
-
-        return ret;
+    if (boolt == _gf_false) {
+        gf_msg_trace(GF_MNT, 0, "Dir exports disabled");
+        ms->export_dirs = 0;
+    } else {
+        gf_msg_trace(GF_MNT, 0, "Dir exports enabled");
+        ms->export_dirs = 1;
+    }
+
+    return ret;
 }
 
-
 int
-mnt3_init_options (struct mount3_state *ms, dict_t *options)
+mnt3_init_options(struct mount3_state *ms, dict_t *options)
 {
-        xlator_list_t   *volentry = NULL;
-        int             ret = -1;
-
-        if ((!ms) || (!options))
-                return -1;
-
-        __mnt3_init_volume_export (ms, options);
-        __mnt3_init_dir_export (ms, options);
-        volentry = ms->nfsx->children;
-        while (volentry) {
-                gf_msg_trace (GF_MNT, 0, "Initing options for: %s",
-                              volentry->xlator->name);
-                ret = __mnt3_init_volume (ms, options, volentry->xlator);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                                NFS_MSG_VOL_INIT_FAIL,
-                                "Volume init failed");
-                        goto err;
-                }
+    xlator_list_t *volentry = NULL;
+    int ret = -1;
 
-                volentry = volentry->next;
+    if ((!ms) || (!options))
+        return -1;
+
+    __mnt3_init_volume_export(ms, options);
+    __mnt3_init_dir_export(ms, options);
+    volentry = ms->nfsx->children;
+    while (volentry) {
+        gf_msg_trace(GF_MNT, 0, "Initing options for: %s",
+                     volentry->xlator->name);
+        ret = __mnt3_init_volume(ms, options, volentry->xlator);
+        if (ret < 0) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_VOL_INIT_FAIL,
+                   "Volume init failed");
+            goto err;
         }
 
+        volentry = volentry->next;
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 struct mount3_state *
-mnt3_init_state (xlator_t *nfsx)
+mnt3_init_state(xlator_t *nfsx)
 {
-        struct mount3_state     *ms = NULL;
-        int                     ret = -1;
-
-        if (!nfsx)
-                return NULL;
+    struct mount3_state *ms = NULL;
+    int ret = -1;
 
-        ms = GF_CALLOC (1, sizeof (*ms), gf_nfs_mt_mount3_state);
-        if (!ms) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                return NULL;
-        }
+    if (!nfsx)
+        return NULL;
 
-        ms->iobpool = nfsx->ctx->iobuf_pool;
-        ms->nfsx = nfsx;
-        INIT_LIST_HEAD (&ms->exportlist);
-        ret = mnt3_init_options (ms, nfsx->options);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_OPT_INIT_FAIL,
-                        "Options init failed");
-                return NULL;
-        }
+    ms = GF_CALLOC(1, sizeof(*ms), gf_nfs_mt_mount3_state);
+    if (!ms) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        return NULL;
+    }
+
+    ms->iobpool = nfsx->ctx->iobuf_pool;
+    ms->nfsx = nfsx;
+    INIT_LIST_HEAD(&ms->exportlist);
+    ret = mnt3_init_options(ms, nfsx->options);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_OPT_INIT_FAIL,
+               "Options init failed");
+        return NULL;
+    }
 
-        INIT_LIST_HEAD (&ms->mountlist);
-        LOCK_INIT (&ms->mountlock);
+    INIT_LIST_HEAD(&ms->mountlist);
+    LOCK_INIT(&ms->mountlock);
 
-        return ms;
+    return ms;
 }
 
 int
-mount_init_state (xlator_t *nfsx)
+mount_init_state(xlator_t *nfsx)
 {
-        int              ret = -1;
-        struct nfs_state *nfs = NULL;
-
-        if (!nfsx)
-                goto out;
-
-        nfs = (struct nfs_state *)nfs_state (nfsx);
-        /*Maintaining global state for MOUNT1 and MOUNT3*/
-        nfs->mstate =  mnt3_init_state (nfsx);
-        if (!nfs->mstate) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate mount state");
-                goto out;
-        }
-        ret = 0;
+    int ret = -1;
+    struct nfs_state *nfs = NULL;
+
+    if (!nfsx)
+        goto out;
+
+    nfs = (struct nfs_state *)nfs_state(nfsx);
+    /*Maintaining global state for MOUNT1 and MOUNT3*/
+    nfs->mstate = mnt3_init_state(nfsx);
+    if (!nfs->mstate) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate mount state");
+        goto out;
+    }
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-rpcsvc_actor_t  mnt3svc_actors[MOUNT3_PROC_COUNT] = {
-        {"NULL",    MOUNT3_NULL,    mnt3svc_null,    NULL, 0, DRC_NA},
-        {"MNT",     MOUNT3_MNT,     mnt3svc_mnt,     NULL, 0, DRC_NA},
-        {"DUMP",    MOUNT3_DUMP,    mnt3svc_dump,    NULL, 0, DRC_NA},
-        {"UMNT",    MOUNT3_UMNT,    mnt3svc_umnt,    NULL, 0, DRC_NA},
-        {"UMNTALL", MOUNT3_UMNTALL, mnt3svc_umntall, NULL, 0, DRC_NA},
-        {"EXPORT",  MOUNT3_EXPORT,  mnt3svc_export,  NULL, 0, DRC_NA}
-};
-
-
+rpcsvc_actor_t mnt3svc_actors[MOUNT3_PROC_COUNT] = {
+    {"NULL", MOUNT3_NULL, mnt3svc_null, NULL, 0, DRC_NA},
+    {"MNT", MOUNT3_MNT, mnt3svc_mnt, NULL, 0, DRC_NA},
+    {"DUMP", MOUNT3_DUMP, mnt3svc_dump, NULL, 0, DRC_NA},
+    {"UMNT", MOUNT3_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA},
+    {"UMNTALL", MOUNT3_UMNTALL, mnt3svc_umntall, NULL, 0, DRC_NA},
+    {"EXPORT", MOUNT3_EXPORT, mnt3svc_export, NULL, 0, DRC_NA}};
 
 /* Static init parts are assigned here, dynamic ones are done in
  * mnt3svc_init and mnt3_init_state.
  * Making MOUNT3 a synctask so that the blocking DNS calls during rpc auth
  * gets offloaded to syncenv, keeping the main/poll thread unblocked
  */
-rpcsvc_program_t        mnt3prog = {
-                        .progname       = "MOUNT3",
-                        .prognum        = MOUNT_PROGRAM,
-                        .progver        = MOUNT_V3,
-                        .progport       = GF_MOUNTV3_PORT,
-                        .actors         = mnt3svc_actors,
-                        .numactors      = MOUNT3_PROC_COUNT,
-                        .min_auth       = AUTH_NULL,
-                        .synctask       = _gf_true,
+rpcsvc_program_t mnt3prog = {
+    .progname = "MOUNT3",
+    .prognum = MOUNT_PROGRAM,
+    .progver = MOUNT_V3,
+    .progport = GF_MOUNTV3_PORT,
+    .actors = mnt3svc_actors,
+    .numactors = MOUNT3_PROC_COUNT,
+    .min_auth = AUTH_NULL,
+    .synctask = _gf_true,
 };
 
 /**
@@ -3718,79 +3687,82 @@ rpcsvc_program_t        mnt3prog = {
  *
  */
 int
-__mnt3_mounted_exports_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__mnt3_mounted_exports_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        char                     *path             = NULL;
-        char                     *host_addr_ip     = NULL;
-        char                     *host_addr_fqdn   = NULL;
-        char                     *keydup           = NULL;
-        char                     *colon            = NULL;
-        struct mnt3_auth_params  *auth_params      = NULL;
-        int                       ret              = 0;
-        int                       auth_status_code = 0;
-
-        gf_msg_trace (GF_MNT, 0, "Checking if key %s is authorized.", key);
-
-        auth_params = (struct mnt3_auth_params *)tmp;
-
-        /* Since we haven't obtained a lock around the mount dict
-         * here, we want to duplicate the key and then process it.
-         * Otherwise we would potentially have a race condition
-         * by modifying the key in the dict when other threads
-         * are accessing it.
-         */
-        keydup = strdupa (key);
-
-        colon = strchr (keydup, ':');
-        if (!colon)
-                return 0;
-
-        *colon = '\0';
-
-        path = alloca (strlen (keydup) + 2);
-        snprintf (path, strlen (keydup) + 2, "/%s", keydup);
-
-        /* Host is one character after ':' */
-        host_addr_ip = colon + 1;
-
-        /* Check if the IP is authorized */
-        auth_status_code = mnt3_auth_host (auth_params, host_addr_ip,
-                                           NULL, path, FALSE, NULL);
-        if (auth_status_code == 0) {
-                goto out;
-        }
-
-        ret = gf_get_hostname_from_ip (host_addr_ip, &host_addr_fqdn);
-        if (ret != 0) {
-                gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR ,
-                        "Authorization failed for IP [%s], but name "
-                        "resolution also failed!", host_addr_ip);
-                goto unmount;
-        }
+    char *path = NULL;
+    char *host_addr_ip = NULL;
+    char *host_addr_fqdn = NULL;
+    char *keydup = NULL;
+    char *colon = NULL;
+    struct mnt3_auth_params *auth_params = NULL;
+    int ret = 0;
+    int auth_status_code = 0;
+
+    gf_msg_trace(GF_MNT, 0, "Checking if key %s is authorized.", key);
+
+    auth_params = (struct mnt3_auth_params *)tmp;
+
+    /* Since we haven't obtained a lock around the mount dict
+     * here, we want to duplicate the key and then process it.
+     * Otherwise we would potentially have a race condition
+     * by modifying the key in the dict when other threads
+     * are accessing it.
+     */
+    keydup = strdupa(key);
+
+    colon = strchr(keydup, ':');
+    if (!colon)
+        return 0;
 
-        /* If not, check if the FQDN is authorized */
-        gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR,
-                "Authorization failed for IP [%s], attempting to"
-                " auth hostname [%s]...", host_addr_ip, host_addr_fqdn);
-
-        auth_status_code = mnt3_auth_host (auth_params, host_addr_fqdn,
-                                           NULL, path, FALSE, NULL);
-        if (auth_status_code == 0) {
-                gf_msg (GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR,
-                        "Authorization succeeded for "
-                        "Client [IP=%s, Hostname=%s].",
-                        host_addr_ip, host_addr_fqdn);
-                goto out;
-        }
+    *colon = '\0';
+
+    path = alloca(strlen(keydup) + 2);
+    snprintf(path, strlen(keydup) + 2, "/%s", keydup);
+
+    /* Host is one character after ':' */
+    host_addr_ip = colon + 1;
+
+    /* Check if the IP is authorized */
+    auth_status_code = mnt3_auth_host(auth_params, host_addr_ip, NULL, path,
+                                      FALSE, NULL);
+    if (auth_status_code == 0) {
+        goto out;
+    }
+
+    ret = gf_get_hostname_from_ip(host_addr_ip, &host_addr_fqdn);
+    if (ret != 0) {
+        gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR,
+               "Authorization failed for IP [%s], but name "
+               "resolution also failed!",
+               host_addr_ip);
+        goto unmount;
+    }
+
+    /* If not, check if the FQDN is authorized */
+    gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR,
+           "Authorization failed for IP [%s], attempting to"
+           " auth hostname [%s]...",
+           host_addr_ip, host_addr_fqdn);
+
+    auth_status_code = mnt3_auth_host(auth_params, host_addr_fqdn, NULL, path,
+                                      FALSE, NULL);
+    if (auth_status_code == 0) {
+        gf_msg(GF_MNT, GF_LOG_DEBUG, 0, NFS_MSG_AUTH_ERROR,
+               "Authorization succeeded for "
+               "Client [IP=%s, Hostname=%s].",
+               host_addr_ip, host_addr_fqdn);
+        goto out;
+    }
 
 unmount:
-         gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_AUTH_ERROR,
-                 "Client [IP=%s, Hostname=%s] not authorized for this mount. "
-                 "Unmounting!", host_addr_ip, host_addr_fqdn);
-         mnt3svc_umount (auth_params->ms, path, host_addr_ip);
+    gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_AUTH_ERROR,
+           "Client [IP=%s, Hostname=%s] not authorized for this mount. "
+           "Unmounting!",
+           host_addr_ip, host_addr_fqdn);
+    mnt3svc_umount(auth_params->ms, path, host_addr_ip);
 out:
-        GF_FREE (host_addr_fqdn);
-        return 0;
+    GF_FREE(host_addr_fqdn);
+    return 0;
 }
 
 /**
@@ -3802,14 +3774,12 @@ out:
  *
  */
 void
-_mnt3_invalidate_old_mounts (struct mount3_state *ms)
+_mnt3_invalidate_old_mounts(struct mount3_state *ms)
 {
-        gf_msg_debug (GF_MNT, 0, "Invalidating old mounts ...");
-        dict_foreach (ms->mountdict, __mnt3_mounted_exports_walk,
-                      ms->auth_params);
+    gf_msg_debug(GF_MNT, 0, "Invalidating old mounts ...");
+    dict_foreach(ms->mountdict, __mnt3_mounted_exports_walk, ms->auth_params);
 }
 
-
 /**
  * _mnt3_has_file_changed -- Checks if a file has changed on disk
  *
@@ -3822,25 +3792,25 @@ _mnt3_invalidate_old_mounts (struct mount3_state *ms)
  * Uses get_file_mtime () in common-utils.c
  */
 gf_boolean_t
-_mnt3_has_file_changed (const char *path, time_t *oldmtime)
+_mnt3_has_file_changed(const char *path, time_t *oldmtime)
 {
-        gf_boolean_t    changed = _gf_false;
-        time_t          mtime   = {0};
-        int             ret     = 0;
+    gf_boolean_t changed = _gf_false;
+    time_t mtime = {0};
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_MNT, path, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT, oldmtime, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT, path, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT, oldmtime, out);
 
-        ret = get_file_mtime (path, &mtime);
-        if (ret < 0)
-                goto out;
+    ret = get_file_mtime(path, &mtime);
+    if (ret < 0)
+        goto out;
 
-        if (mtime != *oldmtime) {
-                changed = _gf_true;
-                *oldmtime = mtime;
-        }
+    if (mtime != *oldmtime) {
+        changed = _gf_true;
+        *oldmtime = mtime;
+    }
 out:
-        return changed;
+    return changed;
 }
 
 /**
@@ -3853,84 +3823,82 @@ out:
  * @return: Always returns NULL
  */
 void *
-_mnt3_auth_param_refresh_thread (void *argv)
+_mnt3_auth_param_refresh_thread(void *argv)
 {
-        struct          mount3_state *mstate    = (struct mount3_state *)argv;
-        char            *exp_file_path          = NULL;
-        char            *ng_file_path           = NULL;
-        size_t          nbytes                  = 0;
-        time_t          exp_time                = 0;
-        time_t          ng_time                 = 0;
-        gf_boolean_t    any_file_changed        = _gf_false;
-        int             ret                     = 0;
-
-        nbytes = strlen (exports_file_path) + 1;
-        exp_file_path = alloca (nbytes);
-        snprintf (exp_file_path, nbytes, "%s", exports_file_path);
-
-        nbytes = strlen (netgroups_file_path) + 1;
-        ng_file_path = alloca (nbytes);
-        snprintf (ng_file_path, nbytes, "%s", netgroups_file_path);
-
-        /* Set the initial timestamps to avoid reloading right after
-         * mnt3svc_init () spawns this thread */
-        get_file_mtime (exp_file_path, &exp_time);
-        get_file_mtime (ng_file_path, &ng_time);
-
-        while (_gf_true) {
-                if (mstate->stop_refresh)
-                        break;
-                any_file_changed = _gf_false;
-
-                /* Sleep before checking the file again */
-                sleep (mstate->nfs->auth_refresh_time_secs);
-
-                if (_mnt3_has_file_changed (exp_file_path, &exp_time)) {
-                        gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_EXP,
-                                "File %s changed, updating exports,",
-                                exp_file_path);
-
-                        ret = mnt3_auth_set_exports_auth (mstate->auth_params,
-                                                          exp_file_path);
-                        if (ret)
-                                gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                        NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
-                                        "Failed to set export auth params.");
-                        else
-                                any_file_changed = _gf_true;
-                }
-
-                if (_mnt3_has_file_changed (ng_file_path, &ng_time)) {
-                        gf_msg (GF_MNT, GF_LOG_INFO, 0,
-                                NFS_MSG_UPDATING_NET_GRP, "File %s changed,"
-                                "updating netgroups", ng_file_path);
-
-                        ret = mnt3_auth_set_netgroups_auth (mstate->auth_params,
-                                                            ng_file_path);
-                        if (ret)
-                                gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                        NFS_MSG_SET_NET_GRP_FAIL,
-                                        "Failed to set netgroup auth params.");
-                        else
-                                any_file_changed = _gf_true;
-                }
-
-                /* If no files changed, go back to sleep */
-                if (!any_file_changed)
-                        continue;
-
-                gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PURGING_AUTH_CACHE,
-                        "Purging auth cache.");
-                auth_cache_purge (mstate->authcache);
-
-                /* Walk through mounts that are no longer authorized
-                 * and unmount them on the server side. This will
-                 * cause subsequent file ops to fail with access denied.
-                 */
-                _mnt3_invalidate_old_mounts (mstate);
-        }
+    struct mount3_state *mstate = (struct mount3_state *)argv;
+    char *exp_file_path = NULL;
+    char *ng_file_path = NULL;
+    size_t nbytes = 0;
+    time_t exp_time = 0;
+    time_t ng_time = 0;
+    gf_boolean_t any_file_changed = _gf_false;
+    int ret = 0;
+
+    nbytes = strlen(exports_file_path) + 1;
+    exp_file_path = alloca(nbytes);
+    snprintf(exp_file_path, nbytes, "%s", exports_file_path);
+
+    nbytes = strlen(netgroups_file_path) + 1;
+    ng_file_path = alloca(nbytes);
+    snprintf(ng_file_path, nbytes, "%s", netgroups_file_path);
+
+    /* Set the initial timestamps to avoid reloading right after
+     * mnt3svc_init () spawns this thread */
+    get_file_mtime(exp_file_path, &exp_time);
+    get_file_mtime(ng_file_path, &ng_time);
+
+    while (_gf_true) {
+        if (mstate->stop_refresh)
+            break;
+        any_file_changed = _gf_false;
+
+        /* Sleep before checking the file again */
+        sleep(mstate->nfs->auth_refresh_time_secs);
+
+        if (_mnt3_has_file_changed(exp_file_path, &exp_time)) {
+            gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_EXP,
+                   "File %s changed, updating exports,", exp_file_path);
+
+            ret = mnt3_auth_set_exports_auth(mstate->auth_params,
+                                             exp_file_path);
+            if (ret)
+                gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
+                       "Failed to set export auth params.");
+            else
+                any_file_changed = _gf_true;
+        }
+
+        if (_mnt3_has_file_changed(ng_file_path, &ng_time)) {
+            gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_NET_GRP,
+                   "File %s changed,"
+                   "updating netgroups",
+                   ng_file_path);
+
+            ret = mnt3_auth_set_netgroups_auth(mstate->auth_params,
+                                               ng_file_path);
+            if (ret)
+                gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SET_NET_GRP_FAIL,
+                       "Failed to set netgroup auth params.");
+            else
+                any_file_changed = _gf_true;
+        }
+
+        /* If no files changed, go back to sleep */
+        if (!any_file_changed)
+            continue;
+
+        gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PURGING_AUTH_CACHE,
+               "Purging auth cache.");
+        auth_cache_purge(mstate->authcache);
+
+        /* Walk through mounts that are no longer authorized
+         * and unmount them on the server side. This will
+         * cause subsequent file ops to fail with access denied.
+         */
+        _mnt3_invalidate_old_mounts(mstate);
+    }
 
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -3946,53 +3914,50 @@ _mnt3_auth_param_refresh_thread (void *argv)
  *                    bubbled up from the functions we call to set the params.
  */
 int
-_mnt3_init_auth_params (struct mount3_state *mstate)
+_mnt3_init_auth_params(struct mount3_state *mstate)
 {
-        int      ret            = -EINVAL;
-        char     *exp_file_path = NULL;
-        char     *ng_file_path  = NULL;
-        size_t   nbytes         = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_MNT, mstate, out);
-
-        mstate->auth_params = mnt3_auth_params_init (mstate);
-        if (!mstate->auth_params) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to init mount auth params.");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        nbytes = strlen (exports_file_path) + 1;
-        exp_file_path = alloca (nbytes);
-        snprintf (exp_file_path, nbytes, "%s", exports_file_path);
-
-        ret = mnt3_auth_set_exports_auth (mstate->auth_params, exp_file_path);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                        NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
-                        "Failed to set export auth params.");
-                goto out;
-        }
-
-        nbytes = strlen (netgroups_file_path) + 1;
-        ng_file_path = alloca (nbytes);
-        snprintf (ng_file_path, nbytes, "%s", netgroups_file_path);
-
-        ret = mnt3_auth_set_netgroups_auth (mstate->auth_params, ng_file_path);
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret,
-                        NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
-                        "Failed to set netgroup auth params.");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -EINVAL;
+    char *exp_file_path = NULL;
+    char *ng_file_path = NULL;
+    size_t nbytes = 0;
+
+    GF_VALIDATE_OR_GOTO(GF_MNT, mstate, out);
+
+    mstate->auth_params = mnt3_auth_params_init(mstate);
+    if (!mstate->auth_params) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to init mount auth params.");
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    nbytes = strlen(exports_file_path) + 1;
+    exp_file_path = alloca(nbytes);
+    snprintf(exp_file_path, nbytes, "%s", exports_file_path);
+
+    ret = mnt3_auth_set_exports_auth(mstate->auth_params, exp_file_path);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
+               "Failed to set export auth params.");
+        goto out;
+    }
+
+    nbytes = strlen(netgroups_file_path) + 1;
+    ng_file_path = alloca(nbytes);
+    snprintf(ng_file_path, nbytes, "%s", netgroups_file_path);
+
+    ret = mnt3_auth_set_netgroups_auth(mstate->auth_params, ng_file_path);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_AUTH_PARAM_FAIL,
+               "Failed to set netgroup auth params.");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * mnt3svc_deinit -- Function called by the nfs translator to cleanup all state
  *
@@ -4001,289 +3966,278 @@ out:
  *         as well as the threads that have been started.
  */
 void
-mnt3svc_deinit (xlator_t *nfsx)
+mnt3svc_deinit(xlator_t *nfsx)
 {
-        struct mount3_state *mstate = NULL;
-        struct nfs_state    *nfs    = NULL;
+    struct mount3_state *mstate = NULL;
+    struct nfs_state *nfs = NULL;
 
-        if (!nfsx || !nfsx->private)
-                return;
-
-        nfs = (struct nfs_state *)nfsx->private;
-        mstate = (struct mount3_state *)nfs->mstate;
-
-        if (nfs->refresh_auth) {
-                /* Mark as true and wait for thread to exit */
-                mstate->stop_refresh = _gf_true;
-                pthread_join (mstate->auth_refresh_thread, NULL);
-        }
-
-        if (nfs->exports_auth)
-                mnt3_auth_params_deinit (mstate->auth_params);
-
-        /* Unmount everything and clear mountdict */
-        LOCK (&mstate->mountlock);
-        {
-                __mnt3svc_umountall (mstate);
-                dict_unref (mstate->mountdict);
-        }
-        UNLOCK (&mstate->mountlock);
+    if (!nfsx || !nfsx->private)
+        return;
 
+    nfs = (struct nfs_state *)nfsx->private;
+    mstate = (struct mount3_state *)nfs->mstate;
+
+    if (nfs->refresh_auth) {
+        /* Mark as true and wait for thread to exit */
+        mstate->stop_refresh = _gf_true;
+        pthread_join(mstate->auth_refresh_thread, NULL);
+    }
+
+    if (nfs->exports_auth)
+        mnt3_auth_params_deinit(mstate->auth_params);
+
+    /* Unmount everything and clear mountdict */
+    LOCK(&mstate->mountlock);
+    {
+        __mnt3svc_umountall(mstate);
+        dict_unref(mstate->mountdict);
+    }
+    UNLOCK(&mstate->mountlock);
 }
 
 rpcsvc_program_t *
-mnt3svc_init (xlator_t *nfsx)
+mnt3svc_init(xlator_t *nfsx)
 {
-        struct mount3_state     *mstate = NULL;
-        struct nfs_state        *nfs = NULL;
-        dict_t                  *options = NULL;
-        char                    *portstr = NULL;
-        int                      ret = -1;
-        pthread_t                udp_thread;
-
-        if (!nfsx || !nfsx->private)
-                return NULL;
-
-        nfs = (struct nfs_state *)nfsx->private;
-
-        gf_msg_debug (GF_MNT, 0, "Initing Mount v3 state");
-        mstate = (struct mount3_state *)nfs->mstate;
-        if (!mstate) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_MNT_STATE_INIT_FAIL,
-                        "Mount v3 state init failed");
-                goto err;
-        }
+    struct mount3_state *mstate = NULL;
+    struct nfs_state *nfs = NULL;
+    dict_t *options = NULL;
+    char *portstr = NULL;
+    int ret = -1;
+    pthread_t udp_thread;
+
+    if (!nfsx || !nfsx->private)
+        return NULL;
 
-        mstate->nfs = nfs;
+    nfs = (struct nfs_state *)nfsx->private;
 
-        mstate->mountdict = dict_new ();
-        if (!mstate->mountdict) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to setup mount dict. Allocation error.");
-                goto err;
-        }
+    gf_msg_debug(GF_MNT, 0, "Initing Mount v3 state");
+    mstate = (struct mount3_state *)nfs->mstate;
+    if (!mstate) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_MNT_STATE_INIT_FAIL,
+               "Mount v3 state init failed");
+        goto err;
+    }
 
-        if (nfs->exports_auth) {
-                ret = _mnt3_init_auth_params (mstate);
-                if (ret < 0)
-                        goto err;
+    mstate->nfs = nfs;
 
-                mstate->authcache = auth_cache_init (nfs->auth_cache_ttl_sec);
-                if (!mstate->authcache) {
-                        ret = -ENOMEM;
-                        goto err;
-                }
+    mstate->mountdict = dict_new();
+    if (!mstate->mountdict) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to setup mount dict. Allocation error.");
+        goto err;
+    }
 
-                mstate->stop_refresh = _gf_false; /* Allow thread to run */
-                ret = gf_thread_create (&mstate->auth_refresh_thread, NULL,
-                                        _mnt3_auth_param_refresh_thread,
-                                        mstate, "nfsauth");
-                if (ret) {
-                        gf_msg_debug (GF_MNT, GF_LOG_DEBUG,
-                                      "Thread creation failed");
-                }
+    if (nfs->exports_auth) {
+        ret = _mnt3_init_auth_params(mstate);
+        if (ret < 0)
+            goto err;
 
-        } else
-                gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_EXP_AUTH_DISABLED,
-                        "Exports auth has been disabled!");
+        mstate->authcache = auth_cache_init(nfs->auth_cache_ttl_sec);
+        if (!mstate->authcache) {
+            ret = -ENOMEM;
+            goto err;
+        }
 
-        mnt3prog.private = mstate;
-        options = dict_new ();
+        mstate->stop_refresh = _gf_false; /* Allow thread to run */
+        ret = gf_thread_create(&mstate->auth_refresh_thread, NULL,
+                               _mnt3_auth_param_refresh_thread, mstate,
+                               "nfsauth");
+        if (ret) {
+            gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Thread creation failed");
+        }
 
-        ret = gf_asprintf (&portstr, "%d", GF_MOUNTV3_PORT);
-        if (ret == -1)
-                goto err;
+    } else
+        gf_msg(GF_MNT, GF_LOG_INFO, 0, NFS_MSG_EXP_AUTH_DISABLED,
+               "Exports auth has been disabled!");
 
-        ret = dict_set_dynstr (options, "transport.socket.listen-port",
-                               portstr);
-        if (ret == -1)
-                goto err;
+    mnt3prog.private = mstate;
+    options = dict_new();
 
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
-        }
+    ret = gf_asprintf(&portstr, "%d", GF_MOUNTV3_PORT);
+    if (ret == -1)
+        goto err;
 
-        if (nfs->allow_insecure) {
-                ret = dict_set_str (options, "rpc-auth-allow-insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED, "dict_set_str error");
-                        goto err;
-                }
-                ret = dict_set_str (options, "rpc-auth.ports.insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED, "dict_set_str error");
-                        goto err;
-                }
-        }
+    ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr);
+    if (ret == -1)
+        goto err;
 
-        ret= rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name);
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    if (nfs->allow_insecure) {
+        ret = dict_set_str(options, "rpc-auth-allow-insecure", "on");
         if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                        NFS_MSG_LISTENERS_CREATE_FAIL,
-                        "Unable to create listeners");
-                dict_unref (options);
-                goto err;
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
         }
-
-        if (nfs->mount_udp) {
-                ret = gf_thread_create (&udp_thread, NULL, mount3udp_thread,
-                                        nfsx, "nfsudp");
-                if (ret) {
-                        gf_msg_debug (GF_MNT, GF_LOG_DEBUG,
-                                      "Thread creation failed");
-                }
+        ret = dict_set_str(options, "rpc-auth.ports.insecure", "on");
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
+        }
+    }
+
+    ret = rpcsvc_create_listeners(nfs->rpcsvc, options, nfsx->name);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL,
+               "Unable to create listeners");
+        dict_unref(options);
+        goto err;
+    }
+
+    if (nfs->mount_udp) {
+        ret = gf_thread_create(&udp_thread, NULL, mount3udp_thread, nfsx,
+                               "nfsudp");
+        if (ret) {
+            gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Thread creation failed");
         }
-        return &mnt3prog;
+    }
+    return &mnt3prog;
 err:
-        return NULL;
+    return NULL;
 }
 
-
-rpcsvc_actor_t  mnt1svc_actors[MOUNT1_PROC_COUNT] = {
-        {"NULL",    MOUNT1_NULL,    mnt3svc_null,   NULL, 0, DRC_NA},
-        {"MNT",     MOUNT1_MNT,     NULL,           NULL, 0, DRC_NA },
-        {"DUMP",    MOUNT1_DUMP,    mnt3svc_dump,   NULL, 0, DRC_NA},
-        {"UMNT",    MOUNT1_UMNT,    mnt3svc_umnt,   NULL, 0, DRC_NA},
-        {"UMNTALL", MOUNT1_UMNTALL, NULL,           NULL, 0, DRC_NA},
-        {"EXPORT",  MOUNT1_EXPORT,  mnt3svc_export, NULL, 0, DRC_NA}
-};
-
-rpcsvc_program_t        mnt1prog = {
-                        .progname       = "MOUNT1",
-                        .prognum        = MOUNT_PROGRAM,
-                        .progver        = MOUNT_V1,
-                        .progport       = GF_MOUNTV1_PORT,
-                        .actors         = mnt1svc_actors,
-                        .numactors      = MOUNT1_PROC_COUNT,
-                        .min_auth       = AUTH_NULL,
-                        .synctask       = _gf_true,
+rpcsvc_actor_t mnt1svc_actors[MOUNT1_PROC_COUNT] = {
+    {"NULL", MOUNT1_NULL, mnt3svc_null, NULL, 0, DRC_NA},
+    {"MNT", MOUNT1_MNT, NULL, NULL, 0, DRC_NA},
+    {"DUMP", MOUNT1_DUMP, mnt3svc_dump, NULL, 0, DRC_NA},
+    {"UMNT", MOUNT1_UMNT, mnt3svc_umnt, NULL, 0, DRC_NA},
+    {"UMNTALL", MOUNT1_UMNTALL, NULL, NULL, 0, DRC_NA},
+    {"EXPORT", MOUNT1_EXPORT, mnt3svc_export, NULL, 0, DRC_NA}};
+
+rpcsvc_program_t mnt1prog = {
+    .progname = "MOUNT1",
+    .prognum = MOUNT_PROGRAM,
+    .progver = MOUNT_V1,
+    .progport = GF_MOUNTV1_PORT,
+    .actors = mnt1svc_actors,
+    .numactors = MOUNT1_PROC_COUNT,
+    .min_auth = AUTH_NULL,
+    .synctask = _gf_true,
 };
 
-
 rpcsvc_program_t *
-mnt1svc_init (xlator_t *nfsx)
+mnt1svc_init(xlator_t *nfsx)
 {
-        struct mount3_state     *mstate = NULL;
-        struct nfs_state        *nfs = NULL;
-        dict_t                  *options = NULL;
-        char                    *portstr = NULL;
-        int                      ret = -1;
-
-        if (!nfsx || !nfsx->private)
-                return NULL;
-
-        nfs = (struct nfs_state *)nfsx->private;
-
-        gf_msg_debug (GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state");
-        mstate = (struct mount3_state *)nfs->mstate;
-        if (!mstate) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL,
-                        NFS_MSG_MNT_STATE_INIT_FAIL,
-                        "Mount v3 state init failed");
-                goto err;
-        }
+    struct mount3_state *mstate = NULL;
+    struct nfs_state *nfs = NULL;
+    dict_t *options = NULL;
+    char *portstr = NULL;
+    int ret = -1;
+
+    if (!nfsx || !nfsx->private)
+        return NULL;
+
+    nfs = (struct nfs_state *)nfsx->private;
 
-        mnt1prog.private = mstate;
+    gf_msg_debug(GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state");
+    mstate = (struct mount3_state *)nfs->mstate;
+    if (!mstate) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_MNT_STATE_INIT_FAIL,
+               "Mount v3 state init failed");
+        goto err;
+    }
 
-        options = dict_new ();
+    mnt1prog.private = mstate;
 
-        ret = gf_asprintf (&portstr, "%d", GF_MOUNTV1_PORT);
-        if (ret == -1)
-                goto err;
+    options = dict_new();
 
-        ret = dict_set_dynstr (options, "transport.socket.listen-port", portstr);
-        if (ret == -1)
-                goto err;
-        ret = dict_set_str (options, "transport-type", "socket");
+    ret = gf_asprintf(&portstr, "%d", GF_MOUNTV1_PORT);
+    if (ret == -1)
+        goto err;
+
+    ret = dict_set_dynstr(options, "transport.socket.listen-port", portstr);
+    if (ret == -1)
+        goto err;
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    if (nfs->allow_insecure) {
+        ret = dict_set_str(options, "rpc-auth-allow-insecure", "on");
         if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
         }
-
-        if (nfs->allow_insecure) {
-                ret = dict_set_str (options, "rpc-auth-allow-insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED,
-                                "dict_set_str error");
-                        goto err;
-                }
-                ret = dict_set_str (options, "rpc-auth.ports.insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED,
-                                "dict_set_str error");
-                        goto err;
-                }
+        ret = dict_set_str(options, "rpc-auth.ports.insecure", "on");
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
         }
+    }
 
 #ifdef IPV6_DEFAULT
-        ret = dict_set_str (options, "transport.address-family", "inet6");
-        if (ret == -1) {
-                gf_log (GF_NFS, GF_LOG_ERROR,
-                        "dict_set_str error when trying to enable ipv6");
-              goto err;
-        }
+    ret = dict_set_str(options, "transport.address-family", "inet6");
+    if (ret == -1) {
+        gf_log(GF_NFS, GF_LOG_ERROR,
+               "dict_set_str error when trying to enable ipv6");
+        goto err;
+    }
 #endif
 
-        ret = rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                        NFS_MSG_LISTENERS_CREATE_FAIL,
-                        "Unable to create listeners");
-                dict_unref (options);
-                goto err;
-        }
+    ret = rpcsvc_create_listeners(nfs->rpcsvc, options, nfsx->name);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL,
+               "Unable to create listeners");
+        dict_unref(options);
+        goto err;
+    }
 
-        return &mnt1prog;
+    return &mnt1prog;
 err:
-        return NULL;
+    return NULL;
 }
 
 int
-mount_reconfigure_state (xlator_t *nfsx, dict_t *options)
+mount_reconfigure_state(xlator_t *nfsx, dict_t *options)
 {
-        int                    ret      = -1;
-        struct nfs_state       *nfs     = NULL;
-        struct mount3_state    *ms      = NULL;
-        struct mnt3_export     *exp     = NULL;
-        struct mnt3_export     *texp  = NULL;
-
-        if ((!nfsx) || (!options))
-                return (-1);
-
-        nfs = (struct nfs_state *)nfs_state (nfsx);
-        if (!nfs)
-                return (-1);
-
-        ms = nfs->mstate;
-        if (!ms)
-                return (-1);
-
-        /*
-         * Free() up the old export list. mnt3_init_options() will
-         * rebuild the export list from scratch. Do it with locking
-         * to avoid unnecessary race conditions.
-         */
-        LOCK (&ms->mountlock);
-        list_for_each_entry_safe (exp, texp, &ms->exportlist, explist) {
-                list_del (&exp->explist);
-                mnt3_export_free (exp);
-        }
-        ret = mnt3_init_options (ms, options);
-        UNLOCK (&ms->mountlock);
-
-        if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RECONF_FAIL,
-                        "Options reconfigure failed");
-                return (-1);
-        }
-
-        return (0);
+    int ret = -1;
+    struct nfs_state *nfs = NULL;
+    struct mount3_state *ms = NULL;
+    struct mnt3_export *exp = NULL;
+    struct mnt3_export *texp = NULL;
+
+    if ((!nfsx) || (!options))
+        return (-1);
+
+    nfs = (struct nfs_state *)nfs_state(nfsx);
+    if (!nfs)
+        return (-1);
+
+    ms = nfs->mstate;
+    if (!ms)
+        return (-1);
+
+    /*
+     * Free() up the old export list. mnt3_init_options() will
+     * rebuild the export list from scratch. Do it with locking
+     * to avoid unnecessary race conditions.
+     */
+    LOCK(&ms->mountlock);
+    list_for_each_entry_safe(exp, texp, &ms->exportlist, explist)
+    {
+        list_del(&exp->explist);
+        mnt3_export_free(exp);
+    }
+    ret = mnt3_init_options(ms, options);
+    UNLOCK(&ms->mountlock);
+
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RECONF_FAIL,
+               "Options reconfigure failed");
+        return (-1);
+    }
+
+    return (0);
 }