Land part 2 of clang-format changes

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

17 files changed, 19018 insertions, 19609 deletions

diff --git a/xlators/nfs/server/src/acl3.c b/xlators/nfs/server/src/acl3.c
index 7cd29889280..ff4bcfd8f4b 100644
--- a/xlators/nfs/server/src/acl3.c
+++ b/xlators/nfs/server/src/acl3.c
@@ -27,233 +27,228 @@
 #include "nfs-messages.h"
 
 static int
-acl3_nfs_acl_to_xattr (aclentry *ace, void *xattrbuf,
-                       int aclcount, int defacl);
+acl3_nfs_acl_to_xattr(aclentry *ace, void *xattrbuf, int aclcount, int defacl);
 
 static int
-acl3_nfs_acl_from_xattr (aclentry *ace, void *xattrbuf,
-                         int bufsize, int defacl);
+acl3_nfs_acl_from_xattr(aclentry *ace, void *xattrbuf, int bufsize, int defacl);
 
-typedef ssize_t (*acl3_serializer) (struct iovec outmsg, void *args);
+typedef ssize_t (*acl3_serializer)(struct iovec outmsg, void *args);
 
-extern void nfs3_call_state_wipe (nfs3_call_state_t *cs);
+extern void
+nfs3_call_state_wipe(nfs3_call_state_t *cs);
 
 extern nfs3_call_state_t *
-nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v);
+nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v);
 
 extern int
-nfs3_fh_validate (struct nfs3_fh *fh);
+nfs3_fh_validate(struct nfs3_fh *fh);
 
 extern void
-nfs3_stat_to_fattr3 (struct iatt *buf, fattr3 *fa);
-
-#define acl3_validate_nfs3_state(request, state, status, label, retval) \
-        do      {                                                       \
-                state = rpcsvc_request_program_private (request);       \
-                if (!state) {                                           \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, errno,            \
-                                NFS_MSG_STATE_MISSING,                  \
-                                "NFSv3 state "                          \
-                                "missing from RPC request");            \
-                        rpcsvc_request_seterr (req, SYSTEM_ERR);        \
-                        status = NFS3ERR_SERVERFAULT;                   \
-                        goto label;                                     \
-                }                                                       \
-        } while (0);                                                    \
-
-#define acl3_validate_gluster_fh(handle, status, errlabel)              \
-        do {                                                            \
-                if (!nfs3_fh_validate (handle)) {                       \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL,           \
-                                NFS_MSG_BAD_HANDLE,                     \
-                                "Bad Handle");                          \
-                        status = NFS3ERR_BADHANDLE;                     \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
-
+nfs3_stat_to_fattr3(struct iatt *buf, fattr3 *fa);
+
+#define acl3_validate_nfs3_state(request, state, status, label, retval)        \
+    do {                                                                       \
+        state = rpcsvc_request_program_private(request);                       \
+        if (!state) {                                                          \
+            gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_STATE_MISSING,         \
+                   "NFSv3 state "                                              \
+                   "missing from RPC request");                                \
+            rpcsvc_request_seterr(req, SYSTEM_ERR);                            \
+            status = NFS3ERR_SERVERFAULT;                                      \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0);
+
+#define acl3_validate_gluster_fh(handle, status, errlabel)                     \
+    do {                                                                       \
+        if (!nfs3_fh_validate(handle)) {                                       \
+            gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_BAD_HANDLE,           \
+                   "Bad Handle");                                              \
+            status = NFS3ERR_BADHANDLE;                                        \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 extern xlator_t *
-nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh);
-
-#define acl3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \
-        do {                                                            \
-                char exportid[256], gfid[256];                          \
-                rpc_transport_t *trans = NULL;                          \
-                volume = nfs3_fh_to_xlator ((nfs3state), handle);      \
-                if (!volume) {                                          \
-                        gf_uuid_unparse (handle->exportid, exportid);   \
-                        gf_uuid_unparse (handle->gfid, gfid);           \
-                        trans = rpcsvc_request_transport (req);         \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, 0,                \
-                                NFS_MSG_FH_TO_VOL_FAIL, "Failed to map "  \
-                                "FH to vol: client=%s, exportid=%s, gfid=%s",\
-                                trans->peerinfo.identifier, exportid,   \
-                                gfid);                                  \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, ESTALE,           \
-                                NFS_MSG_VOLUME_ERROR,                   \
-                                "Stale nfs client %s must be trying to "\
-                                "connect to a deleted volume, please "  \
-                                "unmount it.", trans->peerinfo.identifier);\
-                        status = NFS3ERR_STALE;                         \
-                        goto label;                                     \
-                } else {                                                \
-                        gf_msg_trace (GF_ACL, 0, "FH to Volume: %s",    \
-                                      volume->name);                    \
-                        rpcsvc_request_set_private (req, volume);       \
-                }                                                       \
-        } while (0);                                                    \
-
-#define acl3_volume_started_check(nfs3state, vlm, rtval, erlbl)         \
-        do {                                                            \
-              if ((!nfs_subvolume_started (nfs_state (nfs3state->nfsx), vlm))){\
-                        gf_msg (GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \
-                                "Volume is disabled: %s",                 \
-                                vlm->name);                               \
-                      rtval = RPCSVC_ACTOR_IGNORE;                      \
-                      goto erlbl;                                       \
-              }                                                         \
-        } while (0)                                                     \
-
-#define acl3_check_fh_resolve_status(cst, nfstat, erlabl)               \
-        do {                                                            \
-                xlator_t *xlatorp = NULL;                               \
-                char buf[256], gfid[GF_UUID_BUF_SIZE];                  \
-                rpc_transport_t *trans = NULL;                          \
-                if ((cst)->resolve_ret < 0) {                           \
-                        trans = rpcsvc_request_transport (cst->req);    \
-                        xlatorp = nfs3_fh_to_xlator (cst->nfs3state,    \
-                                                     &cst->resolvefh);  \
-                        gf_uuid_unparse (cst->resolvefh.gfid, gfid);    \
-                        snprintf (buf, sizeof (buf), "(%s) %s : %s",    \
-                                  trans->peerinfo.identifier,           \
-                                  xlatorp ? xlatorp->name : "ERR",      \
-                                  gfid);                                \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, cst->resolve_errno, \
-                                NFS_MSG_RESOLVE_FH_FAIL, "Unable to resolve "\
-                                "FH: %s", buf);                           \
-                        nfstat = nfs3_errno_to_nfsstat3 (cst->resolve_errno);\
-                        goto erlabl;                                    \
-                }                                                       \
-        } while (0)                                                     \
-
-#define acl3_handle_call_state_init(nfs3state, calls, rq, v, opstat, errlabel)\
-        do {                                                            \
-                calls = nfs3_call_state_init ((nfs3state), (rq), v);    \
-                if (!calls) {                                           \
-                        gf_msg (GF_ACL, GF_LOG_ERROR, 0,                \
-                                NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to " \
-                                "init call state");                     \
-                        opstat = NFS3ERR_SERVERFAULT;                   \
-                        rpcsvc_request_seterr (req, SYSTEM_ERR);        \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
-
+nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh);
+
+#define acl3_map_fh_to_volume(nfs3state, handle, req, volume, status, label)   \
+    do {                                                                       \
+        char exportid[256], gfid[256];                                         \
+        rpc_transport_t *trans = NULL;                                         \
+        volume = nfs3_fh_to_xlator((nfs3state), handle);                       \
+        if (!volume) {                                                         \
+            gf_uuid_unparse(handle->exportid, exportid);                       \
+            gf_uuid_unparse(handle->gfid, gfid);                               \
+            trans = rpcsvc_request_transport(req);                             \
+            gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_FH_TO_VOL_FAIL,            \
+                   "Failed to map "                                            \
+                   "FH to vol: client=%s, exportid=%s, gfid=%s",               \
+                   trans->peerinfo.identifier, exportid, gfid);                \
+            gf_msg(GF_ACL, GF_LOG_ERROR, ESTALE, NFS_MSG_VOLUME_ERROR,         \
+                   "Stale nfs client %s must be trying to "                    \
+                   "connect to a deleted volume, please "                      \
+                   "unmount it.",                                              \
+                   trans->peerinfo.identifier);                                \
+            status = NFS3ERR_STALE;                                            \
+            goto label;                                                        \
+        } else {                                                               \
+            gf_msg_trace(GF_ACL, 0, "FH to Volume: %s", volume->name);         \
+            rpcsvc_request_set_private(req, volume);                           \
+        }                                                                      \
+    } while (0);
+
+#define acl3_volume_started_check(nfs3state, vlm, rtval, erlbl)                \
+    do {                                                                       \
+        if ((!nfs_subvolume_started(nfs_state(nfs3state->nfsx), vlm))) {       \
+            gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE,               \
+                   "Volume is disabled: %s", vlm->name);                       \
+            rtval = RPCSVC_ACTOR_IGNORE;                                       \
+            goto erlbl;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define acl3_check_fh_resolve_status(cst, nfstat, erlabl)                      \
+    do {                                                                       \
+        xlator_t *xlatorp = NULL;                                              \
+        char buf[256], gfid[GF_UUID_BUF_SIZE];                                 \
+        rpc_transport_t *trans = NULL;                                         \
+        if ((cst)->resolve_ret < 0) {                                          \
+            trans = rpcsvc_request_transport(cst->req);                        \
+            xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh);      \
+            gf_uuid_unparse(cst->resolvefh.gfid, gfid);                        \
+            snprintf(buf, sizeof(buf), "(%s) %s : %s",                         \
+                     trans->peerinfo.identifier,                               \
+                     xlatorp ? xlatorp->name : "ERR", gfid);                   \
+            gf_msg(GF_ACL, GF_LOG_ERROR, cst->resolve_errno,                   \
+                   NFS_MSG_RESOLVE_FH_FAIL,                                    \
+                   "Unable to resolve "                                        \
+                   "FH: %s",                                                   \
+                   buf);                                                       \
+            nfstat = nfs3_errno_to_nfsstat3(cst->resolve_errno);               \
+            goto erlabl;                                                       \
+        }                                                                      \
+    } while (0)
+
+#define acl3_handle_call_state_init(nfs3state, calls, rq, v, opstat, errlabel) \
+    do {                                                                       \
+        calls = nfs3_call_state_init((nfs3state), (rq), v);                    \
+        if (!calls) {                                                          \
+            gf_msg(GF_ACL, GF_LOG_ERROR, 0, NFS_MSG_INIT_CALL_STAT_FAIL,       \
+                   "Failed to "                                                \
+                   "init call state");                                         \
+            opstat = NFS3ERR_SERVERFAULT;                                      \
+            rpcsvc_request_seterr(req, SYSTEM_ERR);                            \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 int
-acl3svc_submit_reply (rpcsvc_request_t *req, void *arg, acl3_serializer sfunc)
+acl3svc_submit_reply(rpcsvc_request_t *req, void *arg, acl3_serializer sfunc)
 {
-        struct iovec            outmsg  = {0, };
-        struct iobuf            *iob    = NULL;
-        struct nfs3_state       *nfs3   = NULL;
-        int                     ret     = -1;
-        ssize_t                 msglen  = 0;
-        struct iobref           *iobref = NULL;
-
-        if (!req)
-                return -1;
-
-        nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req);
-        if (!nfs3) {
-                gf_msg (GF_ACL, 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.
-         */
-        iob = iobuf_get (nfs3->iobpool);
-        if (!iob) {
-                gf_msg (GF_ACL, 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_ACL, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL,
-                        "Failed to encode message");
-                goto ret;
-        }
-        outmsg.iov_len = msglen;
-
-        iobref = iobref_new ();
-        if (iobref == NULL) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobref");
-                goto ret;
-        }
-
-        ret = iobref_add (iobref, iob);
-        if (ret) {
-                gf_msg (GF_ACL, 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_ACL, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
-                        "Reply submission failed");
-                goto ret;
-        }
-
-        ret = 0;
+    struct iovec outmsg = {
+        0,
+    };
+    struct iobuf *iob = NULL;
+    struct nfs3_state *nfs3 = NULL;
+    int ret = -1;
+    ssize_t msglen = 0;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        return -1;
+
+    nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req);
+    if (!nfs3) {
+        gf_msg(GF_ACL, 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.
+     */
+    iob = iobuf_get(nfs3->iobpool);
+    if (!iob) {
+        gf_msg(GF_ACL, 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_ACL, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL,
+               "Failed to encode message");
+        goto ret;
+    }
+    outmsg.iov_len = msglen;
+
+    iobref = iobref_new();
+    if (iobref == NULL) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobref");
+        goto ret;
+    }
+
+    ret = iobref_add(iobref, iob);
+    if (ret) {
+        gf_msg(GF_ACL, 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_ACL, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
+               "Reply submission failed");
+        goto ret;
+    }
+
+    ret = 0;
 ret:
-        if (iob)
-                iobuf_unref (iob);
-        if (iobref)
-                iobref_unref (iobref);
+    if (iob)
+        iobuf_unref(iob);
+    if (iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
-
 int
-acl3svc_null (rpcsvc_request_t *req)
+acl3svc_null(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
+    struct iovec dummyvec = {
+        0,
+    };
 
-        if (!req) {
-                gf_msg (GF_ACL, 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_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Got NULL request!");
         return 0;
+    }
+    rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL);
+    return 0;
 }
 
 int
-acl3_getacl_reply (rpcsvc_request_t *req, getaclreply *reply)
+acl3_getacl_reply(rpcsvc_request_t *req, getaclreply *reply)
 {
-        acl3svc_submit_reply (req, (void *)reply,
-                              (acl3_serializer)xdr_serialize_getaclreply);
-        return 0;
+    acl3svc_submit_reply(req, (void *)reply,
+                         (acl3_serializer)xdr_serialize_getaclreply);
+    return 0;
 }
 
 int
-acl3_setacl_reply (rpcsvc_request_t *req, setaclreply *reply)
+acl3_setacl_reply(rpcsvc_request_t *req, setaclreply *reply)
 {
-        acl3svc_submit_reply (req, (void *)reply,
-                              (acl3_serializer)xdr_serialize_setaclreply);
-        return 0;
+    acl3svc_submit_reply(req, (void *)reply,
+                         (acl3_serializer)xdr_serialize_setaclreply);
+    return 0;
 }
 
 /* acl3_getacl_cbk: fetch and decode the ACL in the POSIX_ACL_ACCESS_XATTR
@@ -261,63 +256,59 @@ acl3_setacl_reply (rpcsvc_request_t *req, setaclreply *reply)
  * The POSIX_ACL_ACCESS_XATTR can be set on files and directories.
  */
 int
-acl3_getacl_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *dict,
-                 dict_t *xdata)
+acl3_getacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        nfsstat3                 stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t        *cs = NULL;
-        data_t                   *data = NULL;
-        getaclreply              *getaclreply = NULL;
-        int                      aclcount = 0;
-        int                      defacl = 1; /* DEFAULT ACL */
-
-        if (!frame->local) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, frame->local NULL");
-                return -EINVAL;
-        }
-        cs = frame->local;
-        getaclreply = &cs->args.getaclreply;
-        if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        } else if (!dict) {
-                /* no ACL has been set */
-                stat = NFS3_OK;
-                goto err;
-        }
-
-        getaclreply->aclentry.aclentry_val = cs->aclentry;
-
-        /* getfacl: NFS USER ACL */
-        data = dict_get (dict, POSIX_ACL_ACCESS_XATTR);
-        if (data && data->data) {
-                aclcount = acl3_nfs_acl_from_xattr (cs->aclentry,
-                                                    data->data,
-                                                    data->len,
-                                                    !defacl);
-                if (aclcount < 0) {
-                        gf_msg (GF_ACL, GF_LOG_ERROR, aclcount,
-                                NFS_MSG_GET_USER_ACL_FAIL,
-                                "Failed to get USER ACL");
-                        stat = nfs3_errno_to_nfsstat3 (-aclcount);
-                        goto err;
-                }
-                getaclreply->aclcount = aclcount;
-                getaclreply->aclentry.aclentry_len = aclcount;
-        }
-
-        acl3_getacl_reply (cs->req, getaclreply);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+    data_t *data = NULL;
+    getaclreply *getaclreply = NULL;
+    int aclcount = 0;
+    int defacl = 1; /* DEFAULT ACL */
+
+    if (!frame->local) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, frame->local NULL");
+        return -EINVAL;
+    }
+    cs = frame->local;
+    getaclreply = &cs->args.getaclreply;
+    if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    } else if (!dict) {
+        /* no ACL has been set */
+        stat = NFS3_OK;
+        goto err;
+    }
+
+    getaclreply->aclentry.aclentry_val = cs->aclentry;
+
+    /* getfacl: NFS USER ACL */
+    data = dict_get(dict, POSIX_ACL_ACCESS_XATTR);
+    if (data && data->data) {
+        aclcount = acl3_nfs_acl_from_xattr(cs->aclentry, data->data, data->len,
+                                           !defacl);
+        if (aclcount < 0) {
+            gf_msg(GF_ACL, GF_LOG_ERROR, aclcount, NFS_MSG_GET_USER_ACL_FAIL,
+                   "Failed to get USER ACL");
+            stat = nfs3_errno_to_nfsstat3(-aclcount);
+            goto err;
+        }
+        getaclreply->aclcount = aclcount;
+        getaclreply->aclentry.aclentry_len = aclcount;
+    }
+
+    acl3_getacl_reply(cs->req, getaclreply);
+    nfs3_call_state_wipe(cs);
+    return 0;
 
 err:
-        if (getaclreply)
-                getaclreply->status = stat;
-        acl3_getacl_reply (cs->req, getaclreply);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    if (getaclreply)
+        getaclreply->status = stat;
+    acl3_getacl_reply(cs->req, getaclreply);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
 /* acl3_default_getacl_cbk: fetch and decode the ACL set in the
@@ -329,625 +320,604 @@ err:
  * ACL that can be set in POSIX_ACL_DEFAULT_XATTR.
  */
 int
-acl3_default_getacl_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *dict,
-                         dict_t *xdata)
+acl3_default_getacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *dict,
+                        dict_t *xdata)
 {
-        nfsstat3                 stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t        *cs = NULL;
-        data_t                   *data = NULL;
-        getaclreply              *getaclreply = NULL;
-        int                      aclcount = 0;
-        int                      defacl = 1; /* DEFAULT ACL */
-        nfs_user_t               nfu = {0, };
-        int                      ret = -1;
-
-        if (!frame->local) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, frame->local NULL");
-                return -EINVAL;
-        }
-        cs = frame->local;
-        getaclreply = &cs->args.getaclreply;
-        if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        } else if (!dict) {
-                /* no ACL has been set */
-                stat = NFS3_OK;
-                goto err;
-        }
-
-        getaclreply->daclentry.daclentry_val = cs->daclentry;
-
-        /* getfacl: NFS DEFAULT ACL */
-        data = dict_get (dict, POSIX_ACL_DEFAULT_XATTR);
-        if (data && data->data) {
-                aclcount = acl3_nfs_acl_from_xattr (cs->daclentry,
-                                                    data->data,
-                                                    data->len,
-                                                    defacl);
-                if (aclcount < 0) {
-                        gf_msg (GF_ACL, GF_LOG_ERROR, aclcount,
-                                NFS_MSG_GET_DEF_ACL_FAIL,
-                                "Failed to get DEFAULT ACL");
-                        stat = nfs3_errno_to_nfsstat3 (-aclcount);
-                        goto err;
-                }
-
-                getaclreply->daclcount = aclcount;
-                getaclreply->daclentry.daclentry_len = aclcount;
-        }
-
-        getaclreply->attr_follows = TRUE;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                            POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs);
-        if (ret < 0) {
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-                goto err;
-        }
-
-        return 0;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+    data_t *data = NULL;
+    getaclreply *getaclreply = NULL;
+    int aclcount = 0;
+    int defacl = 1; /* DEFAULT ACL */
+    nfs_user_t nfu = {
+        0,
+    };
+    int ret = -1;
+
+    if (!frame->local) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, frame->local NULL");
+        return -EINVAL;
+    }
+    cs = frame->local;
+    getaclreply = &cs->args.getaclreply;
+    if ((op_ret < 0) && (op_errno != ENODATA && op_errno != ENOATTR)) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    } else if (!dict) {
+        /* no ACL has been set */
+        stat = NFS3_OK;
+        goto err;
+    }
+
+    getaclreply->daclentry.daclentry_val = cs->daclentry;
+
+    /* getfacl: NFS DEFAULT ACL */
+    data = dict_get(dict, POSIX_ACL_DEFAULT_XATTR);
+    if (data && data->data) {
+        aclcount = acl3_nfs_acl_from_xattr(cs->daclentry, data->data, data->len,
+                                           defacl);
+        if (aclcount < 0) {
+            gf_msg(GF_ACL, GF_LOG_ERROR, aclcount, NFS_MSG_GET_DEF_ACL_FAIL,
+                   "Failed to get DEFAULT ACL");
+            stat = nfs3_errno_to_nfsstat3(-aclcount);
+            goto err;
+        }
+
+        getaclreply->daclcount = aclcount;
+        getaclreply->daclentry.daclentry_len = aclcount;
+    }
+
+    getaclreply->attr_follows = TRUE;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                       POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs);
+    if (ret < 0) {
+        stat = nfs3_errno_to_nfsstat3(-ret);
+        goto err;
+    }
+
+    return 0;
 
 err:
-        if (getaclreply)
-                getaclreply->status = stat;
-        acl3_getacl_reply (cs->req, getaclreply);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    if (getaclreply)
+        getaclreply->status = stat;
+    acl3_getacl_reply(cs->req, getaclreply);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int
-acl3_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                  dict_t *xdata)
+acl3_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+              int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t              *cs = NULL;
-        getaclreply                     *getaclreply = NULL;
-        int                             ret = -1;
-        nfs_user_t                      nfu = {0, };
-        uint64_t                        deviceid = 0;
-
-        if (!frame->local) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, frame->local NULL");
-                return EINVAL;
-        }
-
-        cs = frame->local;
-        getaclreply = &cs->args.getaclreply;
-
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        }
-
-        /* Fill the attrs before xattrs */
-        getaclreply->attr_follows = TRUE;
-        deviceid = nfs3_request_xlator_deviceid (cs->req);
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        nfs3_stat_to_fattr3 (buf, &(getaclreply->attr));
-
-        nfs_request_user_init (&nfu, cs->req);
-        if (buf->ia_type == IA_IFDIR) {
-                ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                    POSIX_ACL_DEFAULT_XATTR, NULL,
-                                    acl3_default_getacl_cbk, cs);
-        } else {
-                ret = nfs_getxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                    POSIX_ACL_ACCESS_XATTR, NULL,
-                                    acl3_getacl_cbk, cs);
-        }
-
-        if (ret < 0) {
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-                goto err;
-        }
-
-        return 0;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+    getaclreply *getaclreply = NULL;
+    int ret = -1;
+    nfs_user_t nfu = {
+        0,
+    };
+    uint64_t deviceid = 0;
+
+    if (!frame->local) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, frame->local NULL");
+        return EINVAL;
+    }
+
+    cs = frame->local;
+    getaclreply = &cs->args.getaclreply;
+
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    }
+
+    /* Fill the attrs before xattrs */
+    getaclreply->attr_follows = TRUE;
+    deviceid = nfs3_request_xlator_deviceid(cs->req);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    nfs3_stat_to_fattr3(buf, &(getaclreply->attr));
+
+    nfs_request_user_init(&nfu, cs->req);
+    if (buf->ia_type == IA_IFDIR) {
+        ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                           POSIX_ACL_DEFAULT_XATTR, NULL,
+                           acl3_default_getacl_cbk, cs);
+    } else {
+        ret = nfs_getxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                           POSIX_ACL_ACCESS_XATTR, NULL, acl3_getacl_cbk, cs);
+    }
+
+    if (ret < 0) {
+        stat = nfs3_errno_to_nfsstat3(-ret);
+        goto err;
+    }
+
+    return 0;
 err:
-        getaclreply->status = stat;
-        acl3_getacl_reply (cs->req, getaclreply);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    getaclreply->status = stat;
+    acl3_getacl_reply(cs->req, getaclreply);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int
-acl3_getacl_resume (void *carg)
+acl3_getacl_resume(void *carg)
 {
-        int                             ret = -1;
-        nfs3_call_state_t               *cs = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        nfs_user_t                      nfu = {0, };
-
-        if (!carg)
-                return ret;
+    int ret = -1;
+    nfs3_call_state_t *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        acl3_check_fh_resolve_status (cs, stat, acl3err);
-        nfs_request_user_init (&nfu, cs->req);
+    cs = (nfs3_call_state_t *)carg;
+    acl3_check_fh_resolve_status(cs, stat, acl3err);
+    nfs_request_user_init(&nfu, cs->req);
 
-        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                        acl3_stat_cbk, cs);
-        stat = -ret;
+    ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, acl3_stat_cbk,
+                   cs);
+    stat = -ret;
 acl3err:
-        if (ret < 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL,
-                        "unable to open_and_resume");
-                cs->args.getaclreply.status = nfs3_errno_to_nfsstat3 (stat);
-                acl3_getacl_reply (cs->req, &cs->args.getaclreply);
-                nfs3_call_state_wipe (cs);
-        }
-
-        return ret;
+    if (ret < 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL,
+               "unable to open_and_resume");
+        cs->args.getaclreply.status = nfs3_errno_to_nfsstat3(stat);
+        acl3_getacl_reply(cs->req, &cs->args.getaclreply);
+        nfs3_call_state_wipe(cs);
+    }
+
+    return ret;
 }
 
-
 int
-acl3svc_getacl (rpcsvc_request_t *req)
+acl3svc_getacl(rpcsvc_request_t *req)
 {
-        xlator_t                        *vol = NULL;
-        struct nfs_state               *nfs = NULL;
-        nfs3_state_t                   *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-        int                             ret = RPCSVC_ACTOR_ERROR;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        struct nfs3_fh                  fh, *fhp = NULL;
-        getaclargs                      getaclargs;
-        getaclreply                     getaclreply;
-
-        if (!req)
-                return ret;
-
-        acl3_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        memset (&getaclargs, 0, sizeof (getaclargs));
-        memset (&getaclreply, 0, sizeof (getaclreply));
-        getaclargs.fh.n_bytes = (char *)&fh;
-        if (xdr_to_getaclargs(req->msg[0], &getaclargs) <= 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        /* Validate ACL mask */
-        if (getaclargs.mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) {
-                stat = NFS3ERR_INVAL;
-                goto acl3err;
-        }
-
-        fhp = &fh;
-        acl3_validate_gluster_fh (&fh, stat, acl3err);
-        acl3_map_fh_to_volume (nfs->nfs3state, fhp, req, vol, stat, acl3err);
-        acl3_volume_started_check (nfs3, vol, ret, rpcerr);
-        acl3_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     vol, stat, acl3err);
-
-        cs->vol = vol;
-        cs->args.getaclreply.mask = getaclargs.mask;
+    xlator_t *vol = NULL;
+    struct nfs_state *nfs = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    int ret = RPCSVC_ACTOR_ERROR;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    struct nfs3_fh fh, *fhp = NULL;
+    getaclargs getaclargs;
+    getaclreply getaclreply;
+
+    if (!req)
+        return ret;
 
-        ret = nfs3_fh_resolve_and_resume (cs, fhp, NULL, acl3_getacl_resume);
-        stat = nfs3_errno_to_nfsstat3 (-ret);
+    acl3_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    memset(&getaclargs, 0, sizeof(getaclargs));
+    memset(&getaclreply, 0, sizeof(getaclreply));
+    getaclargs.fh.n_bytes = (char *)&fh;
+    if (xdr_to_getaclargs(req->msg[0], &getaclargs) <= 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    /* Validate ACL mask */
+    if (getaclargs.mask & ~(NFS_ACL | NFS_ACLCNT | NFS_DFACL | NFS_DFACLCNT)) {
+        stat = NFS3ERR_INVAL;
+        goto acl3err;
+    }
+
+    fhp = &fh;
+    acl3_validate_gluster_fh(&fh, stat, acl3err);
+    acl3_map_fh_to_volume(nfs->nfs3state, fhp, req, vol, stat, acl3err);
+    acl3_volume_started_check(nfs3, vol, ret, rpcerr);
+    acl3_handle_call_state_init(nfs->nfs3state, cs, req, vol, stat, acl3err);
+
+    cs->vol = vol;
+    cs->args.getaclreply.mask = getaclargs.mask;
+
+    ret = nfs3_fh_resolve_and_resume(cs, fhp, NULL, acl3_getacl_resume);
+    stat = nfs3_errno_to_nfsstat3(-ret);
 
 acl3err:
-        if (ret < 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                getaclreply.status = stat;
-                acl3_getacl_reply (req, &getaclreply);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        getaclreply.status = stat;
+        acl3_getacl_reply(req, &getaclreply);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
 int
-acl3_setacl_cbk (call_frame_t *frame, void *cookie,
-                 xlator_t *this, int32_t op_ret, int32_t op_errno,
-                 dict_t *xdata)
+acl3_setacl_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        nfs3_call_state_t               *cs = NULL;
-        cs = frame->local;
-        if (op_ret < 0) {
-                nfsstat3 status = nfs3_cbk_errno_status (op_ret, op_errno);
-                cs->args.setaclreply.status = status;
-        }
+    nfs3_call_state_t *cs = NULL;
+    cs = frame->local;
+    if (op_ret < 0) {
+        nfsstat3 status = nfs3_cbk_errno_status(op_ret, op_errno);
+        cs->args.setaclreply.status = status;
+    }
 
-        acl3_setacl_reply (cs->req, &cs->args.setaclreply);
+    acl3_setacl_reply(cs->req, &cs->args.setaclreply);
 
-        nfs3_call_state_wipe (cs);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
 int
-acl3_setacl_resume (void *carg)
+acl3_setacl_resume(void *carg)
 {
-        int                             ret = -1;
-        nfs3_call_state_t               *cs = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        nfs_user_t                      nfu = {0, };
-        dict_t                          *xattr = NULL;
-
-        if (!carg)
-                return ret;
-        cs = (nfs3_call_state_t *)carg;
-        acl3_check_fh_resolve_status (cs, stat, acl3err);
-        nfs_request_user_init (&nfu, cs->req);
-        xattr = dict_new();
-        if (cs->aclcount)
-        ret = dict_set_static_bin (xattr, POSIX_ACL_ACCESS_XATTR,
-                                   cs->aclxattr,
-                                   posix_acl_xattr_size (cs->aclcount));
-        if (cs->daclcount)
-        ret = dict_set_static_bin (xattr, POSIX_ACL_DEFAULT_XATTR,
-                                   cs->daclxattr,
-                                   posix_acl_xattr_size (cs->daclcount));
-
-        ret = nfs_setxattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, xattr,
-                            0, NULL, acl3_setacl_cbk, cs);
-        dict_unref (xattr);
+    int ret = -1;
+    nfs3_call_state_t *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    dict_t *xattr = NULL;
+
+    if (!carg)
+        return ret;
+    cs = (nfs3_call_state_t *)carg;
+    acl3_check_fh_resolve_status(cs, stat, acl3err);
+    nfs_request_user_init(&nfu, cs->req);
+    xattr = dict_new();
+    if (cs->aclcount)
+        ret = dict_set_static_bin(xattr, POSIX_ACL_ACCESS_XATTR, cs->aclxattr,
+                                  posix_acl_xattr_size(cs->aclcount));
+    if (cs->daclcount)
+        ret = dict_set_static_bin(xattr, POSIX_ACL_DEFAULT_XATTR, cs->daclxattr,
+                                  posix_acl_xattr_size(cs->daclcount));
+
+    ret = nfs_setxattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, xattr, 0,
+                       NULL, acl3_setacl_cbk, cs);
+    dict_unref(xattr);
 
 acl3err:
-        if (ret < 0) {
-                stat = -ret;
-                gf_msg (GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL,
-                        "unable to open_and_resume");
-                cs->args.setaclreply.status = nfs3_errno_to_nfsstat3 (stat);
-                acl3_setacl_reply (cs->req, &cs->args.setaclreply);
-                nfs3_call_state_wipe (cs);
-        }
-
-        return ret;
+    if (ret < 0) {
+        stat = -ret;
+        gf_msg(GF_ACL, GF_LOG_ERROR, stat, NFS_MSG_OPEN_FAIL,
+               "unable to open_and_resume");
+        cs->args.setaclreply.status = nfs3_errno_to_nfsstat3(stat);
+        acl3_setacl_reply(cs->req, &cs->args.setaclreply);
+        nfs3_call_state_wipe(cs);
+    }
+
+    return ret;
 }
 
-
 int
-acl3svc_setacl (rpcsvc_request_t *req)
+acl3svc_setacl(rpcsvc_request_t *req)
 {
-        xlator_t                       *vol = NULL;
-        struct nfs_state               *nfs = NULL;
-        nfs3_state_t                   *nfs3 = NULL;
-        nfs3_call_state_t              *cs = NULL;
-        int                            ret = RPCSVC_ACTOR_ERROR;
-        nfsstat3                       stat = NFS3ERR_SERVERFAULT;
-        struct nfs3_fh                 fh;
-        struct nfs3_fh                 *fhp = NULL;
-        setaclargs                     setaclargs;
-        setaclreply                    setaclreply;
-        aclentry                       *daclentry = NULL;
-        aclentry                       *aclentry = NULL;
-        int                            aclerrno = 0;
-        int                            defacl = 1;
-
-        if (!req)
-                return ret;
-        aclentry =  GF_CALLOC (NFS_ACL_MAX_ENTRIES, sizeof(*aclentry),
-                               gf_nfs_mt_arr);
-        if (!aclentry) {
-                goto rpcerr;
-        }
-        daclentry = GF_CALLOC (NFS_ACL_MAX_ENTRIES, sizeof(*daclentry),
-                               gf_nfs_mt_arr);
-        if (!daclentry) {
-                goto rpcerr;
-        }
-
-        acl3_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        memset (&setaclargs, 0, sizeof (setaclargs));
-        memset (&setaclreply, 0, sizeof (setaclreply));
-        memset (&fh, 0, sizeof (fh));
-        setaclargs.fh.n_bytes = (char *)&fh;
-        setaclargs.aclentry.aclentry_val = aclentry;
-        setaclargs.daclentry.daclentry_val = daclentry;
-        if (xdr_to_setaclargs(req->msg[0], &setaclargs) <= 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        /* Validate ACL mask */
-        if (setaclargs.mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) {
-                stat = NFS3ERR_INVAL;
-                goto acl3err;
-        }
-
-        fhp = &fh;
-        acl3_validate_gluster_fh (fhp, stat, acl3err);
-        acl3_map_fh_to_volume (nfs->nfs3state, fhp, req, vol, stat, acl3err);
-        acl3_volume_started_check (nfs3, vol, ret, rpcerr);
-        acl3_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     vol, stat, acl3err);
-
-        cs->vol = vol;
-        cs->aclcount = setaclargs.aclcount;
-        cs->daclcount = setaclargs.daclcount;
-
-        /* setfacl: NFS USER ACL */
-        aclerrno = acl3_nfs_acl_to_xattr (aclentry,
-                                          cs->aclxattr,
-                                          cs->aclcount,
-                                          !defacl);
-        if (aclerrno < 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, -aclerrno,
-                        NFS_MSG_SET_USER_ACL_FAIL,
-                        "Failed to set USER ACL");
-                stat = nfs3_errno_to_nfsstat3 (-aclerrno);
-                goto acl3err;
-        }
-
-        /* setfacl: NFS DEFAULT ACL */
-        aclerrno = acl3_nfs_acl_to_xattr (daclentry,
-                                          cs->daclxattr,
-                                          cs->daclcount,
-                                          defacl);
-        if (aclerrno < 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, -aclerrno,
-                        NFS_MSG_SET_DEF_ACL_FAIL,
-                        "Failed to set DEFAULT ACL");
-                stat = nfs3_errno_to_nfsstat3 (-aclerrno);
-                goto acl3err;
-        }
-
-        ret = nfs3_fh_resolve_and_resume (cs, fhp, NULL, acl3_setacl_resume);
-        stat = nfs3_errno_to_nfsstat3 (-ret);
+    xlator_t *vol = NULL;
+    struct nfs_state *nfs = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    int ret = RPCSVC_ACTOR_ERROR;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    struct nfs3_fh fh;
+    struct nfs3_fh *fhp = NULL;
+    setaclargs setaclargs;
+    setaclreply setaclreply;
+    aclentry *daclentry = NULL;
+    aclentry *aclentry = NULL;
+    int aclerrno = 0;
+    int defacl = 1;
+
+    if (!req)
+        return ret;
+    aclentry = GF_CALLOC(NFS_ACL_MAX_ENTRIES, sizeof(*aclentry), gf_nfs_mt_arr);
+    if (!aclentry) {
+        goto rpcerr;
+    }
+    daclentry = GF_CALLOC(NFS_ACL_MAX_ENTRIES, sizeof(*daclentry),
+                          gf_nfs_mt_arr);
+    if (!daclentry) {
+        goto rpcerr;
+    }
+
+    acl3_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    memset(&setaclargs, 0, sizeof(setaclargs));
+    memset(&setaclreply, 0, sizeof(setaclreply));
+    memset(&fh, 0, sizeof(fh));
+    setaclargs.fh.n_bytes = (char *)&fh;
+    setaclargs.aclentry.aclentry_val = aclentry;
+    setaclargs.daclentry.daclentry_val = daclentry;
+    if (xdr_to_setaclargs(req->msg[0], &setaclargs) <= 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    /* Validate ACL mask */
+    if (setaclargs.mask & ~(NFS_ACL | NFS_ACLCNT | NFS_DFACL | NFS_DFACLCNT)) {
+        stat = NFS3ERR_INVAL;
+        goto acl3err;
+    }
+
+    fhp = &fh;
+    acl3_validate_gluster_fh(fhp, stat, acl3err);
+    acl3_map_fh_to_volume(nfs->nfs3state, fhp, req, vol, stat, acl3err);
+    acl3_volume_started_check(nfs3, vol, ret, rpcerr);
+    acl3_handle_call_state_init(nfs->nfs3state, cs, req, vol, stat, acl3err);
+
+    cs->vol = vol;
+    cs->aclcount = setaclargs.aclcount;
+    cs->daclcount = setaclargs.daclcount;
+
+    /* setfacl: NFS USER ACL */
+    aclerrno = acl3_nfs_acl_to_xattr(aclentry, cs->aclxattr, cs->aclcount,
+                                     !defacl);
+    if (aclerrno < 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, -aclerrno, NFS_MSG_SET_USER_ACL_FAIL,
+               "Failed to set USER ACL");
+        stat = nfs3_errno_to_nfsstat3(-aclerrno);
+        goto acl3err;
+    }
+
+    /* setfacl: NFS DEFAULT ACL */
+    aclerrno = acl3_nfs_acl_to_xattr(daclentry, cs->daclxattr, cs->daclcount,
+                                     defacl);
+    if (aclerrno < 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, -aclerrno, NFS_MSG_SET_DEF_ACL_FAIL,
+               "Failed to set DEFAULT ACL");
+        stat = nfs3_errno_to_nfsstat3(-aclerrno);
+        goto acl3err;
+    }
+
+    ret = nfs3_fh_resolve_and_resume(cs, fhp, NULL, acl3_setacl_resume);
+    stat = nfs3_errno_to_nfsstat3(-ret);
 
 acl3err:
-        if (ret < 0) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                setaclreply.status = stat;
-                acl3_setacl_reply (req, &setaclreply);
-                nfs3_call_state_wipe (cs);
-                GF_FREE(aclentry);
-                GF_FREE(daclentry);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        setaclreply.status = stat;
+        acl3_setacl_reply(req, &setaclreply);
+        nfs3_call_state_wipe(cs);
+        GF_FREE(aclentry);
+        GF_FREE(daclentry);
+        return 0;
+    }
 
 rpcerr:
-        if (ret < 0)
-                nfs3_call_state_wipe (cs);
-        if (aclentry)
-                GF_FREE (aclentry);
-        if (daclentry)
-                GF_FREE (daclentry);
-        return ret;
+    if (ret < 0)
+        nfs3_call_state_wipe(cs);
+    if (aclentry)
+        GF_FREE(aclentry);
+    if (daclentry)
+        GF_FREE(daclentry);
+    return ret;
 }
 
-
-
-rpcsvc_actor_t  acl3svc_actors[ACL3_PROC_COUNT] = {
-        {"NULL",       ACL3_NULL,      acl3svc_null,   NULL,   0, DRC_NA},
-        {"GETACL",     ACL3_GETACL,    acl3svc_getacl, NULL,   0, DRC_NA},
-        {"SETACL",     ACL3_SETACL,    acl3svc_setacl, NULL,   0, DRC_NA},
+rpcsvc_actor_t acl3svc_actors[ACL3_PROC_COUNT] = {
+    {"NULL", ACL3_NULL, acl3svc_null, NULL, 0, DRC_NA},
+    {"GETACL", ACL3_GETACL, acl3svc_getacl, NULL, 0, DRC_NA},
+    {"SETACL", ACL3_SETACL, acl3svc_setacl, NULL, 0, DRC_NA},
 };
 
-rpcsvc_program_t        acl3prog = {
-        .progname       = "ACL3",
-        .prognum        = ACL_PROGRAM,
-        .progver        = ACLV3_VERSION,
-        .progport       = GF_NFS3_PORT,
-        .actors         = acl3svc_actors,
-        .numactors      = ACL3_PROC_COUNT,
-        .min_auth       = AUTH_NULL,
+rpcsvc_program_t acl3prog = {
+    .progname = "ACL3",
+    .prognum = ACL_PROGRAM,
+    .progver = ACLV3_VERSION,
+    .progport = GF_NFS3_PORT,
+    .actors = acl3svc_actors,
+    .numactors = ACL3_PROC_COUNT,
+    .min_auth = AUTH_NULL,
 };
 
 rpcsvc_program_t *
 acl3svc_init(xlator_t *nfsx)
 {
-        struct nfs3_state *ns = NULL;
-        struct nfs_state *nfs = NULL;
-        dict_t *options = NULL;
-        int ret = -1;
-        char *portstr = NULL;
-        static gf_boolean_t acl3_inited = _gf_false;
-
-        /* Already inited */
-        if (acl3_inited)
-                return &acl3prog;
-
-        nfs = (struct nfs_state*)nfsx->private;
-
-        ns = nfs->nfs3state;
-        if (!ns) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_ACL_INIT_FAIL,
-                        "ACL3 init failed");
-                goto err;
-        }
-        acl3prog.private = ns;
-
-        options = dict_new ();
-
-        ret = gf_asprintf (&portstr, "%d", GF_ACL3_PORT);
-        if (ret == -1)
-                goto err;
+    struct nfs3_state *ns = NULL;
+    struct nfs_state *nfs = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    char *portstr = NULL;
+    static gf_boolean_t acl3_inited = _gf_false;
+
+    /* Already inited */
+    if (acl3_inited)
+        return &acl3prog;
 
-        ret = dict_set_dynstr (options, "transport.socket.listen-port",
-                               portstr);
-        if (ret == -1)
-                goto err;
-        ret = dict_set_str (options, "transport-type", "socket");
+    nfs = (struct nfs_state *)nfsx->private;
+
+    ns = nfs->nfs3state;
+    if (!ns) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, EINVAL, NFS_MSG_ACL_INIT_FAIL,
+               "ACL3 init failed");
+        goto err;
+    }
+    acl3prog.private = ns;
+
+    options = dict_new();
+
+    ret = gf_asprintf(&portstr, "%d", GF_ACL3_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_ACL, 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_ACL, 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_ACL, 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_ACL, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED,
-                                "dict_set_str error");
-                        goto err;
-                }
+            gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
         }
-
-        ret = dict_set_str (options, "transport.address-family", "inet");
+        ret = dict_set_str(options, "rpc-auth.ports.insecure", "on");
         if (ret == -1) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, errno,
-                        NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
-        }
-
-        ret = rpcsvc_create_listeners (nfs->rpcsvc, options, "ACL");
-        if (ret == -1) {
-                gf_msg (GF_ACL, GF_LOG_ERROR, errno,
-                        NFS_MSG_LISTENERS_CREATE_FAIL,
-                        "Unable to create listeners");
-                dict_unref (options);
-                goto err;
-        }
-
-        acl3_inited = _gf_true;
-        return &acl3prog;
+            gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
+        }
+    }
+
+    ret = dict_set_str(options, "transport.address-family", "inet");
+    if (ret == -1) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    ret = rpcsvc_create_listeners(nfs->rpcsvc, options, "ACL");
+    if (ret == -1) {
+        gf_msg(GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL,
+               "Unable to create listeners");
+        dict_unref(options);
+        goto err;
+    }
+
+    acl3_inited = _gf_true;
+    return &acl3prog;
 err:
-        return NULL;
+    return NULL;
 }
 
 static int
-acl3_nfs_acl_to_xattr (aclentry *ace,      /* ACL entries to be read */
-                       void     *xattrbuf, /* XATTR buf to be populated */
-                       int      aclcount,  /* No of ACLs to be read */
-                       int      defacl)    /* 1 if DEFAULT ACL */
+acl3_nfs_acl_to_xattr(aclentry *ace,  /* ACL entries to be read */
+                      void *xattrbuf, /* XATTR buf to be populated */
+                      int aclcount,   /* No of ACLs to be read */
+                      int defacl)     /* 1 if DEFAULT ACL */
 {
-        int                       idx      = 0;
-        posix_acl_xattr_header    *xheader = NULL;
-        posix_acl_xattr_entry     *xentry  = NULL;
+    int idx = 0;
+    posix_acl_xattr_header *xheader = NULL;
+    posix_acl_xattr_entry *xentry = NULL;
 
-        if ((!ace) || (!xattrbuf))
-                return (-EINVAL);
+    if ((!ace) || (!xattrbuf))
+        return (-EINVAL);
 
-        /* ACL count is ZERO, nothing to do */
-        if (!aclcount)
-                return (0);
+    /* ACL count is ZERO, nothing to do */
+    if (!aclcount)
+        return (0);
 
-        if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES))
+    if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES))
+        return (-EINVAL);
+
+    xheader = (posix_acl_xattr_header *)(xattrbuf);
+    xentry = (posix_acl_xattr_entry *)(xheader + 1);
+
+    /*
+     * For "default ACL", NFSv3 handles the 'type' differently
+     * i.e. by logical OR'ing 'type' with NFS_ACL_DEFAULT.
+     * Which the backend File system does not understand and
+     * that needs to be masked OFF.
+     */
+    xheader->version = POSIX_ACL_XATTR_VERSION;
+
+    for (idx = 0; idx < aclcount; idx++) {
+        xentry->tag = ace->type;
+        if (defacl)
+            xentry->tag &= ~NFS_ACL_DEFAULT;
+        xentry->perm = ace->perm;
+
+        switch (xentry->tag) {
+            case POSIX_ACL_USER:
+            case POSIX_ACL_GROUP:
+                if (xentry->perm & ~S_IRWXO)
+                    return (-EINVAL);
+                xentry->id = ace->uid;
+                break;
+            case POSIX_ACL_USER_OBJ:
+            case POSIX_ACL_GROUP_OBJ:
+            case POSIX_ACL_OTHER:
+                if (xentry->perm & ~S_IRWXO)
+                    return (-EINVAL);
+                xentry->id = POSIX_ACL_UNDEFINED_ID;
+                break;
+            case POSIX_ACL_MASK:
+                /* Solaris sometimes sets additional bits in
+                 * the mask.
+                 */
+                xentry->perm &= S_IRWXO;
+                xentry->id = POSIX_ACL_UNDEFINED_ID;
+                break;
+            default:
                 return (-EINVAL);
-
-        xheader = (posix_acl_xattr_header *) (xattrbuf);
-        xentry  = (posix_acl_xattr_entry  *) (xheader + 1);
-
-        /*
-         * For "default ACL", NFSv3 handles the 'type' differently
-         * i.e. by logical OR'ing 'type' with NFS_ACL_DEFAULT.
-         * Which the backend File system does not understand and
-         * that needs to be masked OFF.
-         */
-        xheader->version = POSIX_ACL_XATTR_VERSION;
-
-        for (idx = 0; idx < aclcount; idx++) {
-                xentry->tag  = ace->type;
-                if (defacl)
-                        xentry->tag &= ~NFS_ACL_DEFAULT;
-                xentry->perm = ace->perm;
-
-                switch (xentry->tag) {
-                case POSIX_ACL_USER:
-                case POSIX_ACL_GROUP:
-                        if (xentry->perm & ~S_IRWXO)
-                                return (-EINVAL);
-                        xentry->id = ace->uid;
-                        break;
-                case POSIX_ACL_USER_OBJ:
-                case POSIX_ACL_GROUP_OBJ:
-                case POSIX_ACL_OTHER:
-                        if (xentry->perm & ~S_IRWXO)
-                                return (-EINVAL);
-                        xentry->id = POSIX_ACL_UNDEFINED_ID;
-                        break;
-                case POSIX_ACL_MASK:
-                        /* Solaris sometimes sets additional bits in
-                         * the mask.
-                         */
-                        xentry->perm &= S_IRWXO;
-                        xentry->id = POSIX_ACL_UNDEFINED_ID;
-                        break;
-                default:
-                        return (-EINVAL);
-                }
-
-                xentry++;
-                ace++;
         }
 
-        /* SUCCESS */
-        return (0);
+        xentry++;
+        ace++;
+    }
+
+    /* SUCCESS */
+    return (0);
 }
 
 static int
-acl3_nfs_acl_from_xattr (aclentry  *ace,      /* ACL entries to be filled */
-                         void      *xattrbuf, /* XATTR buf to be read */
-                         int       bufsize,   /* Size of XATTR buffer */
-                         int       defacl)    /*  1 if DEFAULT ACL */
+acl3_nfs_acl_from_xattr(aclentry *ace,  /* ACL entries to be filled */
+                        void *xattrbuf, /* XATTR buf to be read */
+                        int bufsize,    /* Size of XATTR buffer */
+                        int defacl)     /*  1 if DEFAULT ACL */
 {
-        int                       idx       = 0;
-        ssize_t                   aclcount  = 0;
-        posix_acl_xattr_header    *xheader  = NULL;
-        posix_acl_xattr_entry     *xentry   = NULL;
-
-        if ((!xattrbuf) || (!ace))
+    int idx = 0;
+    ssize_t aclcount = 0;
+    posix_acl_xattr_header *xheader = NULL;
+    posix_acl_xattr_entry *xentry = NULL;
+
+    if ((!xattrbuf) || (!ace))
+        return (-EINVAL);
+
+    aclcount = posix_acl_xattr_count(bufsize);
+    if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES))
+        return (-EINVAL);
+
+    xheader = (posix_acl_xattr_header *)(xattrbuf);
+    xentry = (posix_acl_xattr_entry *)(xheader + 1);
+
+    /* Check for supported POSIX ACL xattr version */
+    if (xheader->version != POSIX_ACL_XATTR_VERSION)
+        return (-ENOSYS);
+
+    for (idx = 0; idx < (int)aclcount; idx++) {
+        ace->type = xentry->tag;
+        if (defacl) {
+            /*
+             * SET the NFS_ACL_DEFAULT flag for default
+             * ACL which was masked OFF during setfacl().
+             */
+            ace->type |= NFS_ACL_DEFAULT;
+        }
+        ace->perm = (xentry->perm & S_IRWXO);
+
+        switch (xentry->tag) {
+            case POSIX_ACL_USER:
+            case POSIX_ACL_GROUP:
+                ace->uid = xentry->id;
+                break;
+            case POSIX_ACL_USER_OBJ:
+            case POSIX_ACL_GROUP_OBJ:
+            case POSIX_ACL_MASK:
+            case POSIX_ACL_OTHER:
+                ace->uid = POSIX_ACL_UNDEFINED_ID;
+                break;
+            default:
                 return (-EINVAL);
-
-        aclcount = posix_acl_xattr_count (bufsize);
-        if ((aclcount < 0) || (aclcount > NFS_ACL_MAX_ENTRIES))
-                return (-EINVAL);
-
-        xheader = (posix_acl_xattr_header *) (xattrbuf);
-        xentry  = (posix_acl_xattr_entry  *) (xheader + 1);
-
-        /* Check for supported POSIX ACL xattr version */
-        if (xheader->version != POSIX_ACL_XATTR_VERSION)
-                return (-ENOSYS);
-
-        for (idx = 0; idx < (int)aclcount; idx++) {
-                ace->type = xentry->tag;
-                if (defacl) {
-                        /*
-                         * SET the NFS_ACL_DEFAULT flag for default
-                         * ACL which was masked OFF during setfacl().
-                         */
-                        ace->type |= NFS_ACL_DEFAULT;
-                }
-                ace->perm = (xentry->perm & S_IRWXO);
-
-                switch (xentry->tag) {
-                case POSIX_ACL_USER:
-                case POSIX_ACL_GROUP:
-                        ace->uid = xentry->id;
-                        break;
-                case POSIX_ACL_USER_OBJ:
-                case POSIX_ACL_GROUP_OBJ:
-                case POSIX_ACL_MASK:
-                case POSIX_ACL_OTHER:
-                        ace->uid = POSIX_ACL_UNDEFINED_ID;
-                        break;
-                default:
-                        return (-EINVAL);
-                }
-
-
-                xentry++;
-                ace++;
         }
 
-        /* SUCCESS: ACL count */
-        return aclcount;
+        xentry++;
+        ace++;
+    }
+
+    /* SUCCESS: ACL count */
+    return aclcount;
 }
diff --git a/xlators/nfs/server/src/auth-cache.c b/xlators/nfs/server/src/auth-cache.c
index a1aacaba61a..248a90b0587 100644
--- a/xlators/nfs/server/src/auth-cache.c
+++ b/xlators/nfs/server/src/auth-cache.c
@@ -18,44 +18,48 @@
 #include "nfs-messages.h"
 
 enum auth_cache_lookup_results {
-        ENTRY_FOUND     =  0,
-        ENTRY_NOT_FOUND = -1,
-        ENTRY_EXPIRED   = -2,
+    ENTRY_FOUND = 0,
+    ENTRY_NOT_FOUND = -1,
+    ENTRY_EXPIRED = -2,
 };
 
 struct auth_cache_entry {
-        GF_REF_DECL;                    /* refcounting */
-        data_t             *data;       /* data_unref() on refcount == 0 */
+    GF_REF_DECL;  /* refcounting */
+    data_t *data; /* data_unref() on refcount == 0 */
 
-        time_t              timestamp;
-        struct export_item *item;
+    time_t timestamp;
+    struct export_item *item;
 };
 
 /* Given a filehandle and an ip, creates a colon delimited hashkey.
  */
-static char*
+static char *
 make_hashkey(struct nfs3_fh *fh, const char *host)
 {
-        char   *hashkey          = NULL;
-        char    exportid[256]    = {0, };
-        char    gfid[256]        = {0, };
-        char    mountid[256]     = {0, };
-        size_t  nbytes           = 0;
-
-        gf_uuid_unparse (fh->exportid, exportid);
-        gf_uuid_unparse (fh->gfid, gfid);
-        gf_uuid_unparse (fh->mountid, mountid);
-
-        nbytes = strlen (exportid) + strlen (host)
-                 + strlen (mountid) + 3;
-        hashkey = GF_MALLOC (nbytes, gf_common_mt_char);
-        if (!hashkey)
-                return NULL;
-
-        snprintf (hashkey, nbytes, "%s:%s:%s", exportid,
-                  mountid, host);
-
-        return hashkey;
+    char *hashkey = NULL;
+    char exportid[256] = {
+        0,
+    };
+    char gfid[256] = {
+        0,
+    };
+    char mountid[256] = {
+        0,
+    };
+    size_t nbytes = 0;
+
+    gf_uuid_unparse(fh->exportid, exportid);
+    gf_uuid_unparse(fh->gfid, gfid);
+    gf_uuid_unparse(fh->mountid, mountid);
+
+    nbytes = strlen(exportid) + strlen(host) + strlen(mountid) + 3;
+    hashkey = GF_MALLOC(nbytes, gf_common_mt_char);
+    if (!hashkey)
+        return NULL;
+
+    snprintf(hashkey, nbytes, "%s:%s:%s", exportid, mountid, host);
+
+    return hashkey;
 }
 
 /**
@@ -66,24 +70,24 @@ make_hashkey(struct nfs3_fh *fh, const char *host)
  * @return : allocated auth cache struct, NULL if allocation failed.
  */
 struct auth_cache *
-auth_cache_init (time_t ttl_sec)
+auth_cache_init(time_t ttl_sec)
 {
-        struct auth_cache *cache = GF_CALLOC (1, sizeof (*cache),
-                                              gf_nfs_mt_auth_cache);
+    struct auth_cache *cache = GF_CALLOC(1, sizeof(*cache),
+                                         gf_nfs_mt_auth_cache);
 
-        GF_VALIDATE_OR_GOTO ("auth-cache", cache, out);
+    GF_VALIDATE_OR_GOTO("auth-cache", cache, out);
 
-        cache->cache_dict = dict_new ();
-        if (!cache->cache_dict) {
-                GF_FREE (cache);
-                cache = NULL;
-                goto out;
-        }
+    cache->cache_dict = dict_new();
+    if (!cache->cache_dict) {
+        GF_FREE(cache);
+        cache = NULL;
+        goto out;
+    }
 
-        LOCK_INIT (&cache->lock);
-        cache->ttl_sec = ttl_sec;
+    LOCK_INIT(&cache->lock);
+    cache->ttl_sec = ttl_sec;
 out:
-        return cache;
+    return cache;
 }
 
 /* auth_cache_entry_free -- called by refcounting subsystem on refcount == 0
@@ -91,22 +95,22 @@ out:
  * @to_free: auth_cache_entry that has refcount == 0 and needs to get free'd
  */
 void
-auth_cache_entry_free (void *to_free)
+auth_cache_entry_free(void *to_free)
 {
-        struct auth_cache_entry *entry      = to_free;
-        data_t                  *entry_data = NULL;
+    struct auth_cache_entry *entry = to_free;
+    data_t *entry_data = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS, entry, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, entry->data, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, entry, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, entry->data, out);
 
-        entry_data = entry->data;
-        /* set data_t->data to NULL, otherwise data_unref() tries to free it */
-        entry_data->data = NULL;
-        data_unref (entry_data);
+    entry_data = entry->data;
+    /* set data_t->data to NULL, otherwise data_unref() tries to free it */
+    entry_data->data = NULL;
+    data_unref(entry_data);
 
-        GF_FREE (entry);
+    GF_FREE(entry);
 out:
-        return;
+    return;
 }
 
 /**
@@ -116,18 +120,18 @@ out:
  *          failed.
  */
 static struct auth_cache_entry *
-auth_cache_entry_init ()
+auth_cache_entry_init()
 {
-        struct auth_cache_entry *entry = NULL;
+    struct auth_cache_entry *entry = NULL;
 
-        entry = GF_CALLOC (1, sizeof (*entry), gf_nfs_mt_auth_cache_entry);
-        if (!entry)
-                gf_msg (GF_NFS, GF_LOG_WARNING, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "failed to allocate entry");
-        else
-                GF_REF_INIT (entry, auth_cache_entry_free);
+    entry = GF_CALLOC(1, sizeof(*entry), gf_nfs_mt_auth_cache_entry);
+    if (!entry)
+        gf_msg(GF_NFS, GF_LOG_WARNING, ENOMEM, NFS_MSG_NO_MEMORY,
+               "failed to allocate entry");
+    else
+        GF_REF_INIT(entry, auth_cache_entry_free);
 
-        return entry;
+    return entry;
 }
 
 /**
@@ -136,46 +140,46 @@ auth_cache_entry_init ()
  * @return: 0 on success, non-zero otherwise.
  */
 static int
-auth_cache_add (struct auth_cache *cache, char *hashkey,
-                struct auth_cache_entry *entry)
+auth_cache_add(struct auth_cache *cache, char *hashkey,
+               struct auth_cache_entry *entry)
 {
-        int      ret        = -1;
-        data_t  *entry_data = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache->cache_dict, out);
-
-        /* FIXME: entry is passed as parameter, this can never fail? */
-        entry = GF_REF_GET (entry);
-        if (!entry) {
-                /* entry does not have any references */
-                ret = -1;
-                goto out;
-        }
-
-        entry_data = bin_to_data (entry, sizeof (*entry));
-        if (!entry_data) {
-                ret = -1;
-                GF_REF_PUT (entry);
-                goto out;
-        }
-
-        /* we'll take an extra ref on the data_t, it gets unref'd when the
-         * auth_cache_entry is released */
-        entry->data = data_ref (entry_data);
-
-        LOCK (&cache->lock);
-        {
-                ret = dict_set (cache->cache_dict, hashkey, entry_data);
-        }
-        UNLOCK (&cache->lock);
-
-        if (ret) {
-                /* adding to dict failed */
-                GF_REF_PUT (entry);
-        }
+    int ret = -1;
+    data_t *entry_data = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache->cache_dict, out);
+
+    /* FIXME: entry is passed as parameter, this can never fail? */
+    entry = GF_REF_GET(entry);
+    if (!entry) {
+        /* entry does not have any references */
+        ret = -1;
+        goto out;
+    }
+
+    entry_data = bin_to_data(entry, sizeof(*entry));
+    if (!entry_data) {
+        ret = -1;
+        GF_REF_PUT(entry);
+        goto out;
+    }
+
+    /* we'll take an extra ref on the data_t, it gets unref'd when the
+     * auth_cache_entry is released */
+    entry->data = data_ref(entry_data);
+
+    LOCK(&cache->lock);
+    {
+        ret = dict_set(cache->cache_dict, hashkey, entry_data);
+    }
+    UNLOCK(&cache->lock);
+
+    if (ret) {
+        /* adding to dict failed */
+        GF_REF_PUT(entry);
+    }
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -186,9 +190,9 @@ out:
  * @return: true when the auth_cache_entry is expired, false otherwise.
  */
 static int
-_auth_cache_expired (struct auth_cache *cache, struct auth_cache_entry *entry)
+_auth_cache_expired(struct auth_cache *cache, struct auth_cache_entry *entry)
 {
-        return ((time (NULL) - entry->timestamp) > cache->ttl_sec);
+    return ((time(NULL) - entry->timestamp) > cache->ttl_sec);
 }
 
 /**
@@ -205,52 +209,52 @@ _auth_cache_expired (struct auth_cache *cache, struct auth_cache_entry *entry)
  * @return: 0 when found, ENTRY_NOT_FOUND or ENTRY_EXPIRED otherwise.
  */
 static enum auth_cache_lookup_results
-auth_cache_get (struct auth_cache *cache, char *hashkey,
-                struct auth_cache_entry **entry)
+auth_cache_get(struct auth_cache *cache, char *hashkey,
+               struct auth_cache_entry **entry)
 {
-        enum auth_cache_lookup_results  ret        = ENTRY_NOT_FOUND;
-        data_t                         *entry_data = NULL;
-        struct auth_cache_entry        *lookup_res = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache->cache_dict, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, hashkey, out);
-
-        LOCK (&cache->lock);
-        {
-                entry_data = dict_get (cache->cache_dict, hashkey);
-                if (!entry_data)
-                        goto unlock;
-
-                /* FIXME: this is dangerous use of entry_data */
-                lookup_res = GF_REF_GET ((struct auth_cache_entry *) entry_data->data);
-                if (lookup_res == NULL) {
-                        /* entry has been free'd */
-                        ret = ENTRY_EXPIRED;
-                        goto unlock;
-                }
-
-                if (_auth_cache_expired (cache, lookup_res)) {
-                        ret = ENTRY_EXPIRED;
-                        GF_REF_PUT (lookup_res->item);
-                        lookup_res->item = NULL;
-
-                        /* free entry and remove from the cache */
-                        GF_FREE (lookup_res);
-                        entry_data->data = NULL;
-                        dict_del (cache->cache_dict, hashkey);
-
-                        goto unlock;
-                }
-
-                *entry = lookup_res;
-                ret = ENTRY_FOUND;
+    enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND;
+    data_t *entry_data = NULL;
+    struct auth_cache_entry *lookup_res = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache->cache_dict, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, hashkey, out);
+
+    LOCK(&cache->lock);
+    {
+        entry_data = dict_get(cache->cache_dict, hashkey);
+        if (!entry_data)
+            goto unlock;
+
+        /* FIXME: this is dangerous use of entry_data */
+        lookup_res = GF_REF_GET((struct auth_cache_entry *)entry_data->data);
+        if (lookup_res == NULL) {
+            /* entry has been free'd */
+            ret = ENTRY_EXPIRED;
+            goto unlock;
+        }
+
+        if (_auth_cache_expired(cache, lookup_res)) {
+            ret = ENTRY_EXPIRED;
+            GF_REF_PUT(lookup_res->item);
+            lookup_res->item = NULL;
+
+            /* free entry and remove from the cache */
+            GF_FREE(lookup_res);
+            entry_data->data = NULL;
+            dict_del(cache->cache_dict, hashkey);
+
+            goto unlock;
         }
+
+        *entry = lookup_res;
+        ret = ENTRY_FOUND;
+    }
 unlock:
-        UNLOCK (&cache->lock);
+    UNLOCK(&cache->lock);
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -270,49 +274,47 @@ out:
  *          0 if found
  */
 enum auth_cache_lookup_results
-auth_cache_lookup (struct auth_cache *cache, struct nfs3_fh *fh,
-                   const char *host_addr, time_t *timestamp,
-                   gf_boolean_t *can_write)
+auth_cache_lookup(struct auth_cache *cache, struct nfs3_fh *fh,
+                  const char *host_addr, time_t *timestamp,
+                  gf_boolean_t *can_write)
 {
-        char                           *hashkey    = NULL;
-        struct auth_cache_entry        *lookup_res = NULL;
-        enum auth_cache_lookup_results  ret        = ENTRY_NOT_FOUND;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, fh, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, host_addr, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, timestamp, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, can_write, out);
-
-        hashkey = make_hashkey (fh, host_addr);
-        if (!hashkey) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        ret = auth_cache_get (cache, hashkey, &lookup_res);
-        switch (ret) {
+    char *hashkey = NULL;
+    struct auth_cache_entry *lookup_res = NULL;
+    enum auth_cache_lookup_results ret = ENTRY_NOT_FOUND;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, fh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, host_addr, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, timestamp, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, can_write, out);
+
+    hashkey = make_hashkey(fh, host_addr);
+    if (!hashkey) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    ret = auth_cache_get(cache, hashkey, &lookup_res);
+    switch (ret) {
         case ENTRY_FOUND:
-                *timestamp = lookup_res->timestamp;
-                *can_write = lookup_res->item->opts->rw;
-                GF_REF_PUT (lookup_res);
-                break;
+            *timestamp = lookup_res->timestamp;
+            *can_write = lookup_res->item->opts->rw;
+            GF_REF_PUT(lookup_res);
+            break;
 
         case ENTRY_NOT_FOUND:
-                gf_msg_debug (GF_NFS, 0, "could not find entry for %s",
-                              host_addr);
-                break;
+            gf_msg_debug(GF_NFS, 0, "could not find entry for %s", host_addr);
+            break;
 
         case ENTRY_EXPIRED:
-                gf_msg_debug (GF_NFS, 0, "entry for host %s has expired",
-                              host_addr);
-                break;
-        }
+            gf_msg_debug(GF_NFS, 0, "entry for host %s has expired", host_addr);
+            break;
+    }
 
 out:
-        GF_FREE (hashkey);
+    GF_FREE(hashkey);
 
-        return ret;
+    return ret;
 }
 
 /* auth_cache_entry_purge -- free up the auth_cache_entry
@@ -327,14 +329,14 @@ out:
  * @v: data_t of the current entry
  */
 int
-auth_cache_entry_purge (dict_t *d, char *k, data_t *v, void *_unused)
+auth_cache_entry_purge(dict_t *d, char *k, data_t *v, void *_unused)
 {
-        struct auth_cache_entry *entry = (struct auth_cache_entry *) v->data;
+    struct auth_cache_entry *entry = (struct auth_cache_entry *)v->data;
 
-        if (entry)
-                GF_REF_PUT (entry);
+    if (entry)
+        GF_REF_PUT(entry);
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -344,26 +346,26 @@ auth_cache_entry_purge (dict_t *d, char *k, data_t *v, void *_unused)
  *
  */
 void
-auth_cache_purge (struct auth_cache *cache)
+auth_cache_purge(struct auth_cache *cache)
 {
-        dict_t *new_cache_dict = dict_new ();
-        dict_t *old_cache_dict = NULL;
-
-        if (!cache || !new_cache_dict)
-                goto out;
-
-        LOCK (&cache->lock);
-        {
-                old_cache_dict = cache->cache_dict;
-                cache->cache_dict = new_cache_dict;
-        }
-        UNLOCK (&cache->lock);
-
-        /* walk all entries and refcount-- with GF_REF_PUT() */
-        dict_foreach (old_cache_dict, auth_cache_entry_purge, NULL);
-        dict_unref (old_cache_dict);
+    dict_t *new_cache_dict = dict_new();
+    dict_t *old_cache_dict = NULL;
+
+    if (!cache || !new_cache_dict)
+        goto out;
+
+    LOCK(&cache->lock);
+    {
+        old_cache_dict = cache->cache_dict;
+        cache->cache_dict = new_cache_dict;
+    }
+    UNLOCK(&cache->lock);
+
+    /* walk all entries and refcount-- with GF_REF_PUT() */
+    dict_foreach(old_cache_dict, auth_cache_entry_purge, NULL);
+    dict_unref(old_cache_dict);
 out:
-        return;
+    return;
 }
 
 /**
@@ -378,25 +380,24 @@ out:
  *
  */
 gf_boolean_t
-is_nfs_fh_cached (struct auth_cache *cache, struct nfs3_fh *fh,
-                  const char *host_addr)
+is_nfs_fh_cached(struct auth_cache *cache, struct nfs3_fh *fh,
+                 const char *host_addr)
 {
-        int          ret       = 0;
-        time_t       timestamp = 0;
-        gf_boolean_t cached    = _gf_false;
-        gf_boolean_t can_write = _gf_false;
+    int ret = 0;
+    time_t timestamp = 0;
+    gf_boolean_t cached = _gf_false;
+    gf_boolean_t can_write = _gf_false;
 
-        if (!fh)
-                goto out;
+    if (!fh)
+        goto out;
 
-        ret = auth_cache_lookup (cache, fh, host_addr, &timestamp, &can_write);
-        cached = (ret == ENTRY_FOUND);
+    ret = auth_cache_lookup(cache, fh, host_addr, &timestamp, &can_write);
+    cached = (ret == ENTRY_FOUND);
 
 out:
-        return cached;
+    return cached;
 }
 
-
 /**
  * is_nfs_fh_cached_and_writeable -- Checks if an NFS FH is cached for the given
  *                                   host and writable
@@ -409,22 +410,22 @@ out:
  *
  */
 gf_boolean_t
-is_nfs_fh_cached_and_writeable (struct auth_cache *cache, struct nfs3_fh *fh,
-                                const char *host_addr)
+is_nfs_fh_cached_and_writeable(struct auth_cache *cache, struct nfs3_fh *fh,
+                               const char *host_addr)
 {
-        int          ret       = 0;
-        time_t       timestamp = 0;
-        gf_boolean_t cached    = _gf_false;
-        gf_boolean_t writable  = _gf_false;
+    int ret = 0;
+    time_t timestamp = 0;
+    gf_boolean_t cached = _gf_false;
+    gf_boolean_t writable = _gf_false;
 
-        if (!fh)
-                goto out;
+    if (!fh)
+        goto out;
 
-        ret = auth_cache_lookup (cache, fh, host_addr, &timestamp, &writable);
-        cached = ((ret == ENTRY_FOUND) && writable);
+    ret = auth_cache_lookup(cache, fh, host_addr, &timestamp, &writable);
+    cached = ((ret == ENTRY_FOUND) && writable);
 
 out:
-        return cached;
+    return cached;
 }
 
 /**
@@ -441,56 +442,58 @@ out:
  *
  */
 int
-cache_nfs_fh (struct auth_cache *cache, struct nfs3_fh *fh,
-              const char *host_addr, struct export_item *export_item)
+cache_nfs_fh(struct auth_cache *cache, struct nfs3_fh *fh,
+             const char *host_addr, struct export_item *export_item)
 {
-        int                      ret        = -EINVAL;
-        char                    *hashkey    = NULL;
-        time_t                   timestamp  = 0;
-        gf_boolean_t             can_write  = _gf_false;
-        struct auth_cache_entry *entry      = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, host_addr, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, cache, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, fh, out);
-
-        /* If we could already find it in the cache, just return */
-        ret = auth_cache_lookup (cache, fh, host_addr, &timestamp, &can_write);
-        if (ret == 0) {
-                gf_msg_trace (GF_NFS, 0, "found cached auth/fh for host "
-                              "%s", host_addr);
-                goto out;
-        }
-
-        hashkey = make_hashkey (fh, host_addr);
-        if (!hashkey) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        entry = auth_cache_entry_init ();
-        if (!entry) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        entry->timestamp = time (NULL);
-        /* Update entry->item if it is pointing to a different export_item */
-        if (entry->item && entry->item != export_item) {
-                GF_REF_PUT (entry->item);
-        }
-        entry->item = GF_REF_GET (export_item);
-
-        ret = auth_cache_add (cache, hashkey, entry);
-        GF_REF_PUT (entry);
-        if (ret)
-                goto out;
-
-        gf_msg_trace (GF_NFS, 0, "Caching file-handle (%s)", host_addr);
-        ret = 0;
+    int ret = -EINVAL;
+    char *hashkey = NULL;
+    time_t timestamp = 0;
+    gf_boolean_t can_write = _gf_false;
+    struct auth_cache_entry *entry = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, host_addr, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, cache, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, fh, out);
+
+    /* If we could already find it in the cache, just return */
+    ret = auth_cache_lookup(cache, fh, host_addr, &timestamp, &can_write);
+    if (ret == 0) {
+        gf_msg_trace(GF_NFS, 0,
+                     "found cached auth/fh for host "
+                     "%s",
+                     host_addr);
+        goto out;
+    }
+
+    hashkey = make_hashkey(fh, host_addr);
+    if (!hashkey) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    entry = auth_cache_entry_init();
+    if (!entry) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    entry->timestamp = time(NULL);
+    /* Update entry->item if it is pointing to a different export_item */
+    if (entry->item && entry->item != export_item) {
+        GF_REF_PUT(entry->item);
+    }
+    entry->item = GF_REF_GET(export_item);
+
+    ret = auth_cache_add(cache, hashkey, entry);
+    GF_REF_PUT(entry);
+    if (ret)
+        goto out;
+
+    gf_msg_trace(GF_NFS, 0, "Caching file-handle (%s)", host_addr);
+    ret = 0;
 
 out:
-        GF_FREE (hashkey);
+    GF_FREE(hashkey);
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/nfs/server/src/exports.c b/xlators/nfs/server/src/exports.c
index 671aa04ffcb..342ad503a6a 100644
--- a/xlators/nfs/server/src/exports.c
+++ b/xlators/nfs/server/src/exports.c
@@ -17,10 +17,14 @@
 #include "parse-utils.h"
 #include "nfs-messages.h"
 
-static void _exp_dict_destroy (dict_t *ng_dict);
-static void _export_options_print (const struct export_options *opts);
-static void _export_options_deinit (struct export_options *opts);
-static void _export_dir_deinit (struct export_dir *dir);
+static void
+_exp_dict_destroy(dict_t *ng_dict);
+static void
+_export_options_print(const struct export_options *opts);
+static void
+_export_options_deinit(struct export_options *opts);
+static void
+_export_dir_deinit(struct export_dir *dir);
 
 static struct parser *netgroup_parser;
 static struct parser *hostname_parser;
@@ -33,36 +37,36 @@ static struct parser *options_parser;
  *          failure: -1
  */
 static int
-_exp_init_parsers ()
+_exp_init_parsers()
 {
-        int ret = -1;
+    int ret = -1;
 
-        netgroup_parser = parser_init (NETGROUP_REGEX_PATTERN);
-        if (!netgroup_parser)
-                goto out;
+    netgroup_parser = parser_init(NETGROUP_REGEX_PATTERN);
+    if (!netgroup_parser)
+        goto out;
 
-        hostname_parser = parser_init (HOSTNAME_REGEX_PATTERN);
-        if (!hostname_parser)
-                goto out;
+    hostname_parser = parser_init(HOSTNAME_REGEX_PATTERN);
+    if (!hostname_parser)
+        goto out;
 
-        options_parser = parser_init (OPTIONS_REGEX_PATTERN);
-        if (!options_parser)
-                goto out;
+    options_parser = parser_init(OPTIONS_REGEX_PATTERN);
+    if (!options_parser)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
  * _exp_deinit_parsers -- Free parsers used in this file
  */
 static void
-_exp_deinit_parsers ()
+_exp_deinit_parsers()
 {
-        parser_deinit (netgroup_parser);
-        parser_deinit (hostname_parser);
-        parser_deinit (options_parser);
+    parser_deinit(netgroup_parser);
+    parser_deinit(hostname_parser);
+    parser_deinit(options_parser);
 }
 
 /**
@@ -74,35 +78,35 @@ _exp_deinit_parsers ()
  * Not for external use.
  */
 struct exports_file *
-_exports_file_init ()
+_exports_file_init()
 {
-        struct exports_file *file = NULL;
+    struct exports_file *file = NULL;
 
-        file = GF_CALLOC (1, sizeof (*file), gf_common_mt_nfs_exports);
-        if (!file) {
-                gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate file struct!");
-                goto out;
-        }
+    file = GF_CALLOC(1, sizeof(*file), gf_common_mt_nfs_exports);
+    if (!file) {
+        gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate file struct!");
+        goto out;
+    }
 
-        file->exports_dict = dict_new ();
-        file->exports_map = dict_new ();
-        if (!file->exports_dict || !file->exports_map) {
-                gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate dict!");
-                goto free_and_out;
-        }
+    file->exports_dict = dict_new();
+    file->exports_map = dict_new();
+    if (!file->exports_dict || !file->exports_map) {
+        gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate dict!");
+        goto free_and_out;
+    }
 
-        goto out;
+    goto out;
 
 free_and_out:
-        if (file->exports_dict)
-                dict_unref (file->exports_dict);
+    if (file->exports_dict)
+        dict_unref(file->exports_dict);
 
-        GF_FREE (file);
-        file = NULL;
+    GF_FREE(file);
+    file = NULL;
 out:
-        return file;
+    return file;
 }
 
 /**
@@ -116,24 +120,24 @@ out:
  * Not for external use.
  */
 static int
-_exp_file_dict_destroy (dict_t *dict, char *key, data_t *val, void *tmp)
+_exp_file_dict_destroy(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct export_dir *dir = NULL;
+    struct export_dir *dir = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_EXP, dict, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dict, out);
 
-        if (val) {
-                dir = (struct export_dir *)val->data;
+    if (val) {
+        dir = (struct export_dir *)val->data;
 
-                if (dir) {
-                        _export_dir_deinit (dir);
-                        val->data = NULL;
-                }
-                dict_del (dict, key);
+        if (dir) {
+            _export_dir_deinit(dir);
+            val->data = NULL;
         }
+        dict_del(dict, key);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 /**
@@ -144,27 +148,25 @@ out:
  * Externally usable.
  */
 void
-exp_file_deinit (struct exports_file *expfile)
+exp_file_deinit(struct exports_file *expfile)
 {
-        if (!expfile)
-                goto out;
+    if (!expfile)
+        goto out;
 
-        if (expfile->exports_dict) {
-                dict_foreach (expfile->exports_dict, _exp_file_dict_destroy,
-                              NULL);
-                dict_unref (expfile->exports_dict);
-        }
+    if (expfile->exports_dict) {
+        dict_foreach(expfile->exports_dict, _exp_file_dict_destroy, NULL);
+        dict_unref(expfile->exports_dict);
+    }
 
-        if (expfile->exports_map) {
-                dict_foreach (expfile->exports_map, _exp_file_dict_destroy,
-                              NULL);
-                dict_unref (expfile->exports_map);
-        }
+    if (expfile->exports_map) {
+        dict_foreach(expfile->exports_map, _exp_file_dict_destroy, NULL);
+        dict_unref(expfile->exports_map);
+    }
 
-        GF_FREE (expfile->filename);
-        GF_FREE (expfile);
+    GF_FREE(expfile->filename);
+    GF_FREE(expfile);
 out:
-        return;
+    return;
 }
 
 /**
@@ -176,16 +178,16 @@ out:
  * Not for external use.
  */
 static struct export_dir *
-_export_dir_init ()
+_export_dir_init()
 {
-        struct export_dir *expdir  = GF_CALLOC (1, sizeof (*expdir),
-                                                gf_common_mt_nfs_exports);
+    struct export_dir *expdir = GF_CALLOC(1, sizeof(*expdir),
+                                          gf_common_mt_nfs_exports);
 
-        if (!expdir)
-                gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate export dir structure!");
+    if (!expdir)
+        gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate export dir structure!");
 
-        return expdir;
+    return expdir;
 }
 
 /**
@@ -196,19 +198,18 @@ _export_dir_init ()
  * Not for external use.
  */
 static void
-_export_dir_deinit (struct export_dir *dir)
+_export_dir_deinit(struct export_dir *dir)
 {
-        GF_VALIDATE_OR_GOTO (GF_EXP, dir, out);
-        GF_FREE (dir->dir_name);
-        _exp_dict_destroy (dir->netgroups);
-        _exp_dict_destroy (dir->hosts);
-        GF_FREE (dir);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dir, out);
+    GF_FREE(dir->dir_name);
+    _exp_dict_destroy(dir->netgroups);
+    _exp_dict_destroy(dir->hosts);
+    GF_FREE(dir);
 
 out:
-        return;
+    return;
 }
 
-
 /**
  * _export_item_print -- Print the elements in the export item.
  *
@@ -217,13 +218,13 @@ out:
  * Not for external use.
  */
 static void
-_export_item_print (const struct export_item *item)
+_export_item_print(const struct export_item *item)
 {
-        GF_VALIDATE_OR_GOTO (GF_EXP, item, out);
-        printf ("%s", item->name);
-        _export_options_print (item->opts);
+    GF_VALIDATE_OR_GOTO(GF_EXP, item, out);
+    printf("%s", item->name);
+    _export_options_print(item->opts);
 out:
-        return;
+    return;
 }
 
 /**
@@ -234,14 +235,14 @@ out:
  * Not for external use.
  */
 static void
-_export_item_deinit (struct export_item *item)
+_export_item_deinit(struct export_item *item)
 {
-        if (!item)
-                return;
+    if (!item)
+        return;
 
-        _export_options_deinit (item->opts);
-        GF_FREE (item->name);
-        GF_FREE (item);
+    _export_options_deinit(item->opts);
+    GF_FREE(item->name);
+    GF_FREE(item);
 }
 
 /**
@@ -253,19 +254,19 @@ _export_item_deinit (struct export_item *item)
  * Not for external use.
  */
 static struct export_item *
-_export_item_init ()
+_export_item_init()
 {
-        struct export_item *item = GF_CALLOC (1, sizeof (*item),
-                                              gf_common_mt_nfs_exports);
-
-        if (item) {
-                GF_REF_INIT(item, _export_item_deinit);
-        } else {
-                gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate export item!");
-        }
+    struct export_item *item = GF_CALLOC(1, sizeof(*item),
+                                         gf_common_mt_nfs_exports);
 
-        return item;
+    if (item) {
+        GF_REF_INIT(item, _export_item_deinit);
+    } else {
+        gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate export item!");
+    }
+
+    return item;
 }
 
 /**
@@ -277,16 +278,16 @@ _export_item_init ()
  * Not for external use.
  */
 static struct export_options *
-_export_options_init ()
+_export_options_init()
 {
-        struct export_options *opts = GF_CALLOC (1, sizeof (*opts),
-                                                 gf_common_mt_nfs_exports);
+    struct export_options *opts = GF_CALLOC(1, sizeof(*opts),
+                                            gf_common_mt_nfs_exports);
 
-        if (!opts)
-                gf_msg (GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate options structure!");
+    if (!opts)
+        gf_msg(GF_EXP, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate options structure!");
 
-        return opts;
+    return opts;
 }
 
 /**
@@ -297,14 +298,14 @@ _export_options_init ()
  * Not for external use.
  */
 static void
-_export_options_deinit (struct export_options *opts)
+_export_options_deinit(struct export_options *opts)
 {
-        if (!opts)
-                return;
+    if (!opts)
+        return;
 
-        GF_FREE (opts->anon_uid);
-        GF_FREE (opts->sec_type);
-        GF_FREE (opts);
+    GF_FREE(opts->anon_uid);
+    GF_FREE(opts->sec_type);
+    GF_FREE(opts);
 }
 
 /**
@@ -315,31 +316,31 @@ _export_options_deinit (struct export_options *opts)
  * Not for external use.
  */
 static void
-_export_options_print (const struct export_options *opts)
+_export_options_print(const struct export_options *opts)
 {
-        GF_VALIDATE_OR_GOTO (GF_EXP, opts, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, opts, out);
 
-        printf ("(");
-        if (opts->rw)
-                printf ("rw,");
-        else
-                printf ("ro,");
+    printf("(");
+    if (opts->rw)
+        printf("rw,");
+    else
+        printf("ro,");
 
-        if (opts->nosuid)
-                printf ("nosuid,");
+    if (opts->nosuid)
+        printf("nosuid,");
 
-        if (opts->root)
-                printf ("root,");
+    if (opts->root)
+        printf("root,");
 
-        if (opts->anon_uid)
-                printf ("anonuid=%s,", opts->anon_uid);
+    if (opts->anon_uid)
+        printf("anonuid=%s,", opts->anon_uid);
 
-        if (opts->sec_type)
-                printf ("sec=%s,", opts->sec_type);
+    if (opts->sec_type)
+        printf("sec=%s,", opts->sec_type);
 
-        printf (") ");
+    printf(") ");
 out:
-        return;
+    return;
 }
 
 /**
@@ -355,14 +356,14 @@ out:
  * Not for external use.
  */
 static int
-__exp_dict_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__exp_dict_free_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        if (val) {
-                GF_REF_PUT ((struct export_item *)val->data);
-                val->data = NULL;
-                dict_del (dict, key);
-        }
-        return 0;
+    if (val) {
+        GF_REF_PUT((struct export_item *)val->data);
+        val->data = NULL;
+        dict_del(dict, key);
+    }
+    return 0;
 }
 
 /**
@@ -374,14 +375,14 @@ __exp_dict_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static void
-_exp_dict_destroy (dict_t *ng_dict)
+_exp_dict_destroy(dict_t *ng_dict)
 {
-        if (!ng_dict)
-                goto out;
+    if (!ng_dict)
+        goto out;
 
-        dict_foreach (ng_dict, __exp_dict_free_walk, NULL);
+    dict_foreach(ng_dict, __exp_dict_free_walk, NULL);
 out:
-        return;
+    return;
 }
 
 /**
@@ -395,20 +396,22 @@ out:
  *           failure: NULL
  */
 struct export_dir *
-exp_file_dir_from_uuid (const struct exports_file *file,
-                        const uuid_t export_uuid)
+exp_file_dir_from_uuid(const struct exports_file *file,
+                       const uuid_t export_uuid)
 {
-        char               export_uuid_str[512] = {0, };
-        data_t            *dirdata              = NULL;
-        struct export_dir *dir                  = NULL;
+    char export_uuid_str[512] = {
+        0,
+    };
+    data_t *dirdata = NULL;
+    struct export_dir *dir = NULL;
 
-        gf_uuid_unparse (export_uuid, export_uuid_str);
+    gf_uuid_unparse(export_uuid, export_uuid_str);
 
-        dirdata = dict_get (file->exports_map, export_uuid_str);
-        if (dirdata)
-                dir = (struct export_dir *)dirdata->data;
+    dirdata = dict_get(file->exports_map, export_uuid_str);
+    if (dirdata)
+        dir = (struct export_dir *)dirdata->data;
 
-        return dir;
+    return dir;
 }
 
 /**
@@ -425,32 +428,36 @@ exp_file_dir_from_uuid (const struct exports_file *file,
  * Not for external use.
  */
 static void
-_exp_file_insert (struct exports_file *file, struct export_dir *dir)
+_exp_file_insert(struct exports_file *file, struct export_dir *dir)
 {
-        data_t   *dirdata              = NULL;
-        uint32_t  hashedval            = 0;
-        uuid_t    export_uuid          = {0, };
-        char      export_uuid_str[512] = {0, };
-        char     *dirdup               = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, file, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, dir, out);
-
-        dirdata = bin_to_data (dir, sizeof (*dir));
-        dict_set (file->exports_dict, dir->dir_name, dirdata);
-
-        dirdup = strdupa (dir->dir_name);
-        while (strlen (dirdup) > 0 && dirdup[0] == '/')
-                dirdup++;
-
-        hashedval = SuperFastHash (dirdup, strlen (dirdup));
-        memset (export_uuid, 0, sizeof (export_uuid));
-        memcpy (export_uuid, &hashedval, sizeof (hashedval));
-        gf_uuid_unparse (export_uuid, export_uuid_str);
-
-        dict_set (file->exports_map, export_uuid_str, dirdata);
+    data_t *dirdata = NULL;
+    uint32_t hashedval = 0;
+    uuid_t export_uuid = {
+        0,
+    };
+    char export_uuid_str[512] = {
+        0,
+    };
+    char *dirdup = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, file, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dir, out);
+
+    dirdata = bin_to_data(dir, sizeof(*dir));
+    dict_set(file->exports_dict, dir->dir_name, dirdata);
+
+    dirdup = strdupa(dir->dir_name);
+    while (strlen(dirdup) > 0 && dirdup[0] == '/')
+        dirdup++;
+
+    hashedval = SuperFastHash(dirdup, strlen(dirdup));
+    memset(export_uuid, 0, sizeof(export_uuid));
+    memcpy(export_uuid, &hashedval, sizeof(hashedval));
+    gf_uuid_unparse(export_uuid, export_uuid_str);
+
+    dict_set(file->exports_map, export_uuid_str, dirdata);
 out:
-        return;
+    return;
 }
 
 /**
@@ -466,12 +473,12 @@ out:
  * Not for external use.
  */
 static int
-__exp_item_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__exp_item_print_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        if (val)
-                _export_item_print ((struct export_item *)val->data);
+    if (val)
+        _export_item_print((struct export_item *)val->data);
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -487,23 +494,22 @@ __exp_item_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static int
-__exp_file_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__exp_file_print_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        if (val) {
-                struct export_dir *dir = (struct export_dir *)val->data;
+    if (val) {
+        struct export_dir *dir = (struct export_dir *)val->data;
 
-                printf ("%s ", key);
+        printf("%s ", key);
 
-                if (dir->netgroups)
-                        dict_foreach (dir->netgroups, __exp_item_print_walk,
-                                      NULL);
+        if (dir->netgroups)
+            dict_foreach(dir->netgroups, __exp_item_print_walk, NULL);
 
-                if (dir->hosts)
-                        dict_foreach (dir->hosts, __exp_item_print_walk, NULL);
+        if (dir->hosts)
+            dict_foreach(dir->hosts, __exp_item_print_walk, NULL);
 
-                printf ("\n");
-        }
-        return 0;
+        printf("\n");
+    }
+    return 0;
 }
 
 /**
@@ -514,29 +520,29 @@ __exp_file_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 void
-exp_file_print (const struct exports_file *file)
+exp_file_print(const struct exports_file *file)
 {
-        GF_VALIDATE_OR_GOTO (GF_EXP, file, out);
-        dict_foreach (file->exports_dict, __exp_file_print_walk, NULL);
+    GF_VALIDATE_OR_GOTO(GF_EXP, file, out);
+    dict_foreach(file->exports_dict, __exp_file_print_walk, NULL);
 out:
-        return;
+    return;
 }
 
-#define __exp_line_get_opt_val(val, equals, ret, errlabel)      \
-        do {                                                    \
-                (val) = (equals) + 1;                           \
-                if (!(*(val))) {                                \
-                        (ret) = 1;                              \
-                        goto errlabel;                          \
-                }                                               \
-        } while (0)                                             \
+#define __exp_line_get_opt_val(val, equals, ret, errlabel)                     \
+    do {                                                                       \
+        (val) = (equals) + 1;                                                  \
+        if (!(*(val))) {                                                       \
+            (ret) = 1;                                                         \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 enum gf_exp_parse_status {
-        GF_EXP_PARSE_SUCCESS                 = 0,
-        GF_EXP_PARSE_ITEM_NOT_FOUND          = 1,
-        GF_EXP_PARSE_ITEM_FAILURE            = 2,
-        GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE = 3,
-        GF_EXP_PARSE_LINE_IGNORING           = 4,
+    GF_EXP_PARSE_SUCCESS = 0,
+    GF_EXP_PARSE_ITEM_NOT_FOUND = 1,
+    GF_EXP_PARSE_ITEM_FAILURE = 2,
+    GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE = 3,
+    GF_EXP_PARSE_LINE_IGNORING = 4,
 };
 
 /**
@@ -559,48 +565,48 @@ enum gf_exp_parse_status {
  * Not for external use.
  */
 static int
-__exp_line_opt_key_value_parse (char *option, struct export_options *opts)
+__exp_line_opt_key_value_parse(char *option, struct export_options *opts)
 {
-        char              *equals   = NULL;
-        char              *right    = NULL;
-        char              *strmatch = option;
-        int                ret      = -EINVAL;
+    char *equals = NULL;
+    char *right = NULL;
+    char *strmatch = option;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_EXP, option, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, opts, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, option, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, opts, out);
 
-        equals = strchr (option, '=');
-        if (!equals) {
-                ret = GF_EXP_PARSE_ITEM_FAILURE;
-                goto out;
-        }
-
-        *equals = 0;
-        /* Now that an '=' has been found the left side is the option and
-         * the right side is the value. We simply have to compare those and
-         * extract it.
-         */
-        if (strcmp (strmatch, "anonuid") == 0) {
-                *equals = '=';
-                /* Get the value for this option */
-                __exp_line_get_opt_val (right, equals, ret, out);
-                opts->anon_uid = gf_strdup (right);
-                GF_CHECK_ALLOC (opts->anon_uid, ret, out);
-        } else if (strcmp (strmatch, "sec") == 0) {
-                *equals = '=';
-                /* Get the value for this option */
-                __exp_line_get_opt_val (right, equals, ret, out);
-                opts->sec_type = gf_strdup (right);
-                GF_CHECK_ALLOC (opts->sec_type, ret, out);
-        } else {
-                *equals = '=';
-                ret = GF_EXP_PARSE_ITEM_FAILURE;
-                goto out;
-        }
+    equals = strchr(option, '=');
+    if (!equals) {
+        ret = GF_EXP_PARSE_ITEM_FAILURE;
+        goto out;
+    }
+
+    *equals = 0;
+    /* Now that an '=' has been found the left side is the option and
+     * the right side is the value. We simply have to compare those and
+     * extract it.
+     */
+    if (strcmp(strmatch, "anonuid") == 0) {
+        *equals = '=';
+        /* Get the value for this option */
+        __exp_line_get_opt_val(right, equals, ret, out);
+        opts->anon_uid = gf_strdup(right);
+        GF_CHECK_ALLOC(opts->anon_uid, ret, out);
+    } else if (strcmp(strmatch, "sec") == 0) {
+        *equals = '=';
+        /* Get the value for this option */
+        __exp_line_get_opt_val(right, equals, ret, out);
+        opts->sec_type = gf_strdup(right);
+        GF_CHECK_ALLOC(opts->sec_type, ret, out);
+    } else {
+        *equals = '=';
+        ret = GF_EXP_PARSE_ITEM_FAILURE;
+        goto out;
+    }
 
-        ret = GF_EXP_PARSE_SUCCESS;
+    ret = GF_EXP_PARSE_SUCCESS;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -619,87 +625,87 @@ out:
  * Not for external use.
  */
 static int
-__exp_line_opt_parse (const char *opt_str, struct export_options **exp_opts)
+__exp_line_opt_parse(const char *opt_str, struct export_options **exp_opts)
 {
-        struct export_options  *opts     = NULL;
-        char                   *strmatch = NULL;
-        int                    ret       = -EINVAL;
-        char                   *equals   = NULL;
+    struct export_options *opts = NULL;
+    char *strmatch = NULL;
+    int ret = -EINVAL;
+    char *equals = NULL;
 
-        ret = parser_set_string (options_parser, opt_str);
-        if (ret < 0)
-                goto out;
+    ret = parser_set_string(options_parser, opt_str);
+    if (ret < 0)
+        goto out;
 
-        while ((strmatch = parser_get_next_match (options_parser))) {
-                if (!opts) {
-                        /* If the options have not been allocated,
-                         * allocate it.
-                         */
-                        opts = _export_options_init ();
-                        if (!opts) {
-                                ret = -ENOMEM;
-                                parser_unset_string (options_parser);
-                                goto out;
-                        }
-                }
-
-                /* First,  check for all the boolean options Second, check for
-                 * an '=', and check the available options there. The string
-                 * parsing here gets slightly messy, but the concept itself
-                 * is pretty simple.
-                 */
-                equals = strchr (strmatch, '=');
-                if (strcmp (strmatch, "root") == 0)
-                        opts->root = _gf_true;
-                else if (strcmp (strmatch, "ro") == 0)
-                        opts->rw = _gf_false;
-                else if (strcmp (strmatch, "rw") == 0)
-                        opts->rw = _gf_true;
-                else if (strcmp (strmatch, "nosuid") == 0)
-                        opts->nosuid = _gf_true;
-                else if (equals) {
-                        ret = __exp_line_opt_key_value_parse (strmatch, opts);
-                        if (ret < 0) {
-                                /* This means invalid key value options were
-                                 * specified, or memory allocation failed.
-                                 * The ret value gets bubbled up to the caller.
-                                 */
-                                GF_FREE (strmatch);
-                                parser_unset_string (options_parser);
-                                _export_options_deinit (opts);
-                                goto out;
-                        }
-                } else
-                        /* Cannot change to gf_msg.
-                         * gf_msg not giving output to STDOUT
-                         * Bug id : BZ1215017
-                         */
-                        gf_log (GF_EXP, GF_LOG_WARNING,
-                                "Could not find any valid options for "
-                                "string: %s", strmatch);
-                GF_FREE (strmatch);
+    while ((strmatch = parser_get_next_match(options_parser))) {
+        if (!opts) {
+            /* If the options have not been allocated,
+             * allocate it.
+             */
+            opts = _export_options_init();
+            if (!opts) {
+                ret = -ENOMEM;
+                parser_unset_string(options_parser);
+                goto out;
+            }
         }
 
-        if (!opts) {
-                /* If opts is not allocated
-                 * that means no matches were found
-                 * which is a parse error. Not marking
-                 * it as "not found" because it is a parse
-                 * error to not have options.
+        /* First,  check for all the boolean options Second, check for
+         * an '=', and check the available options there. The string
+         * parsing here gets slightly messy, but the concept itself
+         * is pretty simple.
+         */
+        equals = strchr(strmatch, '=');
+        if (strcmp(strmatch, "root") == 0)
+            opts->root = _gf_true;
+        else if (strcmp(strmatch, "ro") == 0)
+            opts->rw = _gf_false;
+        else if (strcmp(strmatch, "rw") == 0)
+            opts->rw = _gf_true;
+        else if (strcmp(strmatch, "nosuid") == 0)
+            opts->nosuid = _gf_true;
+        else if (equals) {
+            ret = __exp_line_opt_key_value_parse(strmatch, opts);
+            if (ret < 0) {
+                /* This means invalid key value options were
+                 * specified, or memory allocation failed.
+                 * The ret value gets bubbled up to the caller.
                  */
-                ret = GF_EXP_PARSE_ITEM_FAILURE;
-                parser_unset_string (options_parser);
+                GF_FREE(strmatch);
+                parser_unset_string(options_parser);
+                _export_options_deinit(opts);
                 goto out;
-        }
+            }
+        } else
+            /* Cannot change to gf_msg.
+             * gf_msg not giving output to STDOUT
+             * Bug id : BZ1215017
+             */
+            gf_log(GF_EXP, GF_LOG_WARNING,
+                   "Could not find any valid options for "
+                   "string: %s",
+                   strmatch);
+        GF_FREE(strmatch);
+    }
+
+    if (!opts) {
+        /* If opts is not allocated
+         * that means no matches were found
+         * which is a parse error. Not marking
+         * it as "not found" because it is a parse
+         * error to not have options.
+         */
+        ret = GF_EXP_PARSE_ITEM_FAILURE;
+        parser_unset_string(options_parser);
+        goto out;
+    }
 
-        *exp_opts = opts;
-        parser_unset_string (options_parser);
-        ret = GF_EXP_PARSE_SUCCESS;
+    *exp_opts = opts;
+    parser_unset_string(options_parser);
+    ret = GF_EXP_PARSE_SUCCESS;
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * __exp_line_ng_host_str_parse -- Parse the netgroup or host string
  *
@@ -716,76 +722,76 @@ out:
  * Not for external use.
  */
 static int
-__exp_line_ng_host_str_parse (char *str, struct export_item **exp_item)
+__exp_line_ng_host_str_parse(char *str, struct export_item **exp_item)
 {
-        struct export_item     *item      = NULL;
-        int                     ret       = -EINVAL;
-        char                   *parens    = NULL;
-        char                   *optstr    = NULL;
-        struct export_options  *exp_opts  = NULL;
-        char                   *item_name = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, str, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, exp_item, out);
-
-        /* A netgroup/host string looks like this:
-         * @test(sec=sys,rw,anonuid=0) or host(sec=sys,rw,anonuid=0)
-         * We want to extract the name, 'test' or 'host'
-         * Again, we could setup a regex and use it here,
-         * but its simpler to find the '(' and copy until
-         * there.
-         */
-        parens = strchr (str, '(');
-        if (!parens) {
-                /* Parse error if there are no parens. */
-                ret = GF_EXP_PARSE_ITEM_FAILURE;
-                goto out;
-        }
+    struct export_item *item = NULL;
+    int ret = -EINVAL;
+    char *parens = NULL;
+    char *optstr = NULL;
+    struct export_options *exp_opts = NULL;
+    char *item_name = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, str, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, exp_item, out);
+
+    /* A netgroup/host string looks like this:
+     * @test(sec=sys,rw,anonuid=0) or host(sec=sys,rw,anonuid=0)
+     * We want to extract the name, 'test' or 'host'
+     * Again, we could setup a regex and use it here,
+     * but its simpler to find the '(' and copy until
+     * there.
+     */
+    parens = strchr(str, '(');
+    if (!parens) {
+        /* Parse error if there are no parens. */
+        ret = GF_EXP_PARSE_ITEM_FAILURE;
+        goto out;
+    }
 
-        *parens = '\0'; /* Temporarily terminate it so we can do a copy */
+    *parens = '\0'; /* Temporarily terminate it so we can do a copy */
 
-        if (strlen (str) > FQDN_MAX_LEN) {
-                ret = GF_EXP_PARSE_ITEM_FAILURE;
-                goto out;
-        }
+    if (strlen(str) > FQDN_MAX_LEN) {
+        ret = GF_EXP_PARSE_ITEM_FAILURE;
+        goto out;
+    }
 
-        /* Strip leading whitespaces */
-        while (*str == ' ' || *str == '\t')
-                str++;
+    /* Strip leading whitespaces */
+    while (*str == ' ' || *str == '\t')
+        str++;
 
-        item_name = gf_strdup (str);
-        GF_CHECK_ALLOC (item_name, ret, out);
+    item_name = gf_strdup(str);
+    GF_CHECK_ALLOC(item_name, ret, out);
 
-        gf_msg_trace (GF_EXP, 0, "found hostname/netgroup: %s", item_name);
+    gf_msg_trace(GF_EXP, 0, "found hostname/netgroup: %s", item_name);
 
-        /* Initialize an export item for this */
-        item = _export_item_init ();
-        GF_CHECK_ALLOC (item, ret, free_and_out);
-        item->name = item_name;
+    /* Initialize an export item for this */
+    item = _export_item_init();
+    GF_CHECK_ALLOC(item, ret, free_and_out);
+    item->name = item_name;
 
-        *parens = '('; /* Restore the string */
+    *parens = '('; /* Restore the string */
 
-        /* Options start at the parentheses */
-        optstr = parens;
+    /* Options start at the parentheses */
+    optstr = parens;
 
-        ret = __exp_line_opt_parse (optstr, &exp_opts);
-        if (ret != 0) {
-                /* Bubble up the error to the caller */
-                GF_REF_PUT (item);
-                goto out;
-        }
+    ret = __exp_line_opt_parse(optstr, &exp_opts);
+    if (ret != 0) {
+        /* Bubble up the error to the caller */
+        GF_REF_PUT(item);
+        goto out;
+    }
 
-        item->opts = exp_opts;
+    item->opts = exp_opts;
 
-        *exp_item = item;
+    *exp_item = item;
 
-        ret = GF_EXP_PARSE_SUCCESS;
-        goto out;
+    ret = GF_EXP_PARSE_SUCCESS;
+    goto out;
 
 free_and_out:
-        GF_FREE (item_name);
+    GF_FREE(item_name);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -816,75 +822,75 @@ out:
  * Not for external use.
  */
 static int
-__exp_line_ng_parse (const char *line, dict_t **ng_dict)
+__exp_line_ng_parse(const char *line, dict_t **ng_dict)
 {
-        dict_t                  *netgroups = NULL;
-        char                    *strmatch  = NULL;
-        int                      ret       = -EINVAL;
-        struct export_item      *exp_ng    = NULL;
-        data_t                  *ngdata    = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, line, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, ng_dict, out);
+    dict_t *netgroups = NULL;
+    char *strmatch = NULL;
+    int ret = -EINVAL;
+    struct export_item *exp_ng = NULL;
+    data_t *ngdata = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, line, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, ng_dict, out);
+
+    *ng_dict = NULL; /* Will be set if parse is successful */
+
+    /* Initialize a parser with the line to parse
+     * and the regex used to parse it.
+     */
+    ret = parser_set_string(netgroup_parser, line);
+    if (ret < 0) {
+        goto out;
+    }
 
-        *ng_dict = NULL; /* Will be set if parse is successful */
+    gf_msg_trace(GF_EXP, 0, "parsing line: %s", line);
 
-        /* Initialize a parser with the line to parse
-         * and the regex used to parse it.
-         */
-        ret = parser_set_string (netgroup_parser, line);
-        if (ret < 0) {
-                goto out;
+    while ((strmatch = parser_get_next_match(netgroup_parser))) {
+        if (!netgroups) {
+            /* Allocate a new dict to store the netgroups. */
+            netgroups = dict_new();
+            if (!netgroups) {
+                ret = -ENOMEM;
+                goto free_and_out;
+            }
         }
 
-        gf_msg_trace (GF_EXP, 0, "parsing line: %s", line);
+        gf_msg_trace(GF_EXP, 0, "parsing netgroup: %s", strmatch);
 
-        while ((strmatch = parser_get_next_match (netgroup_parser))) {
-                if (!netgroups) {
-                        /* Allocate a new dict to store the netgroups. */
-                        netgroups = dict_new ();
-                        if (!netgroups) {
-                                ret = -ENOMEM;
-                                goto free_and_out;
-                        }
-                }
+        ret = __exp_line_ng_host_str_parse(strmatch, &exp_ng);
 
-                gf_msg_trace (GF_EXP, 0, "parsing netgroup: %s", strmatch);
-
-                ret = __exp_line_ng_host_str_parse (strmatch, &exp_ng);
-
-                if (ret != 0) {
-                        /* Parsing or other critical errors.
-                         * caller will handle return value.
-                         */
-                        _exp_dict_destroy (netgroups);
-                        goto free_and_out;
-                }
+        if (ret != 0) {
+            /* Parsing or other critical errors.
+             * caller will handle return value.
+             */
+            _exp_dict_destroy(netgroups);
+            goto free_and_out;
+        }
 
-                ngdata = bin_to_data (exp_ng, sizeof (*exp_ng));
-                dict_set (netgroups, exp_ng->name, ngdata);
+        ngdata = bin_to_data(exp_ng, sizeof(*exp_ng));
+        dict_set(netgroups, exp_ng->name, ngdata);
 
-                /* Free this matched string and continue parsing. */
-                GF_FREE (strmatch);
-        }
+        /* Free this matched string and continue parsing. */
+        GF_FREE(strmatch);
+    }
 
-        /* If the netgroups dict was not allocated, then we know that
-         * no matches were found.
-         */
-        if (!netgroups) {
-                ret = GF_EXP_PARSE_ITEM_NOT_FOUND;
-                parser_unset_string (netgroup_parser);
-                goto out;
-        }
+    /* If the netgroups dict was not allocated, then we know that
+     * no matches were found.
+     */
+    if (!netgroups) {
+        ret = GF_EXP_PARSE_ITEM_NOT_FOUND;
+        parser_unset_string(netgroup_parser);
+        goto out;
+    }
 
-        ret = GF_EXP_PARSE_SUCCESS;
-        *ng_dict = netgroups;
+    ret = GF_EXP_PARSE_SUCCESS;
+    *ng_dict = netgroups;
 
 free_and_out:
-        parser_unset_string (netgroup_parser);
-        GF_FREE (strmatch);
+    parser_unset_string(netgroup_parser);
+    GF_FREE(strmatch);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -915,77 +921,75 @@ out:
  * Not for external use.
  */
 static int
-__exp_line_host_parse (const char *line, dict_t **host_dict)
+__exp_line_host_parse(const char *line, dict_t **host_dict)
 {
-        dict_t                  *hosts    = NULL;
-        char                    *strmatch = NULL;
-        int                     ret       = -EINVAL;
-        struct export_item      *exp_host = NULL;
-        data_t                  *hostdata = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, line, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, host_dict, out);
+    dict_t *hosts = NULL;
+    char *strmatch = NULL;
+    int ret = -EINVAL;
+    struct export_item *exp_host = NULL;
+    data_t *hostdata = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, line, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, host_dict, out);
+
+    *host_dict = NULL;
+
+    /* Initialize a parser with the line to parse and the regex used to
+     * parse it.
+     */
+    ret = parser_set_string(hostname_parser, line);
+    if (ret < 0) {
+        goto out;
+    }
 
-        *host_dict = NULL;
+    gf_msg_trace(GF_EXP, 0, "parsing line: %s", line);
 
-        /* Initialize a parser with the line to parse and the regex used to
-         * parse it.
-         */
-        ret = parser_set_string (hostname_parser, line);
-        if (ret < 0) {
-                goto out;
+    while ((strmatch = parser_get_next_match(hostname_parser))) {
+        if (!hosts) {
+            /* Allocate a new dictto store the netgroups. */
+            hosts = dict_new();
+            GF_CHECK_ALLOC(hosts, ret, free_and_out);
         }
 
-        gf_msg_trace (GF_EXP, 0, "parsing line: %s", line);
-
-        while ((strmatch = parser_get_next_match (hostname_parser))) {
-                if (!hosts) {
-                        /* Allocate a new dictto store the netgroups. */
-                        hosts = dict_new ();
-                        GF_CHECK_ALLOC (hosts, ret, free_and_out);
-                }
-
-                gf_msg_trace (GF_EXP, 0, "parsing hostname: %s", strmatch);
+        gf_msg_trace(GF_EXP, 0, "parsing hostname: %s", strmatch);
 
-                ret = __exp_line_ng_host_str_parse (strmatch, &exp_host);
+        ret = __exp_line_ng_host_str_parse(strmatch, &exp_host);
 
-                if (ret != 0) {
-                        /* Parsing or other critical error, free allocated
-                         * memory and exit. The caller will handle the errors.
-                         */
-                        _exp_dict_destroy (hosts);
-                        goto free_and_out;
-                }
-
-                /* Insert export item structure into the hosts dict. */
-                hostdata = bin_to_data (exp_host, sizeof (*exp_host));
-                dict_set (hosts, exp_host->name, hostdata);
+        if (ret != 0) {
+            /* Parsing or other critical error, free allocated
+             * memory and exit. The caller will handle the errors.
+             */
+            _exp_dict_destroy(hosts);
+            goto free_and_out;
+        }
 
+        /* Insert export item structure into the hosts dict. */
+        hostdata = bin_to_data(exp_host, sizeof(*exp_host));
+        dict_set(hosts, exp_host->name, hostdata);
 
-                /* Free this matched string and continue parsing.*/
-                GF_FREE (strmatch);
-        }
+        /* Free this matched string and continue parsing.*/
+        GF_FREE(strmatch);
+    }
 
-        /* If the hosts dict was not allocated, then we know that
-         * no matches were found.
-         */
-        if (!exp_host) {
-                ret = GF_EXP_PARSE_ITEM_NOT_FOUND;
-                parser_unset_string (hostname_parser);
-                goto out;
-        }
+    /* If the hosts dict was not allocated, then we know that
+     * no matches were found.
+     */
+    if (!exp_host) {
+        ret = GF_EXP_PARSE_ITEM_NOT_FOUND;
+        parser_unset_string(hostname_parser);
+        goto out;
+    }
 
-        ret = GF_EXP_PARSE_SUCCESS;
-        *host_dict = hosts;
+    ret = GF_EXP_PARSE_SUCCESS;
+    *host_dict = hosts;
 
 free_and_out:
-        parser_unset_string (hostname_parser);
-        GF_FREE (strmatch);
+    parser_unset_string(hostname_parser);
+    GF_FREE(strmatch);
 out:
-        return ret;
+    return ret;
 }
 
-
 /**
  * __exp_line_dir_parse -- Extract directory name from a line in the exports
  *                         file.
@@ -1010,70 +1014,71 @@ out:
  * Not for external use.
  */
 static int
-__exp_line_dir_parse (const char *line, char **dirname, struct mount3_state *ms)
+__exp_line_dir_parse(const char *line, char **dirname, struct mount3_state *ms)
 {
-        char                    *dir        = NULL;
-        char                    *delim      = NULL;
-        int                     ret         = -EINVAL;
-        char                    *linedup    = NULL;
-        struct mnt3_export      *mnt3export = NULL;
-        size_t                  dirlen      = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, line, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, dirname, out);
-
-        /* Duplicate the line because we don't
-         * want to modify the original string.
+    char *dir = NULL;
+    char *delim = NULL;
+    int ret = -EINVAL;
+    char *linedup = NULL;
+    struct mnt3_export *mnt3export = NULL;
+    size_t dirlen = 0;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, line, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dirname, out);
+
+    /* Duplicate the line because we don't
+     * want to modify the original string.
+     */
+    linedup = strdupa(line);
+
+    /* We use strtok_r () here to split the string by space/tab and get the
+     * the result. We only need the first result of the split.
+     * a simple task. It is worth noting that dirnames always have to be
+     * validated against gluster's vol files so if they don't
+     * match it will be rejected.
+     */
+    dir = linedup;
+    delim = linedup + strcspn(linedup, " \t");
+    *delim = 0;
+
+    if (ms) {
+        /* Match the directory name with an existing
+         * export in the mount state.
          */
-        linedup = strdupa (line);
-
-        /* We use strtok_r () here to split the string by space/tab and get the
-         * the result. We only need the first result of the split.
-         * a simple task. It is worth noting that dirnames always have to be
-         * validated against gluster's vol files so if they don't
-         * match it will be rejected.
-         */
-        dir = linedup;
-        delim = linedup + strcspn (linedup, " \t");
-        *delim = 0;
-
-        if (ms) {
-                /* Match the directory name with an existing
-                 * export in the mount state.
-                 */
-                mnt3export = mnt3_mntpath_to_export (ms, dir, _gf_true);
-                if (!mnt3export) {
-                        gf_msg_debug (GF_EXP, 0, "%s not in mount state, "
-                                      "ignoring!", dir);
-                        ret = GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE;
-                        goto out;
-                }
-        }
-
-        /* Directories can be 1024 bytes in length, check
-         * that the argument provided adheres to
-         * that restriction.
-         */
-        if (strlen (dir) > DIR_MAX_LEN) {
-                ret = -EINVAL;
-                goto out;
+        mnt3export = mnt3_mntpath_to_export(ms, dir, _gf_true);
+        if (!mnt3export) {
+            gf_msg_debug(GF_EXP, 0,
+                         "%s not in mount state, "
+                         "ignoring!",
+                         dir);
+            ret = GF_EXP_PARSE_ITEM_NOT_IN_MOUNT_STATE;
+            goto out;
         }
+    }
+
+    /* Directories can be 1024 bytes in length, check
+     * that the argument provided adheres to
+     * that restriction.
+     */
+    if (strlen(dir) > DIR_MAX_LEN) {
+        ret = -EINVAL;
+        goto out;
+    }
 
-        /* Copy the result of the split */
-        dir = gf_strdup (dir);
-        GF_CHECK_ALLOC (dir, ret, out);
-
-        /* Ensure that trailing slashes are stripped before storing the name */
-        dirlen = strlen (dir);
-        if (dirlen > 0 && dir[dirlen - 1] == '/')
-                dir[dirlen - 1] = '\0';
+    /* Copy the result of the split */
+    dir = gf_strdup(dir);
+    GF_CHECK_ALLOC(dir, ret, out);
 
+    /* Ensure that trailing slashes are stripped before storing the name */
+    dirlen = strlen(dir);
+    if (dirlen > 0 && dir[dirlen - 1] == '/')
+        dir[dirlen - 1] = '\0';
 
-        /* Set the argument to point to the allocated string */
-        *dirname = dir;
-        ret = GF_EXP_PARSE_SUCCESS;
+    /* Set the argument to point to the allocated string */
+    *dirname = dir;
+    ret = GF_EXP_PARSE_SUCCESS;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -1121,126 +1126,126 @@ out:
  * Not for external use.
  */
 static int
-_exp_line_parse (const char *line, struct export_dir **dir,
-                 gf_boolean_t parse_full, struct mount3_state *ms)
+_exp_line_parse(const char *line, struct export_dir **dir,
+                gf_boolean_t parse_full, struct mount3_state *ms)
 {
-        struct export_dir *expdir           = NULL;
-        char              *dirstr           = NULL;
-        dict_t            *netgroups        = NULL;
-        dict_t            *hosts            = NULL;
-        int                ret              = -EINVAL;
-        gf_boolean_t       netgroups_failed = _gf_false;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, line, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, dir, out);
-
-        if (*line == '#' || *line == ' ' || *line == '\t'
-            || *line == '\0' || *line == '\n') {
-                ret = GF_EXP_PARSE_LINE_IGNORING;
-                goto out;
-        }
-
-        expdir = _export_dir_init ();
-        if (!expdir) {
-                *dir = NULL;
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* Get the directory string from the line */
-        ret = __exp_line_dir_parse (line, &dirstr, ms);
-        if (ret < 0) {
-                gf_msg (GF_EXP, GF_LOG_ERROR, 0, NFS_MSG_PARSE_DIR_FAIL,
-                        "Parsing directory failed: %s", strerror (-ret));
-                /* If parsing the directory failed,
-                 * we should simply fail because there's
-                 * nothing else we can extract from the string to make
-                 * the data valuable.
-                 */
-                goto free_and_out;
-        }
-
-        /* Set the dir str */
-        expdir->dir_name = dirstr;
-
-        /* Parse the netgroup part of the string */
-        ret = __exp_line_ng_parse (line, &netgroups);
-        if (ret < 0) {
-                gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                        "Critical error: %s", strerror (-ret));
-                /* Return values less than 0
-                 * indicate critical failures (null parameters,
-                 * failure to allocate memory, etc).
-                 */
-                goto free_and_out;
-        }
-        if (ret != 0) {
-                if (ret == GF_EXP_PARSE_ITEM_FAILURE)
-                        /* Cannot change to gf_msg.
-                         * gf_msg not giving output to STDOUT
-                         * Bug id : BZ1215017
-                         */
-                        gf_log (GF_EXP, GF_LOG_WARNING,
-                                "Error parsing netgroups for: %s", line);
-                /* Even though parsing failed for the netgroups we should let
-                 * host parsing proceed.
-                 */
-                netgroups_failed = _gf_true;
-        }
-
-        /* Parse the host part of the string */
-        ret = __exp_line_host_parse (line, &hosts);
-        if (ret < 0) {
-                gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                        "Critical error: %s", strerror (-ret));
-                goto free_and_out;
-        }
-        if (ret != 0) {
-                if (ret == GF_EXP_PARSE_ITEM_FAILURE)
-                        gf_msg (GF_EXP, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL,
-                                "Error parsing hosts for: %s", line);
-                /* If netgroups parsing failed, AND
-                 * host parsing failed, then there's something really
-                 * wrong with this line, so we're just going to
-                 * log it and fail out.
-                 */
-                if (netgroups_failed)
-                        goto free_and_out;
-        }
+    struct export_dir *expdir = NULL;
+    char *dirstr = NULL;
+    dict_t *netgroups = NULL;
+    dict_t *hosts = NULL;
+    int ret = -EINVAL;
+    gf_boolean_t netgroups_failed = _gf_false;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, line, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dir, out);
+
+    if (*line == '#' || *line == ' ' || *line == '\t' || *line == '\0' ||
+        *line == '\n') {
+        ret = GF_EXP_PARSE_LINE_IGNORING;
+        goto out;
+    }
 
-        expdir->hosts = hosts;
-        expdir->netgroups = netgroups;
-        *dir = expdir;
+    expdir = _export_dir_init();
+    if (!expdir) {
+        *dir = NULL;
+        ret = -ENOMEM;
         goto out;
+    }
+
+    /* Get the directory string from the line */
+    ret = __exp_line_dir_parse(line, &dirstr, ms);
+    if (ret < 0) {
+        gf_msg(GF_EXP, GF_LOG_ERROR, 0, NFS_MSG_PARSE_DIR_FAIL,
+               "Parsing directory failed: %s", strerror(-ret));
+        /* If parsing the directory failed,
+         * we should simply fail because there's
+         * nothing else we can extract from the string to make
+         * the data valuable.
+         */
+        goto free_and_out;
+    }
+
+    /* Set the dir str */
+    expdir->dir_name = dirstr;
+
+    /* Parse the netgroup part of the string */
+    ret = __exp_line_ng_parse(line, &netgroups);
+    if (ret < 0) {
+        gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+               "Critical error: %s", strerror(-ret));
+        /* Return values less than 0
+         * indicate critical failures (null parameters,
+         * failure to allocate memory, etc).
+         */
+        goto free_and_out;
+    }
+    if (ret != 0) {
+        if (ret == GF_EXP_PARSE_ITEM_FAILURE)
+            /* Cannot change to gf_msg.
+             * gf_msg not giving output to STDOUT
+             * Bug id : BZ1215017
+             */
+            gf_log(GF_EXP, GF_LOG_WARNING, "Error parsing netgroups for: %s",
+                   line);
+        /* Even though parsing failed for the netgroups we should let
+         * host parsing proceed.
+         */
+        netgroups_failed = _gf_true;
+    }
+
+    /* Parse the host part of the string */
+    ret = __exp_line_host_parse(line, &hosts);
+    if (ret < 0) {
+        gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+               "Critical error: %s", strerror(-ret));
+        goto free_and_out;
+    }
+    if (ret != 0) {
+        if (ret == GF_EXP_PARSE_ITEM_FAILURE)
+            gf_msg(GF_EXP, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL,
+                   "Error parsing hosts for: %s", line);
+        /* If netgroups parsing failed, AND
+         * host parsing failed, then there's something really
+         * wrong with this line, so we're just going to
+         * log it and fail out.
+         */
+        if (netgroups_failed)
+            goto free_and_out;
+    }
+
+    expdir->hosts = hosts;
+    expdir->netgroups = netgroups;
+    *dir = expdir;
+    goto out;
 
 free_and_out:
-       _export_dir_deinit (expdir);
+    _export_dir_deinit(expdir);
 out:
-        return ret;
+    return ret;
 }
 
 struct export_item *
-exp_dir_get_netgroup (const struct export_dir *expdir, const char *netgroup)
+exp_dir_get_netgroup(const struct export_dir *expdir, const char *netgroup)
 {
-        struct export_item   *lookup_res = NULL;
-        data_t               *dict_res   = NULL;
+    struct export_item *lookup_res = NULL;
+    data_t *dict_res = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, netgroup, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, expdir, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, netgroup, out);
 
-        if (!expdir->netgroups)
-                goto out;
+    if (!expdir->netgroups)
+        goto out;
 
-        dict_res = dict_get (expdir->netgroups, (char *)netgroup);
-        if (!dict_res) {
-                gf_msg_debug (GF_EXP, 0, "%s not found for %s",
-                              netgroup, expdir->dir_name);
-                goto out;
-        }
+    dict_res = dict_get(expdir->netgroups, (char *)netgroup);
+    if (!dict_res) {
+        gf_msg_debug(GF_EXP, 0, "%s not found for %s", netgroup,
+                     expdir->dir_name);
+        goto out;
+    }
 
-        lookup_res = (struct export_item *)dict_res->data;
+    lookup_res = (struct export_item *)dict_res->data;
 out:
-        return lookup_res;
+    return lookup_res;
 }
 /**
  * exp_dir_get_host -- Given a host string and an exports directory structure,
@@ -1254,35 +1259,33 @@ out:
  *          failure: NULL
  */
 struct export_item *
-exp_dir_get_host (const struct export_dir *expdir, const char *host)
+exp_dir_get_host(const struct export_dir *expdir, const char *host)
 {
-        struct export_item   *lookup_res = NULL;
-        data_t               *dict_res   = NULL;
+    struct export_item *lookup_res = NULL;
+    data_t *dict_res = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_EXP, expdir, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, host, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, expdir, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, host, out);
 
-        if (!expdir->hosts)
-                goto out;
+    if (!expdir->hosts)
+        goto out;
+
+    dict_res = dict_get(expdir->hosts, (char *)host);
+    if (!dict_res) {
+        gf_msg_debug(GF_EXP, 0, "%s not found for %s", host, expdir->dir_name);
 
-        dict_res = dict_get (expdir->hosts, (char *)host);
+        /* Check if wildcards are allowed for the host */
+        dict_res = dict_get(expdir->hosts, "*");
         if (!dict_res) {
-                gf_msg_debug (GF_EXP, 0, "%s not found for %s",
-                              host, expdir->dir_name);
-
-                /* Check if wildcards are allowed for the host */
-                dict_res = dict_get (expdir->hosts, "*");
-                if (!dict_res) {
-                        goto out;
-                }
+            goto out;
         }
+    }
 
-        lookup_res = (struct export_item *)dict_res->data;
+    lookup_res = (struct export_item *)dict_res->data;
 out:
-        return lookup_res;
+    return lookup_res;
 }
 
-
 /**
  * exp_file_get_dir -- Return an export dir given a directory name
  *                     Does a lookup from the dict in the file structure.
@@ -1294,38 +1297,37 @@ out:
  *           failure: NULL
  */
 struct export_dir *
-exp_file_get_dir (const struct exports_file *file, const char *dir)
+exp_file_get_dir(const struct exports_file *file, const char *dir)
 {
-        struct export_dir  *lookup_res = NULL;
-        data_t             *dict_res   = NULL;
-        char               *dirdup     = NULL;
-        size_t             dirlen      = 0;
+    struct export_dir *lookup_res = NULL;
+    data_t *dict_res = NULL;
+    char *dirdup = NULL;
+    size_t dirlen = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_EXP, file, out);
-        GF_VALIDATE_OR_GOTO (GF_EXP, dir, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, file, out);
+    GF_VALIDATE_OR_GOTO(GF_EXP, dir, out);
 
-        dirlen = strlen (dir);
-        if (dirlen <= 0)
-                goto out;
+    dirlen = strlen(dir);
+    if (dirlen <= 0)
+        goto out;
 
-        dirdup = (char *)dir; /* Point at the directory */
+    dirdup = (char *)dir; /* Point at the directory */
 
-        /* If directories don't contain a leading slash */
-        if (*dir != '/') {
-                dirdup = alloca (dirlen + 2); /* Leading slash & null byte */
-                snprintf (dirdup, dirlen + 2, "/%s", dir);
-        }
+    /* If directories don't contain a leading slash */
+    if (*dir != '/') {
+        dirdup = alloca(dirlen + 2); /* Leading slash & null byte */
+        snprintf(dirdup, dirlen + 2, "/%s", dir);
+    }
 
-        dict_res = dict_get (file->exports_dict, dirdup);
-        if (!dict_res) {
-                gf_msg_debug (GF_EXP, 0, "%s not found in %s", dirdup,
-                              file->filename);
-                goto out;
-        }
+    dict_res = dict_get(file->exports_dict, dirdup);
+    if (!dict_res) {
+        gf_msg_debug(GF_EXP, 0, "%s not found in %s", dirdup, file->filename);
+        goto out;
+    }
 
-        lookup_res = (struct export_dir *)dict_res->data;
+    lookup_res = (struct export_dir *)dict_res->data;
 out:
-        return lookup_res;
+    return lookup_res;
 }
 
 /**
@@ -1347,129 +1349,130 @@ out:
  * Externally usable.
  */
 int
-exp_file_parse (const char *filepath, struct exports_file **expfile,
-                struct mount3_state *ms)
+exp_file_parse(const char *filepath, struct exports_file **expfile,
+               struct mount3_state *ms)
 {
-        FILE                *fp             = NULL;
-        struct exports_file *file           = NULL;
-        size_t               len            = 0;
-        int                  ret            = -EINVAL;
-        unsigned long        line_number    = 0;
-        char                *line           = NULL;
-        struct export_dir   *expdir         = NULL;
-
-        /* Sets whether we we should parse the entire file or just that which
-         * is present in the mount state */
-        gf_boolean_t    parse_complete_file = _gf_false;
-
-        GF_VALIDATE_OR_GOTO (GF_EXP, expfile, parse_done);
-
-        if (!ms) {
-                /* If mount state is null that means that we
-                 * should go through and parse the whole file
-                 * since we don't have anything to compare against.
-                 */
-                parse_complete_file = _gf_true;
+    FILE *fp = NULL;
+    struct exports_file *file = NULL;
+    size_t len = 0;
+    int ret = -EINVAL;
+    unsigned long line_number = 0;
+    char *line = NULL;
+    struct export_dir *expdir = NULL;
+
+    /* Sets whether we we should parse the entire file or just that which
+     * is present in the mount state */
+    gf_boolean_t parse_complete_file = _gf_false;
+
+    GF_VALIDATE_OR_GOTO(GF_EXP, expfile, parse_done);
+
+    if (!ms) {
+        /* If mount state is null that means that we
+         * should go through and parse the whole file
+         * since we don't have anything to compare against.
+         */
+        parse_complete_file = _gf_true;
+    }
+
+    fp = fopen(filepath, "r");
+    if (!fp) {
+        ret = -errno;
+        goto parse_done;
+    }
+
+    ret = _exp_init_parsers();
+    if (ret < 0)
+        goto parse_done;
+
+    /* Process the file line by line, with each line being parsed into
+     * an struct export_dir struct. If 'parse_complete_file' is set to TRUE
+     * then
+     */
+    while (getline(&line, &len, fp) != -1) {
+        line_number++;      /* Keeping track of line number allows us to
+                             * to log which line numbers were wrong
+                             */
+        strtok(line, "\n"); /* removes the newline character from
+                             * the line
+                             */
+
+        /* Parse the line from the file into an struct export_dir
+         * structure. The process is as follows:
+         * Given a line like :
+         * "/vol @test(sec=sys,rw,anonuid=0) 10.35.11.31(sec=sys,rw)"
+         *
+         * This function will allocate an export dir and set its name
+         * to '/vol', using the function _exp_line_dir_parse ().
+         *
+         * Then it will extract the netgroups from the line, in this
+         * case it would be '@test(sec=sys,rw,anonuid=0)', and set the
+         * item structure's name to '@test'.
+         * It will also extract the options from that string and parse
+         * them into an struct export_options which will be pointed
+         * to by the item structure. This will be put into a dict
+         * which will be pointed to by the export directory structure.
+         *
+         * The same process happens above for the host string
+         * '10.35.11.32(sec=sys,rw)'
+         */
+        ret = _exp_line_parse(line, &expdir, parse_complete_file, ms);
+        if (ret == -ENOMEM) {
+            /* If we get memory allocation errors, we really should
+             * not continue parsing, so just free the allocated
+             * memory and exit.
+             */
+            goto free_and_done;
         }
 
-        fp = fopen (filepath, "r");
-        if (!fp) {
-                ret = -errno;
-                goto parse_done;
+        if (ret < 0) {
+            gf_msg(GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse line #%lu", line_number);
+            continue; /* Skip entering this line and continue */
         }
 
-        ret = _exp_init_parsers ();
-        if (ret < 0)
-                goto parse_done;
+        if (ret == GF_EXP_PARSE_LINE_IGNORING) {
+            /* This just means the line was empty or started with a
+             * '#' or a ' ' and we are ignoring it.
+             */
+            gf_msg_debug(GF_EXP, 0,
+                         "Ignoring line #%lu because it started "
+                         "with a %c",
+                         line_number, *line);
+            continue;
+        }
 
-        /* Process the file line by line, with each line being parsed into
-         * an struct export_dir struct. If 'parse_complete_file' is set to TRUE
-         * then
-         */
-        while (getline (&line, &len, fp) != -1) {
-                line_number++;  /* Keeping track of line number allows us to
-                                 * to log which line numbers were wrong
-                                 */
-                strtok (line, "\n");    /* removes the newline character from
-                                         * the line
-                                         */
-
-                /* Parse the line from the file into an struct export_dir
-                 * structure. The process is as follows:
-                 * Given a line like :
-                 * "/vol @test(sec=sys,rw,anonuid=0) 10.35.11.31(sec=sys,rw)"
-                 *
-                 * This function will allocate an export dir and set its name
-                 * to '/vol', using the function _exp_line_dir_parse ().
-                 *
-                 * Then it will extract the netgroups from the line, in this
-                 * case it would be '@test(sec=sys,rw,anonuid=0)', and set the
-                 * item structure's name to '@test'.
-                 * It will also extract the options from that string and parse
-                 * them into an struct export_options which will be pointed
-                 * to by the item structure. This will be put into a dict
-                 * which will be pointed to by the export directory structure.
-                 *
-                 * The same process happens above for the host string
-                 * '10.35.11.32(sec=sys,rw)'
-                 */
-                ret = _exp_line_parse (line, &expdir, parse_complete_file, ms);
-                if (ret == -ENOMEM) {
-                        /* If we get memory allocation errors, we really should
-                         * not continue parsing, so just free the allocated
-                         * memory and exit.
-                         */
-                        goto free_and_done;
-                }
-
-                if (ret < 0) {
-                        gf_msg (GF_EXP, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse line #%lu", line_number);
-                        continue; /* Skip entering this line and continue */
-                }
-
-                if (ret == GF_EXP_PARSE_LINE_IGNORING) {
-                        /* This just means the line was empty or started with a
-                         * '#' or a ' ' and we are ignoring it.
-                         */
-                        gf_msg_debug (GF_EXP, 0,
-                                      "Ignoring line #%lu because it started "
-                                      "with a %c", line_number, *line);
-                        continue;
-                }
-
-                if (!file) {
-                        file = _exports_file_init ();
-                        GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret,
-                                                "Allocation error while "
-                                                "allocating file struct",
-                                                parse_done);
-
-                        file->filename = gf_strdup (filepath);
-                        GF_CHECK_ALLOC_AND_LOG (GF_EXP, file, ret,
-                                                "Allocation error while "
-                                                "duping filepath",
-                                                free_and_done);
-                }
-
-                /* If the parsing is successful store the export directory
-                 * in the file structure.
-                 */
-                _exp_file_insert (file, expdir);
+        if (!file) {
+            file = _exports_file_init();
+            GF_CHECK_ALLOC_AND_LOG(GF_EXP, file, ret,
+                                   "Allocation error while "
+                                   "allocating file struct",
+                                   parse_done);
+
+            file->filename = gf_strdup(filepath);
+            GF_CHECK_ALLOC_AND_LOG(GF_EXP, file, ret,
+                                   "Allocation error while "
+                                   "duping filepath",
+                                   free_and_done);
         }
 
-        /* line got allocated through getline(), don't use GF_FREE() for it */
-        free (line);
+        /* If the parsing is successful store the export directory
+         * in the file structure.
+         */
+        _exp_file_insert(file, expdir);
+    }
 
-        *expfile = file;
-        goto parse_done;
+    /* line got allocated through getline(), don't use GF_FREE() for it */
+    free(line);
+
+    *expfile = file;
+    goto parse_done;
 
 free_and_done:
-        exp_file_deinit (file);
+    exp_file_deinit(file);
 
 parse_done:
-        if (fp)
-                fclose (fp);
-        _exp_deinit_parsers ();
-        return ret;
+    if (fp)
+        fclose(fp);
+    _exp_deinit_parsers();
+    return ret;
 }
diff --git a/xlators/nfs/server/src/mount3-auth.c b/xlators/nfs/server/src/mount3-auth.c
index 97c95cbfd23..37839c230e8 100644
--- a/xlators/nfs/server/src/mount3-auth.c
+++ b/xlators/nfs/server/src/mount3-auth.c
@@ -54,19 +54,18 @@
  * For external use.
  */
 struct mnt3_auth_params *
-mnt3_auth_params_init (struct mount3_state *ms)
+mnt3_auth_params_init(struct mount3_state *ms)
 {
-        struct mnt3_auth_params *auth_params = NULL;
+    struct mnt3_auth_params *auth_params = NULL;
 
-        auth_params = GF_MALLOC (sizeof (*auth_params),
-                                 gf_nfs_mt_mnt3_auth_params);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out);
+    auth_params = GF_MALLOC(sizeof(*auth_params), gf_nfs_mt_mnt3_auth_params);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out);
 
-        auth_params->ngfile = NULL;
-        auth_params->expfile = NULL;
-        auth_params->ms = ms;
+    auth_params->ngfile = NULL;
+    auth_params->expfile = NULL;
+    auth_params->ms = ms;
 out:
-        return auth_params;
+    return auth_params;
 }
 
 /**
@@ -77,23 +76,23 @@ out:
  * For external use.
  */
 void
-mnt3_auth_params_deinit (struct mnt3_auth_params *auth_params)
+mnt3_auth_params_deinit(struct mnt3_auth_params *auth_params)
 {
-        if (!auth_params)
-                goto out;
-
-        /* Atomically set the auth params in the mount state to NULL
-         * so subsequent fops will be denied while the auth params
-         * are being cleaned up.
-         */
-        (void)__sync_lock_test_and_set (&auth_params->ms->auth_params, NULL);
-
-        ng_file_deinit (auth_params->ngfile);
-        exp_file_deinit (auth_params->expfile);
-        auth_params->ms = NULL;
-        GF_FREE (auth_params);
+    if (!auth_params)
+        goto out;
+
+    /* Atomically set the auth params in the mount state to NULL
+     * so subsequent fops will be denied while the auth params
+     * are being cleaned up.
+     */
+    (void)__sync_lock_test_and_set(&auth_params->ms->auth_params, NULL);
+
+    ng_file_deinit(auth_params->ngfile);
+    exp_file_deinit(auth_params->expfile);
+    auth_params->ms = NULL;
+    GF_FREE(auth_params);
 out:
-        return;
+    return;
 }
 
 /**
@@ -108,32 +107,33 @@ out:
  * For external use.
  */
 int
-mnt3_auth_set_exports_auth (struct mnt3_auth_params *auth_params,
-                            const char *filename)
+mnt3_auth_set_exports_auth(struct mnt3_auth_params *auth_params,
+                           const char *filename)
 {
-        struct exports_file *expfile = NULL;
-        struct exports_file *oldfile = NULL;
-        int                  ret     = -EINVAL;
-
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, filename, out);
-
-        /* Parse the exports file and set the auth parameter */
-        ret = exp_file_parse (filename, &expfile, auth_params->ms);
-        if (ret < 0) {
-                gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR,
-                        "Failed to load & parse file"
-                        " %s, see logs for more information", filename);
-                goto out;
-        }
-
-        /* Atomically set the file pointer */
-        oldfile = __sync_lock_test_and_set (&auth_params->expfile, expfile);
-        exp_file_deinit (oldfile);
-        ret = 0;
+    struct exports_file *expfile = NULL;
+    struct exports_file *oldfile = NULL;
+    int ret = -EINVAL;
+
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, filename, out);
+
+    /* Parse the exports file and set the auth parameter */
+    ret = exp_file_parse(filename, &expfile, auth_params->ms);
+    if (ret < 0) {
+        gf_msg(GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR,
+               "Failed to load & parse file"
+               " %s, see logs for more information",
+               filename);
+        goto out;
+    }
+
+    /* Atomically set the file pointer */
+    oldfile = __sync_lock_test_and_set(&auth_params->expfile, expfile);
+    exp_file_deinit(oldfile);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -148,32 +148,33 @@ out:
  * For external use.
  */
 int
-mnt3_auth_set_netgroups_auth (struct mnt3_auth_params *auth_params,
-                              const char *filename)
+mnt3_auth_set_netgroups_auth(struct mnt3_auth_params *auth_params,
+                             const char *filename)
 {
-        struct netgroups_file *ngfile  = NULL;
-        struct netgroups_file *oldfile = NULL;
-        int                    ret     = -EINVAL;
-
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, filename, out);
-
-        ngfile = ng_file_parse (filename);
-        if (!ngfile) {
-                gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR,
-                        "Failed to load file %s, see logs for more "
-                        "information", filename);
-                ret = -1;
-                goto out;
-        }
-
-        /* Atomically set the file pointer */
-        oldfile = __sync_lock_test_and_set (&auth_params->ngfile, ngfile);
-        ng_file_deinit (oldfile);
-        ret = 0;
+    struct netgroups_file *ngfile = NULL;
+    struct netgroups_file *oldfile = NULL;
+    int ret = -EINVAL;
+
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, filename, out);
+
+    ngfile = ng_file_parse(filename);
+    if (!ngfile) {
+        gf_msg(GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR,
+               "Failed to load file %s, see logs for more "
+               "information",
+               filename);
+        ret = -1;
+        goto out;
+    }
+
+    /* Atomically set the file pointer */
+    oldfile = __sync_lock_test_and_set(&auth_params->ngfile, ngfile);
+    ng_file_deinit(oldfile);
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* Struct used to pass parameters to
@@ -181,8 +182,8 @@ out:
  * checks if an IP matches a subnet
  */
 struct _mnt3_subnet_match_s {
-        char                  *ip;   /* IP address to match */
-        struct export_item   **host; /* Host structure to set */
+    char *ip;                  /* IP address to match */
+    struct export_item **host; /* Host structure to set */
 };
 
 /**
@@ -196,40 +197,40 @@ struct _mnt3_subnet_match_s {
  *
  */
 static int
-_mnt3_auth_subnet_match (dict_t *dict, char *key, data_t *val, void *tmp)
+_mnt3_auth_subnet_match(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct  _mnt3_subnet_match_s *match = NULL;
-
-        match = (struct _mnt3_subnet_match_s *)tmp;
+    struct _mnt3_subnet_match_s *match = NULL;
 
-        if (!match)
-                return 0;
+    match = (struct _mnt3_subnet_match_s *)tmp;
 
-        if (!match->host)
-                return 0;
-
-        if (!match->ip)
-                return 0;
+    if (!match)
+        return 0;
 
-        /* Already found the host */
-        if (*(match->host))
-                return 0;
+    if (!match->host)
+        return 0;
 
-        /* Don't process anything that's not in CIDR */
-        if (!strchr (key, '/'))
-                return 0;
+    if (!match->ip)
+        return 0;
 
-        /* Strip out leading whitespaces */
-        while (*key == ' ')
-                key++;
+    /* Already found the host */
+    if (*(match->host))
+        return 0;
 
-        /* If we found that the IP was in the network, set the host
-         * to point to the value in the dict.
-         */
-        if (gf_is_ip_in_net (key, match->ip)) {
-                *(match->host) = (struct export_item *)val->data;
-        }
+    /* Don't process anything that's not in CIDR */
+    if (!strchr(key, '/'))
         return 0;
+
+    /* Strip out leading whitespaces */
+    while (*key == ' ')
+        key++;
+
+    /* If we found that the IP was in the network, set the host
+     * to point to the value in the dict.
+     */
+    if (gf_is_ip_in_net(key, match->ip)) {
+        *(match->host) = (struct export_item *)val->data;
+    }
+    return 0;
 }
 
 /**
@@ -256,67 +257,69 @@ _mnt3_auth_subnet_match (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static struct export_item *
-_mnt3_auth_check_host_in_export (const struct exports_file *file,
-                                 const char *dir, const char *host,
-                                 struct nfs3_fh *fh)
+_mnt3_auth_check_host_in_export(const struct exports_file *file,
+                                const char *dir, const char *host,
+                                struct nfs3_fh *fh)
 {
-        struct export_dir           *expdir = NULL;
-        struct export_item          *host_s = NULL;
-        struct _mnt3_subnet_match_s  snet_match_s = {0, };
-
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, file, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out);
-
-        /* If the filehandle is defined, use that to perform authentication.
-         * All file operations that need authentication must follow this
-         * code path.
-         */
-        if (fh) {
-                expdir = exp_file_dir_from_uuid (file, fh->mountid);
-                if (!expdir)
-                        goto out;
-        } else {
-                /* Get the exports directory from the exports file */
-                expdir = exp_file_get_dir (file, dir);
-                if (!expdir)
-                        goto out;
-        }
-
-        /* Extract the host from the export directory */
-        host_s = exp_dir_get_host (expdir, host);
-        if (!host_s)
-                goto subnet_match;
-        else
-                goto out;
-
-        /* If the host is not found, we need to walk through the hosts
-         * in the exports directory and see if any of the "hosts" are actually
-         * networks (e.g. 10.5.153.0/24). If they are we should match the
-         * incoming network.
-         */
+    struct export_dir *expdir = NULL;
+    struct export_item *host_s = NULL;
+    struct _mnt3_subnet_match_s snet_match_s = {
+        0,
+    };
+
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, file, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out);
+
+    /* If the filehandle is defined, use that to perform authentication.
+     * All file operations that need authentication must follow this
+     * code path.
+     */
+    if (fh) {
+        expdir = exp_file_dir_from_uuid(file, fh->mountid);
+        if (!expdir)
+            goto out;
+    } else {
+        /* Get the exports directory from the exports file */
+        expdir = exp_file_get_dir(file, dir);
+        if (!expdir)
+            goto out;
+    }
+
+    /* Extract the host from the export directory */
+    host_s = exp_dir_get_host(expdir, host);
+    if (!host_s)
+        goto subnet_match;
+    else
+        goto out;
+
+    /* If the host is not found, we need to walk through the hosts
+     * in the exports directory and see if any of the "hosts" are actually
+     * networks (e.g. 10.5.153.0/24). If they are we should match the
+     * incoming network.
+     */
 subnet_match:
-        if (!expdir->hosts)
-                goto out;
-        snet_match_s.ip = (char *)host;
-        snet_match_s.host = &host_s;
-        dict_foreach (expdir->hosts, _mnt3_auth_subnet_match, &snet_match_s);
+    if (!expdir->hosts)
+        goto out;
+    snet_match_s.ip = (char *)host;
+    snet_match_s.host = &host_s;
+    dict_foreach(expdir->hosts, _mnt3_auth_subnet_match, &snet_match_s);
 out:
-        return host_s;
+    return host_s;
 }
 
 /* This struct represents all the parameters necessary to search through a
  * netgroups file to find a host.
  */
 struct ng_auth_search {
-        const char                  *search_for; /* strings to search for */
-        gf_boolean_t                 found;      /* mark true once found */
-        const struct netgroups_file *file;       /* netgroups file to search */
-        const char                  *expdir;
-        struct export_item          *expitem;    /* pointer to the export */
-        const struct exports_file   *expfile;
-        gf_boolean_t                 _is_host_dict; /* searching a host dict? */
-        struct netgroup_entry       *found_entry;   /* the entry we found! */
+    const char *search_for;            /* strings to search for */
+    gf_boolean_t found;                /* mark true once found */
+    const struct netgroups_file *file; /* netgroups file to search */
+    const char *expdir;
+    struct export_item *expitem; /* pointer to the export */
+    const struct exports_file *expfile;
+    gf_boolean_t _is_host_dict;         /* searching a host dict? */
+    struct netgroup_entry *found_entry; /* the entry we found! */
 };
 
 /**
@@ -332,65 +335,65 @@ struct ng_auth_search {
  * Not for external use.
  */
 static int
-__netgroup_dict_search (dict_t *dict, char *key, data_t *val, void *data)
+__netgroup_dict_search(dict_t *dict, char *key, data_t *val, void *data)
 {
-        struct ng_auth_search *ngsa    = NULL;
-        struct netgroup_entry *ngentry = NULL;
-        data_t                *hdata   = NULL;
-
-        /* 'ngsa' is the search params */
-        ngsa    = (struct ng_auth_search *)data;
-        ngentry = (struct netgroup_entry *)val->data;
-
-        if (ngsa->_is_host_dict) {
-                /* If are on a host dict, we can simply hash the search key
-                 * against the host dict and see if we find anything.
-                 */
-                hdata = dict_get (dict, (char *)ngsa->search_for);
-                if (hdata) {
-                        /* If it was found, log the message, mark the search
-                         * params dict as found and return.
-                         */
-                        gf_msg_debug (GF_MNT_AUTH, errno, "key %s was hashed "
-                                      "and found", key);
-                        ngsa->found = _gf_true;
-                        ngsa->found_entry = (struct netgroup_entry *)hdata->data;
-                        goto out;
-                }
-        }
+    struct ng_auth_search *ngsa = NULL;
+    struct netgroup_entry *ngentry = NULL;
+    data_t *hdata = NULL;
 
-        /* If the key is what we are searching for, mark the item as
-         * found and return.
-         */
-        if (strcmp (key, ngsa->search_for) == 0) {
-                ngsa->found = _gf_true;
-                ngsa->found_entry = ngentry;
-                goto out;
-        }
+    /* 'ngsa' is the search params */
+    ngsa = (struct ng_auth_search *)data;
+    ngentry = (struct netgroup_entry *)val->data;
 
-        /* If we have a netgroup hosts dict, then search the dict using this
-         * same function.
+    if (ngsa->_is_host_dict) {
+        /* If are on a host dict, we can simply hash the search key
+         * against the host dict and see if we find anything.
          */
-        if (ngentry->netgroup_hosts) {
-                ngsa->_is_host_dict = _gf_true;
-                dict_foreach (ngentry->netgroup_hosts, __netgroup_dict_search,
-                                                        ngsa);
-        }
-
-        /* If that search was successful, just return */
-        if (ngsa->found)
-                goto out;
-
-        /* If we have a netgroup dict, then search the dict using this same
-         * function.
-         */
-        if (ngentry->netgroup_ngs) {
-                ngsa->_is_host_dict = _gf_false;
-                dict_foreach (ngentry->netgroup_ngs, __netgroup_dict_search,
-                                                        ngsa);
+        hdata = dict_get(dict, (char *)ngsa->search_for);
+        if (hdata) {
+            /* If it was found, log the message, mark the search
+             * params dict as found and return.
+             */
+            gf_msg_debug(GF_MNT_AUTH, errno,
+                         "key %s was hashed "
+                         "and found",
+                         key);
+            ngsa->found = _gf_true;
+            ngsa->found_entry = (struct netgroup_entry *)hdata->data;
+            goto out;
         }
+    }
+
+    /* If the key is what we are searching for, mark the item as
+     * found and return.
+     */
+    if (strcmp(key, ngsa->search_for) == 0) {
+        ngsa->found = _gf_true;
+        ngsa->found_entry = ngentry;
+        goto out;
+    }
+
+    /* If we have a netgroup hosts dict, then search the dict using this
+     * same function.
+     */
+    if (ngentry->netgroup_hosts) {
+        ngsa->_is_host_dict = _gf_true;
+        dict_foreach(ngentry->netgroup_hosts, __netgroup_dict_search, ngsa);
+    }
+
+    /* If that search was successful, just return */
+    if (ngsa->found)
+        goto out;
+
+    /* If we have a netgroup dict, then search the dict using this same
+     * function.
+     */
+    if (ngentry->netgroup_ngs) {
+        ngsa->_is_host_dict = _gf_false;
+        dict_foreach(ngentry->netgroup_ngs, __netgroup_dict_search, ngsa);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 /**
@@ -416,54 +419,51 @@ out:
  * Not for external use.
  */
 static int
-__export_dir_lookup_netgroup (dict_t *dict, char *key, data_t *val,
-                                void *data)
+__export_dir_lookup_netgroup(dict_t *dict, char *key, data_t *val, void *data)
 {
-        struct ng_auth_search *ngsa    = NULL; /* Search params */
-        struct netgroups_file *nfile   = NULL; /* Netgroups file to search */
-        struct netgroup_entry *ngentry = NULL; /* Entry in the netgroups file */
-        struct export_dir     *tmpdir  = NULL;
-
-        ngsa  = (struct ng_auth_search *)data;
-        nfile = (struct netgroups_file *)ngsa->file;
-
-        GF_ASSERT ((*key == '@'));
-
-        /* We use ++key here because keys start with '@' for ngs */
-        ngentry = ng_file_get_netgroup (nfile, (key + 1));
-        if (!ngentry) {
-                gf_msg_debug (GF_MNT_AUTH, 0, "%s not found in %s",
-                              key, nfile->filename);
-                goto out;
-        }
-
-        tmpdir = exp_file_get_dir (ngsa->expfile, ngsa->expdir);
-        if (!tmpdir)
-                goto out;
-
-        ngsa->expitem = exp_dir_get_netgroup (tmpdir, key);
-        if (!ngsa->expitem)
-                goto out;
-
-        /* Run through the host dict */
-        if (ngentry->netgroup_hosts) {
-                ngsa->_is_host_dict = _gf_true;
-                dict_foreach (ngentry->netgroup_hosts, __netgroup_dict_search,
-                              ngsa);
-        }
-
-        /* If the above search was successful, just return */
-        if (ngsa->found)
-                goto out;
-
-        /* Run through the netgroups dict */
-        if (ngentry->netgroup_ngs) {
-                ngsa->_is_host_dict = _gf_false;
-                dict_foreach (ngentry->netgroup_ngs, __netgroup_dict_search,
-                              ngsa);
-        }
+    struct ng_auth_search *ngsa = NULL;    /* Search params */
+    struct netgroups_file *nfile = NULL;   /* Netgroups file to search */
+    struct netgroup_entry *ngentry = NULL; /* Entry in the netgroups file */
+    struct export_dir *tmpdir = NULL;
+
+    ngsa = (struct ng_auth_search *)data;
+    nfile = (struct netgroups_file *)ngsa->file;
+
+    GF_ASSERT((*key == '@'));
+
+    /* We use ++key here because keys start with '@' for ngs */
+    ngentry = ng_file_get_netgroup(nfile, (key + 1));
+    if (!ngentry) {
+        gf_msg_debug(GF_MNT_AUTH, 0, "%s not found in %s", key,
+                     nfile->filename);
+        goto out;
+    }
+
+    tmpdir = exp_file_get_dir(ngsa->expfile, ngsa->expdir);
+    if (!tmpdir)
+        goto out;
+
+    ngsa->expitem = exp_dir_get_netgroup(tmpdir, key);
+    if (!ngsa->expitem)
+        goto out;
+
+    /* Run through the host dict */
+    if (ngentry->netgroup_hosts) {
+        ngsa->_is_host_dict = _gf_true;
+        dict_foreach(ngentry->netgroup_hosts, __netgroup_dict_search, ngsa);
+    }
+
+    /* If the above search was successful, just return */
+    if (ngsa->found)
+        goto out;
+
+    /* Run through the netgroups dict */
+    if (ngentry->netgroup_ngs) {
+        ngsa->_is_host_dict = _gf_false;
+        dict_foreach(ngentry->netgroup_ngs, __netgroup_dict_search, ngsa);
+    }
 out:
-        return 0;
+    return 0;
 }
 
 /**
@@ -476,25 +476,26 @@ out:
  * @nfile : The netgroups file to set
  *
  */
-void _mnt3_auth_setup_search_params (struct ng_auth_search *params,
-                                     const char *host, const char *dir,
-                                     const struct netgroups_file *nfile,
-                                     const struct exports_file *expfile)
+void
+_mnt3_auth_setup_search_params(struct ng_auth_search *params, const char *host,
+                               const char *dir,
+                               const struct netgroups_file *nfile,
+                               const struct exports_file *expfile)
 {
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, params, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, nfile, out);
-
-        params->search_for = host;
-        params->found = _gf_false;
-        params->file = nfile;
-        params->_is_host_dict = _gf_false;
-        params->found_entry = NULL;
-        params->expitem = NULL;
-        params->expfile = expfile;
-        params->expdir = dir;
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, params, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, nfile, out);
+
+    params->search_for = host;
+    params->found = _gf_false;
+    params->file = nfile;
+    params->_is_host_dict = _gf_false;
+    params->found_entry = NULL;
+    params->expitem = NULL;
+    params->expfile = expfile;
+    params->expdir = dir;
 out:
-        return;
+    return;
 }
 
 /**
@@ -521,43 +522,44 @@ out:
  * Not for external use.
  */
 static struct netgroup_entry *
-_mnt3_auth_check_host_in_netgroup (const struct mnt3_auth_params *auth_params,
-                                   struct nfs3_fh *fh, const char *host,
-                                   const char *dir, struct export_item **item)
+_mnt3_auth_check_host_in_netgroup(const struct mnt3_auth_params *auth_params,
+                                  struct nfs3_fh *fh, const char *host,
+                                  const char *dir, struct export_item **item)
 {
-        struct export_dir     *expdir      = NULL;
-        struct ng_auth_search  ngsa        = {0, };
-        struct netgroup_entry *found_entry = NULL;
-        struct exports_file   *efile       = auth_params->expfile;
-        struct netgroups_file *nfile       = auth_params->ngfile;
-
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, nfile, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, efile, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, item, out);
-
-        if (fh) {
-                expdir = exp_file_dir_from_uuid (efile, fh->mountid);
-                if (!expdir)
-                        goto out;
-        } else {
-                /* Get the exports directory */
-                expdir = exp_file_get_dir (efile, dir);
-                if (!expdir)
-                        goto out;
-        }
-
-        /* Setup search struct */
-        _mnt3_auth_setup_search_params (&ngsa, host, expdir->dir_name, nfile,
-                                        efile);
-
-        /* Do the search */
-        dict_foreach (expdir->netgroups, __export_dir_lookup_netgroup, &ngsa);
-        found_entry = ngsa.found_entry;
-        *item = ngsa.expitem;
+    struct export_dir *expdir = NULL;
+    struct ng_auth_search ngsa = {
+        0,
+    };
+    struct netgroup_entry *found_entry = NULL;
+    struct exports_file *efile = auth_params->expfile;
+    struct netgroups_file *nfile = auth_params->ngfile;
+
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, nfile, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, efile, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, item, out);
+
+    if (fh) {
+        expdir = exp_file_dir_from_uuid(efile, fh->mountid);
+        if (!expdir)
+            goto out;
+    } else {
+        /* Get the exports directory */
+        expdir = exp_file_get_dir(efile, dir);
+        if (!expdir)
+            goto out;
+    }
+
+    /* Setup search struct */
+    _mnt3_auth_setup_search_params(&ngsa, host, expdir->dir_name, nfile, efile);
+
+    /* Do the search */
+    dict_foreach(expdir->netgroups, __export_dir_lookup_netgroup, &ngsa);
+    found_entry = ngsa.found_entry;
+    *item = ngsa.expitem;
 out:
-        return found_entry;
+    return found_entry;
 }
 
 /**
@@ -570,22 +572,22 @@ out:
  *
  */
 int
-check_rw_access (struct export_item *item)
+check_rw_access(struct export_item *item)
 {
-        struct export_options *opts   = NULL;
-        int                    ret    = -EROFS;
+    struct export_options *opts = NULL;
+    int ret = -EROFS;
 
-        if (!item)
-                goto out;
+    if (!item)
+        goto out;
 
-        opts = item->opts;
-        if (!opts)
-                goto out;
+    opts = item->opts;
+    if (!opts)
+        goto out;
 
-        if (opts->rw)
-                ret = 0;
+    if (opts->rw)
+        ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -609,36 +611,32 @@ out:
  *          -EROFS  for unauthorized write operations (rm, mkdir, write)  *
  */
 int
-mnt3_auth_host (const struct mnt3_auth_params *auth_params, const char *host,
-                struct nfs3_fh *fh, const char *dir, gf_boolean_t is_write_op,
-                struct export_item **save_item)
+mnt3_auth_host(const struct mnt3_auth_params *auth_params, const char *host,
+               struct nfs3_fh *fh, const char *dir, gf_boolean_t is_write_op,
+               struct export_item **save_item)
 {
-        int                  auth_status_code = -EACCES;
-        struct export_item  *item             = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, auth_params, out);
-        GF_VALIDATE_OR_GOTO (GF_MNT_AUTH, host, out);
-
-        /* Find the host in the exports file */
-        item = _mnt3_auth_check_host_in_export (auth_params->expfile, dir,
-                                                    host, fh);
-        if (item) {
-                auth_status_code = (is_write_op) ?
-                                   check_rw_access (item) : 0;
-                goto out;
-        }
+    int auth_status_code = -EACCES;
+    struct export_item *item = NULL;
 
-        /* Find the host in the netgroups file for the exports directory */
-        if (_mnt3_auth_check_host_in_netgroup (auth_params, fh, host, dir,
-                                               &item)) {
-                auth_status_code = (is_write_op) ?
-                                   check_rw_access (item) : 0;
-                goto out;
-        }
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, auth_params, out);
+    GF_VALIDATE_OR_GOTO(GF_MNT_AUTH, host, out);
+
+    /* Find the host in the exports file */
+    item = _mnt3_auth_check_host_in_export(auth_params->expfile, dir, host, fh);
+    if (item) {
+        auth_status_code = (is_write_op) ? check_rw_access(item) : 0;
+        goto out;
+    }
+
+    /* Find the host in the netgroups file for the exports directory */
+    if (_mnt3_auth_check_host_in_netgroup(auth_params, fh, host, dir, &item)) {
+        auth_status_code = (is_write_op) ? check_rw_access(item) : 0;
+        goto out;
+    }
 
 out:
-        if (save_item)
-                *save_item = item;
+    if (save_item)
+        *save_item = item;
 
-        return auth_status_code;
+    return auth_status_code;
 }
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);
 }
diff --git a/xlators/nfs/server/src/mount3udp_svc.c b/xlators/nfs/server/src/mount3udp_svc.c
index a9499bf0038..d542e2951c3 100644
--- a/xlators/nfs/server/src/mount3udp_svc.c
+++ b/xlators/nfs/server/src/mount3udp_svc.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "xdr-nfs3.h"
 #include "logging.h"
 #include "mem-pool.h"
@@ -23,224 +22,221 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 
-
-extern struct nfs3_fh*
-nfs3_rootfh (struct svc_req *req, xlator_t *nfsx, char *dp, char *expname);
+extern struct nfs3_fh *
+nfs3_rootfh(struct svc_req *req, xlator_t *nfsx, char *dp, char *expname);
 
 extern 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);
 extern int
-mount3udp_add_mountlist (xlator_t *nfsx, char *host, char *expname);
+mount3udp_add_mountlist(xlator_t *nfsx, char *host, char *expname);
 
 extern int
-mount3udp_delete_mountlist (xlator_t *nfsx, char *host, char *expname);
+mount3udp_delete_mountlist(xlator_t *nfsx, char *host, char *expname);
 
 extern mountstat3
-mnt3svc_errno_to_mnterr (int32_t errnum);
-
+mnt3svc_errno_to_mnterr(int32_t errnum);
 
 /* only this thread will use this, no locking needed */
-char mnthost[INET_ADDRSTRLEN+1];
+char mnthost[INET_ADDRSTRLEN + 1];
 
 #define MNT3UDP_AUTH_LEN 1 /* Only AUTH_UNIX for now */
 
 mountres3 *
 mountudpproc3_mnt_3_svc(dirpath **dpp, struct svc_req *req)
 {
-        struct mountres3        *res = NULL;
-        int                     *autharr = NULL;
-        struct nfs3_fh          *fh = NULL;
-        char                    *mpath = NULL;
-        xlator_t                *nfsx = THIS;
-        char                    expname[PATH_MAX] = {0, };
-        mountstat3              stat = MNT3ERR_SERVERFAULT;
-
-        errno = 0; /* RESET errno */
-
-        mpath = (char *)*dpp;
-        while (*mpath == '/')
-                mpath++;
-
-        res = GF_CALLOC (1, sizeof(*res), gf_nfs_mt_mountres3);
-        if (res == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Unable to allocate memory");
-                goto err;
-        }
-        autharr = GF_CALLOC (MNT3UDP_AUTH_LEN, sizeof(int), gf_nfs_mt_int);
-        if (autharr == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Unable to allocate memory");
-                goto err;
-        }
-
-        autharr[0] = AUTH_UNIX;
-
-        fh = nfs3_rootfh (req, nfsx, mpath, (char *)expname);
-
-        /* FAILURE: No FH */
-        if (fh == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_GET_FH_FAIL,
-                        "Unable to get fh for %s", mpath);
-                if (errno)
-                        stat = mnt3svc_errno_to_mnterr (errno);
-                *res = mnt3svc_set_mountres3 (stat, NULL /* fh */,
-                                              autharr, MNT3UDP_AUTH_LEN);
-                return res;
-        }
-
-        /* SUCCESS */
-        stat = MNT3_OK;
-        *res = mnt3svc_set_mountres3 (stat, fh, autharr, MNT3UDP_AUTH_LEN);
-        (void) mount3udp_add_mountlist (nfsx, mnthost, (char *) expname);
+    struct mountres3 *res = NULL;
+    int *autharr = NULL;
+    struct nfs3_fh *fh = NULL;
+    char *mpath = NULL;
+    xlator_t *nfsx = THIS;
+    char expname[PATH_MAX] = {
+        0,
+    };
+    mountstat3 stat = MNT3ERR_SERVERFAULT;
+
+    errno = 0; /* RESET errno */
+
+    mpath = (char *)*dpp;
+    while (*mpath == '/')
+        mpath++;
+
+    res = GF_CALLOC(1, sizeof(*res), gf_nfs_mt_mountres3);
+    if (res == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Unable to allocate memory");
+        goto err;
+    }
+    autharr = GF_CALLOC(MNT3UDP_AUTH_LEN, sizeof(int), gf_nfs_mt_int);
+    if (autharr == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Unable to allocate memory");
+        goto err;
+    }
+
+    autharr[0] = AUTH_UNIX;
+
+    fh = nfs3_rootfh(req, nfsx, mpath, (char *)expname);
+
+    /* FAILURE: No FH */
+    if (fh == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_GET_FH_FAIL,
+               "Unable to get fh for %s", mpath);
+        if (errno)
+            stat = mnt3svc_errno_to_mnterr(errno);
+        *res = mnt3svc_set_mountres3(stat, NULL /* fh */, autharr,
+                                     MNT3UDP_AUTH_LEN);
         return res;
-
- err:
-        GF_FREE (fh);
-        GF_FREE (res);
-        GF_FREE (autharr);
-        return NULL;
+    }
+
+    /* SUCCESS */
+    stat = MNT3_OK;
+    *res = mnt3svc_set_mountres3(stat, fh, autharr, MNT3UDP_AUTH_LEN);
+    (void)mount3udp_add_mountlist(nfsx, mnthost, (char *)expname);
+    return res;
+
+err:
+    GF_FREE(fh);
+    GF_FREE(res);
+    GF_FREE(autharr);
+    return NULL;
 }
 
 mountstat3 *
 mountudpproc3_umnt_3_svc(dirpath **dp, struct svc_req *req)
 {
-        mountstat3 *stat = NULL;
-        char       *mpath = (char *) *dp;
-        xlator_t   *nfsx = THIS;
-
-        stat = GF_MALLOC (sizeof(mountstat3), gf_nfs_mt_mountstat3);
-        if (stat == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Unable to allocate memory");
-                return NULL;
-        }
-        *stat = MNT3_OK;
-        (void) mount3udp_delete_mountlist (nfsx, mnthost, mpath);
-        return stat;
+    mountstat3 *stat = NULL;
+    char *mpath = (char *)*dp;
+    xlator_t *nfsx = THIS;
+
+    stat = GF_MALLOC(sizeof(mountstat3), gf_nfs_mt_mountstat3);
+    if (stat == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Unable to allocate memory");
+        return NULL;
+    }
+    *stat = MNT3_OK;
+    (void)mount3udp_delete_mountlist(nfsx, mnthost, mpath);
+    return stat;
 }
 
 static void
 mountudp_program_3(struct svc_req *rqstp, register SVCXPRT *transp)
 {
-        union {
-                dirpath mountudpproc3_mnt_3_arg;
-        } argument;
-        char                    *result = NULL;
-        xdrproc_t               _xdr_argument = NULL, _xdr_result = NULL;
-        char *(*local)(char *, struct svc_req *) = NULL;
-        mountres3               *res = NULL;
-        struct sockaddr_in      *sin = NULL;
+    union {
+        dirpath mountudpproc3_mnt_3_arg;
+    } argument;
+    char *result = NULL;
+    xdrproc_t _xdr_argument = NULL, _xdr_result = NULL;
+    char *(*local)(char *, struct svc_req *) = NULL;
+    mountres3 *res = NULL;
+    struct sockaddr_in *sin = NULL;
 
 #if !defined(_TIRPC_SVC_H)
-        sin = svc_getcaller (transp);
+    sin = svc_getcaller(transp);
 #else
-        sin = (struct sockaddr_in *)svc_getcaller (transp);
-        /* 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(transp);
+    /* 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
-        /* And let's make sure that it's actually an IPv4 address. */
-        GF_ASSERT (sin->sin_family == AF_INET);
+    /* And let's make sure that it's actually an IPv4 address. */
+    GF_ASSERT(sin->sin_family == AF_INET);
 
-        inet_ntop (AF_INET, &sin->sin_addr, mnthost, INET_ADDRSTRLEN+1);
+    inet_ntop(AF_INET, &sin->sin_addr, mnthost, INET_ADDRSTRLEN + 1);
 
-        switch (rqstp->rq_proc) {
+    switch (rqstp->rq_proc) {
         case NULLPROC:
-                (void) svc_sendreply (transp, (xdrproc_t) xdr_void,
-                                      (char *)NULL);
-                return;
+            (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
+            return;
 
         case MOUNT3_MNT:
-                _xdr_argument = (xdrproc_t) xdr_dirpath;
-                _xdr_result = (xdrproc_t) xdr_mountres3;
-                local = (char *(*)(char *,
-                                   struct svc_req *)) mountudpproc3_mnt_3_svc;
-                break;
+            _xdr_argument = (xdrproc_t)xdr_dirpath;
+            _xdr_result = (xdrproc_t)xdr_mountres3;
+            local = (char *(*)(char *,
+                               struct svc_req *))mountudpproc3_mnt_3_svc;
+            break;
 
         case MOUNT3_UMNT:
-                _xdr_argument = (xdrproc_t) xdr_dirpath;
-                _xdr_result = (xdrproc_t) xdr_mountstat3;
-                local = (char *(*)(char *,
-                                   struct svc_req *)) mountudpproc3_umnt_3_svc;
-                break;
+            _xdr_argument = (xdrproc_t)xdr_dirpath;
+            _xdr_result = (xdrproc_t)xdr_mountstat3;
+            local = (char *(*)(char *,
+                               struct svc_req *))mountudpproc3_umnt_3_svc;
+            break;
 
         default:
-                svcerr_noproc (transp);
-                return;
-        }
-        memset ((char *)&argument, 0, sizeof (argument));
-        if (!svc_getargs (transp, (xdrproc_t) _xdr_argument,
-                          (caddr_t) &argument)) {
-                svcerr_decode (transp);
-                return;
-        }
-        result = (*local)((char *)&argument, rqstp);
-        if (result == NULL) {
-                gf_msg_debug (GF_MNT, 0, "PROC returned error");
-                svcerr_systemerr (transp);
-        }
-        if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result,
-                                             result)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
-                        "svc_sendreply returned error");
-                svcerr_systemerr (transp);
-        }
-        if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument,
-                           (caddr_t) &argument)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL,
-                        "Unable to free arguments");
-        }
-        if (result == NULL)
-                return;
-        /* free the result */
-        switch (rqstp->rq_proc) {
+            svcerr_noproc(transp);
+            return;
+    }
+    memset((char *)&argument, 0, sizeof(argument));
+    if (!svc_getargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) {
+        svcerr_decode(transp);
+        return;
+    }
+    result = (*local)((char *)&argument, rqstp);
+    if (result == NULL) {
+        gf_msg_debug(GF_MNT, 0, "PROC returned error");
+        svcerr_systemerr(transp);
+    }
+    if (result != NULL &&
+        !svc_sendreply(transp, (xdrproc_t)_xdr_result, result)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
+               "svc_sendreply returned error");
+        svcerr_systemerr(transp);
+    }
+    if (!svc_freeargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL,
+               "Unable to free arguments");
+    }
+    if (result == NULL)
+        return;
+    /* free the result */
+    switch (rqstp->rq_proc) {
         case MOUNT3_MNT:
-                res = (mountres3 *) result;
-                GF_FREE (res->mountres3_u.mountinfo.fhandle.fhandle3_val);
-                GF_FREE (res->mountres3_u.mountinfo.auth_flavors.auth_flavors_val);
-                GF_FREE (res);
-                break;
+            res = (mountres3 *)result;
+            GF_FREE(res->mountres3_u.mountinfo.fhandle.fhandle3_val);
+            GF_FREE(res->mountres3_u.mountinfo.auth_flavors.auth_flavors_val);
+            GF_FREE(res);
+            break;
 
         case MOUNT3_UMNT:
-                GF_FREE (result);
-                break;
-        }
-        return;
+            GF_FREE(result);
+            break;
+    }
+    return;
 }
 
 void *
-mount3udp_thread (void *argv)
+mount3udp_thread(void *argv)
 {
-        xlator_t         *nfsx   = argv;
-        register SVCXPRT *transp = NULL;
-
-        GF_ASSERT (nfsx);
-
-        if (glusterfs_this_set(nfsx)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_XLATOR_SET_FAIL,
-                        "Failed to set xlator, nfs.mount-udp will not work");
-                return NULL;
-        }
-
-        transp = svcudp_create(RPC_ANYSOCK);
-        if (transp == NULL) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
-                        "svcudp_create error");
-                return NULL;
-        }
-        if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3,
-                          mountudp_program_3, IPPROTO_UDP)) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
-                        "svc_register error");
-                return NULL;
-        }
-
-        svc_run ();
-        gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED,
-                "svc_run returned");
+    xlator_t *nfsx = argv;
+    register SVCXPRT *transp = NULL;
+
+    GF_ASSERT(nfsx);
+
+    if (glusterfs_this_set(nfsx)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_XLATOR_SET_FAIL,
+               "Failed to set xlator, nfs.mount-udp will not work");
         return NULL;
+    }
+
+    transp = svcudp_create(RPC_ANYSOCK);
+    if (transp == NULL) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
+               "svcudp_create error");
+        return NULL;
+    }
+    if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, mountudp_program_3,
+                      IPPROTO_UDP)) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR,
+               "svc_register error");
+        return NULL;
+    }
+
+    svc_run();
+    gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED,
+           "svc_run returned");
+    return NULL;
 }
diff --git a/xlators/nfs/server/src/netgroups.c b/xlators/nfs/server/src/netgroups.c
index 01b50092a6d..092d4707205 100644
--- a/xlators/nfs/server/src/netgroups.c
+++ b/xlators/nfs/server/src/netgroups.c
@@ -16,9 +16,12 @@
 #include "parse-utils.h"
 #include "nfs-messages.h"
 
-static void _nge_print (const struct netgroup_entry *nge);
-static void _netgroup_entry_deinit (struct netgroup_entry *ptr);
-static void _netgroup_host_deinit (struct netgroup_host *host);
+static void
+_nge_print(const struct netgroup_entry *nge);
+static void
+_netgroup_entry_deinit(struct netgroup_entry *ptr);
+static void
+_netgroup_host_deinit(struct netgroup_host *host);
 
 static dict_t *__deleted_entries;
 static struct parser *ng_file_parser;
@@ -31,36 +34,36 @@ static struct parser *ng_host_parser;
  *          failure: -1
  */
 static int
-_ng_init_parsers ()
+_ng_init_parsers()
 {
-        int ret = -1;
-
-        /* Initialize the parsers. The only reason this should
-         * ever fail is because of 1) memory allocation errors
-         * 2) the regex in netgroups.h has been changed and no
-         * longer compiles.
-         */
-        ng_file_parser = parser_init (NG_FILE_PARSE_REGEX);
-        if (!ng_file_parser)
-                goto out;
-
-        ng_host_parser = parser_init (NG_HOST_PARSE_REGEX);
-        if (!ng_host_parser)
-                goto out;
-
-        ret = 0;
+    int ret = -1;
+
+    /* Initialize the parsers. The only reason this should
+     * ever fail is because of 1) memory allocation errors
+     * 2) the regex in netgroups.h has been changed and no
+     * longer compiles.
+     */
+    ng_file_parser = parser_init(NG_FILE_PARSE_REGEX);
+    if (!ng_file_parser)
+        goto out;
+
+    ng_host_parser = parser_init(NG_HOST_PARSE_REGEX);
+    if (!ng_host_parser)
+        goto out;
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
  * _ng_deinit_parsers - Free the parsers used in this file
  */
 static void
-_ng_deinit_parsers ()
+_ng_deinit_parsers()
 {
-        parser_deinit (ng_file_parser);
-        parser_deinit (ng_host_parser);
+    parser_deinit(ng_file_parser);
+    parser_deinit(ng_host_parser);
 }
 
 /**
@@ -71,18 +74,18 @@ _ng_deinit_parsers ()
  * Not for external use.
  */
 static struct netgroups_file *
-_netgroups_file_init ()
+_netgroups_file_init()
 {
-        struct netgroups_file *file  = GF_MALLOC (sizeof (*file),
-                                                  gf_common_mt_nfs_netgroups);
+    struct netgroups_file *file = GF_MALLOC(sizeof(*file),
+                                            gf_common_mt_nfs_netgroups);
 
-        if (!file)
-                goto out;
+    if (!file)
+        goto out;
 
-        file->filename     = NULL;
-        file->ng_file_dict = NULL;
+    file->filename = NULL;
+    file->ng_file_dict = NULL;
 out:
-        return file;
+    return file;
 }
 
 /**
@@ -100,17 +103,17 @@ out:
  * Not for external use.
  */
 static int
-__ngf_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__ngf_free_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct netgroup_entry        *nge = NULL;
-
-        if (val) {
-                nge = (struct netgroup_entry *)val->data;
-                _netgroup_entry_deinit (nge);
-                val->data = NULL;
-                dict_del (dict, key); /* Remove the key from this dict */
-        }
-        return 0;
+    struct netgroup_entry *nge = NULL;
+
+    if (val) {
+        nge = (struct netgroup_entry *)val->data;
+        _netgroup_entry_deinit(nge);
+        val->data = NULL;
+        dict_del(dict, key); /* Remove the key from this dict */
+    }
+    return 0;
 }
 
 /**
@@ -128,10 +131,10 @@ __ngf_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static int
-__deleted_entries_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__deleted_entries_free_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        dict_del (dict, key);
-        return 0;
+    dict_del(dict, key);
+    return 0;
 }
 
 /**
@@ -147,26 +150,26 @@ __deleted_entries_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * the memory allocated when parsing the file.
  */
 void
-ng_file_deinit (struct netgroups_file *ngfile)
+ng_file_deinit(struct netgroups_file *ngfile)
 {
-        if (!ngfile) {
-                return;
-        }
+    if (!ngfile) {
+        return;
+    }
 
-        __deleted_entries = dict_new ();
-        GF_VALIDATE_OR_GOTO (GF_NG, __deleted_entries, out);
+    __deleted_entries = dict_new();
+    GF_VALIDATE_OR_GOTO(GF_NG, __deleted_entries, out);
 
-        GF_FREE (ngfile->filename);
-        dict_foreach (ngfile->ng_file_dict, __ngf_free_walk, NULL);
-        dict_unref (ngfile->ng_file_dict);
-        GF_FREE (ngfile);
+    GF_FREE(ngfile->filename);
+    dict_foreach(ngfile->ng_file_dict, __ngf_free_walk, NULL);
+    dict_unref(ngfile->ng_file_dict);
+    GF_FREE(ngfile);
 
-        /* Clean up temporary dict we used to store "freed" names */
-        dict_foreach (__deleted_entries, __deleted_entries_free_walk, NULL);
-        dict_unref (__deleted_entries);
-        __deleted_entries = NULL;
+    /* Clean up temporary dict we used to store "freed" names */
+    dict_foreach(__deleted_entries, __deleted_entries_free_walk, NULL);
+    dict_unref(__deleted_entries);
+    __deleted_entries = NULL;
 out:
-        return;
+    return;
 }
 
 /**
@@ -179,11 +182,11 @@ out:
  * Not for external use.
  */
 static struct netgroup_entry *
-_netgroup_entry_init ()
+_netgroup_entry_init()
 {
-        struct netgroup_entry *entry = GF_CALLOC (1, sizeof (*entry),
-                                                  gf_common_mt_nfs_netgroups);
-        return entry;
+    struct netgroup_entry *entry = GF_CALLOC(1, sizeof(*entry),
+                                             gf_common_mt_nfs_netgroups);
+    return entry;
 }
 
 /**
@@ -202,17 +205,17 @@ _netgroup_entry_init ()
  * Not for external use.
  */
 static int
-__ngh_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__ngh_free_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct netgroup_host *ngh = NULL;
-
-        if (val) {
-                ngh = (struct netgroup_host *)val->data;
-                _netgroup_host_deinit (ngh);
-                val->data = NULL;
-                dict_del (dict, key);
-        }
-        return 0;
+    struct netgroup_host *ngh = NULL;
+
+    if (val) {
+        ngh = (struct netgroup_host *)val->data;
+        _netgroup_host_deinit(ngh);
+        val->data = NULL;
+        dict_del(dict, key);
+    }
+    return 0;
 }
 
 /**
@@ -231,23 +234,23 @@ __ngh_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static int
-__nge_free_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__nge_free_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct netgroup_entry *nge = NULL;
+    struct netgroup_entry *nge = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, dict, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, dict, out);
 
-        if (val) {
-                nge = (struct netgroup_entry *)val->data;
-                if (!dict_get (__deleted_entries, key)) {
-                        _netgroup_entry_deinit (nge);
-                        val->data = NULL;
-                }
-                dict_del (dict, key);
+    if (val) {
+        nge = (struct netgroup_entry *)val->data;
+        if (!dict_get(__deleted_entries, key)) {
+            _netgroup_entry_deinit(nge);
+            val->data = NULL;
         }
+        dict_del(dict, key);
+    }
 
 out:
-        return 0;
+    return 0;
 }
 
 /**
@@ -264,53 +267,53 @@ out:
  * Not for external use.
  */
 static void
-_netgroup_entry_deinit (struct netgroup_entry *ngentry)
+_netgroup_entry_deinit(struct netgroup_entry *ngentry)
 {
-        dict_t  *ng_dict   = NULL;
-        dict_t  *host_dict = NULL;
-        char    *name      = NULL;
-        data_t  *dint      = NULL;
-
-        if (!ngentry)
-                return;
-
-        ng_dict = ngentry->netgroup_ngs;
-        host_dict = ngentry->netgroup_hosts;
-
-        if (ng_dict) {
-                /* Free the dict of netgroup entries */
-                dict_foreach (ng_dict, __nge_free_walk, NULL);
-                dict_unref (ng_dict);
-                ngentry->netgroup_ngs = NULL;
-        }
+    dict_t *ng_dict = NULL;
+    dict_t *host_dict = NULL;
+    char *name = NULL;
+    data_t *dint = NULL;
 
-        if (host_dict) {
-                /* Free the dict of host entries */
-                dict_foreach (host_dict, __ngh_free_walk, NULL);
-                dict_unref (host_dict);
-                ngentry->netgroup_hosts = NULL;
-        }
+    if (!ngentry)
+        return;
 
-        if (ngentry->netgroup_name) {
-                /* Keep track of the netgroup names we've deallocated
-                 * We need to do this because of the nature of this data
-                 * structure. This data structure may hold multiple
-                 * pointers to an already freed object, but these are
-                 * uniquely identifiable by the name. We keep track
-                 * of these names so when we encounter a key who has
-                 * an association to an already freed object, we don't
-                 * free it twice.
-                 */
-                name = strdupa (ngentry->netgroup_name);
+    ng_dict = ngentry->netgroup_ngs;
+    host_dict = ngentry->netgroup_hosts;
+
+    if (ng_dict) {
+        /* Free the dict of netgroup entries */
+        dict_foreach(ng_dict, __nge_free_walk, NULL);
+        dict_unref(ng_dict);
+        ngentry->netgroup_ngs = NULL;
+    }
+
+    if (host_dict) {
+        /* Free the dict of host entries */
+        dict_foreach(host_dict, __ngh_free_walk, NULL);
+        dict_unref(host_dict);
+        ngentry->netgroup_hosts = NULL;
+    }
+
+    if (ngentry->netgroup_name) {
+        /* Keep track of the netgroup names we've deallocated
+         * We need to do this because of the nature of this data
+         * structure. This data structure may hold multiple
+         * pointers to an already freed object, but these are
+         * uniquely identifiable by the name. We keep track
+         * of these names so when we encounter a key who has
+         * an association to an already freed object, we don't
+         * free it twice.
+         */
+        name = strdupa(ngentry->netgroup_name);
 
-                dint = int_to_data (1);
-                dict_set (__deleted_entries, name, dint);
+        dint = int_to_data(1);
+        dict_set(__deleted_entries, name, dint);
 
-                GF_FREE (ngentry->netgroup_name);
-                ngentry->netgroup_name = NULL;
-        }
+        GF_FREE(ngentry->netgroup_name);
+        ngentry->netgroup_name = NULL;
+    }
 
-        GF_FREE (ngentry);
+    GF_FREE(ngentry);
 }
 
 /**
@@ -324,11 +327,11 @@ _netgroup_entry_deinit (struct netgroup_entry *ngentry)
  * Not for external use.
  */
 static struct netgroup_host *
-_netgroup_host_init ()
+_netgroup_host_init()
 {
-        struct netgroup_host *host = GF_CALLOC (1, sizeof (*host),
-                                                gf_common_mt_nfs_netgroups);
-        return host;
+    struct netgroup_host *host = GF_CALLOC(1, sizeof(*host),
+                                           gf_common_mt_nfs_netgroups);
+    return host;
 }
 
 /**
@@ -342,23 +345,23 @@ _netgroup_host_init ()
  * Not for external use.
  */
 static void
-_netgroup_host_deinit (struct netgroup_host *host)
+_netgroup_host_deinit(struct netgroup_host *host)
 {
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_NG, host, err);
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_NG, host, err);
 
-        GF_FREE (host->hostname);
-        host->hostname = NULL;
+    GF_FREE(host->hostname);
+    host->hostname = NULL;
 
-        GF_FREE (host->user);
-        host->user = NULL;
+    GF_FREE(host->user);
+    host->user = NULL;
 
-        GF_FREE (host->domain);
-        host->domain = NULL;
+    GF_FREE(host->domain);
+    host->domain = NULL;
 
-        GF_FREE (host);
+    GF_FREE(host);
 err:
-        return;
+    return;
 }
 
 /**
@@ -377,19 +380,19 @@ err:
  * Not for external use.
  */
 static struct netgroup_entry *
-_nge_dict_get (dict_t *dict, const char *ngname)
+_nge_dict_get(dict_t *dict, const char *ngname)
 {
-        data_t *ngdata = NULL;
+    data_t *ngdata = NULL;
 
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_NG, dict, err);
-        GF_VALIDATE_OR_GOTO (GF_NG, ngname, err);
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_NG, dict, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, ngname, err);
 
-        ngdata = dict_get (dict, (char *)ngname);
-        if (ngdata)
-                return (struct netgroup_entry *)ngdata->data;
+    ngdata = dict_get(dict, (char *)ngname);
+    if (ngdata)
+        return (struct netgroup_entry *)ngdata->data;
 err:
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -405,17 +408,17 @@ err:
  * Not for external use.
  */
 static void
-_nge_dict_insert (dict_t *dict, struct netgroup_entry *nge)
+_nge_dict_insert(dict_t *dict, struct netgroup_entry *nge)
 {
-        data_t *ngdata = NULL;
+    data_t *ngdata = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, dict, err);
-        GF_VALIDATE_OR_GOTO (GF_NG, nge, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, dict, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, nge, err);
 
-        ngdata = bin_to_data (nge, sizeof (*nge));
-        dict_set (dict, nge->netgroup_name, ngdata);
+    ngdata = bin_to_data(nge, sizeof(*nge));
+    dict_set(dict, nge->netgroup_name, ngdata);
 err:
-        return;
+    return;
 }
 
 /**
@@ -434,21 +437,21 @@ err:
  * Externally usable.
  */
 struct netgroup_host *
-ngh_dict_get (dict_t *dict, const char *hostname)
+ngh_dict_get(dict_t *dict, const char *hostname)
 {
-        data_t *ngdata = NULL;
+    data_t *ngdata = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, dict, err);
-        GF_VALIDATE_OR_GOTO (GF_NG, hostname, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, dict, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, hostname, err);
 
-        ngdata = dict_get (dict, (char *)hostname);
-        if (!ngdata)
-                goto err;
+    ngdata = dict_get(dict, (char *)hostname);
+    if (!ngdata)
+        goto err;
 
-        return (struct netgroup_host *)ngdata->data;
+    return (struct netgroup_host *)ngdata->data;
 
 err:
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -464,18 +467,18 @@ err:
  * Not for external use.
  */
 static void
-_ngh_dict_insert (dict_t *dict, struct netgroup_host *ngh)
+_ngh_dict_insert(dict_t *dict, struct netgroup_host *ngh)
 {
-        data_t *ngdata = NULL;
+    data_t *ngdata = NULL;
 
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_NG, dict, err);
-        GF_VALIDATE_OR_GOTO (GF_NG, ngh, err);
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_NG, dict, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, ngh, err);
 
-        ngdata = bin_to_data (ngh, sizeof (*ngh));
-        dict_set (dict, ngh->hostname, ngdata);
+    ngdata = bin_to_data(ngh, sizeof(*ngh));
+    dict_set(dict, ngh->hostname, ngdata);
 err:
-        return;
+    return;
 }
 
 /**
@@ -489,15 +492,15 @@ err:
  * Not for external use.
  */
 static void
-_ngh_print (const struct netgroup_host *ngh)
+_ngh_print(const struct netgroup_host *ngh)
 {
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_NG, ngh, err);
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_NG, ngh, err);
 
-        printf ("(%s,%s,%s)", ngh->hostname, ngh->user ? ngh->user : "",
-                ngh->domain ? ngh->domain : "");
+    printf("(%s,%s,%s)", ngh->hostname, ngh->user ? ngh->user : "",
+           ngh->domain ? ngh->domain : "");
 err:
-        return;
+    return;
 }
 
 /**
@@ -517,12 +520,12 @@ err:
  * Not for external use.
  */
 static int
-__nge_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__nge_print_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        if (val)
-                _nge_print ((struct netgroup_entry *)val->data);
+    if (val)
+        _nge_print((struct netgroup_entry *)val->data);
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -543,12 +546,12 @@ __nge_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static int
-__ngh_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__ngh_print_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        if (val)
-                _ngh_print ((struct netgroup_host *)val->data);
+    if (val)
+        _ngh_print((struct netgroup_host *)val->data);
 
-        return 0;
+    return 0;
 }
 
 /**
@@ -562,20 +565,20 @@ __ngh_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Not for external use.
  */
 static void
-_nge_print (const struct netgroup_entry *nge)
+_nge_print(const struct netgroup_entry *nge)
 {
-        /* Validate args */
-        GF_VALIDATE_OR_GOTO (GF_NG, nge, err);
+    /* Validate args */
+    GF_VALIDATE_OR_GOTO(GF_NG, nge, err);
 
-        printf ("%s ", nge->netgroup_name);
-        if (nge->netgroup_ngs)
-                dict_foreach (nge->netgroup_ngs, __nge_print_walk, NULL);
+    printf("%s ", nge->netgroup_name);
+    if (nge->netgroup_ngs)
+        dict_foreach(nge->netgroup_ngs, __nge_print_walk, NULL);
 
-        if (nge->netgroup_hosts)
-                dict_foreach (nge->netgroup_hosts, __ngh_print_walk, NULL);
+    if (nge->netgroup_hosts)
+        dict_foreach(nge->netgroup_hosts, __ngh_print_walk, NULL);
 
 err:
-        return;
+    return;
 }
 
 /**
@@ -596,16 +599,16 @@ err:
  * Not for external use.
  */
 static int
-__ngf_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
+__ngf_print_walk(dict_t *dict, char *key, data_t *val, void *tmp)
 {
-        struct netgroup_entry *snge = NULL;
-
-        if (val) {
-                snge = (struct netgroup_entry *)val->data;
-                _nge_print (snge);
-                printf ("\n");
-        }
-        return 0;
+    struct netgroup_entry *snge = NULL;
+
+    if (val) {
+        snge = (struct netgroup_entry *)val->data;
+        _nge_print(snge);
+        printf("\n");
+    }
+    return 0;
 }
 
 /**
@@ -625,9 +628,9 @@ __ngf_print_walk (dict_t *dict, char *key, data_t *val, void *tmp)
  * Can be called on any valid 'struct netgroups_file *' type.
  */
 void
-ng_file_print (const struct netgroups_file *ngfile)
+ng_file_print(const struct netgroups_file *ngfile)
 {
-     dict_foreach (ngfile->ng_file_dict, __ngf_print_walk, NULL);
+    dict_foreach(ngfile->ng_file_dict, __ngf_print_walk, NULL);
 }
 
 /**
@@ -646,22 +649,21 @@ ng_file_print (const struct netgroups_file *ngfile)
  * *' as the lookup key.
  */
 struct netgroup_entry *
-ng_file_get_netgroup (const struct netgroups_file *ngfile, const char *netgroup)
+ng_file_get_netgroup(const struct netgroups_file *ngfile, const char *netgroup)
 {
-        data_t *ndata = NULL;
+    data_t *ndata = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, ngfile, err);
-        GF_VALIDATE_OR_GOTO (GF_NG, netgroup, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, ngfile, err);
+    GF_VALIDATE_OR_GOTO(GF_NG, netgroup, err);
 
-        ndata = dict_get (ngfile->ng_file_dict,
-                          (char *)netgroup);
-        if (!ndata)
-                goto err;
+    ndata = dict_get(ngfile->ng_file_dict, (char *)netgroup);
+    if (!ndata)
+        goto err;
 
-        return (struct netgroup_entry *)ndata->data;
+    return (struct netgroup_entry *)ndata->data;
 
 err:
-        return NULL;
+    return NULL;
 }
 
 /**
@@ -679,30 +681,30 @@ err:
  * Not for external use.
  */
 static gf_boolean_t
-__check_host_entry_str (const char *host_str)
+__check_host_entry_str(const char *host_str)
 {
-        unsigned int comma_count = 0;
-        unsigned int i           = 0;
-        gf_boolean_t str_valid   = _gf_true;
+    unsigned int comma_count = 0;
+    unsigned int i = 0;
+    gf_boolean_t str_valid = _gf_true;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, host_str, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, host_str, out);
 
-        for (i = 0; i < strlen (host_str); i++) {
-                if (host_str[i] == ',')
-                        comma_count++;
+    for (i = 0; i < strlen(host_str); i++) {
+        if (host_str[i] == ',')
+            comma_count++;
 
-                /* Spaces are not allowed in this string. e.g, (a,b,c) is valid
-                 * but (a, b,c) is not.
-                 */
-                if (host_str[i] == ' ') {
-                        str_valid = _gf_false;
-                        goto out;
-                }
+        /* Spaces are not allowed in this string. e.g, (a,b,c) is valid
+         * but (a, b,c) is not.
+         */
+        if (host_str[i] == ' ') {
+            str_valid = _gf_false;
+            goto out;
         }
+    }
 
-        str_valid = (comma_count == 2);
+    str_valid = (comma_count == 2);
 out:
-        return str_valid;
+    return str_valid;
 }
 
 /**
@@ -718,66 +720,65 @@ out:
  * Not for external use.
  */
 static int
-_parse_ng_host (char *ng_str, struct netgroup_host **ngh)
+_parse_ng_host(char *ng_str, struct netgroup_host **ngh)
 {
-        struct netgroup_host *ng_host  = NULL;
-        unsigned int          parts    = 0;
-        char                 *match    = NULL;
-        int                   ret      = -EINVAL;
-
-        GF_VALIDATE_OR_GOTO (GF_NG, ng_str, out);
-        GF_VALIDATE_OR_GOTO (GF_NG, ngh, out);
-
-        if (!__check_host_entry_str (ng_str)) {
-                ret = 1; /* Parse failed */
-                goto out;
-        }
-
-        ret = parser_set_string (ng_host_parser, ng_str);
-        if (ret < 0)
-                goto out;
-
-        gf_msg_trace (GF_NG, 0, "parsing host string: %s", ng_str);
-
-        ng_host = _netgroup_host_init ();
-        GF_CHECK_ALLOC (ng_host, ret, free_and_out); /* Sets ret to -ENOMEM on
-                                                      * failure.
-                                                      */
-        while ((match = parser_get_next_match (ng_host_parser)) != NULL) {
-                gf_msg_trace (GF_NG, 0, "found match: %s (parts=%d)", match,
-                              parts);
-
-                switch (parts) {
-                case 0:
-                        ng_host->hostname = match;
-                        break;
-                case 1:
-                        ng_host->user = match;
-                        break;
-                case 2:
-                        ng_host->domain = match;
-                        break;
-                default:
-                        GF_FREE (match);
-                        break;
-                };
-
-                /* We only allow three parts in the host string;
-                 * The format for the string is (a,b,c)
-                 */
-                parts++;
-                if (parts > 2)
-                        break;
-        }
+    struct netgroup_host *ng_host = NULL;
+    unsigned int parts = 0;
+    char *match = NULL;
+    int ret = -EINVAL;
+
+    GF_VALIDATE_OR_GOTO(GF_NG, ng_str, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, ngh, out);
+
+    if (!__check_host_entry_str(ng_str)) {
+        ret = 1; /* Parse failed */
+        goto out;
+    }
+
+    ret = parser_set_string(ng_host_parser, ng_str);
+    if (ret < 0)
+        goto out;
+
+    gf_msg_trace(GF_NG, 0, "parsing host string: %s", ng_str);
+
+    ng_host = _netgroup_host_init();
+    GF_CHECK_ALLOC(ng_host, ret, free_and_out); /* Sets ret to -ENOMEM on
+                                                 * failure.
+                                                 */
+    while ((match = parser_get_next_match(ng_host_parser)) != NULL) {
+        gf_msg_trace(GF_NG, 0, "found match: %s (parts=%d)", match, parts);
+
+        switch (parts) {
+            case 0:
+                ng_host->hostname = match;
+                break;
+            case 1:
+                ng_host->user = match;
+                break;
+            case 2:
+                ng_host->domain = match;
+                break;
+            default:
+                GF_FREE(match);
+                break;
+        };
+
+        /* We only allow three parts in the host string;
+         * The format for the string is (a,b,c)
+         */
+        parts++;
+        if (parts > 2)
+            break;
+    }
 
-        /* Set the parameter */
-        *ngh = ng_host;
-        ret = 0;
+    /* Set the parameter */
+    *ngh = ng_host;
+    ret = 0;
 
 free_and_out:
-        parser_unset_string (ng_host_parser);
+    parser_unset_string(ng_host_parser);
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -796,50 +797,47 @@ out:
  * Not for external use.
  */
 static int
-_ng_handle_host_part (char *match, struct netgroup_entry *ngp)
+_ng_handle_host_part(char *match, struct netgroup_entry *ngp)
 {
-        struct netgroup_host *ngh = NULL;
-        int                   ret = -EINVAL;
-
-        GF_VALIDATE_OR_GOTO (GF_NG, match, out);
-        GF_VALIDATE_OR_GOTO (GF_NG, ngp, out);
-
-        if (!ngp->netgroup_name) {
-                gf_msg (GF_NG, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid: Line starts with hostname!");
-                goto out;
-        }
-
-        /* Parse the host string and get a struct for it */
-        ret = _parse_ng_host (match, &ngh);
-        if (ret < 0) {
-                gf_msg (GF_NG, GF_LOG_CRITICAL, -ret, NFS_MSG_PARSE_FAIL,
-                        "Critical error : %s", strerror (-ret));
-                goto out;
-        }
-        if (ret != 0) {
-                /* Cannot change to gf_msg
-                 * gf_msg not giving output to STDOUT
-                 * Bug id : BZ1215017
-                 */
-                gf_log (GF_NG, GF_LOG_WARNING,
-                        "Parse error for: %s", match);
-                goto out;
-        }
-
+    struct netgroup_host *ngh = NULL;
+    int ret = -EINVAL;
+
+    GF_VALIDATE_OR_GOTO(GF_NG, match, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, ngp, out);
+
+    if (!ngp->netgroup_name) {
+        gf_msg(GF_NG, GF_LOG_WARNING, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid: Line starts with hostname!");
+        goto out;
+    }
+
+    /* Parse the host string and get a struct for it */
+    ret = _parse_ng_host(match, &ngh);
+    if (ret < 0) {
+        gf_msg(GF_NG, GF_LOG_CRITICAL, -ret, NFS_MSG_PARSE_FAIL,
+               "Critical error : %s", strerror(-ret));
+        goto out;
+    }
+    if (ret != 0) {
+        /* Cannot change to gf_msg
+         * gf_msg not giving output to STDOUT
+         * Bug id : BZ1215017
+         */
+        gf_log(GF_NG, GF_LOG_WARNING, "Parse error for: %s", match);
+        goto out;
+    }
 
-        /* Make dict for the parent entry's netgroup hosts */
-        if (!ngp->netgroup_hosts) {
-                ngp->netgroup_hosts = dict_new ();
-                GF_CHECK_ALLOC (ngp->netgroup_hosts, ret,
-                                out);
-        }
+    /* Make dict for the parent entry's netgroup hosts */
+    if (!ngp->netgroup_hosts) {
+        ngp->netgroup_hosts = dict_new();
+        GF_CHECK_ALLOC(ngp->netgroup_hosts, ret, out);
+    }
 
-        /* Insert this entry into the parent netgroup dict */
-        _ngh_dict_insert (ngp->netgroup_hosts, ngh);
+    /* Insert this entry into the parent netgroup dict */
+    _ngh_dict_insert(ngp->netgroup_hosts, ngh);
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -861,29 +859,29 @@ out:
  * Not for external use.
  */
 static int
-_ng_setup_netgroup_entry (char *match, struct netgroups_file *file,
-                          struct netgroup_entry **ng_entry)
+_ng_setup_netgroup_entry(char *match, struct netgroups_file *file,
+                         struct netgroup_entry **ng_entry)
 {
-        struct netgroup_entry *nge           = NULL;
-        int                    ret           = -EINVAL;
+    struct netgroup_entry *nge = NULL;
+    int ret = -EINVAL;
 
-        GF_VALIDATE_OR_GOTO (GF_NG, match, out);
-        GF_VALIDATE_OR_GOTO (GF_NG, file, out);
-        GF_VALIDATE_OR_GOTO (GF_NG, ng_entry, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, match, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, file, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, ng_entry, out);
 
-        nge = _netgroup_entry_init ();
-        GF_CHECK_ALLOC (nge, ret, out);
+    nge = _netgroup_entry_init();
+    GF_CHECK_ALLOC(nge, ret, out);
 
-        nge->netgroup_name = match;
+    nge->netgroup_name = match;
 
-        /* Insert this new entry into the file dict */
-        _nge_dict_insert (file->ng_file_dict, nge);
+    /* Insert this new entry into the file dict */
+    _nge_dict_insert(file->ng_file_dict, nge);
 
-        *ng_entry = nge;
+    *ng_entry = nge;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -952,119 +950,118 @@ out:
  * Not for external use.
  */
 static int
-_parse_ng_line (char *ng_str, struct netgroups_file *file,
-                struct netgroup_entry **ng_entry)
+_parse_ng_line(char *ng_str, struct netgroups_file *file,
+               struct netgroup_entry **ng_entry)
 {
-        struct netgroup_entry  *ngp         = NULL; /* Parent netgroup entry */
-        struct netgroup_entry  *nge         = NULL; /* Generic netgroup entry */
-        char                   *match       = NULL;
-        int                     ret         = -EINVAL;
-        unsigned int            num_entries = 0;
-
-        /* Validate arguments */
-        GF_VALIDATE_OR_GOTO (GF_NG, ng_str, out);
-        GF_VALIDATE_OR_GOTO (GF_NG, file, out);
-
-        if (*ng_str == ' ' || *ng_str == '\0' || *ng_str == '\n') {
-                ret = 0;
-                goto out;
-        }
+    struct netgroup_entry *ngp = NULL; /* Parent netgroup entry */
+    struct netgroup_entry *nge = NULL; /* Generic netgroup entry */
+    char *match = NULL;
+    int ret = -EINVAL;
+    unsigned int num_entries = 0;
 
-        ret = parser_set_string (ng_file_parser, ng_str);
-        if (ret < 0)
-                goto out;
+    /* Validate arguments */
+    GF_VALIDATE_OR_GOTO(GF_NG, ng_str, out);
+    GF_VALIDATE_OR_GOTO(GF_NG, file, out);
 
-        /* This is the first name in the line, and should be the
-         * parent netgroup entry.
-         */
-        match = parser_get_next_match (ng_file_parser);
-        if (!match) {
-                ret = 1;
-                gf_msg (GF_NG, GF_LOG_WARNING, 0,
-                        NFS_MSG_FIND_FIRST_MATCH_FAIL, "Unable to find "
-                        "first match.");
-                gf_msg (GF_NG, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL,
-                        "Error parsing str: %s", ng_str);
-                goto out;
+    if (*ng_str == ' ' || *ng_str == '\0' || *ng_str == '\n') {
+        ret = 0;
+        goto out;
+    }
+
+    ret = parser_set_string(ng_file_parser, ng_str);
+    if (ret < 0)
+        goto out;
+
+    /* This is the first name in the line, and should be the
+     * parent netgroup entry.
+     */
+    match = parser_get_next_match(ng_file_parser);
+    if (!match) {
+        ret = 1;
+        gf_msg(GF_NG, GF_LOG_WARNING, 0, NFS_MSG_FIND_FIRST_MATCH_FAIL,
+               "Unable to find "
+               "first match.");
+        gf_msg(GF_NG, GF_LOG_WARNING, 0, NFS_MSG_PARSE_FAIL,
+               "Error parsing str: %s", ng_str);
+        goto out;
+    }
+
+    /* Lookup to see if the match already exists,
+     * if not, set the parent.
+     */
+    ngp = _nge_dict_get(file->ng_file_dict, match);
+    if (!ngp) {
+        ret = _ng_setup_netgroup_entry(match, file, &ngp);
+        if (ret < 0) {
+            /* Bubble up error to caller. We don't need to free ngp
+             * here because this can only fail if allocating the
+             * struct fails.
+             */
+            goto out;
         }
+    } else
+        GF_FREE(match);
 
-        /* Lookup to see if the match already exists,
-         * if not, set the parent.
+    if (!ngp->netgroup_ngs) {
+        /* If a netgroup dict has not been allocated
+         * for this parent, allocate it.
          */
-        ngp = _nge_dict_get (file->ng_file_dict, match);
-        if (!ngp) {
-                ret = _ng_setup_netgroup_entry (match, file, &ngp);
+        ngp->netgroup_ngs = dict_new();
+        GF_CHECK_ALLOC(ngp->netgroup_ngs, ret, out);
+        /* No need to free anything here since ngp is already
+         * a part of the file. When the file gets
+         * deallocated, we will free ngp.
+         */
+    }
+
+    while ((match = parser_get_next_match(ng_file_parser)) != NULL) {
+        num_entries++;
+        /* This means that we hit a host entry in the line */
+        if (*match == '(') {
+            ret = _ng_handle_host_part(match, ngp);
+            GF_FREE(match);
+            if (ret != 0) {
+                /* If parsing the host fails, bubble the error
+                 * code up to the caller.
+                 */
+                goto out;
+            }
+        } else {
+            nge = _nge_dict_get(file->ng_file_dict, match);
+            if (!nge) {
+                ret = _ng_setup_netgroup_entry(match, file, &nge);
                 if (ret < 0) {
-                        /* Bubble up error to caller. We don't need to free ngp
-                         * here because this can only fail if allocating the
-                         * struct fails.
-                         */
-                        goto out;
+                    /* Bubble up error to caller. We don't
+                     * need to free nge here because this
+                     * can only fail if allocating the
+                     * struct fails.
+                     */
+                    goto out;
                 }
-        } else
-                GF_FREE (match);
+            } else
+                GF_FREE(match);
 
-        if (!ngp->netgroup_ngs) {
-                /* If a netgroup dict has not been allocated
-                 * for this parent, allocate it.
-                 */
-                ngp->netgroup_ngs = dict_new ();
-                GF_CHECK_ALLOC (ngp->netgroup_ngs, ret, out);
-                /* No need to free anything here since ngp is already
-                 * a part of the file. When the file gets
-                 * deallocated, we will free ngp.
-                 */
-        }
-
-        while ((match = parser_get_next_match (ng_file_parser)) != NULL) {
-                num_entries++;
-                /* This means that we hit a host entry in the line */
-                if (*match == '(') {
-                        ret = _ng_handle_host_part (match, ngp);
-                        GF_FREE (match);
-                        if (ret != 0) {
-                                /* If parsing the host fails, bubble the error
-                                 * code up to the caller.
-                                 */
-                                goto out;
-                        }
-                } else {
-                        nge = _nge_dict_get (file->ng_file_dict, match);
-                        if (!nge) {
-                                ret = _ng_setup_netgroup_entry (match, file,
-                                                                &nge);
-                                if (ret < 0) {
-                                        /* Bubble up error to caller. We don't
-                                         * need to free nge here because this
-                                         * can only fail if allocating the
-                                         * struct fails.
-                                         */
-                                        goto out;
-                                }
-                        } else
-                                GF_FREE (match);
-
-                        /* Insert the netgroup into the parent's dict */
-                        _nge_dict_insert (ngp->netgroup_ngs, nge);
-                }
+            /* Insert the netgroup into the parent's dict */
+            _nge_dict_insert(ngp->netgroup_ngs, nge);
         }
+    }
 
-        /* If there are no entries on the RHS, log an error, but continue */
-        if (!num_entries) {
-                /* Cannot change to gf_msg
-                 * gf_msg not giving output to STDOUT
-                 * Bug id : BZ1215017
-                 */
-                gf_log (GF_NG, GF_LOG_WARNING,
-                        "No netgroups were specified except for the parent.");
-        }
+    /* If there are no entries on the RHS, log an error, but continue */
+    if (!num_entries) {
+        /* Cannot change to gf_msg
+         * gf_msg not giving output to STDOUT
+         * Bug id : BZ1215017
+         */
+        gf_log(GF_NG, GF_LOG_WARNING,
+               "No netgroups were specified except for the parent.");
+    }
 
-        *ng_entry = ngp;
-        ret = 0;
+    *ng_entry = ngp;
+    ret = 0;
 
 out:
-        parser_unset_string (ng_file_parser);
-        return ret;
+    parser_unset_string(ng_file_parser);
+    return ret;
 }
 
 /**
@@ -1082,84 +1079,83 @@ out:
  * Externally facing function
  */
 struct netgroups_file *
-ng_file_parse (const char *filepath)
+ng_file_parse(const char *filepath)
 {
-        FILE                  *fp    = NULL;
-        size_t                 len   = 0;
-        size_t                 read  = 0;
-        char                  *line  = NULL;
-        struct netgroups_file *file  = NULL;
-        struct netgroup_entry *nge   = NULL;
-        int                    ret   = 0;
-
-        GF_VALIDATE_OR_GOTO (GF_NG, filepath, err);
-
-        fp = fopen (filepath, "r");
-        if (!fp)
-                goto err;
-
-        file = _netgroups_file_init ();
-        if (!file)
-                goto err;
-
-        file->ng_file_dict = dict_new ();
-        if (!file->ng_file_dict) {
-                gf_msg (GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate netgroup file dict");
-                goto err;
-        }
-
-        file->filename = gf_strdup (filepath);
-        if (!file->filename) {
-                gf_msg (GF_NG, GF_LOG_CRITICAL, errno, NFS_MSG_FILE_OP_FAILED,
-                        "Failed to duplicate filename");
-                goto err;
+    FILE *fp = NULL;
+    size_t len = 0;
+    size_t read = 0;
+    char *line = NULL;
+    struct netgroups_file *file = NULL;
+    struct netgroup_entry *nge = NULL;
+    int ret = 0;
+
+    GF_VALIDATE_OR_GOTO(GF_NG, filepath, err);
+
+    fp = fopen(filepath, "r");
+    if (!fp)
+        goto err;
+
+    file = _netgroups_file_init();
+    if (!file)
+        goto err;
+
+    file->ng_file_dict = dict_new();
+    if (!file->ng_file_dict) {
+        gf_msg(GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate netgroup file dict");
+        goto err;
+    }
+
+    file->filename = gf_strdup(filepath);
+    if (!file->filename) {
+        gf_msg(GF_NG, GF_LOG_CRITICAL, errno, NFS_MSG_FILE_OP_FAILED,
+               "Failed to duplicate filename");
+        goto err;
+    }
+
+    ret = _ng_init_parsers();
+    if (ret < 0)
+        goto err;
+
+    /* Read the file line-by-line and parse it */
+    while ((read = getline(&line, &len, fp)) != -1) {
+        if (*line == '#') /* Lines starting with # are comments */
+            continue;
+
+        /* Parse the line into a netgroup entry */
+        ret = _parse_ng_line(line, file, &nge);
+        if (ret == -ENOMEM) {
+            gf_msg(GF_NG, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "Allocation error "
+                   "while parsing line!");
+            goto err;
         }
-
-        ret = _ng_init_parsers ();
-        if (ret < 0)
-                goto err;
-
-        /* Read the file line-by-line and parse it */
-        while ((read = getline (&line, &len, fp)) != -1) {
-                if (*line == '#') /* Lines starting with # are comments */
-                        continue;
-
-                /* Parse the line into a netgroup entry */
-                ret = _parse_ng_line (line, file, &nge);
-                if (ret == -ENOMEM) {
-                        gf_msg (GF_NG, GF_LOG_CRITICAL, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "Allocation error "
-                                "while parsing line!");
-                        goto err;
-                }
-                if (ret != 0) {
-                        gf_msg_debug (GF_NG, 0, "Failed to parse line %s",
-                                      line);
-                        continue;
-                }
+        if (ret != 0) {
+            gf_msg_debug(GF_NG, 0, "Failed to parse line %s", line);
+            continue;
         }
+    }
 
-        /* line got allocated through getline(), don't use GF_FREE() for it */
-        free (line);
+    /* line got allocated through getline(), don't use GF_FREE() for it */
+    free(line);
 
-        if (fp)
-                fclose(fp);
+    if (fp)
+        fclose(fp);
 
-        _ng_deinit_parsers ();
+    _ng_deinit_parsers();
 
-        return file;
+    return file;
 
 err:
-        if (line)
-                free(line);
+    if (line)
+        free(line);
 
-        if (file)
-                ng_file_deinit (file);
+    if (file)
+        ng_file_deinit(file);
 
-        _ng_deinit_parsers ();
+    _ng_deinit_parsers();
 
-        if (fp)
-                fclose (fp);
-        return NULL;
+    if (fp)
+        fclose(fp);
+    return NULL;
 }
diff --git a/xlators/nfs/server/src/nfs-common.c b/xlators/nfs/server/src/nfs-common.c
index 2f742d44366..2e8d401ba52 100644
--- a/xlators/nfs/server/src/nfs-common.c
+++ b/xlators/nfs/server/src/nfs-common.c
@@ -24,293 +24,285 @@
 #include <libgen.h>
 
 xlator_t *
-nfs_xlid_to_xlator (xlator_list_t *cl, uint8_t xlid)
+nfs_xlid_to_xlator(xlator_list_t *cl, uint8_t xlid)
 {
-        xlator_t        *xl = NULL;
-        uint8_t         id = 0;
-
-        while (id <= xlid) {
-                if (!cl) {
-                        xl = NULL;
-                        break;
-                }
-
-                xl = cl->xlator;
-                cl = cl->next;
-                id++;
+    xlator_t *xl = NULL;
+    uint8_t id = 0;
+
+    while (id <= xlid) {
+        if (!cl) {
+            xl = NULL;
+            break;
         }
 
-        return xl;
-}
+        xl = cl->xlator;
+        cl = cl->next;
+        id++;
+    }
 
+    return xl;
+}
 
 xlator_t *
-nfs_path_to_xlator (xlator_list_t *cl, char *path)
+nfs_path_to_xlator(xlator_list_t *cl, char *path)
 {
-        return NULL;
+    return NULL;
 }
 
-
 uint16_t
-nfs_xlator_to_xlid (xlator_list_t *cl, xlator_t *xl)
+nfs_xlator_to_xlid(xlator_list_t *cl, xlator_t *xl)
 {
-        uint16_t        xlid = 0;
+    uint16_t xlid = 0;
 
-        if ((!cl) || (!xl))
-                return 0;
+    if ((!cl) || (!xl))
+        return 0;
 
-        while (cl) {
-                if (xl == cl->xlator)
-                        break;
-                cl = cl->next;
-                ++xlid;
-        }
+    while (cl) {
+        if (xl == cl->xlator)
+            break;
+        cl = cl->next;
+        ++xlid;
+    }
 
-        return xlid;
+    return xlid;
 }
 
-
 xlator_t *
-nfs_mntpath_to_xlator (xlator_list_t *cl, char *path)
+nfs_mntpath_to_xlator(xlator_list_t *cl, char *path)
 {
-        char            *volname  = NULL; /* volume name only */
-        char            *volptr   = NULL; /* ptr to original volname */
-        size_t           pathlen  = -1;
-        xlator_t        *targetxl = NULL;
-        int              i        = 0;
-
-        if ((!cl) || (!path))
-                return NULL;
-
-        gf_msg_trace (GF_NFS, 0, "Subvolume search: %s", path);
-
-        volname = volptr = gf_strdup (path);
-        if (!volname)
-                return NULL;
-
-        if (volname[0] == '/')
-                volname++;
-
-        pathlen = strlen (volname);
-        for (i = 0; i < pathlen; i++) {
-                if (volname[i] == '/') {
-                        volname[i] = '\0';
-                        break;
-                }
-        }
+    char *volname = NULL; /* volume name only */
+    char *volptr = NULL;  /* ptr to original volname */
+    size_t pathlen = -1;
+    xlator_t *targetxl = NULL;
+    int i = 0;
 
-        while (cl) {
-                gf_msg_trace (GF_NFS, 0, "Volname: %s and cl->xlator->name: %s",
-                              volname, cl->xlator->name);
+    if ((!cl) || (!path))
+        return NULL;
 
-                if (strcmp (volname, cl->xlator->name) == 0) {
-                        targetxl = cl->xlator;
-                        break;
-                }
+    gf_msg_trace(GF_NFS, 0, "Subvolume search: %s", path);
 
-                cl = cl->next;
+    volname = volptr = gf_strdup(path);
+    if (!volname)
+        return NULL;
+
+    if (volname[0] == '/')
+        volname++;
+
+    pathlen = strlen(volname);
+    for (i = 0; i < pathlen; i++) {
+        if (volname[i] == '/') {
+            volname[i] = '\0';
+            break;
         }
+    }
 
-        GF_FREE (volptr);
+    while (cl) {
+        gf_msg_trace(GF_NFS, 0, "Volname: %s and cl->xlator->name: %s", volname,
+                     cl->xlator->name);
 
-        return targetxl;
-}
+        if (strcmp(volname, cl->xlator->name) == 0) {
+            targetxl = cl->xlator;
+            break;
+        }
+
+        cl = cl->next;
+    }
 
+    GF_FREE(volptr);
+
+    return targetxl;
+}
 
 void
-nfs_loc_wipe (loc_t *loc)
+nfs_loc_wipe(loc_t *loc)
 {
-        loc_wipe (loc);
+    loc_wipe(loc);
 }
 
-
 int
-nfs_loc_copy (loc_t *dst, loc_t *src)
+nfs_loc_copy(loc_t *dst, loc_t *src)
 {
-        int  ret = -1;
+    int ret = -1;
 
-        ret = loc_copy (dst, src);
+    ret = loc_copy(dst, src);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path)
+nfs_loc_fill(loc_t *loc, inode_t *inode, inode_t *parent, char *path)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if (!loc)
-                return ret;
-
-        if (inode) {
-                loc->inode = inode_ref (inode);
-                if (!gf_uuid_is_null (inode->gfid))
-                        gf_uuid_copy (loc->gfid, inode->gfid);
-        }
+    if (!loc)
+        return ret;
 
-        if (parent)
-                loc->parent = inode_ref (parent);
-
-        if (path) {
-                loc->path = gf_strdup (path);
-                if (!loc->path) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "strdup failed");
-                        goto loc_wipe;
-                }
-                loc->name = strrchr (loc->path, '/');
-                if (loc->name)
-                        loc->name++;
+    if (inode) {
+        loc->inode = inode_ref(inode);
+        if (!gf_uuid_is_null(inode->gfid))
+            gf_uuid_copy(loc->gfid, inode->gfid);
+    }
+
+    if (parent)
+        loc->parent = inode_ref(parent);
+
+    if (path) {
+        loc->path = gf_strdup(path);
+        if (!loc->path) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "strdup failed");
+            goto loc_wipe;
         }
+        loc->name = strrchr(loc->path, '/');
+        if (loc->name)
+            loc->name++;
+    }
 
-        ret = 0;
+    ret = 0;
 loc_wipe:
-        if (ret < 0)
-                nfs_loc_wipe (loc);
+    if (ret < 0)
+        nfs_loc_wipe(loc);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_inode_loc_fill (inode_t *inode, loc_t *loc, int how)
+nfs_inode_loc_fill(inode_t *inode, loc_t *loc, int how)
 {
-        char            *resolvedpath = NULL;
-        inode_t         *parent = NULL;
-        int             ret = -EFAULT;
-
-        if ((!inode) || (!loc))
-                return ret;
-
-        /* If gfid is not null, then the inode is already linked to
-         * the inode table, and not a newly created one. For newly
-         * created inode, inode_path returns null gfid as the path.
-         */
-        if (!gf_uuid_is_null (inode->gfid)) {
-                ret = inode_path (inode, NULL, &resolvedpath);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_PATH_RESOLVE_FAIL, "path resolution "
-                                "failed %s", resolvedpath);
-                        goto err;
-                }
-        }
+    char *resolvedpath = NULL;
+    inode_t *parent = NULL;
+    int ret = -EFAULT;
 
-        if (resolvedpath == NULL) {
-                char tmp_path[GFID_STR_PFX_LEN + 1] = {0,};
-                snprintf (tmp_path, sizeof (tmp_path), "<gfid:%s>",
-                          uuid_utoa (loc->gfid));
-                resolvedpath = gf_strdup (tmp_path);
-        } else {
-                parent = inode_parent (inode, loc->pargfid, NULL);
-        }
+    if ((!inode) || (!loc))
+        return ret;
 
-        ret = nfs_loc_fill (loc, inode, parent, resolvedpath);
+    /* If gfid is not null, then the inode is already linked to
+     * the inode table, and not a newly created one. For newly
+     * created inode, inode_path returns null gfid as the path.
+     */
+    if (!gf_uuid_is_null(inode->gfid)) {
+        ret = inode_path(inode, NULL, &resolvedpath);
         if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
-                        NFS_MSG_LOC_FILL_RESOLVE_FAIL,
-                        "loc fill resolution failed %s", resolvedpath);
-                goto err;
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PATH_RESOLVE_FAIL,
+                   "path resolution "
+                   "failed %s",
+                   resolvedpath);
+            goto err;
         }
-
-        ret = 0;
+    }
+
+    if (resolvedpath == NULL) {
+        char tmp_path[GFID_STR_PFX_LEN + 1] = {
+            0,
+        };
+        snprintf(tmp_path, sizeof(tmp_path), "<gfid:%s>", uuid_utoa(loc->gfid));
+        resolvedpath = gf_strdup(tmp_path);
+    } else {
+        parent = inode_parent(inode, loc->pargfid, NULL);
+    }
+
+    ret = nfs_loc_fill(loc, inode, parent, resolvedpath);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_LOC_FILL_RESOLVE_FAIL,
+               "loc fill resolution failed %s", resolvedpath);
+        goto err;
+    }
+
+    ret = 0;
 err:
-        if (parent)
-                inode_unref (parent);
+    if (parent)
+        inode_unref(parent);
 
-        GF_FREE (resolvedpath);
+    GF_FREE(resolvedpath);
 
-        return ret;
+    return ret;
 }
 
 int
-nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc, int how)
+nfs_gfid_loc_fill(inode_table_t *itable, uuid_t gfid, loc_t *loc, int how)
 {
-        int             ret = -EFAULT;
-        inode_t         *inode = NULL;
-
-        if (!loc)
-                return ret;
-
-        inode = inode_find (itable, gfid);
-        if (!inode) {
-		gf_msg_trace (GF_NFS, 0, "Inode not found in itable, will "
-                              "try to create one.");
-                if (how == NFS_RESOLVE_CREATE) {
-			gf_msg_trace (GF_NFS, 0, "Inode needs to be created.");
-                        inode = inode_new (itable);
-                        if (!inode) {
-                                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM,
-                                        NFS_MSG_NO_MEMORY, "Failed to "
-                                        "allocate memory");
-                                ret = -ENOMEM;
-                                goto err;
-                        }
-
-                } else {
-			gf_msg (GF_NFS, GF_LOG_ERROR, ENOENT,
-                                NFS_MSG_INODE_NOT_FOUND, "Inode not found in "
-                                "itable and no creation was requested.");
-                        ret = -ENOENT;
-                        goto err;
-                }
+    int ret = -EFAULT;
+    inode_t *inode = NULL;
+
+    if (!loc)
+        return ret;
+
+    inode = inode_find(itable, gfid);
+    if (!inode) {
+        gf_msg_trace(GF_NFS, 0,
+                     "Inode not found in itable, will "
+                     "try to create one.");
+        if (how == NFS_RESOLVE_CREATE) {
+            gf_msg_trace(GF_NFS, 0, "Inode needs to be created.");
+            inode = inode_new(itable);
+            if (!inode) {
+                gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                       "Failed to "
+                       "allocate memory");
+                ret = -ENOMEM;
+                goto err;
+            }
+
         } else {
-		gf_msg_trace (GF_NFS, 0, "Inode was found in the itable.");
-	}
+            gf_msg(GF_NFS, GF_LOG_ERROR, ENOENT, NFS_MSG_INODE_NOT_FOUND,
+                   "Inode not found in "
+                   "itable and no creation was requested.");
+            ret = -ENOENT;
+            goto err;
+        }
+    } else {
+        gf_msg_trace(GF_NFS, 0, "Inode was found in the itable.");
+    }
 
-        gf_uuid_copy (loc->gfid, gfid);
+    gf_uuid_copy(loc->gfid, gfid);
 
-        ret = nfs_inode_loc_fill (inode, loc, how);
-	if (ret < 0) {
-		gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
-                        NFS_MSG_INODE_LOC_FILL_ERROR,
-                        "Inode loc filling failed.: %s", strerror (-ret));
-		goto err;
-	}
+    ret = nfs_inode_loc_fill(inode, loc, how);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR,
+               "Inode loc filling failed.: %s", strerror(-ret));
+        goto err;
+    }
 
 err:
-        if (inode)
-                inode_unref (inode);
-        return ret;
+    if (inode)
+        inode_unref(inode);
+    return ret;
 }
 
-
 int
-nfs_root_loc_fill (inode_table_t *itable, loc_t *loc)
+nfs_root_loc_fill(inode_table_t *itable, loc_t *loc)
 {
-        uuid_t  rootgfid = {0, };
+    uuid_t rootgfid = {
+        0,
+    };
 
-        rootgfid[15] = 1;
-        return nfs_gfid_loc_fill (itable, rootgfid, loc, NFS_RESOLVE_EXIST);
+    rootgfid[15] = 1;
+    return nfs_gfid_loc_fill(itable, rootgfid, loc, NFS_RESOLVE_EXIST);
 }
 
-
-
 int
-nfs_parent_inode_loc_fill (inode_t *parent, inode_t *entryinode, char *entry,
-                           loc_t *loc)
+nfs_parent_inode_loc_fill(inode_t *parent, inode_t *entryinode, char *entry,
+                          loc_t *loc)
 {
-        int             ret = -EFAULT;
-        char            *path = NULL;
+    int ret = -EFAULT;
+    char *path = NULL;
 
-        if ((!parent) || (!entry) || (!loc) || (!entryinode))
-                return ret;
+    if ((!parent) || (!entry) || (!loc) || (!entryinode))
+        return ret;
 
-        ret = inode_path (parent, entry, &path);
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL,
-                        "path resolution failed %s", path);
-                goto err;
-        }
+    ret = inode_path(parent, entry, &path);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL,
+               "path resolution failed %s", path);
+        goto err;
+    }
 
-        ret = nfs_loc_fill (loc, entryinode, parent, path);
-        GF_FREE (path);
+    ret = nfs_loc_fill(loc, entryinode, parent, path);
+    GF_FREE(path);
 err:
-        return ret;
+    return ret;
 }
 
-
 /* Returns -1 if parent is not available, return -2 if the entry is not
  * available. In case the return is going to be -2, and how = NFS_RESOLVE_CREATE
  * it does however fill in the loc so that it can be used to perform a lookup
@@ -318,151 +310,144 @@ err:
  * On other errors, return -3. 0 on success.
  */
 int
-nfs_entry_loc_fill (xlator_t *this, inode_table_t *itable, uuid_t pargfid,
-                    char *entry, loc_t *loc, int how, gf_boolean_t *freshlookup)
+nfs_entry_loc_fill(xlator_t *this, inode_table_t *itable, uuid_t pargfid,
+                   char *entry, loc_t *loc, int how, gf_boolean_t *freshlookup)
 {
-        inode_t         *parent = NULL;
-        inode_t         *entryinode = NULL;
-        int             ret = -3;
-        char            *resolvedpath = NULL;
-        int             pret = -3;
-
-        if ((!itable) || (!entry) || (!loc))
-                return ret;
+    inode_t *parent = NULL;
+    inode_t *entryinode = NULL;
+    int ret = -3;
+    char *resolvedpath = NULL;
+    int pret = -3;
 
-        parent = inode_find (itable, pargfid);
-
-        ret = -1;
-        /* Will need hard resolution now */
-        if (!parent || inode_ctx_get (parent, this, NULL))
-                goto err;
-
-        gf_uuid_copy (loc->pargfid, pargfid);
-
-        ret = -2;
-        entryinode = inode_grep (itable, parent, entry);
-        if (!entryinode || inode_ctx_get (entryinode, this, NULL)) {
-                if (how == NFS_RESOLVE_CREATE) {
-                        /* Even though we'll create the inode and the loc for
-                         * a missing inode, we still need to return -2 so
-                         * that the caller can use the filled loc to call
-                         * lookup.
-                         */
-                        if (!entryinode) {
-                                entryinode = inode_new (itable);
-                                if (freshlookup)
-                                        *freshlookup = _gf_true;
-                        }
-                        /* Cannot change ret because that must
-                         * continue to have -2.
-                         */
-                        pret = nfs_parent_inode_loc_fill (parent, entryinode,
-                                                          entry, loc);
-                        /* Only if parent loc fill fails, should we notify error
-                         * through ret, otherwise, we still need to force a
-                         * lookup by returning -2.
-                         */
-                        if (pret < 0)
-			         ret = -3;
-                }
-                goto err;
-        }
-
-        ret = inode_path (parent, entry, &resolvedpath);
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL,
-                        "path resolution failed %s", resolvedpath);
-                ret = -3;
-                goto err;
-        }
+    if ((!itable) || (!entry) || (!loc))
+        return ret;
 
-        ret = nfs_loc_fill (loc, entryinode, parent, resolvedpath);
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INODE_LOC_FILL_ERROR,
-                        "loc_fill failed %s", resolvedpath);
+    parent = inode_find(itable, pargfid);
+
+    ret = -1;
+    /* Will need hard resolution now */
+    if (!parent || inode_ctx_get(parent, this, NULL))
+        goto err;
+
+    gf_uuid_copy(loc->pargfid, pargfid);
+
+    ret = -2;
+    entryinode = inode_grep(itable, parent, entry);
+    if (!entryinode || inode_ctx_get(entryinode, this, NULL)) {
+        if (how == NFS_RESOLVE_CREATE) {
+            /* Even though we'll create the inode and the loc for
+             * a missing inode, we still need to return -2 so
+             * that the caller can use the filled loc to call
+             * lookup.
+             */
+            if (!entryinode) {
+                entryinode = inode_new(itable);
+                if (freshlookup)
+                    *freshlookup = _gf_true;
+            }
+            /* Cannot change ret because that must
+             * continue to have -2.
+             */
+            pret = nfs_parent_inode_loc_fill(parent, entryinode, entry, loc);
+            /* Only if parent loc fill fails, should we notify error
+             * through ret, otherwise, we still need to force a
+             * lookup by returning -2.
+             */
+            if (pret < 0)
                 ret = -3;
         }
+        goto err;
+    }
+
+    ret = inode_path(parent, entry, &resolvedpath);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PATH_RESOLVE_FAIL,
+               "path resolution failed %s", resolvedpath);
+        ret = -3;
+        goto err;
+    }
+
+    ret = nfs_loc_fill(loc, entryinode, parent, resolvedpath);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INODE_LOC_FILL_ERROR,
+               "loc_fill failed %s", resolvedpath);
+        ret = -3;
+    }
 
 err:
-        if (parent)
-                inode_unref (parent);
+    if (parent)
+        inode_unref(parent);
 
-        if (entryinode)
-                inode_unref (entryinode);
+    if (entryinode)
+        inode_unref(entryinode);
 
-        GF_FREE (resolvedpath);
+    GF_FREE(resolvedpath);
 
-        return ret;
+    return ret;
 }
 
-
 uint32_t
-nfs_hash_gfid (uuid_t gfid)
+nfs_hash_gfid(uuid_t gfid)
 {
-        uint32_t                hash = 0;
-        uint64_t                msb64 = 0;
-        uint64_t                lsb64 = 0;
-        uint32_t                a1 = 0;
-        uint32_t                a2 = 0;
-        uint32_t                a3 = 0;
-        uint32_t                a4 = 0;
-        uint32_t                b1 = 0;
-        uint32_t                b2 = 0;
+    uint32_t hash = 0;
+    uint64_t msb64 = 0;
+    uint64_t lsb64 = 0;
+    uint32_t a1 = 0;
+    uint32_t a2 = 0;
+    uint32_t a3 = 0;
+    uint32_t a4 = 0;
+    uint32_t b1 = 0;
+    uint32_t b2 = 0;
 
-        if (__is_root_gfid (gfid))
-                return 0x1;
+    if (__is_root_gfid(gfid))
+        return 0x1;
 
-        memcpy (&msb64, &gfid[8], 8);
-        memcpy (&lsb64, &gfid[0], 8);
+    memcpy(&msb64, &gfid[8], 8);
+    memcpy(&lsb64, &gfid[0], 8);
 
-        a1 = (msb64 << 32);
-        a2 = (msb64 >> 32);
-        a3 = (lsb64 << 32);
-        a4 = (lsb64 >> 32);
+    a1 = (msb64 << 32);
+    a2 = (msb64 >> 32);
+    a3 = (lsb64 << 32);
+    a4 = (lsb64 >> 32);
 
-        b1 = a1 ^ a4;
-        b2 = a2 ^ a3;
+    b1 = a1 ^ a4;
+    b2 = a2 ^ a3;
 
-        hash = b1 ^ b2;
+    hash = b1 ^ b2;
 
-        return hash;
+    return hash;
 }
 
-
 void
-nfs_fix_generation (xlator_t *this, inode_t *inode)
+nfs_fix_generation(xlator_t *this, inode_t *inode)
 {
-        uint64_t                 raw_ctx        = 0;
-        struct nfs_inode_ctx    *ictx           = NULL;
-        struct nfs_state        *priv           = NULL;
-        int                      ret            = -1;
-
-        if (!inode) {
-                return;
-        }
-        priv = this->private;
-
-        if (inode_ctx_get(inode,this,&raw_ctx) == 0) {
-                ictx = (struct nfs_inode_ctx *)raw_ctx;
-                ictx->generation = priv->generation;
+    uint64_t raw_ctx = 0;
+    struct nfs_inode_ctx *ictx = NULL;
+    struct nfs_state *priv = NULL;
+    int ret = -1;
+
+    if (!inode) {
+        return;
+    }
+    priv = this->private;
+
+    if (inode_ctx_get(inode, this, &raw_ctx) == 0) {
+        ictx = (struct nfs_inode_ctx *)raw_ctx;
+        ictx->generation = priv->generation;
+    } else {
+        ictx = GF_CALLOC(1, sizeof(struct nfs_inode_ctx), gf_nfs_mt_inode_ctx);
+        if (!ictx) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "could not allocate nfs inode ctx");
+            return;
         }
-        else {
-                ictx = GF_CALLOC (1, sizeof (struct nfs_inode_ctx),
-                                  gf_nfs_mt_inode_ctx);
-                if (!ictx) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "could not allocate nfs inode ctx");
-                        return;
-                }
-                INIT_LIST_HEAD(&ictx->shares);
-                ictx->generation = priv->generation;
-                ret = inode_ctx_put (inode, this, (uint64_t)ictx);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                NFS_MSG_INODE_CTX_STORE_FAIL,
-                                "could not store nfs inode ctx");
-                        return;
-                }
+        INIT_LIST_HEAD(&ictx->shares);
+        ictx->generation = priv->generation;
+        ret = inode_ctx_put(inode, this, (uint64_t)ictx);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_INODE_CTX_STORE_FAIL,
+                   "could not store nfs inode ctx");
+            return;
         }
+    }
 }
diff --git a/xlators/nfs/server/src/nfs-fops.c b/xlators/nfs/server/src/nfs-fops.c
index 44141001361..9abb2ac4eeb 100644
--- a/xlators/nfs/server/src/nfs-fops.c
+++ b/xlators/nfs/server/src/nfs-fops.c
@@ -26,355 +26,345 @@
 static int gf_auth_max_groups_nfs_log = 0;
 
 void
-nfs_fix_groups (xlator_t *this, call_stack_t *root)
+nfs_fix_groups(xlator_t *this, call_stack_t *root)
 {
-        struct passwd    mypw;
-        char             mystrs[1024];
-        struct passwd    *result;
-        gid_t            *mygroups;
-        int              ngroups;
-        int              i;
-        int              max_groups;
-        struct nfs_state *priv = this->private;
-        const gid_list_t *agl;
-        gid_list_t gl;
-
-        if (!priv->server_aux_gids) {
-                return;
-        }
-
-        /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */
-        max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len,
-                                                  AUTH_GLUSTERFS_v2);
-
-	agl = gid_cache_lookup(&priv->gid_cache, root->uid, 0, 0);
-	if (agl) {
-		if (agl->gl_count > max_groups) {
-			GF_LOG_OCCASIONALLY (gf_auth_max_groups_nfs_log,
-					this->name, GF_LOG_WARNING,
-					"too many groups, reducing %d -> %d",
-					agl->gl_count, max_groups);
-		}
-
-		for (ngroups = 0; ngroups < agl->gl_count
-				&& ngroups <= max_groups; ngroups++) {
-			root->groups[ngroups] = agl->gl_list[ngroups];
-		}
-		root->ngrps = ngroups;
-		gid_cache_release(&priv->gid_cache, agl);
-		return;
-	}
-
-	/* No cached list found. */
-        if (getpwuid_r(root->uid,&mypw,mystrs,sizeof(mystrs),&result) != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL,
-                        "getpwuid_r(%u) failed", root->uid);
-                return;
-        }
-
-        if (!result) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL,
-                        "getpwuid_r(%u) found nothing", root->uid);
-                return;
+    struct passwd mypw;
+    char mystrs[1024];
+    struct passwd *result;
+    gid_t *mygroups;
+    int ngroups;
+    int i;
+    int max_groups;
+    struct nfs_state *priv = this->private;
+    const gid_list_t *agl;
+    gid_list_t gl;
+
+    if (!priv->server_aux_gids) {
+        return;
+    }
+
+    /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */
+    max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len,
+                                              AUTH_GLUSTERFS_v2);
+
+    agl = gid_cache_lookup(&priv->gid_cache, root->uid, 0, 0);
+    if (agl) {
+        if (agl->gl_count > max_groups) {
+            GF_LOG_OCCASIONALLY(gf_auth_max_groups_nfs_log, this->name,
+                                GF_LOG_WARNING,
+                                "too many groups, reducing %d -> %d",
+                                agl->gl_count, max_groups);
         }
 
-        gf_msg_trace (this->name, 0, "mapped %u => %s",
-                      root->uid, result->pw_name);
-
-        ngroups = gf_getgrouplist (result->pw_name, root->gid, &mygroups);
-        if (ngroups == -1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_MAP_GRP_LIST_FAIL,
-                        "could not map %s to group list", result->pw_name);
-                return;
+        for (ngroups = 0; ngroups < agl->gl_count && ngroups <= max_groups;
+             ngroups++) {
+            root->groups[ngroups] = agl->gl_list[ngroups];
         }
+        root->ngrps = ngroups;
+        gid_cache_release(&priv->gid_cache, agl);
+        return;
+    }
 
+    /* No cached list found. */
+    if (getpwuid_r(root->uid, &mypw, mystrs, sizeof(mystrs), &result) != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL,
+               "getpwuid_r(%u) failed", root->uid);
+        return;
+    }
 
-	/* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */
-	if (ngroups > max_groups) {
-		GF_LOG_OCCASIONALLY (gf_auth_max_groups_nfs_log,
-				     this->name, GF_LOG_WARNING,
-				     "too many groups, reducing %d -> %d",
-				     ngroups, max_groups);
-
-	}
+    if (!result) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_GETPWUID_FAIL,
+               "getpwuid_r(%u) found nothing", root->uid);
+        return;
+    }
 
-	/* Copy data to the frame. */
-        for (i = 0; i < ngroups && i < max_groups; ++i) {
-                gf_msg_trace (this->name, 0, "%s is in group %u",
-                              result->pw_name, mygroups[i]);
-                root->groups[i] = mygroups[i];
-        }
-        root->ngrps = ngroups;
+    gf_msg_trace(this->name, 0, "mapped %u => %s", root->uid, result->pw_name);
 
-        /* Add the group data to the cache. */
-        gl.gl_list = mygroups;
-        gl.gl_id = root->uid;
-        gl.gl_uid = 0;
-        gl.gl_gid = 0;
-        gl.gl_count = ngroups;
-        if (gid_cache_add(&priv->gid_cache, &gl) != 1)
-                GF_FREE(mygroups);
+    ngroups = gf_getgrouplist(result->pw_name, root->gid, &mygroups);
+    if (ngroups == -1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_MAP_GRP_LIST_FAIL,
+               "could not map %s to group list", result->pw_name);
+        return;
+    }
+
+    /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */
+    if (ngroups > max_groups) {
+        GF_LOG_OCCASIONALLY(
+            gf_auth_max_groups_nfs_log, this->name, GF_LOG_WARNING,
+            "too many groups, reducing %d -> %d", ngroups, max_groups);
+    }
+
+    /* Copy data to the frame. */
+    for (i = 0; i < ngroups && i < max_groups; ++i) {
+        gf_msg_trace(this->name, 0, "%s is in group %u", result->pw_name,
+                     mygroups[i]);
+        root->groups[i] = mygroups[i];
+    }
+    root->ngrps = ngroups;
+
+    /* Add the group data to the cache. */
+    gl.gl_list = mygroups;
+    gl.gl_id = root->uid;
+    gl.gl_uid = 0;
+    gl.gl_gid = 0;
+    gl.gl_count = ngroups;
+    if (gid_cache_add(&priv->gid_cache, &gl) != 1)
+        GF_FREE(mygroups);
 }
 
 struct nfs_fop_local *
-nfs_fop_local_init (xlator_t *nfsx)
+nfs_fop_local_init(xlator_t *nfsx)
 {
-        struct nfs_fop_local    *l = NULL;
+    struct nfs_fop_local *l = NULL;
 
-        if (!nfsx)
-                return NULL;
+    if (!nfsx)
+        return NULL;
 
-        l = mem_get (nfs_fop_mempool (nfsx));
+    l = mem_get(nfs_fop_mempool(nfsx));
 
-        memset (l, 0, sizeof (*l));
-        return l;
+    memset(l, 0, sizeof(*l));
+    return l;
 }
 
 void
-nfs_fop_local_wipe (xlator_t *nfsx, struct nfs_fop_local *l)
+nfs_fop_local_wipe(xlator_t *nfsx, struct nfs_fop_local *l)
 {
-        if ((!nfsx) || (!l))
-                return;
+    if ((!nfsx) || (!l))
+        return;
 
-        if (l->iobref)
-                iobref_unref (l->iobref);
+    if (l->iobref)
+        iobref_unref(l->iobref);
 
-        if (l->parent)
-                inode_unref (l->parent);
+    if (l->parent)
+        inode_unref(l->parent);
 
-        if (l->inode)
-                inode_unref (l->inode);
+    if (l->inode)
+        inode_unref(l->inode);
 
-        if (l->newparent)
-                inode_unref (l->newparent);
+    if (l->newparent)
+        inode_unref(l->newparent);
 
-        if (l->dictgfid)
-                dict_unref (l->dictgfid);
+    if (l->dictgfid)
+        dict_unref(l->dictgfid);
 
-        mem_put (l);
+    mem_put(l);
 
-        return;
+    return;
 }
 
-#define nfs_stack_destroy(nfl, fram)                                    \
-        do {                                                            \
-                nfs_fop_local_wipe ((nfl)->nfsx, nfl);                  \
-                (fram)->local = NULL;                                   \
-                STACK_DESTROY ((fram)->root);                           \
-        } while (0)                                                     \
-
-
-pthread_mutex_t         ctr = PTHREAD_MUTEX_INITIALIZER;
-unsigned int            cval = 1;
+#define nfs_stack_destroy(nfl, fram)                                           \
+    do {                                                                       \
+        nfs_fop_local_wipe((nfl)->nfsx, nfl);                                  \
+        (fram)->local = NULL;                                                  \
+        STACK_DESTROY((fram)->root);                                           \
+    } while (0)
 
+pthread_mutex_t ctr = PTHREAD_MUTEX_INITIALIZER;
+unsigned int cval = 1;
 
 int
-nfs_frame_getctr ()
+nfs_frame_getctr()
 {
-        uint64_t val = 0;
-
-        pthread_mutex_lock (&ctr);
-        {
-                if (cval == 0)
-                        cval = 1;
-                val = cval;
-                cval++;
-        }
-        pthread_mutex_unlock (&ctr);
-
-        return val;
+    uint64_t val = 0;
+
+    pthread_mutex_lock(&ctr);
+    {
+        if (cval == 0)
+            cval = 1;
+        val = cval;
+        cval++;
+    }
+    pthread_mutex_unlock(&ctr);
+
+    return val;
 }
 
-
 call_frame_t *
-nfs_create_frame (xlator_t *xl, nfs_user_t *nfu)
+nfs_create_frame(xlator_t *xl, nfs_user_t *nfu)
 {
-        call_frame_t    *frame = NULL;
-        int             x = 0;
-        int             y = 0;
-
-        if ((!xl) || (!nfu) || (nfu->ngrps > NFS_NGROUPS))
-                return NULL;
-
-        frame = create_frame (xl, (call_pool_t *)xl->ctx->pool);
-        if (!frame)
-                goto err;
-	if (call_stack_alloc_groups (frame->root, nfu->ngrps) != 0) {
-		STACK_DESTROY (frame->root);
-		frame = NULL;
-		goto err;
-	}
-
-        frame->root->pid = NFS_PID;
-        frame->root->uid = nfu->uid;
-        frame->root->gid = nfu->gids[NFS_PRIMGID_IDX];
-        memcpy (&frame->root->identifier, &nfu->identifier, UNIX_PATH_MAX);
-        frame->root->lk_owner = nfu->lk_owner;
-
-        if (nfu->ngrps != 1) {
-                frame->root->ngrps = nfu->ngrps - 1;
-
-                gf_msg_trace (GF_NFS, 0, "uid: %d, gid %d, gids: %d",
-                              frame->root->uid, frame->root->gid,
-                              frame->root->ngrps);
-                for(y = 0, x = 1;  y < frame->root->ngrps; x++,y++) {
-                        gf_msg_trace (GF_NFS, 0, "gid: %d", nfu->gids[x]);
-                        frame->root->groups[y] = nfu->gids[x];
-                }
+    call_frame_t *frame = NULL;
+    int x = 0;
+    int y = 0;
+
+    if ((!xl) || (!nfu) || (nfu->ngrps > NFS_NGROUPS))
+        return NULL;
+
+    frame = create_frame(xl, (call_pool_t *)xl->ctx->pool);
+    if (!frame)
+        goto err;
+    if (call_stack_alloc_groups(frame->root, nfu->ngrps) != 0) {
+        STACK_DESTROY(frame->root);
+        frame = NULL;
+        goto err;
+    }
+
+    frame->root->pid = NFS_PID;
+    frame->root->uid = nfu->uid;
+    frame->root->gid = nfu->gids[NFS_PRIMGID_IDX];
+    memcpy(&frame->root->identifier, &nfu->identifier, UNIX_PATH_MAX);
+    frame->root->lk_owner = nfu->lk_owner;
+
+    if (nfu->ngrps != 1) {
+        frame->root->ngrps = nfu->ngrps - 1;
+
+        gf_msg_trace(GF_NFS, 0, "uid: %d, gid %d, gids: %d", frame->root->uid,
+                     frame->root->gid, frame->root->ngrps);
+        for (y = 0, x = 1; y < frame->root->ngrps; x++, y++) {
+            gf_msg_trace(GF_NFS, 0, "gid: %d", nfu->gids[x]);
+            frame->root->groups[y] = nfu->gids[x];
         }
+    }
 
-        /*
-         * It's tempting to do this *instead* of using nfu above, but we need
-         * to have those values in case nfs_fix_groups doesn't do anything.
-         */
-        nfs_fix_groups(xl,frame->root);
+    /*
+     * It's tempting to do this *instead* of using nfu above, but we need
+     * to have those values in case nfs_fix_groups doesn't do anything.
+     */
+    nfs_fix_groups(xl, frame->root);
 
 err:
-        return frame;
+    return frame;
 }
 
-#define nfs_fop_handle_frame_create(fram, xla, nfuser, retval, errlabel)      \
-        do {                                                                  \
-                fram = nfs_create_frame (xla, (nfuser));                \
-                if (!fram) {                                                  \
-                        retval = (-ENOMEM);                                   \
-                        gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM,                \
-                                NFS_MSG_NO_MEMORY, "Frame creation failed");\
-                        goto errlabel;                                        \
-                }                                                             \
-        } while (0)                                                           \
+#define nfs_fop_handle_frame_create(fram, xla, nfuser, retval, errlabel)       \
+    do {                                                                       \
+        fram = nfs_create_frame(xla, (nfuser));                                \
+        if (!fram) {                                                           \
+            retval = (-ENOMEM);                                                \
+            gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,            \
+                   "Frame creation failed");                                   \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 /* Look into the  inode and parent inode of a loc and save enough state
  * for us to determine in the callback whether to funge the ino in the stat buf
  * with 1 for the parent.
  */
-#define nfs_fop_save_root_ino(locl, loc)                                \
-        do {                                                            \
-                if (((loc)->inode) &&                                   \
-                    __is_root_gfid ((loc)->inode->gfid))                \
-                        (locl)->rootinode = 1;                          \
-                else if (((loc)->parent) &&                             \
-                         __is_root_gfid ((loc)->parent->gfid))          \
-                        (locl)->rootparentinode = 1;                    \
-        } while (0)
+#define nfs_fop_save_root_ino(locl, loc)                                       \
+    do {                                                                       \
+        if (((loc)->inode) && __is_root_gfid((loc)->inode->gfid))              \
+            (locl)->rootinode = 1;                                             \
+        else if (((loc)->parent) && __is_root_gfid((loc)->parent->gfid))       \
+            (locl)->rootparentinode = 1;                                       \
+    } while (0)
 
 /* Do the same for an fd */
-#define nfs_fop_save_root_fd_ino(locl, fdesc)                           \
-        do {                                                            \
-                if (__is_root_gfid ((fdesc)->inode->gfid))              \
-                        (locl)->rootinode = 1;                          \
-        } while (0)
-
+#define nfs_fop_save_root_fd_ino(locl, fdesc)                                  \
+    do {                                                                       \
+        if (__is_root_gfid((fdesc)->inode->gfid))                              \
+            (locl)->rootinode = 1;                                             \
+    } while (0)
 
 /* Use the state saved by the previous macro to funge the ino in the appropriate
  * structure.
  */
-#define nfs_fop_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar)  \
-        do {                                                                \
-                if (fopret == -1)                                           \
-                        break;                                              \
-                if ((locl)->rootinode) {                                    \
-                        if ((preattr)) {                                    \
-                                ((struct iatt *)(preattr))->ia_ino = 1;     \
-                                ((struct iatt *)(preattr))->ia_dev = 0;     \
-                        }                                                   \
-                        if ((postattr)) {                                   \
-                                ((struct iatt *)(postattr))->ia_ino = 1;    \
-                                ((struct iatt *)(postattr))->ia_dev = 0;    \
-                        }                                                   \
-                } else if ((locl)->rootparentinode) {                       \
-                        if ((prepar)) {                                     \
-                                ((struct iatt *)(prepar))->ia_ino = 1;      \
-                                ((struct iatt *)(prepar))->ia_dev = 0;      \
-                        }                                                   \
-                        if ((postpar)) {                                    \
-                                ((struct iatt *)(postpar))->ia_ino = 1;     \
-                                ((struct iatt *)(postpar))->ia_dev = 0;     \
-                        }                                                   \
-                }                                                           \
-        } while (0)                                                         \
+#define nfs_fop_restore_root_ino(locl, fopret, preattr, postattr, prepar,      \
+                                 postpar)                                      \
+    do {                                                                       \
+        if (fopret == -1)                                                      \
+            break;                                                             \
+        if ((locl)->rootinode) {                                               \
+            if ((preattr)) {                                                   \
+                ((struct iatt *)(preattr))->ia_ino = 1;                        \
+                ((struct iatt *)(preattr))->ia_dev = 0;                        \
+            }                                                                  \
+            if ((postattr)) {                                                  \
+                ((struct iatt *)(postattr))->ia_ino = 1;                       \
+                ((struct iatt *)(postattr))->ia_dev = 0;                       \
+            }                                                                  \
+        } else if ((locl)->rootparentinode) {                                  \
+            if ((prepar)) {                                                    \
+                ((struct iatt *)(prepar))->ia_ino = 1;                         \
+                ((struct iatt *)(prepar))->ia_dev = 0;                         \
+            }                                                                  \
+            if ((postpar)) {                                                   \
+                ((struct iatt *)(postpar))->ia_ino = 1;                        \
+                ((struct iatt *)(postpar))->ia_dev = 0;                        \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 
 /* If the newly created, inode's parent is root, we'll need to funge the ino
  * in the parent attr when we receive them in the callback.
  */
-#define nfs_fop_newloc_save_root_ino(locl, newloc)                      \
-        do {                                                            \
-                if (((newloc)->inode) &&                                \
-                    __is_root_gfid ((newloc)->inode->gfid))             \
-                        (locl)->newrootinode = 1;                       \
-                else if (((newloc)->parent) &&                          \
-                         __is_root_gfid ((newloc)->parent->gfid))       \
-                        (locl)->newrootparentinode = 1;                 \
-        } while (0)
-
-#define nfs_fop_newloc_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar)  \
-        do {                                                                   \
-                if (fopret == -1)                                              \
-                        break;                                                 \
+#define nfs_fop_newloc_save_root_ino(locl, newloc)                             \
+    do {                                                                       \
+        if (((newloc)->inode) && __is_root_gfid((newloc)->inode->gfid))        \
+            (locl)->newrootinode = 1;                                          \
+        else if (((newloc)->parent) && __is_root_gfid((newloc)->parent->gfid)) \
+            (locl)->newrootparentinode = 1;                                    \
+    } while (0)
+
+#define nfs_fop_newloc_restore_root_ino(locl, fopret, preattr, postattr,       \
+                                        prepar, postpar)                       \
+    do {                                                                       \
+        if (fopret == -1)                                                      \
+            break;                                                             \
                                                                                \
-                if ((locl)->newrootinode) {                                    \
-                        if ((preattr))                                         \
-                                ((struct iatt *)(preattr))->ia_ino = 1;        \
-                        if ((postattr))                                        \
-                                ((struct iatt *)(postattr))->ia_ino = 1;       \
-                } else if ((locl)->newrootparentinode) {                       \
-                        if ((prepar))                                          \
-                                ((struct iatt *)(prepar))->ia_ino = 1;         \
-                        if ((postpar))                                         \
-                                ((struct iatt *)(postpar))->ia_ino = 1;        \
-                }                                                              \
-        } while (0)                                                            \
+        if ((locl)->newrootinode) {                                            \
+            if ((preattr))                                                     \
+                ((struct iatt *)(preattr))->ia_ino = 1;                        \
+            if ((postattr))                                                    \
+                ((struct iatt *)(postattr))->ia_ino = 1;                       \
+        } else if ((locl)->newrootparentinode) {                               \
+            if ((prepar))                                                      \
+                ((struct iatt *)(prepar))->ia_ino = 1;                         \
+            if ((postpar))                                                     \
+                ((struct iatt *)(postpar))->ia_ino = 1;                        \
+        }                                                                      \
+    } while (0)
 
 dict_t *
-nfs_gfid_dict (inode_t *inode)
+nfs_gfid_dict(inode_t *inode)
 {
-        uuid_t  newgfid = {0, };
-        unsigned char *dyngfid = NULL;
-        dict_t  *dictgfid = NULL;
-        int     ret = -1;
-        uuid_t  rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
-
-        dyngfid = GF_MALLOC (sizeof (uuid_t), gf_common_mt_char);
-        if (dyngfid == NULL)
-                return (NULL);
-
-        gf_uuid_generate (newgfid);
-
-        if (gf_uuid_compare (inode->gfid, rootgfid) == 0)
-                memcpy (dyngfid, rootgfid, sizeof (uuid_t));
-        else
-                memcpy (dyngfid, newgfid, sizeof (uuid_t));
-
-        dictgfid = dict_new ();
-        if (!dictgfid) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, errno,
-                        NFS_MSG_GFID_DICT_CREATE_FAIL,
-                        "Failed to create gfid dict");
-                GF_FREE (dyngfid);
-                return (NULL);
-        }
-
-        ret = dict_set_gfuuid (dictgfid, "gfid-req", dyngfid, false);
-        if (ret < 0) {
-                GF_FREE (dyngfid);
-                dict_unref (dictgfid);
-                return (NULL);
-        }
-
-        return dictgfid;
+    uuid_t newgfid = {
+        0,
+    };
+    unsigned char *dyngfid = NULL;
+    dict_t *dictgfid = NULL;
+    int ret = -1;
+    uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+
+    dyngfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char);
+    if (dyngfid == NULL)
+        return (NULL);
+
+    gf_uuid_generate(newgfid);
+
+    if (gf_uuid_compare(inode->gfid, rootgfid) == 0)
+        memcpy(dyngfid, rootgfid, sizeof(uuid_t));
+    else
+        memcpy(dyngfid, newgfid, sizeof(uuid_t));
+
+    dictgfid = dict_new();
+    if (!dictgfid) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_GFID_DICT_CREATE_FAIL,
+               "Failed to create gfid dict");
+        GF_FREE(dyngfid);
+        return (NULL);
+    }
+
+    ret = dict_set_gfuuid(dictgfid, "gfid-req", dyngfid, false);
+    if (ret < 0) {
+        GF_FREE(dyngfid);
+        dict_unref(dictgfid);
+        return (NULL);
+    }
+
+    return dictgfid;
 }
 
-#define nfs_fop_gfid_setup(nflcl, inode, retval, erlbl)                 \
-        do {                                                            \
-                if (nflcl) {                                            \
-                        (nflcl)->dictgfid = nfs_gfid_dict (inode);      \
-                                                                        \
-                        if (!((nflcl)->dictgfid)) {                     \
-                                retval = -EFAULT;                       \
-                                goto erlbl;                             \
-                        }                                               \
-                }                                                       \
-        } while (0)                                                     \
+#define nfs_fop_gfid_setup(nflcl, inode, retval, erlbl)                        \
+    do {                                                                       \
+        if (nflcl) {                                                           \
+            (nflcl)->dictgfid = nfs_gfid_dict(inode);                          \
+                                                                               \
+            if (!((nflcl)->dictgfid)) {                                        \
+                retval = -EFAULT;                                              \
+                goto erlbl;                                                    \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
 
 /* Fops Layer Explained
  * The fops layer has three types of functions. They can all be identified by
@@ -402,1300 +392,1237 @@ nfs_gfid_dict (inode_t *inode)
  */
 
 int32_t
-nfs_fop_lookup_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)
+nfs_fop_lookup_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)
 {
-        struct nfs_fop_local    *local = NULL;
-        fop_lookup_cbk_t        progcbk;
+    struct nfs_fop_local *local = NULL;
+    fop_lookup_cbk_t progcbk;
 
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
 
-        nfl_to_prog_data (local, progcbk, frame);
-        nfs_fop_restore_root_ino (local, op_ret, buf, NULL, NULL, postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         xattr, postparent);
+    nfl_to_prog_data(local, progcbk, frame);
+    nfs_fop_restore_root_ino(local, op_ret, buf, NULL, NULL, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, xattr,
+                postparent);
 
-        nfs_stack_destroy (local, frame);
-        return 0;
+    nfs_stack_destroy(local, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_lookup (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                fop_lookup_cbk_t cbk, void *local)
+nfs_fop_lookup(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+               fop_lookup_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!xl) || (!loc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Lookup: %s", loc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, loc);
-        nfs_fop_gfid_setup (nfl, loc->inode, ret, err);
+    gf_msg_trace(GF_NFS, 0, "Lookup: %s", loc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, loc);
+    nfs_fop_gfid_setup(nfl, loc->inode, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_lookup_cbk, xl, xl,
-                           xl->fops->lookup, loc, nfl->dictgfid);
+    STACK_WIND_COOKIE(frame, nfs_fop_lookup_cbk, xl, xl, xl->fops->lookup, loc,
+                      nfl->dictgfid);
 
-        ret = 0;
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-nfs_fop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+nfs_fop_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_access_cbk_t        progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_access_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
 int
-nfs_fop_access (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                int32_t accesstest, fop_access_cbk_t cbk, void *local)
+nfs_fop_access(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+               int32_t accesstest, fop_access_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-        uint32_t                accessbits = 0;
-
-        if ((!xl) || (!loc) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Access: %s", loc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, loc);
-
-        accessbits = nfs3_request_to_accessbits (accesstest);
-        STACK_WIND_COOKIE (frame, nfs_fop_access_cbk, xl, xl, xl->fops->access,
-                           loc, accessbits, NULL);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    uint32_t accessbits = 0;
 
+    if ((!xl) || (!loc) || (!nfu))
         return ret;
+
+    gf_msg_trace(GF_NFS, 0, "Access: %s", loc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, loc);
+
+    accessbits = nfs3_request_to_accessbits(accesstest);
+    STACK_WIND_COOKIE(frame, nfs_fop_access_cbk, xl, xl, xl->fops->access, loc,
+                      accessbits, NULL);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
+
+    return ret;
 }
 
 int32_t
-nfs_fop_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                  dict_t *xdata)
+nfs_fop_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_stat_cbk_t          progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_stat_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_stat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-              fop_stat_cbk_t cbk, void *local)
+nfs_fop_stat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+             fop_stat_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!xl) || (!loc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Stat: %s", loc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, loc);
+    gf_msg_trace(GF_NFS, 0, "Stat: %s", loc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, loc);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_stat_cbk, xl, xl, xl->fops->stat,
-                           loc, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_stat_cbk, xl, xl, xl->fops->stat, loc,
+                      NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                   dict_t *xdata)
+nfs_fop_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_fstat_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_fstat_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_fstat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-               fop_fstat_cbk_t cbk, void *local)
+nfs_fop_fstat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+              fop_fstat_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!fd) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!fd) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "FStat");
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_fd_ino (nfl, fd);
+    gf_msg_trace(GF_NFS, 0, "FStat");
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_fd_ino(nfl, fd);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_fstat_cbk, xl, xl, xl->fops->fstat,
-                           fd, NULL);
+    STACK_WIND_COOKIE(frame, nfs_fop_fstat_cbk, xl, xl, xl->fops->fstat, fd,
+                      NULL);
 
-        ret = 0;
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+nfs_fop_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_opendir_cbk_t       progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_opendir_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_opendir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                 fd_t *dirfd, fop_opendir_cbk_t cbk, void *local)
+nfs_fop_opendir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                fd_t *dirfd, fop_opendir_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!dirfd) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!dirfd) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Opendir: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    gf_msg_trace(GF_NFS, 0, "Opendir: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_opendir_cbk, xl, xl,
-                           xl->fops->opendir, pathloc, dirfd, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_opendir_cbk, xl, xl, xl->fops->opendir,
+                      pathloc, dirfd, NULL);
+    ret = 0;
 
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nfs_fop_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
+nfs_fop_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_flush_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_flush_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_flush (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-               fop_flush_cbk_t cbk, void *local)
+nfs_fop_flush(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+              fop_flush_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!fd) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!fd) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_flush_cbk, xl, xl, xl->fops->flush,
-                           fd, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_flush_cbk, xl, xl, xl->fops->flush, fd,
+                      NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                      dict_t *xdata)
+nfs_fop_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                     dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_readdirp_cbk_t      progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_readdirp_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, entries, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, entries, xdata);
 
-        nfs_stack_destroy (nfl, frame);
+    nfs_stack_destroy(nfl, frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_fop_readdirp (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd,
-                  size_t bufsize, off_t offset, fop_readdirp_cbk_t cbk,
-                  void *local)
+nfs_fop_readdirp(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd,
+                 size_t bufsize, off_t offset, fop_readdirp_cbk_t cbk,
+                 void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!dirfd) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!dirfd) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "readdir");
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    gf_msg_trace(GF_NFS, 0, "readdir");
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_readdirp_cbk, xl, xl,
-                           xl->fops->readdirp, dirfd, bufsize, offset, 0);
+    STACK_WIND_COOKIE(frame, nfs_fop_readdirp_cbk, xl, xl, xl->fops->readdirp,
+                      dirfd, bufsize, offset, 0);
 
-        ret = 0;
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct statvfs *buf,
-                    dict_t *xdata)
+nfs_fop_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                   dict_t *xdata)
 {
+    struct nfs_fop_local *nfl = NULL;
+    fop_statfs_cbk_t progcbk = NULL;
 
-        struct nfs_fop_local    *nfl = NULL;
-        fop_statfs_cbk_t        progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, buf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_statfs (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                fop_statfs_cbk_t cbk, void *local)
+nfs_fop_statfs(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+               fop_statfs_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Statfs: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    gf_msg_trace(GF_NFS, 0, "Statfs: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_statfs_cbk, xl, xl,
-                           xl->fops->statfs, pathloc, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_statfs_cbk, xl, xl, xl->fops->statfs,
+                      pathloc, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+nfs_fop_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_create_cbk_t        progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_create_cbk_t progcbk = NULL;
 
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent,
-                                  postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, inode, buf,
-                         preparent, postparent, NULL);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, inode, buf,
+                preparent, postparent, NULL);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                int flags, mode_t mode, fd_t *fd, fop_create_cbk_t cbk,
-                void *local)
+nfs_fop_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+               int flags, mode_t mode, fd_t *fd, fop_create_cbk_t cbk,
+               void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Create: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
-        nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err);
+    gf_msg_trace(GF_NFS, 0, "Create: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
+    nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_create_cbk, xl, xl, xl->fops->create,
-                           pathloc, flags, mode, 0, fd, nfl->dictgfid);
+    STACK_WIND_COOKIE(frame, nfs_fop_create_cbk, xl, xl, xl->fops->create,
+                      pathloc, flags, mode, 0, fd, nfl->dictgfid);
 
-        ret = 0;
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *pre,
-                     struct iatt *post, dict_t *xdata)
+nfs_fop_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *pre,
+                    struct iatt *post, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_setattr_cbk_t       progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, pre, post, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, pre, post,
-                         xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_setattr_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, pre, post, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, pre, post, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
-
 int
-nfs_fop_setattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                 struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk,
-                 void *local)
+nfs_fop_setattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk,
+                void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Setattr: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
+    gf_msg_trace(GF_NFS, 0, "Setattr: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_setattr_cbk, xl, xl,
-                           xl->fops->setattr, pathloc, buf, valid, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_setattr_cbk, xl, xl, xl->fops->setattr,
+                      pathloc, buf, valid, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs_fop_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_mkdir_cbk_t         progcbk = NULL;
-
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL,preparent, postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_mkdir_cbk_t progcbk = NULL;
+
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-               mode_t mode, fop_mkdir_cbk_t cbk, void *local)
+nfs_fop_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+              mode_t mode, fop_mkdir_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Mkdir: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
-        nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err);
-
-        STACK_WIND_COOKIE  (frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir,
-                            pathloc, mode, 0, nfl->dictgfid);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    gf_msg_trace(GF_NFS, 0, "Mkdir: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
+    nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err);
 
-int32_t
-nfs_fop_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
-{
-        struct nfs_fop_local    *nfl = NULL;
-        fop_symlink_cbk_t       progcbk = NULL;
+    STACK_WIND_COOKIE(frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir,
+                      pathloc, mode, 0, nfl->dictgfid);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
+    return ret;
+}
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+int32_t
+nfs_fop_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
+{
+    struct nfs_fop_local *nfl = NULL;
+    fop_symlink_cbk_t progcbk = NULL;
+
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
 int
-nfs_fop_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
-                 loc_t *pathloc, fop_symlink_cbk_t cbk, void *local)
+nfs_fop_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
+                loc_t *pathloc, fop_symlink_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!target) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Symlink: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
-        nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err);
-
-        STACK_WIND_COOKIE  (frame, nfs_fop_symlink_cbk, xl, xl,
-                            xl->fops->symlink, target, pathloc,
-                            0, nfl->dictgfid);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
+    if ((!nfsx) || (!xl) || (!pathloc) || (!target) || (!nfu))
         return ret;
-}
 
+    gf_msg_trace(GF_NFS, 0, "Symlink: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
+    nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err);
+
+    STACK_WIND_COOKIE(frame, nfs_fop_symlink_cbk, xl, xl, xl->fops->symlink,
+                      target, pathloc, 0, nfl->dictgfid);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
+
+    return ret;
+}
 
 int32_t
-nfs_fop_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)
+nfs_fop_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)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_readlink_cbk_t      progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, path, buf,
-                         xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_readlink_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, path, buf, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_readlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                  size_t size, fop_readlink_cbk_t cbk, void *local)
+nfs_fop_readlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                 size_t size, fop_readlink_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Readlink: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
+    gf_msg_trace(GF_NFS, 0, "Readlink: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_readlink_cbk, xl, xl,
-                           xl->fops->readlink, pathloc, size, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_readlink_cbk, xl, xl, xl->fops->readlink,
+                      pathloc, size, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs_fop_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_mknod_cbk_t         progcbk = NULL;
-
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_mknod_cbk_t progcbk = NULL;
+
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-               mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
+nfs_fop_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+              mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Mknod: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
-        nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err);
-
-        STACK_WIND_COOKIE  (frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod,
-                            pathloc, mode, dev, 0, nfl->dictgfid);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
+
+    gf_msg_trace(GF_NFS, 0, "Mknod: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
+    nfs_fop_gfid_setup(nfl, pathloc->inode, ret, err);
+
+    STACK_WIND_COOKIE(frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod,
+                      pathloc, mode, dev, 0, nfl->dictgfid);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
+
+    return ret;
 }
 
 int32_t
-nfs_fop_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs_fop_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = frame->local;
-        fop_rmdir_cbk_t         progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent,
-                                  postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, preparent,
-                         postparent, NULL);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = frame->local;
+    fop_rmdir_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent,
+                NULL);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
-
 int
-nfs_fop_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-               fop_rmdir_cbk_t cbk, void *local)
+nfs_fop_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+              fop_rmdir_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Rmdir: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
+    gf_msg_trace(GF_NFS, 0, "Rmdir: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_rmdir_cbk, xl, xl, xl->fops->rmdir,
-                           pathloc, 0, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_rmdir_cbk, xl, xl, xl->fops->rmdir,
+                      pathloc, 0, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
-
-        return ret;
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
+    return ret;
 }
 
-
 int32_t
-nfs_fop_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+nfs_fop_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = frame->local;
-        fop_unlink_cbk_t         progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent,
-                                  postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, preparent,
-                         postparent, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    struct nfs_fop_local *nfl = frame->local;
+    fop_unlink_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent,
+                xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                fop_unlink_cbk_t cbk, void *local)
+nfs_fop_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+               fop_unlink_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Unlink: %s", pathloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, pathloc);
+    gf_msg_trace(GF_NFS, 0, "Unlink: %s", pathloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, pathloc);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_unlink_cbk, xl, xl,
-                           xl->fops->unlink, pathloc, 0, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_unlink_cbk, xl, xl, xl->fops->unlink,
+                      pathloc, 0, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
-
-        return ret;
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
+    return ret;
 }
 
-
 int32_t
-nfs_fop_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
+nfs_fop_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_link_cbk_t          progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_link_cbk_t progcbk = NULL;
 
-        if (op_ret == 0) {
-                nfs_fix_generation(this,inode);
-        }
+    if (op_ret == 0) {
+        nfs_fix_generation(this, inode);
+    }
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent,
-                                  postparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, buf, NULL, preparent, postparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-              loc_t *newloc, fop_link_cbk_t cbk, void *local)
+nfs_fop_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+             loc_t *newloc, fop_link_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Link: %s -> %s", newloc->path,
-                      oldloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, newloc);
-
-        STACK_WIND_COOKIE (frame, nfs_fop_link_cbk, xl, xl, xl->fops->link,
-                           oldloc, newloc, NULL);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
         return ret;
-}
 
+    gf_msg_trace(GF_NFS, 0, "Link: %s -> %s", newloc->path, oldloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, newloc);
 
-int32_t
-nfs_fop_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
-{
+    STACK_WIND_COOKIE(frame, nfs_fop_link_cbk, xl, xl, xl->fops->link, oldloc,
+                      newloc, NULL);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        struct nfs_fop_local    *nfl = NULL;
-        fop_rename_cbk_t        progcbk = NULL;
-
-        nfl_to_prog_data (nfl, progcbk, frame);
-        /* The preattr arg needs to be NULL instead of @buf because it is
-         * possible that the new parent is not root whereas the source dir
-         * could have been. That is handled in the next macro.
-         */
-        nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preoldparent,
-                                  postoldparent);
-        nfs_fop_newloc_restore_root_ino (nfl, op_ret, buf, NULL, prenewparent,
-                                         postnewparent);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, buf,
-                         preoldparent, postoldparent, prenewparent,
-                         postnewparent, xdata);
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    return ret;
 }
 
+int32_t
+nfs_fop_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
+{
+    struct nfs_fop_local *nfl = NULL;
+    fop_rename_cbk_t progcbk = NULL;
+
+    nfl_to_prog_data(nfl, progcbk, frame);
+    /* The preattr arg needs to be NULL instead of @buf because it is
+     * possible that the new parent is not root whereas the source dir
+     * could have been. That is handled in the next macro.
+     */
+    nfs_fop_restore_root_ino(nfl, op_ret, NULL, NULL, preoldparent,
+                             postoldparent);
+    nfs_fop_newloc_restore_root_ino(nfl, op_ret, buf, NULL, prenewparent,
+                                    postnewparent);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, buf, preoldparent,
+                postoldparent, prenewparent, postnewparent, xdata);
+    nfs_stack_destroy(nfl, frame);
+    return 0;
+}
 
 int
-nfs_fop_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-                loc_t *newloc, fop_rename_cbk_t cbk, void *local)
+nfs_fop_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+               loc_t *newloc, fop_rename_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
-                return ret;
-
-        gf_msg_trace (GF_NFS, 0, "Rename: %s -> %s", oldloc->path,
-                      newloc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, oldloc);
-        nfs_fop_newloc_save_root_ino (nfl, newloc);
-
-        STACK_WIND_COOKIE (frame, nfs_fop_rename_cbk, xl, xl,
-                           xl->fops->rename, oldloc, newloc, NULL);
-        ret = 0;
-err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
         return ret;
-}
 
+    gf_msg_trace(GF_NFS, 0, "Rename: %s -> %s", oldloc->path, newloc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, oldloc);
+    nfs_fop_newloc_save_root_ino(nfl, newloc);
+
+    STACK_WIND_COOKIE(frame, nfs_fop_rename_cbk, xl, xl, xl->fops->rename,
+                      oldloc, newloc, NULL);
+    ret = 0;
+err:
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
+
+    return ret;
+}
 
 int32_t
-nfs_fop_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+nfs_fop_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_open_cbk_t          progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_open_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata);
-        nfs_stack_destroy (nfl, frame);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata);
+    nfs_stack_destroy(nfl, frame);
 
-        return 0;
+    return 0;
 }
 
 int
-nfs_fop_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-              int32_t flags, fd_t *fd, fop_open_cbk_t cbk,
-              void *local)
+nfs_fop_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+             int32_t flags, fd_t *fd, fop_open_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!loc) || (!fd) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!loc) || (!fd) || (!nfu))
+        return ret;
 
-        gf_msg_trace (GF_NFS, 0, "Open: %s", loc->path);
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    gf_msg_trace(GF_NFS, 0, "Open: %s", loc->path);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_open_cbk, xl, xl, xl->fops->open,
-                           loc, flags, fd, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_open_cbk, xl, xl, xl->fops->open, loc,
+                      flags, fd, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
+nfs_fop_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_writev_cbk_t        progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_writev_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, prebuf,
-                         postbuf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
+    nfs_stack_destroy(nfl, frame);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_fop_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-               struct iobref *srciobref, struct iovec *vector, int32_t count,
-               off_t offset, fop_writev_cbk_t cbk, void *local)
+nfs_fop_write(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+              struct iobref *srciobref, struct iovec *vector, int32_t count,
+              off_t offset, fop_writev_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
-        int flags = 0;
-        nfs3_call_state_t       *cs = local;
-
-        if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciobref))
-                return ret;
-
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_fd_ino (nfl, fd);
-/*
-        nfl->iobref = iobref_new ();
-        if (!nfl->iobref) {
-                gf_log (GF_NFS, GF_LOG_ERROR, "iobref creation failed");
-                ret = -ENOMEM;
-                goto err;
-        }
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int flags = 0;
+    nfs3_call_state_t *cs = local;
 
-        iobref_add (nfl->iobref, srciob);
-*/
+    if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciobref))
+        return ret;
 
-        switch (cs->writetype) {
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_fd_ino(nfl, fd);
+    /*
+            nfl->iobref = iobref_new ();
+            if (!nfl->iobref) {
+                    gf_log (GF_NFS, GF_LOG_ERROR, "iobref creation failed");
+                    ret = -ENOMEM;
+                    goto err;
+            }
+
+            iobref_add (nfl->iobref, srciob);
+    */
+
+    switch (cs->writetype) {
         case UNSTABLE:
-                break;
+            break;
         case DATA_SYNC:
-                flags |= O_DSYNC;
-                break;
+            flags |= O_DSYNC;
+            break;
         case FILE_SYNC:
-                flags |= O_SYNC;
-                break;
-        }
+            flags |= O_SYNC;
+            break;
+    }
 
-        STACK_WIND_COOKIE (frame, nfs_fop_writev_cbk, xl, xl,xl->fops->writev,
-                           fd, vector, count, offset, flags, srciobref, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_writev_cbk, xl, xl, xl->fops->writev, fd,
+                      vector, count, offset, flags, srciobref, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
+nfs_fop_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_fsync_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_fsync_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, prebuf,
-                         postbuf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
-
 int
-nfs_fop_fsync (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-               int32_t datasync, fop_fsync_cbk_t cbk, void *local)
+nfs_fop_fsync(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+              int32_t datasync, fop_fsync_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!fd))
-                return ret;
+    if ((!nfsx) || (!xl) || (!fd))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_fd_ino (nfl, fd);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_fd_ino(nfl, fd);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_fsync_cbk, xl, xl,
-                           xl->fops->fsync, fd, datasync, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_fsync_cbk, xl, xl, xl->fops->fsync, fd,
+                      datasync, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                   dict_t *xdata)
+nfs_fop_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                  dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_readv_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_readv_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, stbuf, NULL, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, vector, count,
-                         stbuf, iobref, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, stbuf, NULL, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, vector, count, stbuf,
+                iobref, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_read (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-              size_t size, off_t offset, fop_readv_cbk_t cbk, void *local)
+nfs_fop_read(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+             size_t size, off_t offset, fop_readv_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!fd) || (!nfu))
-                return ret;
+    if ((!xl) || (!fd) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_fd_ino (nfl, fd);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_fd_ino(nfl, fd);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_readv_cbk, xl, xl, xl->fops->readv,
-                           fd, size, offset, 0, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_readv_cbk, xl, xl, xl->fops->readv, fd,
+                      size, offset, 0, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-nfs_fop_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                dict_t *xdata)
+nfs_fop_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+               dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_lk_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_lk_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
+    nfl_to_prog_data(nfl, progcbk, frame);
 
-        if (!op_ret)
-                fd_lk_insert_and_merge (nfl->fd, nfl->cmd, &nfl->flock);
+    if (!op_ret)
+        fd_lk_insert_and_merge(nfl->fd, nfl->cmd, &nfl->flock);
 
-        fd_unref (nfl->fd);
+    fd_unref(nfl->fd);
 
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, flock, xdata);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, flock, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_lk (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-            int cmd, struct gf_flock *flock, fop_lk_cbk_t cbk, void *local)
+nfs_fop_lk(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, int cmd,
+           struct gf_flock *flock, fop_lk_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!fd) || (!nfu))
-                return ret;
+    if ((!xl) || (!fd) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        nfl->cmd   = cmd;
-        nfl->fd    = fd_ref (fd);
-        nfl->flock = *flock;
+    nfl->cmd = cmd;
+    nfl->fd = fd_ref(fd);
+    nfl->flock = *flock;
 
-        STACK_WIND_COOKIE (frame, nfs_fop_lk_cbk, xl, xl, xl->fops->lk,
-                           fd, cmd, flock, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_lk_cbk, xl, xl, xl->fops->lk, fd, cmd,
+                      flock, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
 int32_t
-nfs_fop_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *dict,
-                dict_t *xdata)
+nfs_fop_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_getxattr_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_getxattr_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
+    nfl_to_prog_data(nfl, progcbk, frame);
 
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, dict, xdata);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, dict, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_getxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                  char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local)
+nfs_fop_getxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+                 char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!xl) || (!loc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_getxattr_cbk, xl, xl, xl->fops->getxattr,
-                           loc, name, NULL);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_getxattr_cbk, xl, xl, xl->fops->getxattr,
+                      loc, name, NULL);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *xdata)
+nfs_fop_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_setxattr_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_setxattr_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
+    nfl_to_prog_data(nfl, progcbk, frame);
 
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, xdata);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_setxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu,
-                  loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata,
-                  fop_setxattr_cbk_t cbk, void *local)
+nfs_fop_setxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+                 dict_t *dict, int32_t flags, dict_t *xdata,
+                 fop_setxattr_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!xl) || (!loc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
 
-        STACK_WIND_COOKIE (frame, nfs_fop_setxattr_cbk, xl, xl, xl->fops->setxattr,
-                           loc, dict, flags, xdata);
-        ret = 0;
+    STACK_WIND_COOKIE(frame, nfs_fop_setxattr_cbk, xl, xl, xl->fops->setxattr,
+                      loc, dict, flags, xdata);
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_fop_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
+nfs_fop_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_truncate_cbk_t      progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_truncate_cbk_t progcbk = NULL;
 
-        nfl_to_prog_data (nfl, progcbk, frame);
-        nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, prebuf,
-                         postbuf, xdata);
+    nfl_to_prog_data(nfl, progcbk, frame);
+    nfs_fop_restore_root_ino(nfl, op_ret, prebuf, postbuf, NULL, NULL);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata);
 
-        nfs_stack_destroy (nfl, frame);
-        return 0;
+    nfs_stack_destroy(nfl, frame);
+    return 0;
 }
 
-
 int
-nfs_fop_truncate (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                  off_t offset, fop_truncate_cbk_t cbk, void *local)
+nfs_fop_truncate(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+                 off_t offset, fop_truncate_cbk_t cbk, void *local)
 {
-        call_frame_t            *frame = NULL;
-        int                     ret = -EFAULT;
-        struct nfs_fop_local    *nfl = NULL;
+    call_frame_t *frame = NULL;
+    int ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
 
-        if ((!nfsx) || (!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!loc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err);
-        nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err);
-        nfs_fop_save_root_ino (nfl, loc);
+    nfs_fop_handle_frame_create(frame, nfsx, nfu, ret, err);
+    nfs_fop_handle_local_init(frame, nfsx, nfl, cbk, local, ret, err);
+    nfs_fop_save_root_ino(nfl, loc);
 
-        STACK_WIND_COOKIE  (frame, nfs_fop_truncate_cbk, xl, xl,
-                            xl->fops->truncate, loc, offset, NULL);
+    STACK_WIND_COOKIE(frame, nfs_fop_truncate_cbk, xl, xl, xl->fops->truncate,
+                      loc, offset, NULL);
 
-        ret = 0;
+    ret = 0;
 err:
-        if (ret < 0) {
-                if (frame)
-                        nfs_stack_destroy (nfl, frame);
-        }
+    if (ret < 0) {
+        if (frame)
+            nfs_stack_destroy(nfl, frame);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/nfs/server/src/nfs-generics.c b/xlators/nfs/server/src/nfs-generics.c
index 7e10ea8978c..feadb4cfb3f 100644
--- a/xlators/nfs/server/src/nfs-generics.c
+++ b/xlators/nfs/server/src/nfs-generics.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-
 #include "string.h"
 
 #include "nfs.h"
@@ -17,323 +16,297 @@
 #include "nfs-generics.h"
 #include "xlator.h"
 
-
 int
-nfs_fstat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-           fop_stat_cbk_t cbk, void *local)
+nfs_fstat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+          fop_stat_cbk_t cbk, void *local)
 {
-        int             ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!fd) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_fop_fstat (nfsx, xl, nfu, fd, cbk, local);
+    if ((!nfsx) || (!xl) || (!fd) || (!nfu))
         return ret;
+
+    ret = nfs_fop_fstat(nfsx, xl, nfu, fd, cbk, local);
+    return ret;
 }
 
 int
-nfs_access (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-            int32_t accesstest, fop_access_cbk_t cbk, void *local)
+nfs_access(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+           int32_t accesstest, fop_access_cbk_t cbk, void *local)
 {
-        int             ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        ret = nfs_fop_access (nfsx, xl, nfu, pathloc, accesstest, cbk, local);
+    ret = nfs_fop_access(nfsx, xl, nfu, pathloc, accesstest, cbk, local);
 
-        return ret;
+    return ret;
 }
 
 int
-nfs_stat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-          fop_stat_cbk_t cbk, void *local)
+nfs_stat(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+         fop_stat_cbk_t cbk, void *local)
 {
-        int             ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        ret = nfs_fop_stat (nfsx, xl, nfu, pathloc, cbk, local);
+    ret = nfs_fop_stat(nfsx, xl, nfu, pathloc, cbk, local);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_readdirp (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd,
-              size_t bufsize, off_t offset, fop_readdir_cbk_t cbk, void *local)
+nfs_readdirp(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd,
+             size_t bufsize, off_t offset, fop_readdir_cbk_t cbk, void *local)
 {
-        if ((!nfsx) || (!xl) || (!dirfd) || (!nfu))
-                return -EFAULT;
+    if ((!nfsx) || (!xl) || (!dirfd) || (!nfu))
+        return -EFAULT;
 
-        return nfs_fop_readdirp (nfsx, xl, nfu, dirfd, bufsize, offset, cbk,
-                                 local);
+    return nfs_fop_readdirp(nfsx, xl, nfu, dirfd, bufsize, offset, cbk, local);
 }
 
-
 int
-nfs_lookup (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-            fop_lookup_cbk_t cbk, void *local)
+nfs_lookup(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+           fop_lookup_cbk_t cbk, void *local)
 {
-        int             ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        ret = nfs_fop_lookup (nfsx, xl, nfu, pathloc, cbk, local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
+
+    ret = nfs_fop_lookup(nfsx, xl, nfu, pathloc, cbk, local);
+    return ret;
 }
 
 int
-nfs_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-            int flags, mode_t mode, fop_create_cbk_t cbk, void *local)
+nfs_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+           int flags, mode_t mode, fop_create_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_inode_create (nfsx, xl, nfu, pathloc, flags, mode, cbk,local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_create(nfsx, xl, nfu, pathloc, flags, mode, cbk, local);
+    return ret;
+}
 
 int
-nfs_flush (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-           fop_flush_cbk_t cbk, void *local)
+nfs_flush(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+          fop_flush_cbk_t cbk, void *local)
 {
-        return nfs_fop_flush (nfsx, xl, nfu, fd, cbk, local);
+    return nfs_fop_flush(nfsx, xl, nfu, fd, cbk, local);
 }
 
-
-
 int
-nfs_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-           mode_t mode, fop_mkdir_cbk_t cbk, void *local)
+nfs_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+          mode_t mode, fop_mkdir_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        ret = nfs_inode_mkdir (nfsx, xl, nfu, pathloc, mode, cbk, local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
-
 
+    ret = nfs_inode_mkdir(nfsx, xl, nfu, pathloc, mode, cbk, local);
+    return ret;
+}
 
 int
-nfs_truncate (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-              off_t offset, fop_truncate_cbk_t cbk, void *local)
+nfs_truncate(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+             off_t offset, fop_truncate_cbk_t cbk, void *local)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        ret = nfs_fop_truncate (nfsx, xl, nfu, pathloc, offset, cbk, local);
+    if ((!xl) || (!pathloc) || (!nfu))
         return ret;
+
+    ret = nfs_fop_truncate(nfsx, xl, nfu, pathloc, offset, cbk, local);
+    return ret;
 }
 
 int
-nfs_read (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, size_t size,
-          off_t offset, fop_readv_cbk_t cbk, void *local)
+nfs_read(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, size_t size,
+         off_t offset, fop_readv_cbk_t cbk, void *local)
 {
-        return nfs_fop_read (nfsx, xl, nfu, fd, size, offset, cbk, local);
+    return nfs_fop_read(nfsx, xl, nfu, fd, size, offset, cbk, local);
 }
 
 int
-nfs_lk (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-        int cmd, struct gf_flock *flock, fop_lk_cbk_t cbk, void *local)
+nfs_lk(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, int cmd,
+       struct gf_flock *flock, fop_lk_cbk_t cbk, void *local)
 {
-        return nfs_fop_lk ( nfsx, xl, nfu, fd, cmd, flock, cbk, local);
+    return nfs_fop_lk(nfsx, xl, nfu, fd, cmd, flock, cbk, local);
 }
 
 int
-nfs_getxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-              char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local)
+nfs_getxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+             char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local)
 {
-        return nfs_fop_getxattr (nfsx, xl, nfu, loc, name, xdata, cbk, local);
+    return nfs_fop_getxattr(nfsx, xl, nfu, loc, name, xdata, cbk, local);
 }
 
 int
-nfs_setxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu,
-              loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata,
-              fop_setxattr_cbk_t cbk, void *local)
+nfs_setxattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+             dict_t *dict, int32_t flags, dict_t *xdata, fop_setxattr_cbk_t cbk,
+             void *local)
 {
-        return nfs_fop_setxattr (nfsx, xl, nfu, loc, dict, flags, xdata, cbk,
-                                local);
+    return nfs_fop_setxattr(nfsx, xl, nfu, loc, dict, flags, xdata, cbk, local);
 }
 
 int
-nfs_fsync (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-           int32_t datasync, fop_fsync_cbk_t cbk, void *local)
+nfs_fsync(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+          int32_t datasync, fop_fsync_cbk_t cbk, void *local)
 {
-        return nfs_fop_fsync (nfsx, xl, nfu, fd, datasync, cbk, local);
+    return nfs_fop_fsync(nfsx, xl, nfu, fd, datasync, cbk, local);
 }
 
-
 int
-nfs_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
-           struct iobref *srciobref, struct iovec *vector, int32_t count,
-           off_t offset, fop_writev_cbk_t cbk, void *local)
+nfs_write(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd,
+          struct iobref *srciobref, struct iovec *vector, int32_t count,
+          off_t offset, fop_writev_cbk_t cbk, void *local)
 {
-        return nfs_fop_write (nfsx, xl, nfu, fd, srciobref, vector, count,
-                              offset, cbk, local);
+    return nfs_fop_write(nfsx, xl, nfu, fd, srciobref, vector, count, offset,
+                         cbk, local);
 }
 
-
 int
-nfs_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-          int32_t flags, fop_open_cbk_t cbk, void *local)
+nfs_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+         int32_t flags, fop_open_cbk_t cbk, void *local)
 {
-        int             ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_inode_open (nfsx, xl, nfu, pathloc, flags, cbk,
-                              local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_open(nfsx, xl, nfu, pathloc, flags, cbk, local);
+    return ret;
+}
 
 int
-nfs_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-            loc_t *newloc, fop_rename_cbk_t cbk, void *local)
+nfs_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+           loc_t *newloc, fop_rename_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_inode_rename (nfsx, xl, nfu, oldloc, newloc, cbk, local);
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_rename(nfsx, xl, nfu, oldloc, newloc, cbk, local);
+    return ret;
+}
 
 int
-nfs_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-          loc_t *newloc, fop_link_cbk_t cbk, void *local)
+nfs_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+         loc_t *newloc, fop_link_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
-                return ret;
-
-        ret = nfs_inode_link (nfsx, xl, nfu, oldloc, newloc, cbk, local);
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_link(nfsx, xl, nfu, oldloc, newloc, cbk, local);
+    return ret;
+}
 
 int
-nfs_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-            fop_unlink_cbk_t cbk, void *local)
+nfs_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+           fop_unlink_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
-
-        if ((!xl) || (!pathloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_inode_unlink (nfsx, xl, nfu, pathloc, cbk, local);
+    if ((!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_unlink(nfsx, xl, nfu, pathloc, cbk, local);
+    return ret;
+}
 
 int
-nfs_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *path,
-           fop_rmdir_cbk_t cbk, void *local)
+nfs_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *path,
+          fop_rmdir_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!path) || (!nfu))
-                return ret;
-
-        ret = nfs_inode_rmdir (nfsx, xl, nfu, path, cbk, local);
+    if ((!nfsx) || (!xl) || (!path) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_rmdir(nfsx, xl, nfu, path, cbk, local);
+    return ret;
+}
 
 int
-nfs_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-           mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
+nfs_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+          mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_inode_mknod (nfsx, xl, nfu, pathloc, mode, dev, cbk, local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_inode_mknod(nfsx, xl, nfu, pathloc, mode, dev, cbk, local);
+    return ret;
+}
 
 int
-nfs_readlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *linkloc,
-              fop_readlink_cbk_t cbk, void *local)
+nfs_readlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *linkloc,
+             fop_readlink_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!linkloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_fop_readlink (nfsx, xl, nfu, linkloc, NFS_PATH_MAX, cbk,
-                                local);
+    if ((!nfsx) || (!xl) || (!linkloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_fop_readlink(nfsx, xl, nfu, linkloc, NFS_PATH_MAX, cbk, local);
+    return ret;
+}
 
 int
-nfs_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
-             loc_t *linkloc, fop_symlink_cbk_t cbk, void *local)
+nfs_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
+            loc_t *linkloc, fop_symlink_cbk_t cbk, void *local)
 {
-        int                     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!linkloc) || (!target) || (!nfu))
-                return ret;
-
-        ret = nfs_inode_symlink (nfsx, xl, nfu, target, linkloc, cbk, local);
+    if ((!nfsx) || (!xl) || (!linkloc) || (!target) || (!nfu))
         return ret;
-}
-
 
+    ret = nfs_inode_symlink(nfsx, xl, nfu, target, linkloc, cbk, local);
+    return ret;
+}
 
 int
-nfs_setattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-             struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk,
-             void *local)
+nfs_setattr(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+            struct iatt *buf, int32_t valid, fop_setattr_cbk_t cbk, void *local)
 {
-        int     ret = -EFAULT;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    int ret = -EFAULT;
 
-        ret = nfs_fop_setattr (nfsx, xl, nfu, pathloc, buf, valid, cbk, local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
-}
 
+    ret = nfs_fop_setattr(nfsx, xl, nfu, pathloc, buf, valid, cbk, local);
+    return ret;
+}
 
 int
-nfs_statfs (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-            fop_statfs_cbk_t cbk, void *local)
+nfs_statfs(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+           fop_statfs_cbk_t cbk, void *local)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        ret = nfs_fop_statfs (nfsx, xl, nfu, pathloc, cbk, local);
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
         return ret;
+
+    ret = nfs_fop_statfs(nfsx, xl, nfu, pathloc, cbk, local);
+    return ret;
 }
 
 int
-nfs_opendir (xlator_t *nfsx, xlator_t *fopxl, nfs_user_t *nfu, loc_t *pathloc,
-             fop_opendir_cbk_t cbk, void *local)
+nfs_opendir(xlator_t *nfsx, xlator_t *fopxl, nfs_user_t *nfu, loc_t *pathloc,
+            fop_opendir_cbk_t cbk, void *local)
 {
-        if ((!nfsx) || (!fopxl) || (!pathloc) || (!nfu))
-                return -EFAULT;
+    if ((!nfsx) || (!fopxl) || (!pathloc) || (!nfu))
+        return -EFAULT;
 
-        return nfs_inode_opendir (nfsx, fopxl, nfu, pathloc, cbk, local);
+    return nfs_inode_opendir(nfsx, fopxl, nfu, pathloc, cbk, local);
 }
-
diff --git a/xlators/nfs/server/src/nfs-inodes.c b/xlators/nfs/server/src/nfs-inodes.c
index 91703c70a1f..9999e884ffa 100644
--- a/xlators/nfs/server/src/nfs-inodes.c
+++ b/xlators/nfs/server/src/nfs-inodes.c
@@ -18,588 +18,562 @@
 
 #include <libgen.h>
 
-#define inodes_nfl_to_prog_data(nflocal, pcbk, fram)                    \
-        do {                                                            \
-                nflocal = fram->local;                                  \
-                fram->local = nflocal->proglocal;                       \
-                *VOID(&pcbk) = nflocal->progcbk;                                \
-                nfs_fop_local_wipe (nflocal->nfsx, nflocal);            \
-        } while (0)                                                     \
+#define inodes_nfl_to_prog_data(nflocal, pcbk, fram)                           \
+    do {                                                                       \
+        nflocal = fram->local;                                                 \
+        fram->local = nflocal->proglocal;                                      \
+        *VOID(&pcbk) = nflocal->progcbk;                                       \
+        nfs_fop_local_wipe(nflocal->nfsx, nflocal);                            \
+    } while (0)
 
 void
-nfl_inodes_init (struct nfs_fop_local *nfl, inode_t *inode, inode_t *parent,
-                 inode_t *newparent, const char *name, const char *newname)
+nfl_inodes_init(struct nfs_fop_local *nfl, inode_t *inode, inode_t *parent,
+                inode_t *newparent, const char *name, const char *newname)
 {
-        if (!nfl)
-                return;
+    if (!nfl)
+        return;
 
-        if (inode)
-                nfl->inode = inode_ref (inode);
+    if (inode)
+        nfl->inode = inode_ref(inode);
 
-        if (parent)
-                nfl->parent = inode_ref (parent);
+    if (parent)
+        nfl->parent = inode_ref(parent);
 
-        if (newparent)
-                nfl->newparent = inode_ref (newparent);
+    if (newparent)
+        nfl->newparent = inode_ref(newparent);
 
-        if (name)
-                snprintf (nfl->path, NFS_NAME_MAX, "%s", name);
+    if (name)
+        snprintf(nfl->path, NFS_NAME_MAX, "%s", name);
 
-        if (newname)
-                snprintf (nfl->newpath, NFS_NAME_MAX, "%s", newname);
-        return;
+    if (newname)
+        snprintf(nfl->newpath, NFS_NAME_MAX, "%s", newname);
+    return;
 }
 
-
 int32_t
-nfs_inode_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode
-                      , struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata)
+nfs_inode_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                     struct iatt *buf, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = frame->local;
-        fop_create_cbk_t        progcbk = NULL;
-        inode_t                 *linked_inode = NULL;
+    struct nfs_fop_local *nfl = frame->local;
+    fop_create_cbk_t progcbk = NULL;
+    inode_t *linked_inode = NULL;
 
-        if (op_ret == -1)
-                goto do_not_link;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        linked_inode = inode_link (inode, nfl->parent, nfl->path, buf);
+    linked_inode = inode_link(inode, nfl->parent, nfl->path, buf);
 
 do_not_link:
-        /* NFS does not need it, upper layers should not expect the pointer to
-         * be a valid fd.
-         */
-        fd_unref (fd);
-
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, inode, buf,
-                         preparent, postparent, xdata);
-
-        if (linked_inode) {
-                inode_lookup (linked_inode);
-                inode_unref (linked_inode);
-        }
-
-        return 0;
+    /* NFS does not need it, upper layers should not expect the pointer to
+     * be a valid fd.
+     */
+    fd_unref(fd);
+
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, inode, buf,
+                preparent, postparent, xdata);
+
+    if (linked_inode) {
+        inode_lookup(linked_inode);
+        inode_unref(linked_inode);
+    }
+
+    return 0;
 }
 
-
 int
-nfs_inode_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu,
-                  loc_t *pathloc, int flags, int mode, fop_create_cbk_t cbk,
-                  void *local)
+nfs_inode_create(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                 int flags, int mode, fop_create_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
-        fd_t                    *newfd = NULL;
-
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
-
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-
-        newfd = fd_create (pathloc->inode, 0);
-        if (!newfd) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to create new fd");
-                ret = -ENOMEM;
-                goto wipe_nfl;
-        }
-
-        /* The parent and base name will be needed to link the new inode
-         * into the inode table.
-         */
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
-        ret = nfs_fop_create (nfsx, xl, nfu, pathloc, flags, mode, newfd,
-                              nfs_inode_create_cbk, nfl);
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
+    fd_t *newfd = NULL;
+
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
+
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+
+    newfd = fd_create(pathloc->inode, 0);
+    if (!newfd) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to create new fd");
+        ret = -ENOMEM;
+        goto wipe_nfl;
+    }
+
+    /* The parent and base name will be needed to link the new inode
+     * into the inode table.
+     */
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
+    ret = nfs_fop_create(nfsx, xl, nfu, pathloc, flags, mode, newfd,
+                         nfs_inode_create_cbk, nfl);
 wipe_nfl:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+nfs_inode_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = frame->local;
-        fop_mkdir_cbk_t         progcbk = NULL;
-        inode_t                 *linked_inode = NULL;
+    struct nfs_fop_local *nfl = frame->local;
+    fop_mkdir_cbk_t progcbk = NULL;
+    inode_t *linked_inode = NULL;
 
-        if (op_ret == -1)
-                goto do_not_link;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        linked_inode = inode_link (inode, nfl->parent, nfl->path, buf);
+    linked_inode = inode_link(inode, nfl->parent, nfl->path, buf);
 
 do_not_link:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
 
-        if (linked_inode) {
-                inode_lookup (linked_inode);
-                inode_unref (linked_inode);
-        }
+    if (linked_inode) {
+        inode_lookup(linked_inode);
+        inode_unref(linked_inode);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                 int mode, fop_mkdir_cbk_t cbk, void *local)
+nfs_inode_mkdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                int mode, fop_mkdir_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
-        ret = nfs_fop_mkdir (nfsx, xl, nfu, pathloc, mode, nfs_inode_mkdir_cbk,
-                             nfl);
-        if (ret < 0)
-                nfs_fop_local_wipe (nfsx, nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
+    ret = nfs_fop_mkdir(nfsx, xl, nfu, pathloc, mode, nfs_inode_mkdir_cbk, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(nfsx, nfl);
 
 err:
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+nfs_inode_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-
-        struct nfs_fop_local    *nfl = NULL;
-        fop_open_cbk_t          progcbk = NULL;
-
-        if ((op_ret == -1) && (fd))
-                fd_unref (fd);
-        /* Not needed here since the fd is cached in higher layers and the bind
-         * must happen atomically when the fd gets added to the fd LRU.
-         */
-/*        else
-                fd_bind (fd);
-*/
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata);
-        return 0;
+    struct nfs_fop_local *nfl = NULL;
+    fop_open_cbk_t progcbk = NULL;
+
+    if ((op_ret == -1) && (fd))
+        fd_unref(fd);
+    /* Not needed here since the fd is cached in higher layers and the bind
+     * must happen atomically when the fd gets added to the fd LRU.
+     */
+    /*        else
+                    fd_bind (fd);
+    */
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata);
+    return 0;
 }
 
-
 int
-nfs_inode_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                int32_t flags, fop_open_cbk_t cbk, void *local)
+nfs_inode_open(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+               int32_t flags, fop_open_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fd_t                    *newfd = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    fd_t *newfd = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!loc) || (!nfu))
+        return ret;
 
-        newfd = fd_create (loc->inode, 0);
-        if (!newfd) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to create fd");
-                ret = -ENOMEM;
-                goto err;
-        }
+    newfd = fd_create(loc->inode, 0);
+    if (!newfd) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to create fd");
+        ret = -ENOMEM;
+        goto err;
+    }
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, fd_err);
-        ret = nfs_fop_open (nfsx, xl, nfu, loc, flags, newfd,
-                            nfs_inode_open_cbk, nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, fd_err);
+    ret = nfs_fop_open(nfsx, xl, nfu, loc, flags, newfd, nfs_inode_open_cbk,
+                       nfl);
 
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
 fd_err:
-        if (ret < 0)
-                if (newfd)
-                        fd_unref (newfd);
+    if (ret < 0)
+        if (newfd)
+            fd_unref(newfd);
 
 err:
 
-        return ret;
+    return ret;
 }
 
-
-
 int32_t
-nfs_inode_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                      struct iatt *preoldparent, struct iatt *postoldparent,
-                      struct iatt *prenewparent, struct iatt *postnewparent,
-                      dict_t *xdata)
+nfs_inode_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                     struct iatt *preoldparent, struct iatt *postoldparent,
+                     struct iatt *prenewparent, struct iatt *postnewparent,
+                     dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_rename_cbk_t        progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_rename_cbk_t progcbk = NULL;
 
-        nfl = frame->local;
-        if (op_ret == -1)
-                goto do_not_link;
+    nfl = frame->local;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        inode_rename (this->itable, nfl->parent, nfl->path, nfl->newparent,
-                      nfl->newpath, nfl->inode, buf);
+    inode_rename(this->itable, nfl->parent, nfl->path, nfl->newparent,
+                 nfl->newpath, nfl->inode, buf);
 
 do_not_link:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, buf,
-                         preoldparent, postoldparent, prenewparent,
-                         postnewparent, xdata);
-        return 0;
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, buf, preoldparent,
+                postoldparent, prenewparent, postnewparent, xdata);
+    return 0;
 }
 
-
 int
-nfs_inode_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-                  loc_t *newloc, fop_rename_cbk_t cbk, void *local)
+nfs_inode_rename(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+                 loc_t *newloc, fop_rename_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc))
-                return ret;
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc))
+        return ret;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, oldloc->inode, oldloc->parent, newloc->parent,
-                         oldloc->name, newloc->name);
-        ret = nfs_fop_rename (nfsx,xl, nfu, oldloc, newloc, nfs_inode_rename_cbk
-                              , nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, oldloc->inode, oldloc->parent, newloc->parent,
+                    oldloc->name, newloc->name);
+    ret = nfs_fop_rename(nfsx, xl, nfu, oldloc, newloc, nfs_inode_rename_cbk,
+                         nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+nfs_inode_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_link_cbk_t          progcbk = NULL;
-        inode_t                 *linked_inode = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_link_cbk_t progcbk = NULL;
+    inode_t *linked_inode = NULL;
 
-        if (op_ret == -1)
-                goto do_not_link;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        nfl = frame->local;
-        linked_inode = inode_link (inode, nfl->newparent, nfl->path, buf);
+    nfl = frame->local;
+    linked_inode = inode_link(inode, nfl->newparent, nfl->path, buf);
 
 do_not_link:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
 
-        if (linked_inode) {
-                inode_lookup (linked_inode);
-                inode_unref (linked_inode);
-        }
+    if (linked_inode) {
+        inode_lookup(linked_inode);
+        inode_unref(linked_inode);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
-                loc_t *newloc, fop_link_cbk_t cbk, void *local)
+nfs_inode_link(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc,
+               loc_t *newloc, fop_link_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local            *nfl = NULL;
-        int                             ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
-                return -EFAULT;
+    if ((!nfsx) || (!xl) || (!oldloc) || (!newloc) || (!nfu))
+        return -EFAULT;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, NULL, NULL, newloc->parent, newloc->name, NULL);
-        ret = nfs_fop_link (nfsx, xl, nfu, oldloc, newloc, nfs_inode_link_cbk,
-                            nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, NULL, NULL, newloc->parent, newloc->name, NULL);
+    ret = nfs_fop_link(nfsx, xl, nfu, oldloc, newloc, nfs_inode_link_cbk, nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                      struct iatt *postparent, dict_t *xdata)
+nfs_inode_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                     struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_unlink_cbk_t        progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_unlink_cbk_t progcbk = NULL;
 
-        nfl = frame->local;
+    nfl = frame->local;
 
-        if (op_ret == -1)
-                goto do_not_unlink;
+    if (op_ret == -1)
+        goto do_not_unlink;
 
-        inode_unlink (nfl->inode, nfl->parent, nfl->path);
-        inode_forget (nfl->inode, 0);
+    inode_unlink(nfl->inode, nfl->parent, nfl->path);
+    inode_forget(nfl->inode, 0);
 
 do_not_unlink:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, preparent,
-                         postparent, xdata);
-        return 0;
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent,
+                xdata);
+    return 0;
 }
 
-
 int
-nfs_inode_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                  fop_unlink_cbk_t cbk, void *local)
+nfs_inode_unlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                 fop_unlink_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local            *nfl = NULL;
-        int                             ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return -EFAULT;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return -EFAULT;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
-        ret = nfs_fop_unlink (nfsx, xl, nfu, pathloc, nfs_inode_unlink_cbk,nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
+    ret = nfs_fop_unlink(nfsx, xl, nfu, pathloc, nfs_inode_unlink_cbk, nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+nfs_inode_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_rmdir_cbk_t         progcbk = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_rmdir_cbk_t progcbk = NULL;
 
-        nfl = frame->local;
+    nfl = frame->local;
 
-        if (op_ret == -1)
-                goto do_not_unlink;
+    if (op_ret == -1)
+        goto do_not_unlink;
 
-        inode_unlink (nfl->inode, nfl->parent, nfl->path);
-        inode_forget (nfl->inode, 0);
+    inode_unlink(nfl->inode, nfl->parent, nfl->path);
+    inode_forget(nfl->inode, 0);
 
 do_not_unlink:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, preparent,
-                         postparent, xdata);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, preparent, postparent,
+                xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                 fop_rmdir_cbk_t cbk, void *local)
+nfs_inode_rmdir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                fop_rmdir_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
 
-        ret = nfs_fop_rmdir (nfsx, xl, nfu, pathloc, nfs_inode_rmdir_cbk, nfl);
+    ret = nfs_fop_rmdir(nfsx, xl, nfu, pathloc, nfs_inode_rmdir_cbk, nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
-        return ret;
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
+    return ret;
 }
 
-
 int32_t
-nfs_inode_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
+nfs_inode_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_mknod_cbk_t         progcbk = NULL;
-        inode_t                 *linked_inode = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_mknod_cbk_t progcbk = NULL;
+    inode_t *linked_inode = NULL;
 
-        nfl = frame->local;
+    nfl = frame->local;
 
-        if (op_ret == -1)
-                goto do_not_link;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        linked_inode = inode_link (inode, nfl->parent, nfl->path, buf);
+    linked_inode = inode_link(inode, nfl->parent, nfl->path, buf);
 
 do_not_link:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
 
-        if (linked_inode) {
-                inode_lookup (linked_inode);
-                inode_unref (linked_inode);
-        }
+    if (linked_inode) {
+        inode_lookup(linked_inode);
+        inode_unref(linked_inode);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
-                 mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
+nfs_inode_mknod(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc,
+                mode_t mode, dev_t dev, fop_mknod_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!pathloc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
 
-        ret = nfs_fop_mknod (nfsx, xl, nfu, pathloc, mode, dev,
-                             nfs_inode_mknod_cbk, nfl);
+    ret = nfs_fop_mknod(nfsx, xl, nfu, pathloc, mode, dev, nfs_inode_mknod_cbk,
+                        nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs_inode_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, inode_t *inode,
-                       struct iatt *buf, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
+nfs_inode_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, inode_t *inode,
+                      struct iatt *buf, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fop_symlink_cbk_t       progcbk = NULL;
-        inode_t                 *linked_inode = NULL;
+    struct nfs_fop_local *nfl = NULL;
+    fop_symlink_cbk_t progcbk = NULL;
+    inode_t *linked_inode = NULL;
 
-        nfl = frame->local;
-        if (op_ret == -1)
-                goto do_not_link;
+    nfl = frame->local;
+    if (op_ret == -1)
+        goto do_not_link;
 
-        linked_inode = inode_link (inode, nfl->parent, nfl->path, buf);
+    linked_inode = inode_link(inode, nfl->parent, nfl->path, buf);
 
 do_not_link:
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                         preparent, postparent, xdata);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
+                postparent, xdata);
 
-        if (linked_inode) {
-                inode_lookup (linked_inode);
-                inode_unref (linked_inode);
-        }
+    if (linked_inode) {
+        inode_lookup(linked_inode);
+        inode_unref(linked_inode);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
-                   loc_t *pathloc, fop_symlink_cbk_t cbk, void *local)
+nfs_inode_symlink(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target,
+                  loc_t *pathloc, fop_symlink_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!target) || (!pathloc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!target) || (!pathloc) || (!nfu))
+        return ret;
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        nfl_inodes_init (nfl, pathloc->inode, pathloc->parent, NULL,
-                         pathloc->name, NULL);
-        ret = nfs_fop_symlink (nfsx, xl, nfu, target, pathloc,
-                               nfs_inode_symlink_cbk, nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    nfl_inodes_init(nfl, pathloc->inode, pathloc->parent, NULL, pathloc->name,
+                    NULL);
+    ret = nfs_fop_symlink(nfsx, xl, nfu, target, pathloc, nfs_inode_symlink_cbk,
+                          nfl);
 
 err:
-        if (ret < 0)
-                nfs_fop_local_wipe (xl, nfl);
+    if (ret < 0)
+        nfs_fop_local_wipe(xl, nfl);
 
-        return ret;
+    return ret;
 }
 
 int32_t
-nfs_inode_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+nfs_inode_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
+    struct nfs_fop_local *nfl = NULL;
+    fop_open_cbk_t progcbk = NULL;
 
-        struct nfs_fop_local    *nfl = NULL;
-        fop_open_cbk_t          progcbk = NULL;
+    if (op_ret != -1)
+        fd_bind(fd);
 
-        if (op_ret != -1)
-                fd_bind (fd);
+    inodes_nfl_to_prog_data(nfl, progcbk, frame);
 
-        inodes_nfl_to_prog_data (nfl, progcbk, frame);
+    if (progcbk)
+        progcbk(frame, cookie, this, op_ret, op_errno, fd, xdata);
 
-        if (progcbk)
-                progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata);
-
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_inode_opendir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
-                   fop_opendir_cbk_t cbk, void *local)
+nfs_inode_opendir(xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc,
+                  fop_opendir_cbk_t cbk, void *local)
 {
-        struct nfs_fop_local    *nfl = NULL;
-        fd_t                    *newfd = NULL;
-        int                     ret = -EFAULT;
+    struct nfs_fop_local *nfl = NULL;
+    fd_t *newfd = NULL;
+    int ret = -EFAULT;
 
-        if ((!nfsx) || (!xl) || (!loc) || (!nfu))
-                return ret;
+    if ((!nfsx) || (!xl) || (!loc) || (!nfu))
+        return ret;
 
-        newfd = fd_create (loc->inode, 0);
-        if (!newfd) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to create fd");
-                ret = -ENOMEM;
-                goto err;
-        }
+    newfd = fd_create(loc->inode, 0);
+    if (!newfd) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to create fd");
+        ret = -ENOMEM;
+        goto err;
+    }
 
-        nfs_fop_handle_local_init (NULL, nfsx, nfl, cbk, local, ret, err);
-        ret = nfs_fop_opendir (nfsx, xl, nfu, loc, newfd,
-                               nfs_inode_opendir_cbk, nfl);
+    nfs_fop_handle_local_init(NULL, nfsx, nfl, cbk, local, ret, err);
+    ret = nfs_fop_opendir(nfsx, xl, nfu, loc, newfd, nfs_inode_opendir_cbk,
+                          nfl);
 
 err:
-        if (ret < 0) {
-                if (newfd)
-                        fd_unref (newfd);
-                nfs_fop_local_wipe (xl, nfl);
-        }
+    if (ret < 0) {
+        if (newfd)
+            fd_unref(newfd);
+        nfs_fop_local_wipe(xl, nfl);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c
index 7f741695fb5..a20fab3ef79 100644
--- a/xlators/nfs/server/src/nfs.c
+++ b/xlators/nfs/server/src/nfs.c
@@ -12,7 +12,6 @@
  * Every other protocol version gets initialized from here.
  */
 
-
 #include "defaults.h"
 #include "rpcsvc.h"
 #include "dict.h"
@@ -33,1449 +32,1393 @@
 #include "rpcsvc.h"
 #include "nfs-messages.h"
 
-#define OPT_SERVER_AUX_GIDS             "nfs.server-aux-gids"
-#define OPT_SERVER_GID_CACHE_TIMEOUT    "nfs.server.aux-gid-timeout"
-#define OPT_SERVER_RPC_STATD             "nfs.rpc-statd"
-#define OPT_SERVER_RPC_STATD_PIDFILE     "nfs.rpc-statd-pidfile"
+#define OPT_SERVER_AUX_GIDS "nfs.server-aux-gids"
+#define OPT_SERVER_GID_CACHE_TIMEOUT "nfs.server.aux-gid-timeout"
+#define OPT_SERVER_RPC_STATD "nfs.rpc-statd"
+#define OPT_SERVER_RPC_STATD_PIDFILE "nfs.rpc-statd-pidfile"
 #define OPT_SERVER_RPC_STATD_NOTIFY_PIDFILE "nfs.rpc-statd-notify-pidfile"
 
-#define NFS_DATADIR                     GLUSTERD_DEFAULT_WORKDIR "/nfs"
+#define NFS_DATADIR GLUSTERD_DEFAULT_WORKDIR "/nfs"
 
 /* Forward declaration */
-static int nfs_add_initer (struct list_head *list, nfs_version_initer_t init,
-                           gf_boolean_t required);
+static int
+nfs_add_initer(struct list_head *list, nfs_version_initer_t init,
+               gf_boolean_t required);
 
 static int
-nfs_init_version (xlator_t *this, nfs_version_initer_t init,
-                  gf_boolean_t required)
+nfs_init_version(xlator_t *this, nfs_version_initer_t init,
+                 gf_boolean_t required)
 {
-        int                       ret       = -1;
-        struct nfs_initer_list    *version  = NULL;
-        struct nfs_initer_list    *tmp      = NULL;
-        rpcsvc_program_t          *prog     = NULL;
-        struct list_head          *versions = NULL;
-        struct nfs_state          *nfs      = NULL;
-        gf_boolean_t              found     = _gf_false;
-
-        if ((!this) || (!this->private) || (!init))
-                return (-1);
-
-        nfs = (struct nfs_state *)this->private;
-
-        ret = nfs_add_initer (&nfs->versions, init, required);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
-                        "Failed to add protocol initializer");
-                goto err;
-        }
-
-        versions = &nfs->versions;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                prog = version->program;
-                if (version->init == init) {
-                        prog = init(this);
-                        if (!prog) {
-                                ret = -1;
-                                goto err;
-                        }
-                        version->program = prog;
-                        found = _gf_true;
-                        break;
-                }
-        }
-
-        /* program not added */
-        if (!found) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_NOT_FOUND,
-                        "Program: %s NOT found", prog->progname);
-                goto err;
-        }
-
-        /* Check if nfs.port is configured */
-        if (nfs->override_portnum)
-                prog->progport = nfs->override_portnum;
-
-        gf_msg_debug (GF_NFS, 0, "Starting program: %s", prog->progname);
-
-        ret = rpcsvc_program_register (nfs->rpcsvc, prog, _gf_false);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL,
-                        "Program: %s init failed", prog->progname);
-                goto err;
-        }
-
-        /* Registration with portmapper is disabled, Nothing to do */
-        if (!nfs->register_portmap)
-                goto err;
+    int ret = -1;
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    rpcsvc_program_t *prog = NULL;
+    struct list_head *versions = NULL;
+    struct nfs_state *nfs = NULL;
+    gf_boolean_t found = _gf_false;
+
+    if ((!this) || (!this->private) || (!init))
+        return (-1);
 
-        ret = rpcsvc_program_register_portmap (prog, prog->progport);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL,
-                        "Program  %s registration failed", prog->progname);
+    nfs = (struct nfs_state *)this->private;
+
+    ret = nfs_add_initer(&nfs->versions, init, required);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+               "Failed to add protocol initializer");
+        goto err;
+    }
+
+    versions = &nfs->versions;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        prog = version->program;
+        if (version->init == init) {
+            prog = init(this);
+            if (!prog) {
+                ret = -1;
                 goto err;
-        }
-        ret = 0; /* All well */
+            }
+            version->program = prog;
+            found = _gf_true;
+            break;
+        }
+    }
+
+    /* program not added */
+    if (!found) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_NOT_FOUND,
+               "Program: %s NOT found", prog->progname);
+        goto err;
+    }
+
+    /* Check if nfs.port is configured */
+    if (nfs->override_portnum)
+        prog->progport = nfs->override_portnum;
+
+    gf_msg_debug(GF_NFS, 0, "Starting program: %s", prog->progname);
+
+    ret = rpcsvc_program_register(nfs->rpcsvc, prog, _gf_false);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL,
+               "Program: %s init failed", prog->progname);
+        goto err;
+    }
+
+    /* Registration with portmapper is disabled, Nothing to do */
+    if (!nfs->register_portmap)
+        goto err;
+
+    ret = rpcsvc_program_register_portmap(prog, prog->progport);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL,
+               "Program  %s registration failed", prog->progname);
+        goto err;
+    }
+    ret = 0; /* All well */
 err:
-        return ret;
+    return ret;
 }
 
 static int
-nfs_deinit_version (struct nfs_state *nfs, nfs_version_initer_t init)
+nfs_deinit_version(struct nfs_state *nfs, nfs_version_initer_t init)
 {
-        int                       ret       = -1;
-        struct nfs_initer_list    *version  = NULL;
-        struct nfs_initer_list    *tmp      = NULL;
-        rpcsvc_program_t          *prog     = NULL;
-        struct list_head          *versions = NULL;
+    int ret = -1;
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    rpcsvc_program_t *prog = NULL;
+    struct list_head *versions = NULL;
 
-        if ((!nfs) || (!init))
-                return (-1);
+    if ((!nfs) || (!init))
+        return (-1);
 
-        versions = &nfs->versions;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                prog = version->program;
-                if (version->init == init) {
-                        prog = version->program;
-                        ret = rpcsvc_program_unregister (nfs->rpcsvc, prog);
-                        if (ret != 0)
-                                return (-1);
-                        list_del (&version->list);
-                        GF_FREE (version);
-                        return (0);
-                }
+    versions = &nfs->versions;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        prog = version->program;
+        if (version->init == init) {
+            prog = version->program;
+            ret = rpcsvc_program_unregister(nfs->rpcsvc, prog);
+            if (ret != 0)
+                return (-1);
+            list_del(&version->list);
+            GF_FREE(version);
+            return (0);
         }
+    }
 
-        return (-1);
+    return (-1);
 }
 
 static int
-nfs_reconfigure_acl3 (xlator_t *this)
+nfs_reconfigure_acl3(xlator_t *this)
 {
-        struct nfs_state          *nfs     = NULL;
+    struct nfs_state *nfs = NULL;
 
-        if ((!this) || (!this->private))
-                return (-1);
+    if ((!this) || (!this->private))
+        return (-1);
 
-        nfs = (struct nfs_state *)this->private;
+    nfs = (struct nfs_state *)this->private;
 
-        /* ACL is enabled */
-        if (nfs->enable_acl)
-                return nfs_init_version (this, acl3svc_init, _gf_false);
+    /* ACL is enabled */
+    if (nfs->enable_acl)
+        return nfs_init_version(this, acl3svc_init, _gf_false);
 
-        /* ACL is disabled */
-        return nfs_deinit_version (nfs, acl3svc_init);
+    /* ACL is disabled */
+    return nfs_deinit_version(nfs, acl3svc_init);
 }
 
 static int
-nfs_reconfigure_nlm4 (xlator_t *this)
+nfs_reconfigure_nlm4(xlator_t *this)
 {
-        struct nfs_state          *nfs     = NULL;
+    struct nfs_state *nfs = NULL;
 
-        if ((!this) || (!this->private))
-                return (-1);
+    if ((!this) || (!this->private))
+        return (-1);
 
-        nfs = (struct nfs_state *)this->private;
+    nfs = (struct nfs_state *)this->private;
 
-        /* NLM is enabled */
-        if (nfs->enable_nlm)
-                return nfs_init_version (this, nlm4svc_init, _gf_false);
+    /* NLM is enabled */
+    if (nfs->enable_nlm)
+        return nfs_init_version(this, nlm4svc_init, _gf_false);
 
-        /* NLM is disabled */
-        return nfs_deinit_version (nfs, nlm4svc_init);
+    /* NLM is disabled */
+    return nfs_deinit_version(nfs, nlm4svc_init);
 }
 
 static int
-nfs_program_register_portmap_all (struct nfs_state *nfs)
+nfs_program_register_portmap_all(struct nfs_state *nfs)
 {
-        struct list_head                *versions = NULL;
-        struct nfs_initer_list          *version = NULL;
-        struct nfs_initer_list          *tmp = NULL;
-        rpcsvc_program_t                *prog = NULL;
+    struct list_head *versions = NULL;
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    rpcsvc_program_t *prog = NULL;
 
-        if (nfs == NULL)
-                return (-1);
+    if (nfs == NULL)
+        return (-1);
 
-        versions = &nfs->versions;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                prog = version->program;
-                if (prog == NULL)
-                        continue;
-                if (nfs->override_portnum)
-                        prog->progport = nfs->override_portnum;
-                (void) rpcsvc_program_register_portmap (prog, prog->progport);
+    versions = &nfs->versions;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        prog = version->program;
+        if (prog == NULL)
+            continue;
+        if (nfs->override_portnum)
+            prog->progport = nfs->override_portnum;
+        (void)rpcsvc_program_register_portmap(prog, prog->progport);
 #ifdef IPV6_DEFAULT
-                (void) rpcsvc_program_register_rpcbind6 (prog, prog->progport);
+        (void)rpcsvc_program_register_rpcbind6(prog, prog->progport);
 #endif
+    }
 
-        }
-
-        return (0);
+    return (0);
 }
 
 static int
-nfs_program_unregister_portmap_all (struct nfs_state *nfs)
+nfs_program_unregister_portmap_all(struct nfs_state *nfs)
 {
-        struct list_head                *versions = NULL;
-        struct nfs_initer_list          *version = NULL;
-        struct nfs_initer_list          *tmp = NULL;
-        rpcsvc_program_t                *prog = NULL;
+    struct list_head *versions = NULL;
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    rpcsvc_program_t *prog = NULL;
 
-        if (nfs == NULL)
-                return (-1);
+    if (nfs == NULL)
+        return (-1);
 
-        versions = &nfs->versions;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                prog = version->program;
-                if (prog == NULL)
-                        continue;
-                (void) rpcsvc_program_unregister_portmap (prog);
+    versions = &nfs->versions;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        prog = version->program;
+        if (prog == NULL)
+            continue;
+        (void)rpcsvc_program_unregister_portmap(prog);
 #ifdef IPV6_DEFAULT
-                (void) rpcsvc_program_unregister_rpcbind6 (prog);
+        (void)rpcsvc_program_unregister_rpcbind6(prog);
 #endif
-        }
+    }
 
-        return (0);
+    return (0);
 }
 
 /* Every NFS version must call this function with the init function
  * for its particular version.
  */
 static int
-nfs_add_initer (struct list_head *list, nfs_version_initer_t init,
-                gf_boolean_t required)
+nfs_add_initer(struct list_head *list, nfs_version_initer_t init,
+               gf_boolean_t required)
 {
-        struct nfs_initer_list  *new = NULL;
-        if ((!list) || (!init))
-                return -1;
-
-        new = GF_CALLOC (1, sizeof (*new), gf_nfs_mt_nfs_initer_list);
-        if (!new) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                return -1;
-        }
-
-        new->init = init;
-        new->required = required;
-        list_add_tail (&new->list, list);
-        return 0;
+    struct nfs_initer_list *new = NULL;
+    if ((!list) || (!init))
+        return -1;
+
+    new = GF_CALLOC(1, sizeof(*new), gf_nfs_mt_nfs_initer_list);
+    if (!new) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        return -1;
+    }
+
+    new->init = init;
+    new->required = required;
+    list_add_tail(&new->list, list);
+    return 0;
 }
 
-
 int
-nfs_deinit_versions (struct list_head *versions, xlator_t *this)
+nfs_deinit_versions(struct list_head *versions, xlator_t *this)
 {
-        struct nfs_initer_list          *version = NULL;
-        struct nfs_initer_list          *tmp = NULL;
-        struct nfs_state                *nfs = NULL;
-
-        if ((!versions) || (!this))
-                return -1;
-
-        nfs = (struct nfs_state *)this->private;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                /* TODO: Add version specific destructor.
-                 * if (!version->deinit)
-                        goto err;
-
-                   version->deinit (this);
-                */
-                if (version->program)
-                        rpcsvc_program_unregister (nfs->rpcsvc,
-                                                   (version->program));
-
-                list_del (&version->list);
-                GF_FREE (version);
-        }
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    struct nfs_state *nfs = NULL;
+
+    if ((!versions) || (!this))
+        return -1;
+
+    nfs = (struct nfs_state *)this->private;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        /* TODO: Add version specific destructor.
+         * if (!version->deinit)
+                goto err;
 
-        return 0;
+           version->deinit (this);
+        */
+        if (version->program)
+            rpcsvc_program_unregister(nfs->rpcsvc, (version->program));
+
+        list_del(&version->list);
+        GF_FREE(version);
+    }
+
+    return 0;
 }
 
 int
-nfs_init_versions (struct nfs_state *nfs, xlator_t *this)
+nfs_init_versions(struct nfs_state *nfs, xlator_t *this)
 {
-        struct nfs_initer_list          *version = NULL;
-        struct nfs_initer_list          *tmp = NULL;
-        rpcsvc_program_t                *prog = NULL;
-        int                             ret = -1;
-        struct list_head                *versions = NULL;
-
-        if ((!nfs) || (!this))
-                return -1;
-
-        gf_msg_debug (GF_NFS, 0, "Initing protocol versions");
-        versions = &nfs->versions;
-        list_for_each_entry_safe (version, tmp, versions, list) {
-                if (!version->init) {
-                        ret = -1;
-                        goto err;
-                }
-
-                prog = version->init (this);
-                if (!prog) {
-                        ret = -1;
-                        goto err;
-                }
-
-                version->program = prog;
-                if (nfs->override_portnum)
-                        prog->progport = nfs->override_portnum;
-                gf_msg_debug (GF_NFS, 0, "Starting program: %s",
-                        prog->progname);
-
-                ret = rpcsvc_program_register (nfs->rpcsvc, prog, _gf_false);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_PGM_INIT_FAIL,
-                                "Program: %s init failed", prog->progname);
-                        goto err;
-                }
-                if (nfs->register_portmap) {
-                        ret = rpcsvc_program_register_portmap (prog,
-                                                               prog->progport);
-                        if (ret == -1) {
-                                gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                        NFS_MSG_PGM_REG_FAIL,
-                                        "%s program  %s registration failed",
-                                        version->required ?
-                                        "Required" : "Optional",
-                                        prog->progname);
-
-                                /* fatal error if the program is required */
-                                if (version->required)
-                                        goto err;
-                        }
+    struct nfs_initer_list *version = NULL;
+    struct nfs_initer_list *tmp = NULL;
+    rpcsvc_program_t *prog = NULL;
+    int ret = -1;
+    struct list_head *versions = NULL;
+
+    if ((!nfs) || (!this))
+        return -1;
+
+    gf_msg_debug(GF_NFS, 0, "Initing protocol versions");
+    versions = &nfs->versions;
+    list_for_each_entry_safe(version, tmp, versions, list)
+    {
+        if (!version->init) {
+            ret = -1;
+            goto err;
+        }
+
+        prog = version->init(this);
+        if (!prog) {
+            ret = -1;
+            goto err;
+        }
+
+        version->program = prog;
+        if (nfs->override_portnum)
+            prog->progport = nfs->override_portnum;
+        gf_msg_debug(GF_NFS, 0, "Starting program: %s", prog->progname);
+
+        ret = rpcsvc_program_register(nfs->rpcsvc, prog, _gf_false);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_INIT_FAIL,
+                   "Program: %s init failed", prog->progname);
+            goto err;
+        }
+        if (nfs->register_portmap) {
+            ret = rpcsvc_program_register_portmap(prog, prog->progport);
+            if (ret == -1) {
+                gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL,
+                       "%s program  %s registration failed",
+                       version->required ? "Required" : "Optional",
+                       prog->progname);
+
+                /* fatal error if the program is required */
+                if (version->required)
+                    goto err;
+            }
 #ifdef IPV6_DEFAULT
-                        ret = rpcsvc_program_register_rpcbind6 (prog,
-                                                                prog->progport);
-                        if (ret == -1) {
-                                gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                        NFS_MSG_PGM_REG_FAIL,
-                                        "Program (ipv6) %s registration failed",
-                                        prog->progname);
-                                goto err;
-                        }
+            ret = rpcsvc_program_register_rpcbind6(prog, prog->progport);
+            if (ret == -1) {
+                gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PGM_REG_FAIL,
+                       "Program (ipv6) %s registration failed", prog->progname);
+                goto err;
+            }
 #endif
-                }
-
         }
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_add_all_initiators (struct nfs_state *nfs)
+nfs_add_all_initiators(struct nfs_state *nfs)
 {
-        int     ret = 0;
-
-        /* Add the initializers for all versions. */
-        ret = nfs_add_initer (&nfs->versions, mnt3svc_init, _gf_true);
+    int ret = 0;
+
+    /* Add the initializers for all versions. */
+    ret = nfs_add_initer(&nfs->versions, mnt3svc_init, _gf_true);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+               "Failed to add MOUNT3 protocol initializer");
+        goto ret;
+    }
+
+    ret = nfs_add_initer(&nfs->versions, mnt1svc_init, _gf_true);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+               "Failed to add MOUNT1 protocol initializer");
+        goto ret;
+    }
+
+    ret = nfs_add_initer(&nfs->versions, nfs3svc_init, _gf_true);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+               "Failed to add NFS3 protocol initializer");
+        goto ret;
+    }
+
+    if (nfs->enable_nlm == _gf_true) {
+        ret = nfs_add_initer(&nfs->versions, nlm4svc_init, _gf_false);
         if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
-                        "Failed to add MOUNT3 protocol initializer");
-                goto ret;
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+                   "Failed to add protocol initializer");
+            goto ret;
         }
+    }
 
-        ret = nfs_add_initer (&nfs->versions, mnt1svc_init, _gf_true);
+    if (nfs->enable_acl == _gf_true) {
+        ret = nfs_add_initer(&nfs->versions, acl3svc_init, _gf_false);
         if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
-                        "Failed to add MOUNT1 protocol initializer");
-                goto ret;
-        }
-
-        ret = nfs_add_initer (&nfs->versions, nfs3svc_init, _gf_true);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
-                        "Failed to add NFS3 protocol initializer");
-                goto ret;
-        }
-
-        if (nfs->enable_nlm == _gf_true) {
-                ret = nfs_add_initer (&nfs->versions, nlm4svc_init, _gf_false);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_PROT_INIT_ADD_FAIL,
-                                "Failed to add protocol initializer");
-                        goto ret;
-                }
-        }
-
-        if (nfs->enable_acl == _gf_true) {
-                ret = nfs_add_initer (&nfs->versions, acl3svc_init, _gf_false);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_PROT_INIT_ADD_FAIL,
-                                "Failed to add ACL protocol initializer");
-                        goto ret;
-                }
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_PROT_INIT_ADD_FAIL,
+                   "Failed to add ACL protocol initializer");
+            goto ret;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 ret:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_subvolume_started (struct nfs_state *nfs, xlator_t *xl)
+nfs_subvolume_started(struct nfs_state *nfs, xlator_t *xl)
 {
-        int     x = 0;
-        int     started = 0;
-
-        if ((!nfs) || (!xl))
-                return 1;
-
-        LOCK (&nfs->svinitlock);
-        {
-                for (;x < nfs->allsubvols; ++x) {
-                        if (nfs->initedxl[x] == xl) {
-                                started = 1;
-                                goto unlock;
-                       }
-               }
+    int x = 0;
+    int started = 0;
+
+    if ((!nfs) || (!xl))
+        return 1;
+
+    LOCK(&nfs->svinitlock);
+    {
+        for (; x < nfs->allsubvols; ++x) {
+            if (nfs->initedxl[x] == xl) {
+                started = 1;
+                goto unlock;
+            }
         }
+    }
 unlock:
-        UNLOCK (&nfs->svinitlock);
+    UNLOCK(&nfs->svinitlock);
 
-        return started;
+    return started;
 }
 
-
 int
-nfs_subvolume_set_started (struct nfs_state *nfs, xlator_t *xl)
+nfs_subvolume_set_started(struct nfs_state *nfs, xlator_t *xl)
 {
-        int     x = 0;
-
-        if ((!nfs) || (!xl))
-                return 1;
-
-        LOCK (&nfs->svinitlock);
-        {
-                for (;x < nfs->allsubvols; ++x) {
-                        if (nfs->initedxl[x] == xl) {
-                                gf_msg_debug (GF_NFS, 0,
-                                        "Volume already started %s",
-                                        xl->name);
-                                break;
-                        }
-
-                        if (nfs->initedxl[x] == NULL) {
-                                nfs->initedxl[x] = xl;
-                                ++nfs->upsubvols;
-                                gf_msg_debug (GF_NFS, 0, "Starting up: %s "
-                                        ", vols started till now: %d", xl->name,
-                                        nfs->upsubvols);
-                                goto unlock;
-                        }
-               }
-        }
+    int x = 0;
+
+    if ((!nfs) || (!xl))
+        return 1;
+
+    LOCK(&nfs->svinitlock);
+    {
+        for (; x < nfs->allsubvols; ++x) {
+            if (nfs->initedxl[x] == xl) {
+                gf_msg_debug(GF_NFS, 0, "Volume already started %s", xl->name);
+                break;
+            }
+
+            if (nfs->initedxl[x] == NULL) {
+                nfs->initedxl[x] = xl;
+                ++nfs->upsubvols;
+                gf_msg_debug(GF_NFS, 0,
+                             "Starting up: %s "
+                             ", vols started till now: %d",
+                             xl->name, nfs->upsubvols);
+                goto unlock;
+            }
+        }
+    }
 unlock:
-        UNLOCK (&nfs->svinitlock);
+    UNLOCK(&nfs->svinitlock);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs_start_subvol_lookup_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)
+nfs_start_subvol_lookup_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)
 {
-        if (op_ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, op_errno,
-                        NFS_MSG_LOOKUP_ROOT_FAIL,
-                        "Failed to lookup root: %s",
-                        strerror (op_errno));
-                goto err;
-        }
-
-        nfs_subvolume_set_started (this->private, ((xlator_t *)cookie));
-        gf_msg_trace (GF_NFS, 0, "Started %s", ((xlator_t *)cookie)->name);
+    if (op_ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, op_errno, NFS_MSG_LOOKUP_ROOT_FAIL,
+               "Failed to lookup root: %s", strerror(op_errno));
+        goto err;
+    }
+
+    nfs_subvolume_set_started(this->private, ((xlator_t *)cookie));
+    gf_msg_trace(GF_NFS, 0, "Started %s", ((xlator_t *)cookie)->name);
 err:
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_startup_subvolume (xlator_t *nfsx, xlator_t *xl)
+nfs_startup_subvolume(xlator_t *nfsx, xlator_t *xl)
 {
-        int             ret = -1;
-        loc_t           rootloc = {0, };
-        nfs_user_t      nfu = {0, };
-
-        if ((!nfsx) || (!xl))
-                return -1;
-
-        if (nfs_subvolume_started (nfsx->private, xl)) {
-                gf_msg_trace (GF_NFS, 0, "Subvolume already started: %s",
-                        xl->name);
-                ret = 0;
-                goto err;
-        }
-
-        ret = nfs_root_loc_fill (xl->itable, &rootloc);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, 0,
-                        NFS_MSG_ROOT_LOC_INIT_FAIL,
-                        "Failed to init root loc");
-                goto err;
-        }
-
-        nfs_user_root_create (&nfu);
-        ret = nfs_fop_lookup (nfsx, xl, &nfu, &rootloc,
-                              nfs_start_subvol_lookup_cbk,
-                              (void *)nfsx->private);
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, -ret,
-                        NFS_MSG_LOOKUP_ROOT_FAIL,
-                        "Failed to lookup root: %s", strerror (-ret));
-                goto err;
-        }
-
-        nfs_loc_wipe (&rootloc);
+    int ret = -1;
+    loc_t rootloc = {
+        0,
+    };
+    nfs_user_t nfu = {
+        0,
+    };
+
+    if ((!nfsx) || (!xl))
+        return -1;
+
+    if (nfs_subvolume_started(nfsx->private, xl)) {
+        gf_msg_trace(GF_NFS, 0, "Subvolume already started: %s", xl->name);
+        ret = 0;
+        goto err;
+    }
+
+    ret = nfs_root_loc_fill(xl->itable, &rootloc);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_ROOT_LOC_INIT_FAIL,
+               "Failed to init root loc");
+        goto err;
+    }
+
+    nfs_user_root_create(&nfu);
+    ret = nfs_fop_lookup(nfsx, xl, &nfu, &rootloc, nfs_start_subvol_lookup_cbk,
+                         (void *)nfsx->private);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, -ret, NFS_MSG_LOOKUP_ROOT_FAIL,
+               "Failed to lookup root: %s", strerror(-ret));
+        goto err;
+    }
+
+    nfs_loc_wipe(&rootloc);
 
 err:
-        return ret;
+    return ret;
 }
 
 int
-nfs_startup_subvolumes (xlator_t *nfsx)
+nfs_startup_subvolumes(xlator_t *nfsx)
 {
-        int                     ret = -1;
-        xlator_list_t           *cl = NULL;
-        struct nfs_state        *nfs = NULL;
-
-        if (!nfsx)
-                return -1;
-
-        nfs = nfsx->private;
-        cl = nfs->subvols;
-        while (cl) {
-                gf_msg_debug (GF_NFS, 0, "Starting subvolume: %s",
-                        cl->xlator->name);
-                ret = nfs_startup_subvolume (nfsx, cl->xlator);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_CRITICAL, 0,
-                                NFS_MSG_STARTUP_FAIL,
-                                "Failed to start-up xlator: %s",
-                                cl->xlator->name);
-                        goto err;
-                }
-                cl = cl->next;
+    int ret = -1;
+    xlator_list_t *cl = NULL;
+    struct nfs_state *nfs = NULL;
+
+    if (!nfsx)
+        return -1;
+
+    nfs = nfsx->private;
+    cl = nfs->subvols;
+    while (cl) {
+        gf_msg_debug(GF_NFS, 0, "Starting subvolume: %s", cl->xlator->name);
+        ret = nfs_startup_subvolume(nfsx, cl->xlator);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_STARTUP_FAIL,
+                   "Failed to start-up xlator: %s", cl->xlator->name);
+            goto err;
         }
+        cl = cl->next;
+    }
 
-        ret = 0;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_init_subvolume (struct nfs_state *nfs, xlator_t *xl)
+nfs_init_subvolume(struct nfs_state *nfs, xlator_t *xl)
 {
-        unsigned int    lrusize = 0;
-        int             ret = -1;
-
-        if ((!nfs) || (!xl))
-                return -1;
-
-        lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT;
-        xl->itable = inode_table_new (lrusize, xl);
-        if (!xl->itable) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate inode table");
-                goto err;
-        }
-        ret = 0;
+    unsigned int lrusize = 0;
+    int ret = -1;
+
+    if ((!nfs) || (!xl))
+        return -1;
+
+    lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT;
+    xl->itable = inode_table_new(lrusize, xl);
+    if (!xl->itable) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate inode table");
+        goto err;
+    }
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-nfs_init_subvolumes (struct nfs_state *nfs, xlator_list_t *cl)
+nfs_init_subvolumes(struct nfs_state *nfs, xlator_list_t *cl)
 {
-        int             ret = -1;
-        unsigned int    lrusize = 0;
-        int             svcount = 0;
-
-        if ((!nfs) || (!cl))
-                return -1;
-
-        lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT;
-        nfs->subvols = cl;
-        gf_msg_trace (GF_NFS, 0, "inode table lru: %d", lrusize);
-
-        while (cl) {
-                gf_msg_debug (GF_NFS, 0, "Initing subvolume: %s",
-                        cl->xlator->name);
-                ret = nfs_init_subvolume (nfs, cl->xlator);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_CRITICAL, 0,
-                                NFS_MSG_XLATOR_INIT_FAIL, "Failed to init "
-                                "xlator: %s", cl->xlator->name);
-                        goto err;
-                }
-                ++svcount;
-                cl = cl->next;
-        }
+    int ret = -1;
+    unsigned int lrusize = 0;
+    int svcount = 0;
 
-        LOCK_INIT (&nfs->svinitlock);
-        nfs->initedxl = GF_CALLOC (svcount, sizeof (xlator_t *),
-                                   gf_nfs_mt_xlator_t );
-        if (!nfs->initedxl) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocated inited xls");
-                ret = -1;
-                goto err;
-        }
+    if ((!nfs) || (!cl))
+        return -1;
 
-        gf_msg_trace (GF_NFS, 0, "Inited volumes: %d", svcount);
-        nfs->allsubvols = svcount;
-        ret = 0;
+    lrusize = nfs->memfactor * GF_NFS_INODE_LRU_MULT;
+    nfs->subvols = cl;
+    gf_msg_trace(GF_NFS, 0, "inode table lru: %d", lrusize);
+
+    while (cl) {
+        gf_msg_debug(GF_NFS, 0, "Initing subvolume: %s", cl->xlator->name);
+        ret = nfs_init_subvolume(nfs, cl->xlator);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_XLATOR_INIT_FAIL,
+                   "Failed to init "
+                   "xlator: %s",
+                   cl->xlator->name);
+            goto err;
+        }
+        ++svcount;
+        cl = cl->next;
+    }
+
+    LOCK_INIT(&nfs->svinitlock);
+    nfs->initedxl = GF_CALLOC(svcount, sizeof(xlator_t *), gf_nfs_mt_xlator_t);
+    if (!nfs->initedxl) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocated inited xls");
+        ret = -1;
+        goto err;
+    }
+
+    gf_msg_trace(GF_NFS, 0, "Inited volumes: %d", svcount);
+    nfs->allsubvols = svcount;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs_user_root_create (nfs_user_t *newnfu)
+nfs_user_root_create(nfs_user_t *newnfu)
 {
-        if (!newnfu)
-                return -1;
+    if (!newnfu)
+        return -1;
 
-        newnfu->uid = 0;
-        newnfu->gids[0] = 0;
-        newnfu->ngrps = 1;
+    newnfu->uid = 0;
+    newnfu->gids[0] = 0;
+    newnfu->ngrps = 1;
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs_user_create (nfs_user_t *newnfu, uid_t uid, gid_t gid,
-                 rpc_transport_t *trans, gid_t *auxgids, int auxcount)
+nfs_user_create(nfs_user_t *newnfu, uid_t uid, gid_t gid,
+                rpc_transport_t *trans, gid_t *auxgids, int auxcount)
 {
-        int     x = 1;
-        int     y = 0;
-
-        /* We test for GF_REQUEST_MAXGROUPS instead of  NFS_FOP_NGROUPS because
-         * the latter accounts for the @gid being in @auxgids, which is not the
-         * case here.
-         */
-        if ((!newnfu) || (auxcount > GF_REQUEST_MAXGROUPS))
-                return -1;
-
-        newnfu->uid = uid;
-        newnfu->gids[0] = gid;
-        newnfu->ngrps = 1;
-        if (trans) {
-                memcpy (&newnfu->identifier, trans->peerinfo.identifier,
-                       UNIX_PATH_MAX);
-        }
-
-        gf_msg_trace (GF_NFS, 0, "uid: %d, gid %d, gids: %d", uid, gid,
-                auxcount);
-
-        if (!auxgids)
-                return 0;
+    int x = 1;
+    int y = 0;
+
+    /* We test for GF_REQUEST_MAXGROUPS instead of  NFS_FOP_NGROUPS because
+     * the latter accounts for the @gid being in @auxgids, which is not the
+     * case here.
+     */
+    if ((!newnfu) || (auxcount > GF_REQUEST_MAXGROUPS))
+        return -1;
+
+    newnfu->uid = uid;
+    newnfu->gids[0] = gid;
+    newnfu->ngrps = 1;
+    if (trans) {
+        memcpy(&newnfu->identifier, trans->peerinfo.identifier, UNIX_PATH_MAX);
+    }
+
+    gf_msg_trace(GF_NFS, 0, "uid: %d, gid %d, gids: %d", uid, gid, auxcount);
+
+    if (!auxgids)
+        return 0;
 
-        for (; y < auxcount; ++x,++y) {
-                newnfu->gids[x] = auxgids[y];
-                ++newnfu->ngrps;
-                gf_msg_trace (GF_NFS, 0, "gid: %d", auxgids[y]);
-        }
+    for (; y < auxcount; ++x, ++y) {
+        newnfu->gids[x] = auxgids[y];
+        ++newnfu->ngrps;
+        gf_msg_trace(GF_NFS, 0, "gid: %d", auxgids[y]);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 void
-nfs_request_user_init (nfs_user_t *nfu, rpcsvc_request_t *req)
+nfs_request_user_init(nfs_user_t *nfu, rpcsvc_request_t *req)
 {
-        gid_t           *gidarr = NULL;
-        int             gids = 0;
+    gid_t *gidarr = NULL;
+    int gids = 0;
 
-        if ((!req) || (!nfu))
-                return;
+    if ((!req) || (!nfu))
+        return;
 
-        gidarr = rpcsvc_auth_unix_auxgids (req, &gids);
-        nfs_user_create (nfu, rpcsvc_request_uid (req),
-                         rpcsvc_request_gid (req),
-                         rpcsvc_request_transport (req),
-                         gidarr, gids);
+    gidarr = rpcsvc_auth_unix_auxgids(req, &gids);
+    nfs_user_create(nfu, rpcsvc_request_uid(req), rpcsvc_request_gid(req),
+                    rpcsvc_request_transport(req), gidarr, gids);
 
-        return;
+    return;
 }
 
 void
-nfs_request_primary_user_init (nfs_user_t *nfu, rpcsvc_request_t *req,
-                               uid_t uid, gid_t gid)
+nfs_request_primary_user_init(nfs_user_t *nfu, rpcsvc_request_t *req, uid_t uid,
+                              gid_t gid)
 {
-        gid_t           *gidarr = NULL;
-        int             gids = 0;
+    gid_t *gidarr = NULL;
+    int gids = 0;
 
-        if ((!req) || (!nfu))
-                return;
+    if ((!req) || (!nfu))
+        return;
 
-        gidarr = rpcsvc_auth_unix_auxgids (req, &gids);
-        nfs_user_create (nfu, uid, gid, rpcsvc_request_transport (req),
-                         gidarr, gids);
+    gidarr = rpcsvc_auth_unix_auxgids(req, &gids);
+    nfs_user_create(nfu, uid, gid, rpcsvc_request_transport(req), gidarr, gids);
 
-        return;
+    return;
 }
 
-
 int32_t
-mem_acct_init (xlator_t *this)
+mem_acct_init(xlator_t *this)
 {
-        int     ret = -1;
-
-        if (!this)
-                return ret;
+    int ret = -1;
 
-        ret = xlator_mem_acct_init (this, gf_nfs_mt_end + 1);
+    if (!this)
+        return ret;
 
-        if (ret != 0) {
-                gf_msg (this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory accounting init failed");
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_nfs_mt_end + 1);
 
+    if (ret != 0) {
+        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory accounting init failed");
         return ret;
-}
+    }
 
+    return ret;
+}
 
 struct nfs_state *
-nfs_init_state (xlator_t *this)
+nfs_init_state(xlator_t *this)
 {
-        struct nfs_state        *nfs = NULL;
-        int                     i = 0, ret = -1;
-        unsigned int            fopspoolsize = 0;
-        char                    *optstr = NULL;
-        gf_boolean_t            boolt = _gf_false;
-        struct stat             stbuf = {0,};
-
-        if (!this)
-                return NULL;
-
-        if (!this->children) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NFS_MAN_DISABLE,
-                        "NFS is manually disabled: Exiting");
-                /* Nothing for nfs process to do, exit cleanly */
-                kill (getpid (), SIGTERM);
-        }
-
-        nfs = GF_CALLOC (1, sizeof (*nfs), gf_nfs_mt_nfs_state);
-        if (!nfs) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "memory allocation failed");
-                return NULL;
+    struct nfs_state *nfs = NULL;
+    int i = 0, ret = -1;
+    unsigned int fopspoolsize = 0;
+    char *optstr = NULL;
+    gf_boolean_t boolt = _gf_false;
+    struct stat stbuf = {
+        0,
+    };
+
+    if (!this)
+        return NULL;
+
+    if (!this->children) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NFS_MAN_DISABLE,
+               "NFS is manually disabled: Exiting");
+        /* Nothing for nfs process to do, exit cleanly */
+        kill(getpid(), SIGTERM);
+    }
+
+    nfs = GF_CALLOC(1, sizeof(*nfs), gf_nfs_mt_nfs_state);
+    if (!nfs) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "memory allocation failed");
+        return NULL;
+    }
+
+    nfs->memfactor = GF_NFS_DEFAULT_MEMFACTOR;
+    if (dict_get(this->options, "nfs.mem-factor")) {
+        ret = dict_get_str(this->options, "nfs.mem-factor", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_DICT_GET_FAILED,
+                   "Failed to parse dict");
+            goto free_rpcsvc;
         }
 
-        nfs->memfactor = GF_NFS_DEFAULT_MEMFACTOR;
-        if (dict_get (this->options, "nfs.mem-factor")) {
-                ret = dict_get_str (this->options, "nfs.mem-factor",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
-                                NFS_MSG_DICT_GET_FAILED,
-                                "Failed to parse dict");
-                        goto free_rpcsvc;
-                }
-
-                ret = gf_string2uint (optstr, &nfs->memfactor);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse uint string");
-                        goto free_rpcsvc;
-                }
+        ret = gf_string2uint(optstr, &nfs->memfactor);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse uint string");
+            goto free_rpcsvc;
+        }
+    }
+
+    fopspoolsize = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT;
+    /* FIXME: Really saddens me to see this as xlator wide. */
+    nfs->foppool = mem_pool_new(struct nfs_fop_local, fopspoolsize);
+    if (!nfs->foppool) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to allocate fops local pool");
+        goto free_rpcsvc;
+    }
+
+    nfs->dynamicvolumes = GF_NFS_DVM_OFF;
+    if (dict_get(this->options, "nfs.dynamic-volumes")) {
+        ret = dict_get_str(this->options, "nfs.dynamic-volumes", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_DICT_GET_FAILED,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        fopspoolsize = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT;
-        /* FIXME: Really saddens me to see this as xlator wide. */
-        nfs->foppool = mem_pool_new (struct nfs_fop_local, fopspoolsize);
-        if (!nfs->foppool) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to allocate fops local pool");
-                goto free_rpcsvc;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool string");
+            goto free_foppool;
+        }
+
+        if (boolt == _gf_true)
+            nfs->dynamicvolumes = GF_NFS_DVM_ON;
+    }
+
+    nfs->enable_nlm = _gf_true;
+    ret = dict_get_str_boolean(this->options, "nfs.nlm", _gf_true);
+    if (ret == _gf_false) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_MAN_DISABLE,
+               "NLM is manually disabled");
+        nfs->enable_nlm = _gf_false;
+    }
+
+    nfs->enable_acl = _gf_true;
+    ret = dict_get_str_boolean(this->options, "nfs.acl", _gf_true);
+    if (ret == _gf_false) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_MAN_DISABLE,
+               "ACL is manually disabled");
+        nfs->enable_acl = _gf_false;
+    }
+
+    nfs->enable_ino32 = 0;
+    if (dict_get(this->options, "nfs.enable-ino32")) {
+        ret = dict_get_str(this->options, "nfs.enable-ino32", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        nfs->dynamicvolumes = GF_NFS_DVM_OFF;
-        if (dict_get (this->options, "nfs.dynamic-volumes")) {
-                ret = dict_get_str (this->options, "nfs.dynamic-volumes",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
-                                NFS_MSG_DICT_GET_FAILED,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_true)
-                        nfs->dynamicvolumes = GF_NFS_DVM_ON;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool string");
+            goto free_foppool;
         }
 
-        nfs->enable_nlm = _gf_true;
-        ret = dict_get_str_boolean (this->options, "nfs.nlm", _gf_true);
-        if (ret == _gf_false) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_MAN_DISABLE,
-                        "NLM is manually disabled");
-                nfs->enable_nlm = _gf_false;
-        }
+        if (boolt == _gf_true)
+            nfs->enable_ino32 = 1;
+    }
 
-        nfs->enable_acl = _gf_true;
-        ret = dict_get_str_boolean (this->options, "nfs.acl", _gf_true);
-        if (ret == _gf_false) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_MAN_DISABLE,
-                        "ACL is manually disabled");
-                nfs->enable_acl = _gf_false;
+    if (dict_get(this->options, "nfs.port")) {
+        ret = dict_get_str(this->options, "nfs.port", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        nfs->enable_ino32 = 0;
-        if (dict_get (this->options, "nfs.enable-ino32")) {
-                ret = dict_get_str (this->options, "nfs.enable-ino32",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_true)
-                        nfs->enable_ino32 = 1;
+        ret = gf_string2uint(optstr, &nfs->override_portnum);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse uint string");
+            goto free_foppool;
         }
+    }
 
-        if (dict_get (this->options, "nfs.port")) {
-                ret = dict_get_str (this->options, "nfs.port",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2uint (optstr, &nfs->override_portnum);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse uint string");
-                        goto free_foppool;
-                }
+    if (dict_get(this->options, "transport.socket.bind-address")) {
+        ret = dict_get_str(this->options, "transport.socket.bind-address",
+                           &optstr);
+        if (ret < 0) {
+            gf_log(GF_NFS, GF_LOG_ERROR,
+                   "Failed to parse "
+                   "transport.socket.bind-address string");
+        } else {
+            this->instance_name = gf_strdup(optstr);
+            for (i = 0; i < strlen(this->instance_name); i++) {
+                if (this->instance_name[i] == '.' ||
+                    this->instance_name[i] == ':')
+                    this->instance_name[i] = '_';
+            }
         }
+    }
 
-        if (dict_get (this->options, "transport.socket.bind-address")) {
-                ret = dict_get_str (this->options,
-                        "transport.socket.bind-address",
-                        &optstr);
-                if (ret < 0) {
-                        gf_log (GF_NFS, GF_LOG_ERROR, "Failed to parse "
-                                "transport.socket.bind-address string");
-                } else {
-                        this->instance_name = gf_strdup (optstr);
-                        for (i = 0; i < strlen (this->instance_name); i++) {
-                                if (this->instance_name[i] == '.' ||
-                                    this->instance_name[i] == ':')
-                                        this->instance_name[i] = '_';
-                        }
-                }
+    if (dict_get(this->options, "transport.socket.listen-port") == NULL) {
+        if (nfs->override_portnum)
+            ret = gf_asprintf(&optstr, "%d", nfs->override_portnum);
+        else
+            ret = gf_asprintf(&optstr, "%d", GF_NFS3_PORT);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "failed mem-allocation");
+            goto free_foppool;
         }
-
-        if (dict_get(this->options, "transport.socket.listen-port") == NULL) {
-                if (nfs->override_portnum)
-                        ret = gf_asprintf (&optstr, "%d",
-                                           nfs->override_portnum);
-                else
-                        ret = gf_asprintf (&optstr, "%d", GF_NFS3_PORT);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                                "failed mem-allocation");
-                        goto free_foppool;
-                }
-                ret = dict_set_dynstr (this->options,
-                                       "transport.socket.listen-port", optstr);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_DICT_SET_FAILED,
-                                "dict_set_dynstr error");
-                        goto free_foppool;
-                }
+        ret = dict_set_dynstr(this->options, "transport.socket.listen-port",
+                              optstr);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_dynstr error");
+            goto free_foppool;
         }
+    }
 
 #ifdef IPV6_DEFAULT
-        ret = dict_set_str (this->options, "transport.address-family",
-                            "inet6");
-        if (ret == -1) {
-                gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error");
-                goto free_foppool;
-        }
+    ret = dict_set_str(this->options, "transport.address-family", "inet6");
+    if (ret == -1) {
+        gf_log(GF_NFS, GF_LOG_ERROR, "dict_set_str error");
+        goto free_foppool;
+    }
 #endif
 
-        /* Right only socket support exists between nfs client and
-         * gluster nfs, so we can set default value as socket
-         */
-        ret = dict_set_str (this->options, "transport-type", "socket");
+    /* Right only socket support exists between nfs client and
+     * gluster nfs, so we can set default value as socket
+     */
+    ret = dict_set_str(this->options, "transport-type", "socket");
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto free_foppool;
+    }
+
+    nfs->mount_udp = 0;
+    if (dict_get(this->options, "nfs.mount-udp")) {
+        ret = dict_get_str(this->options, "nfs.mount-udp", &optstr);
         if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto free_foppool;
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        nfs->mount_udp = 0;
-        if (dict_get(this->options, "nfs.mount-udp")) {
-                ret = dict_get_str (this->options, "nfs.mount-udp", &optstr);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool "
-                                "string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_true)
-                        nfs->mount_udp = 1;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool "
+                   "string");
+            goto free_foppool;
         }
 
-        nfs->exports_auth = GF_NFS_DEFAULT_EXPORT_AUTH;
-        if (dict_get(this->options, "nfs.exports-auth-enable")) {
-                ret = dict_get_str (this->options, "nfs.exports-auth-enable",
-                                    &optstr);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_true)
-                        nfs->exports_auth = 1;
-        }
+        if (boolt == _gf_true)
+            nfs->mount_udp = 1;
+    }
 
-        nfs->auth_refresh_time_secs = GF_NFS_DEFAULT_AUTH_REFRESH_INTERVAL_SEC;
-        if (dict_get (this->options, "nfs.auth-refresh-interval-sec")) {
-                ret = dict_get_str (this->options,
-                                    "nfs.auth-refresh-interval-sec", &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2uint (optstr, &nfs->auth_refresh_time_secs);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse uint string");
-                        goto free_foppool;
-                }
+    nfs->exports_auth = GF_NFS_DEFAULT_EXPORT_AUTH;
+    if (dict_get(this->options, "nfs.exports-auth-enable")) {
+        ret = dict_get_str(this->options, "nfs.exports-auth-enable", &optstr);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        nfs->auth_cache_ttl_sec = GF_NFS_DEFAULT_AUTH_CACHE_TTL_SEC;
-        if (dict_get (this->options, "nfs.auth-cache-ttl-sec")) {
-                ret = dict_get_str (this->options,
-                                    "nfs.auth-cache-ttl-sec", &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2uint (optstr, &nfs->auth_cache_ttl_sec);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse uint string");
-                        goto free_foppool;
-                }
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool string");
+            goto free_foppool;
         }
 
-        /* TODO: Make this a configurable option in case we don't want to read
-         * exports/netgroup files off disk when they change. */
-        nfs->refresh_auth = 1;
-
-        nfs->rmtab = gf_strdup (NFS_DATADIR "/rmtab");
-        if (dict_get(this->options, "nfs.mount-rmtab")) {
-                ret = dict_get_str (this->options, "nfs.mount-rmtab", &nfs->rmtab);
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                /* check if writing the rmtab is disabled*/
-                if (nfs->rmtab && strcmp ("/-", nfs->rmtab) == 0) {
-                        GF_FREE (nfs->rmtab);
-                        nfs->rmtab = NULL;
-                }
-        }
+        if (boolt == _gf_true)
+            nfs->exports_auth = 1;
+    }
 
-        /* support both options rpc-auth.ports.insecure and
-         * rpc-auth-allow-insecure for backward compatibility
-         */
-        nfs->allow_insecure = 1;
-        if (dict_get(this->options, "rpc-auth.ports.insecure")) {
-                ret = dict_get_str (this->options, "rpc-auth.ports.insecure",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool "
-                                "string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_false)
-                        nfs->allow_insecure = 0;
+    nfs->auth_refresh_time_secs = GF_NFS_DEFAULT_AUTH_REFRESH_INTERVAL_SEC;
+    if (dict_get(this->options, "nfs.auth-refresh-interval-sec")) {
+        ret = dict_get_str(this->options, "nfs.auth-refresh-interval-sec",
+                           &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        if (dict_get(this->options, "rpc-auth-allow-insecure")) {
-                ret = dict_get_str (this->options, "rpc-auth-allow-insecure",
-                                    &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse dict");
-                        goto free_foppool;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
-                                "Failed to parse bool string");
-                        goto free_foppool;
-                }
-
-                if (boolt == _gf_false)
-                        nfs->allow_insecure = 0;
+        ret = gf_string2uint(optstr, &nfs->auth_refresh_time_secs);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse uint string");
+            goto free_foppool;
         }
+    }
 
-        if (nfs->allow_insecure) {
-                /* blindly set both the options */
-                ret = dict_set_str (this->options,
-                                    "rpc-auth-allow-insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_DICT_SET_FAILED, "dict_set_str error");
-                        goto free_foppool;
-                }
-                ret = dict_set_str (this->options,
-                                    "rpc-auth.ports.insecure", "on");
-                if (ret == -1) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_DICT_SET_FAILED, "dict_set_str error");
-                        goto free_foppool;
-                }
+    nfs->auth_cache_ttl_sec = GF_NFS_DEFAULT_AUTH_CACHE_TTL_SEC;
+    if (dict_get(this->options, "nfs.auth-cache-ttl-sec")) {
+        ret = dict_get_str(this->options, "nfs.auth-cache-ttl-sec", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        GF_OPTION_INIT ("nfs.rdirplus", nfs->rdirplus, bool, free_foppool);
-
-	GF_OPTION_INIT (OPT_SERVER_RPC_STATD, nfs->rpc_statd, path, free_foppool);
-
-	GF_OPTION_INIT (OPT_SERVER_RPC_STATD_PIDFILE, nfs->rpc_statd_pid_file, path, free_foppool);
+        ret = gf_string2uint(optstr, &nfs->auth_cache_ttl_sec);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse uint string");
+            goto free_foppool;
+        }
+    }
 
-        GF_OPTION_INIT (OPT_SERVER_AUX_GIDS, nfs->server_aux_gids,
-                        bool, free_foppool);
-        GF_OPTION_INIT (OPT_SERVER_GID_CACHE_TIMEOUT,
-                        nfs->server_aux_gids_max_age,
-                        uint32, free_foppool);
+    /* TODO: Make this a configurable option in case we don't want to read
+     * exports/netgroup files off disk when they change. */
+    nfs->refresh_auth = 1;
 
-        if (gid_cache_init(&nfs->gid_cache, nfs->server_aux_gids_max_age) < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                        NFS_MSG_INIT_GRP_CACHE_FAIL,
-                        "Failed to initialize group cache.");
-                goto free_foppool;
+    nfs->rmtab = gf_strdup(NFS_DATADIR "/rmtab");
+    if (dict_get(this->options, "nfs.mount-rmtab")) {
+        ret = dict_get_str(this->options, "nfs.mount-rmtab", &nfs->rmtab);
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        ret = sys_access (nfs->rpc_statd, X_OK);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_WARNING, EPERM, NFS_MSG_NO_PERM,
-                        "%s not enough permissions to access. Disabling NLM",
-                        nfs->rpc_statd);
-                nfs->enable_nlm = _gf_false;
+        /* check if writing the rmtab is disabled*/
+        if (nfs->rmtab && strcmp("/-", nfs->rmtab) == 0) {
+            GF_FREE(nfs->rmtab);
+            nfs->rmtab = NULL;
+        }
+    }
+
+    /* support both options rpc-auth.ports.insecure and
+     * rpc-auth-allow-insecure for backward compatibility
+     */
+    nfs->allow_insecure = 1;
+    if (dict_get(this->options, "rpc-auth.ports.insecure")) {
+        ret = dict_get_str(this->options, "rpc-auth.ports.insecure", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        ret = sys_stat (nfs->rpc_statd, &stbuf);
-        if (ret || !S_ISREG (stbuf.st_mode)) {
-                gf_msg (GF_NFS, GF_LOG_WARNING, 0, NFS_MSG_REG_FILE_ERROR,
-                        "%s not a regular file. Disabling NLM", nfs->rpc_statd);
-                nfs->enable_nlm = _gf_false;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool "
+                   "string");
+            goto free_foppool;
         }
 
-        nfs->rpcsvc =  rpcsvc_init (this, this->ctx,
-                                    this->options, fopspoolsize);
-        if (!nfs->rpcsvc) {
-                ret = -1;
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_INIT_FAIL,
-                        "RPC service init failed");
-                goto free_foppool;
-        }
+        if (boolt == _gf_false)
+            nfs->allow_insecure = 0;
+    }
 
-        ret = rpcsvc_set_throttle_on (nfs->rpcsvc);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_ENABLE_THROTTLE_FAIL,
-                        "Enabling throttle failed");
-                goto free_foppool;
+    if (dict_get(this->options, "rpc-auth-allow-insecure")) {
+        ret = dict_get_str(this->options, "rpc-auth-allow-insecure", &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse dict");
+            goto free_foppool;
         }
 
-        ret = rpcsvc_set_outstanding_rpc_limit (nfs->rpcsvc,
-                                                this->options,
-                                                RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT);
+        ret = gf_string2boolean(optstr, &boolt);
         if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_CONFIG_FAIL,
-                        "Failed to configure outstanding-rpc-limit");
-                goto free_foppool;
+            gf_msg(GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_PARSE_FAIL,
+                   "Failed to parse bool string");
+            goto free_foppool;
         }
 
-        nfs->register_portmap = rpcsvc_register_portmap_enabled (nfs->rpcsvc);
+        if (boolt == _gf_false)
+            nfs->allow_insecure = 0;
+    }
 
-        GF_OPTION_INIT ("nfs.event-threads",
-                        nfs->event_threads, uint32, free_foppool);
-        event_reconfigure_threads (this->ctx->event_pool, nfs->event_threads);
-
-        this->private = (void *)nfs;
-        INIT_LIST_HEAD (&nfs->versions);
-        nfs->generation = 1965;
-
-        ret = 0;
+    if (nfs->allow_insecure) {
+        /* blindly set both the options */
+        ret = dict_set_str(this->options, "rpc-auth-allow-insecure", "on");
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto free_foppool;
+        }
+        ret = dict_set_str(this->options, "rpc-auth.ports.insecure", "on");
+        if (ret == -1) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto free_foppool;
+        }
+    }
+
+    GF_OPTION_INIT("nfs.rdirplus", nfs->rdirplus, bool, free_foppool);
+
+    GF_OPTION_INIT(OPT_SERVER_RPC_STATD, nfs->rpc_statd, path, free_foppool);
+
+    GF_OPTION_INIT(OPT_SERVER_RPC_STATD_PIDFILE, nfs->rpc_statd_pid_file, path,
+                   free_foppool);
+
+    GF_OPTION_INIT(OPT_SERVER_AUX_GIDS, nfs->server_aux_gids, bool,
+                   free_foppool);
+    GF_OPTION_INIT(OPT_SERVER_GID_CACHE_TIMEOUT, nfs->server_aux_gids_max_age,
+                   uint32, free_foppool);
+
+    if (gid_cache_init(&nfs->gid_cache, nfs->server_aux_gids_max_age) < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_GRP_CACHE_FAIL,
+               "Failed to initialize group cache.");
+        goto free_foppool;
+    }
+
+    ret = sys_access(nfs->rpc_statd, X_OK);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_WARNING, EPERM, NFS_MSG_NO_PERM,
+               "%s not enough permissions to access. Disabling NLM",
+               nfs->rpc_statd);
+        nfs->enable_nlm = _gf_false;
+    }
+
+    ret = sys_stat(nfs->rpc_statd, &stbuf);
+    if (ret || !S_ISREG(stbuf.st_mode)) {
+        gf_msg(GF_NFS, GF_LOG_WARNING, 0, NFS_MSG_REG_FILE_ERROR,
+               "%s not a regular file. Disabling NLM", nfs->rpc_statd);
+        nfs->enable_nlm = _gf_false;
+    }
+
+    nfs->rpcsvc = rpcsvc_init(this, this->ctx, this->options, fopspoolsize);
+    if (!nfs->rpcsvc) {
+        ret = -1;
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_INIT_FAIL,
+               "RPC service init failed");
+        goto free_foppool;
+    }
+
+    ret = rpcsvc_set_throttle_on(nfs->rpcsvc);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_ENABLE_THROTTLE_FAIL,
+               "Enabling throttle failed");
+        goto free_foppool;
+    }
+
+    ret = rpcsvc_set_outstanding_rpc_limit(
+        nfs->rpcsvc, this->options, RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RPC_CONFIG_FAIL,
+               "Failed to configure outstanding-rpc-limit");
+        goto free_foppool;
+    }
+
+    nfs->register_portmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc);
+
+    GF_OPTION_INIT("nfs.event-threads", nfs->event_threads, uint32,
+                   free_foppool);
+    event_reconfigure_threads(this->ctx->event_pool, nfs->event_threads);
+
+    this->private = (void *)nfs;
+    INIT_LIST_HEAD(&nfs->versions);
+    nfs->generation = 1965;
+
+    ret = 0;
 
 free_foppool:
-        if (ret < 0)
-                mem_pool_destroy (nfs->foppool);
+    if (ret < 0)
+        mem_pool_destroy(nfs->foppool);
 
 free_rpcsvc:
-        /*
-         * rpcsvc_deinit */
-        if (ret < 0) {
-                GF_FREE (nfs);
-                nfs = NULL;
-        }
-
-        return nfs;
+    /*
+     * rpcsvc_deinit */
+    if (ret < 0) {
+        GF_FREE(nfs);
+        nfs = NULL;
+    }
+
+    return nfs;
 }
 
 int
-nfs_drc_init (xlator_t *this)
+nfs_drc_init(xlator_t *this)
 {
-        int       ret     = -1;
-        rpcsvc_t *svc     = NULL;
+    int ret = -1;
+    rpcsvc_t *svc = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS, this, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, this->private, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, this, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, this->private, out);
 
-        svc = ((struct nfs_state *)(this->private))->rpcsvc;
-        if (!svc)
-                goto out;
+    svc = ((struct nfs_state *)(this->private))->rpcsvc;
+    if (!svc)
+        goto out;
 
-        ret = rpcsvc_drc_init (svc, this->options);
+    ret = rpcsvc_drc_init(svc, this->options);
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 int
-nfs_reconfigure_state (xlator_t *this, dict_t *options)
+nfs_reconfigure_state(xlator_t *this, dict_t *options)
 {
-        int                 ret = 0;
-        int                 keyindx = 0;
-        char                *rmtab = NULL;
-        char                *rpc_statd = NULL;
-        gf_boolean_t        optbool;
-        uint32_t            optuint32;
-        struct nfs_state    *nfs = NULL;
-        char                *blacklist_keys[] = {
-                                        "nfs.port",
-                                        "nfs.transport-type",
-                                        "nfs.mem-factor",
-                                        NULL};
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, this, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, this->private, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, options, out);
-
-        nfs = (struct nfs_state *)this->private;
-
-        /* Black listed options can't be reconfigured, they need
-         * NFS to be restarted. There are two cases 1. SET 2. UNSET.
-         * 1. SET */
-        while (blacklist_keys[keyindx]) {
-                if (dict_get (options, blacklist_keys[keyindx])) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0,
-                                NFS_MSG_RECONFIG_FAIL,
-                                "Reconfiguring %s needs NFS restart",
-                                blacklist_keys[keyindx]);
-                        goto out;
-                }
-                keyindx ++;
-        }
-
-        /* UNSET for nfs.mem-factor */
-        if ((!dict_get (options, "nfs.mem-factor")) &&
-            (nfs->memfactor != GF_NFS_DEFAULT_MEMFACTOR)) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL,
-                        "Reconfiguring nfs.mem-factor needs NFS restart");
-                goto out;
-        }
-
-        /* UNSET for nfs.port */
-        if ((!dict_get (options, "nfs.port")) &&
-            (nfs->override_portnum)) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "Reconfiguring nfs.port needs NFS restart");
-                goto out;
-        }
-
-        /* reconfig nfs.rpc-statd...  */
-        rpc_statd = GF_RPC_STATD_PROG;
-        if (dict_get (options, OPT_SERVER_RPC_STATD_PIDFILE)) {
-                ret = dict_get_str (options, "nfs.rpc-statd", &rpc_statd);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read reconfigured option: "
-                                "nfs.rpc-statd");
-                        goto out;
-                }
-        }
-
-        if (strcmp(nfs->rpc_statd, rpc_statd) != 0) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL,
-                        "Reconfiguring nfs.rpc-statd needs NFS restart");
-                goto out;
-        }
-
-        /* reconfig nfs.mount-rmtab */
-        rmtab = NFS_DATADIR "/rmtab";
-        if (dict_get (options, "nfs.mount-rmtab")) {
-                ret = dict_get_str (options, "nfs.mount-rmtab", &rmtab);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read reconfigured option:"
-                                " nfs.mount-rmtab");
-                        goto out;
-                }
-                gf_path_strip_trailing_slashes (rmtab);
-        }
-        /* check if writing the rmtab is disabled*/
-        if (strcmp ("/-", rmtab) == 0) {
-                GF_FREE (nfs->rmtab);
-                nfs->rmtab = NULL;
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_WRITE_FAIL,
-                        "Disabled writing of nfs.mount-rmtab");
-        } else if (!nfs->rmtab || strcmp (nfs->rmtab, rmtab) != 0) {
-                mount_rewrite_rmtab (nfs->mstate, rmtab);
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_PATH,
-                        "Reconfigured nfs.mount-rmtab path: %s", nfs->rmtab);
-        }
-
-        GF_OPTION_RECONF (OPT_SERVER_AUX_GIDS, optbool,
-                                               options, bool, out);
-        if (nfs->server_aux_gids != optbool) {
-                nfs->server_aux_gids = optbool;
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
-                        "Reconfigured %s with value %d", OPT_SERVER_AUX_GIDS,
-                        optbool);
-        }
-
-        GF_OPTION_RECONF (OPT_SERVER_GID_CACHE_TIMEOUT, optuint32,
-                                               options, uint32, out);
-        if (nfs->server_aux_gids_max_age != optuint32) {
-                nfs->server_aux_gids_max_age = optuint32;
-                gid_cache_reconf (&nfs->gid_cache, optuint32);
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
-                        "Reconfigured %s with value %d",
-                        OPT_SERVER_GID_CACHE_TIMEOUT, optuint32);
-        }
-
-        GF_OPTION_RECONF ("nfs.rdirplus", optbool,
-                                          options, bool, out);
-        if (nfs->rdirplus != optbool) {
-                nfs->rdirplus = optbool;
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
-                        "Reconfigured nfs.rdirplus with value %d", optbool);
-        }
-
-        /* reconfig nfs.dynamic-volumes */
-        ret = dict_get_str_boolean (options, "nfs.dynamic-volumes",
-                                             GF_NFS_DVM_OFF);
-        switch (ret) {
+    int ret = 0;
+    int keyindx = 0;
+    char *rmtab = NULL;
+    char *rpc_statd = NULL;
+    gf_boolean_t optbool;
+    uint32_t optuint32;
+    struct nfs_state *nfs = NULL;
+    char *blacklist_keys[] = {"nfs.port", "nfs.transport-type",
+                              "nfs.mem-factor", NULL};
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, this, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, this->private, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, options, out);
+
+    nfs = (struct nfs_state *)this->private;
+
+    /* Black listed options can't be reconfigured, they need
+     * NFS to be restarted. There are two cases 1. SET 2. UNSET.
+     * 1. SET */
+    while (blacklist_keys[keyindx]) {
+        if (dict_get(options, blacklist_keys[keyindx])) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+                   "Reconfiguring %s needs NFS restart",
+                   blacklist_keys[keyindx]);
+            goto out;
+        }
+        keyindx++;
+    }
+
+    /* UNSET for nfs.mem-factor */
+    if ((!dict_get(options, "nfs.mem-factor")) &&
+        (nfs->memfactor != GF_NFS_DEFAULT_MEMFACTOR)) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL,
+               "Reconfiguring nfs.mem-factor needs NFS restart");
+        goto out;
+    }
+
+    /* UNSET for nfs.port */
+    if ((!dict_get(options, "nfs.port")) && (nfs->override_portnum)) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "Reconfiguring nfs.port needs NFS restart");
+        goto out;
+    }
+
+    /* reconfig nfs.rpc-statd...  */
+    rpc_statd = GF_RPC_STATD_PROG;
+    if (dict_get(options, OPT_SERVER_RPC_STATD_PIDFILE)) {
+        ret = dict_get_str(options, "nfs.rpc-statd", &rpc_statd);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read reconfigured option: "
+                   "nfs.rpc-statd");
+            goto out;
+        }
+    }
+
+    if (strcmp(nfs->rpc_statd, rpc_statd) != 0) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_FAIL,
+               "Reconfiguring nfs.rpc-statd needs NFS restart");
+        goto out;
+    }
+
+    /* reconfig nfs.mount-rmtab */
+    rmtab = NFS_DATADIR "/rmtab";
+    if (dict_get(options, "nfs.mount-rmtab")) {
+        ret = dict_get_str(options, "nfs.mount-rmtab", &rmtab);
+        if (ret < 0) {
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read reconfigured option:"
+                   " nfs.mount-rmtab");
+            goto out;
+        }
+        gf_path_strip_trailing_slashes(rmtab);
+    }
+    /* check if writing the rmtab is disabled*/
+    if (strcmp("/-", rmtab) == 0) {
+        GF_FREE(nfs->rmtab);
+        nfs->rmtab = NULL;
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_WRITE_FAIL,
+               "Disabled writing of nfs.mount-rmtab");
+    } else if (!nfs->rmtab || strcmp(nfs->rmtab, rmtab) != 0) {
+        mount_rewrite_rmtab(nfs->mstate, rmtab);
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_PATH,
+               "Reconfigured nfs.mount-rmtab path: %s", nfs->rmtab);
+    }
+
+    GF_OPTION_RECONF(OPT_SERVER_AUX_GIDS, optbool, options, bool, out);
+    if (nfs->server_aux_gids != optbool) {
+        nfs->server_aux_gids = optbool;
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
+               "Reconfigured %s with value %d", OPT_SERVER_AUX_GIDS, optbool);
+    }
+
+    GF_OPTION_RECONF(OPT_SERVER_GID_CACHE_TIMEOUT, optuint32, options, uint32,
+                     out);
+    if (nfs->server_aux_gids_max_age != optuint32) {
+        nfs->server_aux_gids_max_age = optuint32;
+        gid_cache_reconf(&nfs->gid_cache, optuint32);
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
+               "Reconfigured %s with value %d", OPT_SERVER_GID_CACHE_TIMEOUT,
+               optuint32);
+    }
+
+    GF_OPTION_RECONF("nfs.rdirplus", optbool, options, bool, out);
+    if (nfs->rdirplus != optbool) {
+        nfs->rdirplus = optbool;
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VALUE,
+               "Reconfigured nfs.rdirplus with value %d", optbool);
+    }
+
+    /* reconfig nfs.dynamic-volumes */
+    ret = dict_get_str_boolean(options, "nfs.dynamic-volumes", GF_NFS_DVM_OFF);
+    switch (ret) {
         case GF_NFS_DVM_ON:
         case GF_NFS_DVM_OFF:
-                optbool = ret;
-                break;
+            optbool = ret;
+            break;
         default:
-                optbool = GF_NFS_DVM_OFF;
-                break;
-        }
-        if (nfs->dynamicvolumes != optbool) {
-                nfs->dynamicvolumes = optbool;
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VOL,
-                        "Reconfigured nfs.dynamic-volumes with value %d",
-                        optbool);
-        }
-
-        optbool = _gf_false;
-        if (dict_get (options, "nfs.enable-ino32")) {
-                ret = dict_get_str_boolean (options, "nfs.enable-ino32",
-                                                      _gf_false);
-                if (ret < 0) {
-                        gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read reconfigured option: "
-                                "nfs.enable-ino32");
-                        goto out;
-                }
-                optbool = ret;
-        }
-        if (nfs->enable_ino32 != optbool) {
-                nfs->enable_ino32 = optbool;
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_ENABLE,
-                        "Reconfigured nfs.enable-ino32 with value %d", optbool);
-        }
-
-        /* nfs.nlm is enabled by default */
-        ret = dict_get_str_boolean (options, "nfs.nlm", _gf_true);
+            optbool = GF_NFS_DVM_OFF;
+            break;
+    }
+    if (nfs->dynamicvolumes != optbool) {
+        nfs->dynamicvolumes = optbool;
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_VOL,
+               "Reconfigured nfs.dynamic-volumes with value %d", optbool);
+    }
+
+    optbool = _gf_false;
+    if (dict_get(options, "nfs.enable-ino32")) {
+        ret = dict_get_str_boolean(options, "nfs.enable-ino32", _gf_false);
         if (ret < 0) {
-                optbool = _gf_true;
-        } else {
-                optbool = ret;
-        }
-        if (nfs->enable_nlm != optbool) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_INFO, "NLM is"
-                        " manually %s", (optbool ? "enabled":"disabled"));
-                nfs->enable_nlm = optbool;
-                nfs_reconfigure_nlm4 (this);
-        }
-
-        /* nfs.acl is enabled by default */
-        ret = dict_get_str_boolean (options, "nfs.acl", _gf_true);
-        if (ret < 0) {
-                optbool = _gf_true;
-        } else {
-                optbool = ret;
-        }
-        if (nfs->enable_acl != optbool) {
-                gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_INFO, "ACL is "
-                        "manually %s", (optbool ? "enabled":"disabled"));
-                nfs->enable_acl = optbool;
-                nfs_reconfigure_acl3 (this);
-        }
-
-        GF_OPTION_RECONF ("nfs.event-threads",
-                            nfs->event_threads, options, uint32, out);
-        event_reconfigure_threads (this->ctx->event_pool, nfs->event_threads);
-
-
-        ret = 0;
+            gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read reconfigured option: "
+                   "nfs.enable-ino32");
+            goto out;
+        }
+        optbool = ret;
+    }
+    if (nfs->enable_ino32 != optbool) {
+        nfs->enable_ino32 = optbool;
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_RECONFIG_ENABLE,
+               "Reconfigured nfs.enable-ino32 with value %d", optbool);
+    }
+
+    /* nfs.nlm is enabled by default */
+    ret = dict_get_str_boolean(options, "nfs.nlm", _gf_true);
+    if (ret < 0) {
+        optbool = _gf_true;
+    } else {
+        optbool = ret;
+    }
+    if (nfs->enable_nlm != optbool) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_NLM_INFO,
+               "NLM is"
+               " manually %s",
+               (optbool ? "enabled" : "disabled"));
+        nfs->enable_nlm = optbool;
+        nfs_reconfigure_nlm4(this);
+    }
+
+    /* nfs.acl is enabled by default */
+    ret = dict_get_str_boolean(options, "nfs.acl", _gf_true);
+    if (ret < 0) {
+        optbool = _gf_true;
+    } else {
+        optbool = ret;
+    }
+    if (nfs->enable_acl != optbool) {
+        gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_ACL_INFO,
+               "ACL is "
+               "manually %s",
+               (optbool ? "enabled" : "disabled"));
+        nfs->enable_acl = optbool;
+        nfs_reconfigure_acl3(this);
+    }
+
+    GF_OPTION_RECONF("nfs.event-threads", nfs->event_threads, options, uint32,
+                     out);
+    event_reconfigure_threads(this->ctx->event_pool, nfs->event_threads);
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 /*
  * reconfigure() for NFS server xlator.
  */
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        int                      ret = 0;
-        struct nfs_state         *nfs = NULL;
-        gf_boolean_t             regpmap = _gf_true;
-
-        if ((!this) || (!this->private) || (!options))
-                return (-1);
+    int ret = 0;
+    struct nfs_state *nfs = NULL;
+    gf_boolean_t regpmap = _gf_true;
 
-        nfs = (struct nfs_state *)this->private;
+    if ((!this) || (!this->private) || (!options))
+        return (-1);
 
-        /* Reconfigure nfs options */
-        ret = nfs_reconfigure_state(this, options);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "nfs reconfigure state failed");
-                return (-1);
-        }
+    nfs = (struct nfs_state *)this->private;
 
-        /* Reconfigure nfs3 options */
-        ret = nfs3_reconfigure_state(this, options);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "nfs3 reconfigure state failed");
-                return (-1);
-        }
+    /* Reconfigure nfs options */
+    ret = nfs_reconfigure_state(this, options);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "nfs reconfigure state failed");
+        return (-1);
+    }
 
-        /* Reconfigure mount options */
-        ret = mount_reconfigure_state(this, options);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "mount reconfigure state failed");
-                return (-1);
-        }
+    /* Reconfigure nfs3 options */
+    ret = nfs3_reconfigure_state(this, options);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "nfs3 reconfigure state failed");
+        return (-1);
+    }
 
-        /* Reconfigure rpc layer */
-        ret = rpcsvc_reconfigure_options (nfs->rpcsvc, options);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "rpcsvc reconfigure options failed");
-                return (-1);
-        }
+    /* Reconfigure mount options */
+    ret = mount_reconfigure_state(this, options);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "mount reconfigure state failed");
+        return (-1);
+    }
 
-        /* Reconfigure rpc.outstanding-rpc-limit */
-        ret = rpcsvc_set_outstanding_rpc_limit (nfs->rpcsvc,
-                                       options,
-                                       RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT);
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "Failed to reconfigure outstanding-rpc-limit");
-                return (-1);
-        }
+    /* Reconfigure rpc layer */
+    ret = rpcsvc_reconfigure_options(nfs->rpcsvc, options);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "rpcsvc reconfigure options failed");
+        return (-1);
+    }
+
+    /* Reconfigure rpc.outstanding-rpc-limit */
+    ret = rpcsvc_set_outstanding_rpc_limit(
+        nfs->rpcsvc, options, RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT);
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "Failed to reconfigure outstanding-rpc-limit");
+        return (-1);
+    }
 
-        regpmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc);
-        if (nfs->register_portmap != regpmap) {
-                nfs->register_portmap = regpmap;
-                if (regpmap) {
-                        (void) nfs_program_register_portmap_all (nfs);
-                } else {
-                        (void) nfs_program_unregister_portmap_all (nfs);
-                }
+    regpmap = rpcsvc_register_portmap_enabled(nfs->rpcsvc);
+    if (nfs->register_portmap != regpmap) {
+        nfs->register_portmap = regpmap;
+        if (regpmap) {
+            (void)nfs_program_register_portmap_all(nfs);
+        } else {
+            (void)nfs_program_unregister_portmap_all(nfs);
         }
+    }
 
-        /* Reconfigure drc */
-        ret = rpcsvc_drc_reconfigure (nfs->rpcsvc, options);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
-                        "rpcsvc DRC reconfigure failed");
-                return (-1);
-        }
+    /* Reconfigure drc */
+    ret = rpcsvc_drc_reconfigure(nfs->rpcsvc, options);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_RECONFIG_FAIL,
+               "rpcsvc DRC reconfigure failed");
+        return (-1);
+    }
 
-        return (0);
+    return (0);
 }
 
 /* Main init() routine for NFS server xlator. It inits NFS v3 protocol
@@ -1496,650 +1439,604 @@ reconfigure (xlator_t *this, dict_t *options)
  *      -1 (FAILURE) if any of them FAILS.
  */
 int
-init (xlator_t *this) {
-
-        struct nfs_state        *nfs = NULL;
-        int                     ret = -1;
+init(xlator_t *this)
+{
+    struct nfs_state *nfs = NULL;
+    int ret = -1;
 
-        if (!this)
-                return (-1);
+    if (!this)
+        return (-1);
 
-        nfs = nfs_init_state (this);
-        if (!nfs) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL,
-                        "Failed to init nfs option");
-                return (-1);
-        }
+    nfs = nfs_init_state(this);
+    if (!nfs) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL,
+               "Failed to init nfs option");
+        return (-1);
+    }
 
-        ret = nfs_add_all_initiators (nfs);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to add initiators");
-                return (-1);
-        }
+    ret = nfs_add_all_initiators(nfs);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
+               "Failed to add initiators");
+        return (-1);
+    }
 
-        ret = nfs_init_subvolumes (nfs, this->children);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to init NFS exports");
-                return (-1);
-        }
+    ret = nfs_init_subvolumes(nfs, this->children);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
+               "Failed to init NFS exports");
+        return (-1);
+    }
 
-        ret = mount_init_state (this);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to init Mount state");
-                return (-1);
-        }
+    ret = mount_init_state(this);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
+               "Failed to init Mount state");
+        return (-1);
+    }
 
-        ret = nlm4_init_state (this);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to init NLM state");
-                return (-1);
-        }
+    ret = nlm4_init_state(this);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_CRITICAL, 0, NFS_MSG_INIT_FAIL,
+               "Failed to init NLM state");
+        return (-1);
+    }
 
-        ret = nfs_init_versions (nfs, this);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to initialize protocols");
-                return (-1);
-        }
+    ret = nfs_init_versions(nfs, this);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
+               "Failed to initialize protocols");
+        return (-1);
+    }
 
-        ret = nfs_drc_init (this);
-        if (ret) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
-                        "Failed to initialize DRC");
-                return (-1);
-        }
+    ret = nfs_drc_init(this);
+    if (ret) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_INIT_FAIL,
+               "Failed to initialize DRC");
+        return (-1);
+    }
 
-        gf_msg (GF_NFS, GF_LOG_INFO, 0, NFS_MSG_STARTED,
-                "NFS service started");
-        return (0); /* SUCCESS */
+    gf_msg(GF_NFS, GF_LOG_INFO, 0, NFS_MSG_STARTED, "NFS service started");
+    return (0); /* SUCCESS */
 }
 
-
 int
-notify (xlator_t *this, int32_t event, void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        xlator_t                *subvol = NULL;
-        struct nfs_state        *priv   = NULL;
+    xlator_t *subvol = NULL;
+    struct nfs_state *priv = NULL;
 
-        subvol = (xlator_t *)data;
+    subvol = (xlator_t *)data;
 
-        gf_msg_trace (GF_NFS, 0, "Notification received: %d",
-                event);
+    gf_msg_trace(GF_NFS, 0, "Notification received: %d", event);
 
-        switch (event) {
+    switch (event) {
         case GF_EVENT_CHILD_UP:
-                nfs_startup_subvolume (this, subvol);
-                break;
+            nfs_startup_subvolume(this, subvol);
+            break;
 
         case GF_EVENT_SOME_DESCENDENT_DOWN:
         case GF_EVENT_SOME_DESCENDENT_UP:
-                priv = this->private;
-                ++(priv->generation);
-                break;
+            priv = this->private;
+            ++(priv->generation);
+            break;
 
         case GF_EVENT_PARENT_UP:
-                default_notify (this, GF_EVENT_PARENT_UP, data);
-                break;
-        }
+            default_notify(this, GF_EVENT_PARENT_UP, data);
+            break;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-
-        struct nfs_state        *nfs = NULL;
-
-        mnt3svc_deinit (this);
-        nfs = (struct nfs_state *)this->private;
-        gf_msg_debug (GF_NFS, 0, "NFS service going down");
-        nfs_deinit_versions (&nfs->versions, this);
-        GF_FREE (this->instance_name);
-        return 0;
+    struct nfs_state *nfs = NULL;
+
+    mnt3svc_deinit(this);
+    nfs = (struct nfs_state *)this->private;
+    gf_msg_debug(GF_NFS, 0, "NFS service going down");
+    nfs_deinit_versions(&nfs->versions, this);
+    GF_FREE(this->instance_name);
+    return 0;
 }
 
 int32_t
-nfs_forget (xlator_t *this, inode_t *inode)
+nfs_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t                 ctx    = 0;
-        struct nfs_inode_ctx    *ictx   = NULL;
+    uint64_t ctx = 0;
+    struct nfs_inode_ctx *ictx = NULL;
 
-        if (inode_ctx_del (inode, this, &ctx))
-                return -1;
+    if (inode_ctx_del(inode, this, &ctx))
+        return -1;
 
-        ictx = (struct nfs_inode_ctx *)ctx;
-        GF_FREE (ictx);
+    ictx = (struct nfs_inode_ctx *)ctx;
+    GF_FREE(ictx);
 
-        return 0;
+    return 0;
 }
 
 gf_boolean_t
-_nfs_export_is_for_vol (char *exname, char *volname)
+_nfs_export_is_for_vol(char *exname, char *volname)
 {
-        gf_boolean_t    ret = _gf_false;
-        char            *tmp = NULL;
+    gf_boolean_t ret = _gf_false;
+    char *tmp = NULL;
 
-        tmp = exname;
-        if (tmp[0] == '/')
-                tmp++;
+    tmp = exname;
+    if (tmp[0] == '/')
+        tmp++;
 
-        if (!strcmp (tmp, volname))
-                ret = _gf_true;
+    if (!strcmp(tmp, volname))
+        ret = _gf_true;
 
-        return ret;
+    return ret;
 }
 
 int
-nfs_priv_to_dict (xlator_t *this, dict_t *dict, char *brickname)
+nfs_priv_to_dict(xlator_t *this, dict_t *dict, char *brickname)
 {
-        int                     ret = -1;
-        struct nfs_state        *priv = NULL;
-        struct mountentry       *mentry = NULL;
-        char                    *volname = NULL;
-        char                    key[1024] = {0,};
-        int                     count = 0;
-
-        GF_VALIDATE_OR_GOTO (THIS->name, this, out);
-        GF_VALIDATE_OR_GOTO (THIS->name, dict, out);
-
-        priv = this->private;
-        GF_ASSERT (priv);
+    int ret = -1;
+    struct nfs_state *priv = NULL;
+    struct mountentry *mentry = NULL;
+    char *volname = NULL;
+    char key[1024] = {
+        0,
+    };
+    int count = 0;
+
+    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+    GF_VALIDATE_OR_GOTO(THIS->name, dict, out);
+
+    priv = this->private;
+    GF_ASSERT(priv);
+
+    ret = dict_get_str(dict, "volname", &volname);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, -ret, NFS_MSG_VOL_NOT_FOUND,
+               "Could not get volname");
+        goto out;
+    }
+
+    list_for_each_entry(mentry, &priv->mstate->mountlist, mlist)
+    {
+        if (!_nfs_export_is_for_vol(mentry->exname, volname))
+            continue;
+
+        snprintf(key, sizeof(key), "client%d.hostname", count);
+        ret = dict_set_str(dict, key, mentry->hostname);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL,
+                   "Error writing hostname to dict");
+            goto out;
+        }
 
-        ret = dict_get_str (dict, "volname", &volname);
+        /* No connection data available yet in nfs server.
+         * Hence, setting to 0 to prevent cli failing
+         */
+        snprintf(key, sizeof(key), "client%d.bytesread", count);
+        ret = dict_set_uint64(dict, key, 0);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, -ret, NFS_MSG_VOL_NOT_FOUND,
-                        "Could not get volname");
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL,
+                   "Error writing bytes read to dict");
+            goto out;
         }
 
-        list_for_each_entry (mentry, &priv->mstate->mountlist, mlist) {
-                if (!_nfs_export_is_for_vol (mentry->exname, volname))
-                        continue;
-
-                snprintf (key, sizeof (key), "client%d.hostname", count);
-                ret = dict_set_str (dict, key, mentry->hostname);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                NFS_MSG_WRITE_FAIL,
-                                "Error writing hostname to dict");
-                        goto out;
-                }
-
-                /* No connection data available yet in nfs server.
-                 * Hence, setting to 0 to prevent cli failing
-                 */
-                snprintf (key, sizeof (key), "client%d.bytesread", count);
-                ret = dict_set_uint64 (dict, key, 0);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                NFS_MSG_WRITE_FAIL,
-                                "Error writing bytes read to dict");
-                        goto out;
-                }
-
-                snprintf (key, sizeof (key), "client%d.byteswrite", count);
-                ret = dict_set_uint64 (dict, key, 0);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                NFS_MSG_WRITE_FAIL,
-                                "Error writing bytes write to dict");
-                        goto out;
-                }
-
-                count++;
+        snprintf(key, sizeof(key), "client%d.byteswrite", count);
+        ret = dict_set_uint64(dict, key, 0);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL,
+                   "Error writing bytes write to dict");
+            goto out;
         }
 
-        ret = dict_set_int32 (dict, "clientcount", count);
-        if (ret)
-                gf_msg (this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL,
-                        "Error writing client count to dict");
+        count++;
+    }
+
+    ret = dict_set_int32(dict, "clientcount", count);
+    if (ret)
+        gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_WRITE_FAIL,
+               "Error writing client count to dict");
 
 out:
-        gf_msg_debug (THIS->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug(THIS->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 extern int32_t
-nlm_priv (xlator_t *this);
+nlm_priv(xlator_t *this);
 
 int32_t
-nfs_priv (xlator_t *this)
+nfs_priv(xlator_t *this)
 {
-        int32_t ret = -1;
-
-        /* DRC needs the global drc structure, xl is of no use to it. */
-        ret = rpcsvc_drc_priv (((struct nfs_state *)(this->private))->rpcsvc->drc);
-        if (ret) {
-                gf_msg_debug (this->name, 0, "Statedump of DRC failed");
-                goto out;
-        }
-
-        ret = nlm_priv (this);
-        if (ret) {
-                gf_msg_debug (this->name, 0, "Statedump of NLM failed");
-                goto out;
-        }
- out:
-        return ret;
+    int32_t ret = -1;
+
+    /* DRC needs the global drc structure, xl is of no use to it. */
+    ret = rpcsvc_drc_priv(((struct nfs_state *)(this->private))->rpcsvc->drc);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Statedump of DRC failed");
+        goto out;
+    }
+
+    ret = nlm_priv(this);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Statedump of NLM failed");
+        goto out;
+    }
+out:
+    return ret;
 }
 
-
 struct xlator_cbks cbks = {
-        .forget      = nfs_forget,
+    .forget = nfs_forget,
 };
 
 struct xlator_fops fops;
 
 struct xlator_dumpops dumpops = {
-        .priv           = nfs_priv,
-        .priv_to_dict   = nfs_priv_to_dict,
+    .priv = nfs_priv,
+    .priv_to_dict = nfs_priv_to_dict,
 };
 
 /* TODO: If needed, per-volume options below can be extended to be export
  * specific also because after export-dir is introduced, a volume is not
  * necessarily an export whereas different subdirectories within that volume
  * can be and may need these options to be specified separately.
-*/
+ */
 struct volume_options options[] = {
-        { .key  = {"nfs3.read-size"},
-          .type = GF_OPTION_TYPE_SIZET,
-          .min  = GF_NFS3_RTMIN,
-          .max  = GF_NFS3_RTMAX,
-          .default_value = TOSTRING(GF_NFS3_RTPREF),
-          .description = "Size in which the client should issue read requests "
-                         "to the Gluster NFSv3 server. Must be a multiple of "
-                         "4KB (4096). Min and Max supported values are 4KB "
-                         "(4096) and 1MB (1048576) respectively. If the "
-                         "specified value is within the supported range but "
-                         "not a multiple of 4096, it is rounded up to the "
-                         "nearest multiple of 4096."
-        },
-        { .key  = {"nfs3.write-size"},
-          .type = GF_OPTION_TYPE_SIZET,
-          .min  = GF_NFS3_WTMIN,
-          .max  = GF_NFS3_WTMAX,
-          .default_value = TOSTRING(GF_NFS3_WTPREF),
-          .description = "Size in which the client should issue write requests "
-                         "to the Gluster NFSv3 server. Must be a multiple of "
-                         "1KB (1024). Min and Max supported values are "
-                         "4KB (4096) and 1MB(1048576) respectively. If the "
-                         "specified value is within the supported range but "
-                         "not a multiple of 4096, it is rounded up to the "
-                         "nearest multiple of 4096."
-        },
-        { .key  = {"nfs3.readdir-size"},
-          .type = GF_OPTION_TYPE_SIZET,
-          .min  = GF_NFS3_DTMIN,
-          .max  = GF_NFS3_DTMAX,
-          .default_value = TOSTRING(GF_NFS3_DTPREF),
-          .description = "Size in which the client should issue directory "
-                         "reading requests to the Gluster NFSv3 server. Must "
-                         "be a multiple of 1KB (1024). Min and Max supported "
-                         "values are 4KB (4096) and 1MB (1048576) respectively."
-                         "If the specified value is within the supported range "
-                         "but not a multiple of 4096, it is rounded up to the "
-                         "nearest multiple of 4096."
-        },
-        { .key  = {"nfs3.*.volume-access"},
-          .type = GF_OPTION_TYPE_STR,
-          .value = {"read-only", "read-write"},
-          .default_value = "read-write",
-          .description = "Type of access desired for this subvolume: "
-                         " read-only, read-write(default)"
-        },
-        { .key  = {"nfs3.*.trusted-write"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "On an UNSTABLE write from client, return STABLE flag"
-                         " to force client to not send a COMMIT request. In "
-                         "some environments, combined with a replicated "
-                         "GlusterFS setup, this option can improve write "
-                         "performance. This flag allows user to trust Gluster"
-                         " replication logic to sync data to the disks and "
-                         "recover when required. COMMIT requests if received "
-                         "will be handled in a default manner by fsyncing."
-                         " STABLE writes are still handled in a sync manner. "
-                         "Off by default."
-
-        },
-        { .key  = {"nfs3.*.trusted-sync"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "All writes and COMMIT requests are treated as async."
-                         " This implies that no write requests are guaranteed"
-                         " to be on server disks when the write reply is "
-                         "received at the NFS client. Trusted sync includes "
-                         " trusted-write behaviour. Off by default."
-
-        },
-        { .key  = {"nfs3.*.export-dir"},
-          .type = GF_OPTION_TYPE_PATH,
-          .default_value = "",
-          .description = "By default, all subvolumes of nfs are exported as "
-                         "individual exports. There are cases where a "
-                         "subdirectory or subdirectories in the volume need to "
-                         "be exported separately. This option can also be used "
-                         "in conjunction with nfs3.export-volumes option to "
-                         "restrict exports only to the subdirectories specified"
-                         " through this option. Must be an absolute path. Along"
-                         " with path allowed list of IPs/hostname can be "
-                         "associated with each subdirectory. If provided "
-                         "connection will allowed only from these IPs. By "
-                         "default connections from all IPs are allowed. "
-                         "Format: <dir>[(hostspec[|hostspec|...])][,...]. Where"
-                         " hostspec can be an IP address, hostname or an IP "
-                         "range in CIDR notation. "
-                         "e.g. /foo(192.168.1.0/24|host1|10.1.1.8),/host2."
-                         " NOTE: Care must be taken while configuring this "
-                         "option as invalid entries and/or unreachable DNS "
-                         "servers can introduce unwanted delay in all the mount"
-                         " calls."
-        },
-        { .key  = {"nfs3.export-dirs"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "By default, all subvolumes of nfs are exported as "
-                         "individual exports. There are cases where a "
-                         "subdirectory or subdirectories in the volume need to "
-                         "be exported separately. Enabling this option allows "
-                         "any directory on a volumes to be exported separately."
-                         "Directory exports are enabled by default."
-        },
-        { .key  = {"nfs3.export-volumes"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Enable or disable exporting whole volumes, instead "
-                         "if used in conjunction with nfs3.export-dir, can "
-                         "allow setting up only subdirectories as exports. On "
-                         "by default."
-        },
-        { .key  = {"rpc-auth.auth-unix"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Disable or enable the AUTH_UNIX authentication type."
-                         "Must always be enabled for better interoperability. "
-                         "However, can be disabled if needed. Enabled by "
-                         "default"
-        },
-        { .key  = {"rpc-auth.auth-null"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Disable or enable the AUTH_NULL authentication type."
-                         "Must always be enabled. This option is here only to"
-                         " avoid unrecognized option warnings"
-        },
-        { .key  = {"rpc-auth.auth-unix.*"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Disable or enable the AUTH_UNIX authentication type "
-                         "for a particular exported volume overriding defaults"
-                         " and general setting for AUTH_UNIX scheme. Must "
-                         "always be enabled for better interoperability. "
-                         "However, can be disabled if needed. Enabled by "
-                         "default."
-        },
-        { .key  = {"rpc-auth.auth-unix.*.allow"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "on",
-          .description = "Disable or enable the AUTH_UNIX authentication type "
-                         "for a particular exported volume overriding defaults"
-                         " and general setting for AUTH_UNIX scheme. Must "
-                         "always be enabled for better interoperability. "
-                         "However, can be disabled if needed. Enabled by "
-                         "default."
-        },
-        { .key  = {"rpc-auth.auth-null.*"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "Disable or enable the AUTH_NULL authentication type "
-                         "for a particular exported volume overriding defaults"
-                         " and general setting for AUTH_NULL. Must always be "
-                         "enabled. This option is here only to avoid "
-                         "unrecognized option warnings."
-        },
-        { .key  = {"rpc-auth.addr.allow"},
-          .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
-          .default_value = "all",
-          .description = "Allow a comma separated list of addresses and/or"
-                         " hostnames to connect to the server. By default, all"
-                         " connections are allowed. This allows users to "
-                         "define a general rule for all exported volumes."
-        },
-        { .key  = {"rpc-auth.addr.reject"},
-          .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
-          .default_value = "none",
-          .description = "Reject a comma separated list of addresses and/or"
-                         " hostnames from connecting to the server. By default,"
-                         " all connections are allowed. This allows users to "
-                         "define a general rule for all exported volumes."
-        },
-        { .key  = {"rpc-auth.addr.*.allow"},
-          .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
-          .default_value = "all",
-          .description = "Allow a comma separated list of addresses and/or"
-                         " hostnames to connect to the server. By default, all"
-                         " connections are allowed. This allows users to "
-                         "define a rule for a specific exported volume."
-        },
-        { .key  = {"rpc-auth.addr.*.reject"},
-          .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
-          .default_value = "none",
-          .description = "Reject a comma separated list of addresses and/or"
-                         " hostnames from connecting to the server. By default,"
-                         " all connections are allowed. This allows users to "
-                         "define a rule for a specific exported volume."
-        },
-        { .key  = {"rpc-auth.ports.insecure"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Allow client connections from unprivileged ports. By "
-                         "default only privileged ports are allowed. This is a"
-                         "global setting in case insecure ports are to be "
-                         "enabled for all exports using a single option."
-        },
-        { .key  = {"rpc-auth.ports.*.insecure"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Allow client connections from unprivileged ports. By "
-                         "default only privileged ports are allowed. Use this"
-                         " option to enable or disable insecure ports for "
-                         "a specific subvolume and to override the global "
-                         "setting set by the previous option."
-        },
-        { .key  = {"rpc-auth.addr.namelookup"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Users have the option of turning on name lookup for"
-                  " incoming client connections using this option. Use this "
-                  "option to turn on name lookups during address-based "
-                  "authentication. Turning this on will enable you to"
-                  " use hostnames in nfs.rpc-auth-* filters. In some "
-                  "setups, the name server can take too long to reply to DNS "
-                  "queries resulting in timeouts of mount requests. By "
-                  "default, name lookup is off"
-        },
-        { .key  = {"nfs.dynamic-volumes"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Internal option set to tell gnfs to use a different"
-                         " scheme for encoding file handles when DVM is being"
-                         " used."
-        },
-        { .key  = {"nfs3.*.volume-id"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "",
-          .description = "When nfs.dynamic-volumes is set, gnfs expects every "
-                         "subvolume to have this option set for it, so that "
-                         "gnfs can use this option to identify the volume. "
-                         "If all subvolumes do not have this option set, an "
-                         "error is reported."
-        },
-        { .key  = {"nfs.enable-ino32"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "no",
-          .description = "For nfs clients or apps that do not support 64-bit "
-                         "inode numbers, use this option to make NFS return "
-                         "32-bit inode numbers instead. Disabled by default, so"
-                         " NFS returns 64-bit inode numbers."
-        },
-        { .key  = {"rpc.register-with-portmap"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "For systems that need to run multiple nfs servers, "
-                         "only one registration is possible with "
-                         "portmap service. Use this option to turn off portmap "
-                         "registration for Gluster NFS. On by default"
-        },
-        { .key  = {"rpc.outstanding-rpc-limit"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT,
-          .max  = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT,
-          .default_value = TOSTRING(RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT),
-          .description = "Parameter to throttle the number of incoming RPC "
-                         "requests from a client. 0 means no limit (can "
-                         "potentially run out of memory)"
-        },
-        { .key  = {"nfs.port"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 1,
-          .max  = 0xffff,
-          .default_value = TOSTRING(GF_NFS3_PORT),
-          .description = "Use this option on systems that need Gluster NFS to "
-                         "be associated with a non-default port number."
-        },
-        { .key  = {"nfs.mem-factor"},
-          .type = GF_OPTION_TYPE_INT,
-          .min  = 1,
-          .max  = 1024,
-          .default_value = TOSTRING(GF_NFS_DEFAULT_MEMFACTOR),
-          .description = "Use this option to make NFS be faster on systems by "
-                         "using more memory. This option specifies a multiple "
-                         "that determines the total amount of memory used. "
-                         "Default value is 15. Increase to use more memory in "
-                         "order to improve performance for certain use cases."
-                         "Please consult gluster-users list before using this "
-                         "option."
-        },
-        { .key  = {"nfs.*.disable"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false",
-          .description = "This option is used to start or stop the NFS server "
-                         "for individual volumes."
-        },
-        { .key  = {"nfs.nlm"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "This option, if set to 'off', disables NLM server "
-                         "by not registering the service with the portmapper."
-                         " Set it to 'on' to re-enable it. Default value: 'on'"
-        },
-
-        { .key = {"nfs.mount-udp"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "set the option to 'on' to enable mountd on UDP. "
-                         "Required for some Solaris and AIX NFS clients. "
-                         "The need for enabling this option often depends "
-                         "on the usage of NLM."
-        },
-        { .key = {"nfs.mount-rmtab"},
-          .type = GF_OPTION_TYPE_PATH,
-          .default_value = NFS_DATADIR "/rmtab",
-          .description = "Set the location of the cache file that is used to "
-                         "list all the NFS-clients that have connected "
-                         "through the MOUNT protocol. If this is on shared "
-                         "storage, all GlusterFS servers will update and "
-                         "output (with 'showmount') the same list. Set to "
-                         "\"/-\" to disable."
-        },
-        { .key = {OPT_SERVER_RPC_STATD},
-          .type = GF_OPTION_TYPE_PATH,
-          .default_value = GF_RPC_STATD_PROG,
-          .description = "The executable of RPC statd utility. "
-                         "Defaults to " GF_RPC_STATD_PROG
-        },
-        { .key = {OPT_SERVER_RPC_STATD_PIDFILE},
-          .type = GF_OPTION_TYPE_PATH,
-          .default_value = GF_RPC_STATD_PIDFILE,
-          .description = "The pid file of RPC statd utility. "
-                         "Defaults to " GF_RPC_STATD_PIDFILE
-        },
-        { .key = {OPT_SERVER_AUX_GIDS},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "off",
-          .description = "Let the server look up which groups a user belongs "
-                         "to, overwriting the list passed from the client. "
-                         "This enables support for group lists longer than "
-                         "can be passed through the NFS protocol, but is not "
-                         "secure unless users and groups are well synchronized "
-                         "between clients and servers."
-        },
-        { .key = {OPT_SERVER_GID_CACHE_TIMEOUT},
-          .type = GF_OPTION_TYPE_INT,
-          .min = 0,
-          .max = 3600,
-          .default_value = "300",
-          .description = "Number of seconds to cache auxiliary-GID data, when "
-                         OPT_SERVER_AUX_GIDS " is set."
-        },
-        { .key = {"nfs.acl"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "This option is used to control ACL support for NFS."
-        },
-        { .key  = {"nfs.drc"},
-          .type = GF_OPTION_TYPE_STR,
-          .default_value = "off",
-          .description = "Enable Duplicate Request Cache in gNFS server to "
-                         "improve correctness of non-idempotent operations like "
-                         "write, delete, link, et al"
-        },
-        { .key  = {"nfs.drc-size"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0x20000",
-          .description = "Sets the number of non-idempotent "
-                         "requests to cache in drc"
-        },
-        { .key = {"nfs.exports-auth-enable"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .description = "Set the option to 'on' to enable exports/netgroup "
-                         "authentication in the NFS server and mount daemon."
-        },
-
-        { .key = {"nfs.auth-refresh-interval-sec"},
-          .type = GF_OPTION_TYPE_INT,
-          .description = "Frequency in seconds that the daemon should check for"
-                         " changes in the exports/netgroups file."
-        },
-
-       { .key = {"nfs.auth-cache-ttl-sec"},
-          .type = GF_OPTION_TYPE_INT,
-          .description = "Sets the TTL of an entry in the auth cache. Value is "
-                         "in seconds."
-        },
-        { .key  = {"nfs.rdirplus"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "on",
-          .description = "When this option is set to off NFS falls back to "
-                         "standard readdir instead of readdirp"
-        },
-        { .key = {"nfs.event-threads"},
-          .type = GF_OPTION_TYPE_SIZET,
-          .min = 1,
-          .max = 32,
-          .default_value = "1",
-          .description = "Specifies the number of event threads to execute in"
-                         "in parallel. Larger values would help process"
-                         " responses faster, depending on available processing"
-                         " power. Range 1-32 threads.",
-          .op_version = {GD_OP_VERSION_4_0_0},
-          .flags = OPT_FLAG_SETTABLE,
-        },
-        { .key  = {NULL} },
+    {.key = {"nfs3.read-size"},
+     .type = GF_OPTION_TYPE_SIZET,
+     .min = GF_NFS3_RTMIN,
+     .max = GF_NFS3_RTMAX,
+     .default_value = TOSTRING(GF_NFS3_RTPREF),
+     .description = "Size in which the client should issue read requests "
+                    "to the Gluster NFSv3 server. Must be a multiple of "
+                    "4KB (4096). Min and Max supported values are 4KB "
+                    "(4096) and 1MB (1048576) respectively. If the "
+                    "specified value is within the supported range but "
+                    "not a multiple of 4096, it is rounded up to the "
+                    "nearest multiple of 4096."},
+    {.key = {"nfs3.write-size"},
+     .type = GF_OPTION_TYPE_SIZET,
+     .min = GF_NFS3_WTMIN,
+     .max = GF_NFS3_WTMAX,
+     .default_value = TOSTRING(GF_NFS3_WTPREF),
+     .description = "Size in which the client should issue write requests "
+                    "to the Gluster NFSv3 server. Must be a multiple of "
+                    "1KB (1024). Min and Max supported values are "
+                    "4KB (4096) and 1MB(1048576) respectively. If the "
+                    "specified value is within the supported range but "
+                    "not a multiple of 4096, it is rounded up to the "
+                    "nearest multiple of 4096."},
+    {.key = {"nfs3.readdir-size"},
+     .type = GF_OPTION_TYPE_SIZET,
+     .min = GF_NFS3_DTMIN,
+     .max = GF_NFS3_DTMAX,
+     .default_value = TOSTRING(GF_NFS3_DTPREF),
+     .description = "Size in which the client should issue directory "
+                    "reading requests to the Gluster NFSv3 server. Must "
+                    "be a multiple of 1KB (1024). Min and Max supported "
+                    "values are 4KB (4096) and 1MB (1048576) respectively."
+                    "If the specified value is within the supported range "
+                    "but not a multiple of 4096, it is rounded up to the "
+                    "nearest multiple of 4096."},
+    {.key = {"nfs3.*.volume-access"},
+     .type = GF_OPTION_TYPE_STR,
+     .value = {"read-only", "read-write"},
+     .default_value = "read-write",
+     .description = "Type of access desired for this subvolume: "
+                    " read-only, read-write(default)"},
+    {.key = {"nfs3.*.trusted-write"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "On an UNSTABLE write from client, return STABLE flag"
+                    " to force client to not send a COMMIT request. In "
+                    "some environments, combined with a replicated "
+                    "GlusterFS setup, this option can improve write "
+                    "performance. This flag allows user to trust Gluster"
+                    " replication logic to sync data to the disks and "
+                    "recover when required. COMMIT requests if received "
+                    "will be handled in a default manner by fsyncing."
+                    " STABLE writes are still handled in a sync manner. "
+                    "Off by default."
+
+    },
+    {.key = {"nfs3.*.trusted-sync"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "All writes and COMMIT requests are treated as async."
+                    " This implies that no write requests are guaranteed"
+                    " to be on server disks when the write reply is "
+                    "received at the NFS client. Trusted sync includes "
+                    " trusted-write behaviour. Off by default."
+
+    },
+    {.key = {"nfs3.*.export-dir"},
+     .type = GF_OPTION_TYPE_PATH,
+     .default_value = "",
+     .description = "By default, all subvolumes of nfs are exported as "
+                    "individual exports. There are cases where a "
+                    "subdirectory or subdirectories in the volume need to "
+                    "be exported separately. This option can also be used "
+                    "in conjunction with nfs3.export-volumes option to "
+                    "restrict exports only to the subdirectories specified"
+                    " through this option. Must be an absolute path. Along"
+                    " with path allowed list of IPs/hostname can be "
+                    "associated with each subdirectory. If provided "
+                    "connection will allowed only from these IPs. By "
+                    "default connections from all IPs are allowed. "
+                    "Format: <dir>[(hostspec[|hostspec|...])][,...]. Where"
+                    " hostspec can be an IP address, hostname or an IP "
+                    "range in CIDR notation. "
+                    "e.g. /foo(192.168.1.0/24|host1|10.1.1.8),/host2."
+                    " NOTE: Care must be taken while configuring this "
+                    "option as invalid entries and/or unreachable DNS "
+                    "servers can introduce unwanted delay in all the mount"
+                    " calls."},
+    {.key = {"nfs3.export-dirs"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "By default, all subvolumes of nfs are exported as "
+                    "individual exports. There are cases where a "
+                    "subdirectory or subdirectories in the volume need to "
+                    "be exported separately. Enabling this option allows "
+                    "any directory on a volumes to be exported separately."
+                    "Directory exports are enabled by default."},
+    {.key = {"nfs3.export-volumes"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Enable or disable exporting whole volumes, instead "
+                    "if used in conjunction with nfs3.export-dir, can "
+                    "allow setting up only subdirectories as exports. On "
+                    "by default."},
+    {.key = {"rpc-auth.auth-unix"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Disable or enable the AUTH_UNIX authentication type."
+                    "Must always be enabled for better interoperability. "
+                    "However, can be disabled if needed. Enabled by "
+                    "default"},
+    {.key = {"rpc-auth.auth-null"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Disable or enable the AUTH_NULL authentication type."
+                    "Must always be enabled. This option is here only to"
+                    " avoid unrecognized option warnings"},
+    {.key = {"rpc-auth.auth-unix.*"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Disable or enable the AUTH_UNIX authentication type "
+                    "for a particular exported volume overriding defaults"
+                    " and general setting for AUTH_UNIX scheme. Must "
+                    "always be enabled for better interoperability. "
+                    "However, can be disabled if needed. Enabled by "
+                    "default."},
+    {.key = {"rpc-auth.auth-unix.*.allow"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "on",
+     .description = "Disable or enable the AUTH_UNIX authentication type "
+                    "for a particular exported volume overriding defaults"
+                    " and general setting for AUTH_UNIX scheme. Must "
+                    "always be enabled for better interoperability. "
+                    "However, can be disabled if needed. Enabled by "
+                    "default."},
+    {.key = {"rpc-auth.auth-null.*"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "Disable or enable the AUTH_NULL authentication type "
+                    "for a particular exported volume overriding defaults"
+                    " and general setting for AUTH_NULL. Must always be "
+                    "enabled. This option is here only to avoid "
+                    "unrecognized option warnings."},
+    {.key = {"rpc-auth.addr.allow"},
+     .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
+     .default_value = "all",
+     .description = "Allow a comma separated list of addresses and/or"
+                    " hostnames to connect to the server. By default, all"
+                    " connections are allowed. This allows users to "
+                    "define a general rule for all exported volumes."},
+    {.key = {"rpc-auth.addr.reject"},
+     .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
+     .default_value = "none",
+     .description = "Reject a comma separated list of addresses and/or"
+                    " hostnames from connecting to the server. By default,"
+                    " all connections are allowed. This allows users to "
+                    "define a general rule for all exported volumes."},
+    {.key = {"rpc-auth.addr.*.allow"},
+     .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
+     .default_value = "all",
+     .description = "Allow a comma separated list of addresses and/or"
+                    " hostnames to connect to the server. By default, all"
+                    " connections are allowed. This allows users to "
+                    "define a rule for a specific exported volume."},
+    {.key = {"rpc-auth.addr.*.reject"},
+     .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR,
+     .default_value = "none",
+     .description = "Reject a comma separated list of addresses and/or"
+                    " hostnames from connecting to the server. By default,"
+                    " all connections are allowed. This allows users to "
+                    "define a rule for a specific exported volume."},
+    {.key = {"rpc-auth.ports.insecure"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Allow client connections from unprivileged ports. By "
+                    "default only privileged ports are allowed. This is a"
+                    "global setting in case insecure ports are to be "
+                    "enabled for all exports using a single option."},
+    {.key = {"rpc-auth.ports.*.insecure"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Allow client connections from unprivileged ports. By "
+                    "default only privileged ports are allowed. Use this"
+                    " option to enable or disable insecure ports for "
+                    "a specific subvolume and to override the global "
+                    "setting set by the previous option."},
+    {.key = {"rpc-auth.addr.namelookup"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Users have the option of turning on name lookup for"
+                    " incoming client connections using this option. Use this "
+                    "option to turn on name lookups during address-based "
+                    "authentication. Turning this on will enable you to"
+                    " use hostnames in nfs.rpc-auth-* filters. In some "
+                    "setups, the name server can take too long to reply to DNS "
+                    "queries resulting in timeouts of mount requests. By "
+                    "default, name lookup is off"},
+    {.key = {"nfs.dynamic-volumes"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Internal option set to tell gnfs to use a different"
+                    " scheme for encoding file handles when DVM is being"
+                    " used."},
+    {.key = {"nfs3.*.volume-id"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "",
+     .description = "When nfs.dynamic-volumes is set, gnfs expects every "
+                    "subvolume to have this option set for it, so that "
+                    "gnfs can use this option to identify the volume. "
+                    "If all subvolumes do not have this option set, an "
+                    "error is reported."},
+    {.key = {"nfs.enable-ino32"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "no",
+     .description = "For nfs clients or apps that do not support 64-bit "
+                    "inode numbers, use this option to make NFS return "
+                    "32-bit inode numbers instead. Disabled by default, so"
+                    " NFS returns 64-bit inode numbers."},
+    {.key = {"rpc.register-with-portmap"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "For systems that need to run multiple nfs servers, "
+                    "only one registration is possible with "
+                    "portmap service. Use this option to turn off portmap "
+                    "registration for Gluster NFS. On by default"},
+    {.key = {"rpc.outstanding-rpc-limit"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT,
+     .max = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT,
+     .default_value = TOSTRING(RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT),
+     .description = "Parameter to throttle the number of incoming RPC "
+                    "requests from a client. 0 means no limit (can "
+                    "potentially run out of memory)"},
+    {.key = {"nfs.port"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 0xffff,
+     .default_value = TOSTRING(GF_NFS3_PORT),
+     .description = "Use this option on systems that need Gluster NFS to "
+                    "be associated with a non-default port number."},
+    {.key = {"nfs.mem-factor"},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 1,
+     .max = 1024,
+     .default_value = TOSTRING(GF_NFS_DEFAULT_MEMFACTOR),
+     .description = "Use this option to make NFS be faster on systems by "
+                    "using more memory. This option specifies a multiple "
+                    "that determines the total amount of memory used. "
+                    "Default value is 15. Increase to use more memory in "
+                    "order to improve performance for certain use cases."
+                    "Please consult gluster-users list before using this "
+                    "option."},
+    {.key = {"nfs.*.disable"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false",
+     .description = "This option is used to start or stop the NFS server "
+                    "for individual volumes."},
+    {.key = {"nfs.nlm"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "This option, if set to 'off', disables NLM server "
+                    "by not registering the service with the portmapper."
+                    " Set it to 'on' to re-enable it. Default value: 'on'"},
+
+    {.key = {"nfs.mount-udp"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "set the option to 'on' to enable mountd on UDP. "
+                    "Required for some Solaris and AIX NFS clients. "
+                    "The need for enabling this option often depends "
+                    "on the usage of NLM."},
+    {.key = {"nfs.mount-rmtab"},
+     .type = GF_OPTION_TYPE_PATH,
+     .default_value = NFS_DATADIR "/rmtab",
+     .description = "Set the location of the cache file that is used to "
+                    "list all the NFS-clients that have connected "
+                    "through the MOUNT protocol. If this is on shared "
+                    "storage, all GlusterFS servers will update and "
+                    "output (with 'showmount') the same list. Set to "
+                    "\"/-\" to disable."},
+    {.key = {OPT_SERVER_RPC_STATD},
+     .type = GF_OPTION_TYPE_PATH,
+     .default_value = GF_RPC_STATD_PROG,
+     .description = "The executable of RPC statd utility. "
+                    "Defaults to " GF_RPC_STATD_PROG},
+    {.key = {OPT_SERVER_RPC_STATD_PIDFILE},
+     .type = GF_OPTION_TYPE_PATH,
+     .default_value = GF_RPC_STATD_PIDFILE,
+     .description = "The pid file of RPC statd utility. "
+                    "Defaults to " GF_RPC_STATD_PIDFILE},
+    {.key = {OPT_SERVER_AUX_GIDS},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "off",
+     .description = "Let the server look up which groups a user belongs "
+                    "to, overwriting the list passed from the client. "
+                    "This enables support for group lists longer than "
+                    "can be passed through the NFS protocol, but is not "
+                    "secure unless users and groups are well synchronized "
+                    "between clients and servers."},
+    {.key = {OPT_SERVER_GID_CACHE_TIMEOUT},
+     .type = GF_OPTION_TYPE_INT,
+     .min = 0,
+     .max = 3600,
+     .default_value = "300",
+     .description = "Number of seconds to cache auxiliary-GID data, "
+                    "when " OPT_SERVER_AUX_GIDS " is set."},
+    {.key = {"nfs.acl"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "This option is used to control ACL support for NFS."},
+    {.key = {"nfs.drc"},
+     .type = GF_OPTION_TYPE_STR,
+     .default_value = "off",
+     .description = "Enable Duplicate Request Cache in gNFS server to "
+                    "improve correctness of non-idempotent operations like "
+                    "write, delete, link, et al"},
+    {.key = {"nfs.drc-size"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "0x20000",
+     .description = "Sets the number of non-idempotent "
+                    "requests to cache in drc"},
+    {.key = {"nfs.exports-auth-enable"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .description = "Set the option to 'on' to enable exports/netgroup "
+                    "authentication in the NFS server and mount daemon."},
+
+    {.key = {"nfs.auth-refresh-interval-sec"},
+     .type = GF_OPTION_TYPE_INT,
+     .description = "Frequency in seconds that the daemon should check for"
+                    " changes in the exports/netgroups file."},
+
+    {.key = {"nfs.auth-cache-ttl-sec"},
+     .type = GF_OPTION_TYPE_INT,
+     .description = "Sets the TTL of an entry in the auth cache. Value is "
+                    "in seconds."},
+    {.key = {"nfs.rdirplus"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "on",
+     .description = "When this option is set to off NFS falls back to "
+                    "standard readdir instead of readdirp"},
+    {
+        .key = {"nfs.event-threads"},
+        .type = GF_OPTION_TYPE_SIZET,
+        .min = 1,
+        .max = 32,
+        .default_value = "1",
+        .description = "Specifies the number of event threads to execute in"
+                       "in parallel. Larger values would help process"
+                       " responses faster, depending on available processing"
+                       " power. Range 1-32 threads.",
+        .op_version = {GD_OP_VERSION_4_0_0},
+        .flags = OPT_FLAG_SETTABLE,
+    },
+    {.key = {NULL}},
 };
diff --git a/xlators/nfs/server/src/nfs3-fh.c b/xlators/nfs/server/src/nfs3-fh.c
index 3feeae39dae..c63f9328f57 100644
--- a/xlators/nfs/server/src/nfs3-fh.c
+++ b/xlators/nfs/server/src/nfs3-fh.c
@@ -20,167 +20,167 @@
 #include "common-utils.h"
 #include "nfs-messages.h"
 
-
 int
-nfs3_fh_validate (struct nfs3_fh *fh)
+nfs3_fh_validate(struct nfs3_fh *fh)
 {
-	if (!fh)
-		return 0;
+    if (!fh)
+        return 0;
 
-	if (fh->ident[0] != GF_NFSFH_IDENT0)
-		return 0;
+    if (fh->ident[0] != GF_NFSFH_IDENT0)
+        return 0;
 
-	if (fh->ident[1] != GF_NFSFH_IDENT1)
-		return 0;
+    if (fh->ident[1] != GF_NFSFH_IDENT1)
+        return 0;
 
-       if (fh->ident[2] != GF_NFSFH_IDENT2)
-               return 0;
+    if (fh->ident[2] != GF_NFSFH_IDENT2)
+        return 0;
 
-       if (fh->ident[3] != GF_NFSFH_IDENT3)
-               return 0;
+    if (fh->ident[3] != GF_NFSFH_IDENT3)
+        return 0;
 
-        return 1;
+    return 1;
 }
 
-
 void
-nfs3_fh_init (struct nfs3_fh *fh, struct iatt *buf)
+nfs3_fh_init(struct nfs3_fh *fh, struct iatt *buf)
 {
-        if ((!fh) || (!buf))
-                return;
+    if ((!fh) || (!buf))
+        return;
 
-        fh->ident[0] = GF_NFSFH_IDENT0;
-        fh->ident[1] = GF_NFSFH_IDENT1;
-        fh->ident[2] = GF_NFSFH_IDENT2;
-        fh->ident[3] = GF_NFSFH_IDENT3;
+    fh->ident[0] = GF_NFSFH_IDENT0;
+    fh->ident[1] = GF_NFSFH_IDENT1;
+    fh->ident[2] = GF_NFSFH_IDENT2;
+    fh->ident[3] = GF_NFSFH_IDENT3;
 
-        gf_uuid_copy (fh->gfid, buf->ia_gfid);
+    gf_uuid_copy(fh->gfid, buf->ia_gfid);
 }
 
-
 struct nfs3_fh
-nfs3_fh_build_indexed_root_fh (xlator_list_t *cl, xlator_t *xl)
+nfs3_fh_build_indexed_root_fh(xlator_list_t *cl, xlator_t *xl)
 {
-        struct nfs3_fh  fh = {{0}, };
-        struct iatt     buf = {0, };
-        uuid_t          root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
-
-        if ((!cl) || (!xl))
-                return fh;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    struct iatt buf = {
+        0,
+    };
+    uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+
+    if ((!cl) || (!xl))
+        return fh;
 
-        gf_uuid_copy (buf.ia_gfid, root);
-        nfs3_fh_init (&fh, &buf);
-        fh.exportid [15] = nfs_xlator_to_xlid (cl, xl);
+    gf_uuid_copy(buf.ia_gfid, root);
+    nfs3_fh_init(&fh, &buf);
+    fh.exportid[15] = nfs_xlator_to_xlid(cl, xl);
 
-        return fh;
+    return fh;
 }
 
-
 struct nfs3_fh
-nfs3_fh_build_uuid_root_fh (uuid_t volumeid, uuid_t mountid)
+nfs3_fh_build_uuid_root_fh(uuid_t volumeid, uuid_t mountid)
 {
-        struct nfs3_fh  fh = {{0}, };
-        struct iatt     buf = {0, };
-        uuid_t          root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
-
-        gf_uuid_copy (buf.ia_gfid, root);
-        nfs3_fh_init (&fh, &buf);
-        gf_uuid_copy (fh.exportid, volumeid);
-        gf_uuid_copy (fh.mountid, mountid);
-
-        return fh;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    struct iatt buf = {
+        0,
+    };
+    uuid_t root = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+
+    gf_uuid_copy(buf.ia_gfid, root);
+    nfs3_fh_init(&fh, &buf);
+    gf_uuid_copy(fh.exportid, volumeid);
+    gf_uuid_copy(fh.mountid, mountid);
+
+    return fh;
 }
 
-
 int
-nfs3_fh_is_root_fh (struct nfs3_fh *fh)
+nfs3_fh_is_root_fh(struct nfs3_fh *fh)
 {
-        uuid_t  rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+    uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
-        if (!fh)
-                return 0;
+    if (!fh)
+        return 0;
 
-        if (gf_uuid_compare (fh->gfid, rootgfid) == 0)
-                return 1;
+    if (gf_uuid_compare(fh->gfid, rootgfid) == 0)
+        return 1;
 
-        return 0;
+    return 0;
 }
 
-
 void
-nfs3_fh_to_str (struct nfs3_fh *fh, char *str, size_t len)
+nfs3_fh_to_str(struct nfs3_fh *fh, char *str, size_t len)
 {
-        char            gfid[GF_UUID_BUF_SIZE];
-        char            exportid[GF_UUID_BUF_SIZE];
-        char            mountid[GF_UUID_BUF_SIZE];
+    char gfid[GF_UUID_BUF_SIZE];
+    char exportid[GF_UUID_BUF_SIZE];
+    char mountid[GF_UUID_BUF_SIZE];
 
-        if ((!fh) || (!str))
-                return;
+    if ((!fh) || (!str))
+        return;
 
-        snprintf (str, len, "FH: exportid %s, gfid %s, mountid %s",
-                  uuid_utoa_r (fh->exportid, exportid),
-                  uuid_utoa_r (fh->gfid, gfid),
-                  uuid_utoa_r (fh->mountid, mountid));
+    snprintf(str, len, "FH: exportid %s, gfid %s, mountid %s",
+             uuid_utoa_r(fh->exportid, exportid), uuid_utoa_r(fh->gfid, gfid),
+             uuid_utoa_r(fh->mountid, mountid));
 }
 
 void
-nfs3_log_fh (struct nfs3_fh *fh)
+nfs3_log_fh(struct nfs3_fh *fh)
 {
-        char    gfidstr[512];
-        char    exportidstr[512];
+    char gfidstr[512];
+    char exportidstr[512];
 
-        if (!fh)
-                return;
+    if (!fh)
+        return;
 
-        gf_msg_trace ("nfs3-fh", 0, "filehandle: exportid 0x%s, gfid 0x%s",
-                      uuid_utoa_r (fh->exportid, exportidstr),
-                      uuid_utoa_r (fh->gfid, gfidstr));
+    gf_msg_trace("nfs3-fh", 0, "filehandle: exportid 0x%s, gfid 0x%s",
+                 uuid_utoa_r(fh->exportid, exportidstr),
+                 uuid_utoa_r(fh->gfid, gfidstr));
 }
 
 int
-nfs3_fh_build_parent_fh (struct nfs3_fh *child, struct iatt *newstat,
-                         struct nfs3_fh *newfh)
+nfs3_fh_build_parent_fh(struct nfs3_fh *child, struct iatt *newstat,
+                        struct nfs3_fh *newfh)
 {
-        if ((!child) || (!newstat) || (!newfh))
-                return -1;
+    if ((!child) || (!newstat) || (!newfh))
+        return -1;
 
-        nfs3_fh_init (newfh, newstat);
-        gf_uuid_copy (newfh->exportid, child->exportid);
-        return 0;
+    nfs3_fh_init(newfh, newstat);
+    gf_uuid_copy(newfh->exportid, child->exportid);
+    return 0;
 }
 
 int
-nfs3_build_fh (inode_t *inode, uuid_t exportid, struct nfs3_fh *newfh)
+nfs3_build_fh(inode_t *inode, uuid_t exportid, struct nfs3_fh *newfh)
 {
-        if (!newfh || !inode)
-                return -1;
-
-        newfh->ident[0] = GF_NFSFH_IDENT0;
-        newfh->ident[1] = GF_NFSFH_IDENT1;
-        newfh->ident[2] = GF_NFSFH_IDENT2;
-        newfh->ident[3] = GF_NFSFH_IDENT3;
-        gf_uuid_copy (newfh->gfid, inode->gfid);
-        gf_uuid_copy (newfh->exportid, exportid);
-        /*gf_uuid_copy (newfh->mountid, mountid);*/
-        return 0;
+    if (!newfh || !inode)
+        return -1;
+
+    newfh->ident[0] = GF_NFSFH_IDENT0;
+    newfh->ident[1] = GF_NFSFH_IDENT1;
+    newfh->ident[2] = GF_NFSFH_IDENT2;
+    newfh->ident[3] = GF_NFSFH_IDENT3;
+    gf_uuid_copy(newfh->gfid, inode->gfid);
+    gf_uuid_copy(newfh->exportid, exportid);
+    /*gf_uuid_copy (newfh->mountid, mountid);*/
+    return 0;
 }
 
 int
-nfs3_fh_build_child_fh (struct nfs3_fh *parent, struct iatt *newstat,
-                        struct nfs3_fh *newfh)
+nfs3_fh_build_child_fh(struct nfs3_fh *parent, struct iatt *newstat,
+                       struct nfs3_fh *newfh)
 {
-        if ((!parent) || (!newstat) || (!newfh))
-                return -1;
+    if ((!parent) || (!newstat) || (!newfh))
+        return -1;
 
-        nfs3_fh_init (newfh, newstat);
-        gf_uuid_copy (newfh->exportid, parent->exportid);
-        gf_uuid_copy (newfh->mountid, parent->mountid);
-        return 0;
+    nfs3_fh_init(newfh, newstat);
+    gf_uuid_copy(newfh->exportid, parent->exportid);
+    gf_uuid_copy(newfh->mountid, parent->mountid);
+    return 0;
 }
 
-
 uint32_t
-nfs3_fh_compute_size ()
+nfs3_fh_compute_size()
 {
-        return GF_NFSFH_STATIC_SIZE;
+    return GF_NFSFH_STATIC_SIZE;
 }
diff --git a/xlators/nfs/server/src/nfs3-helpers.c b/xlators/nfs/server/src/nfs3-helpers.c
index 27edf471db2..7fa278fdc24 100644
--- a/xlators/nfs/server/src/nfs3-helpers.c
+++ b/xlators/nfs/server/src/nfs3-helpers.c
@@ -27,231 +27,222 @@
 #include <string.h>
 
 extern int
-nfs3_set_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh);
+nfs3_set_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh);
 
 extern int
-nfs3_is_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh);
+nfs3_is_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh);
 
+#define nfs3_call_resume(cst)                                                  \
+    do {                                                                       \
+        if (((cst)) && (cst)->resume_fn)                                       \
+            (cst)->resume_fn(cst);                                             \
+    } while (0)
 
-#define nfs3_call_resume(cst)                                   \
-        do {                                                    \
-                if (((cst)) && (cst)->resume_fn)                \
-                        (cst)->resume_fn (cst);                 \
-        } while (0)                                             \
-
-#define nfs3_call_resume_estale(csta)                           \
-        do {                                                    \
-                (csta)->resolve_ret = -1;                       \
-                (csta)->resolve_errno = ESTALE;                 \
-                nfs3_call_resume (csta);                        \
-        } while (0)                                             \
+#define nfs3_call_resume_estale(csta)                                          \
+    do {                                                                       \
+        (csta)->resolve_ret = -1;                                              \
+        (csta)->resolve_errno = ESTALE;                                        \
+        nfs3_call_resume(csta);                                                \
+    } while (0)
 
 struct nfs3stat_strerror {
-        nfsstat3        stat;
-        char            strerror[100];
+    nfsstat3 stat;
+    char strerror[100];
 };
 
-
 struct nfs3stat_strerror nfs3stat_strerror_table[] = {
-        { NFS3_OK,              "Call completed successfully."          },
-        { NFS3ERR_PERM,         "Not owner"                             },
-        { NFS3ERR_NOENT,        "No such file or directory"             },
-        { NFS3ERR_IO,           "I/O error"                             },
-        { NFS3ERR_NXIO,         "I/O error"                             },
-        { NFS3ERR_ACCES,        "Permission denied"                     },
-        { NFS3ERR_EXIST,        "File exists"                           },
-        { NFS3ERR_XDEV,         "Attempt to do a cross-device hard link"},
-        { NFS3ERR_NODEV,        "No such device"                        },
-        { NFS3ERR_NOTDIR,       "Not a directory"                       },
-        { NFS3ERR_ISDIR,        "Is a directory"                        },
-        { NFS3ERR_INVAL,        "Invalid argument for operation"        },
-        { NFS3ERR_FBIG,         "File too large"                        },
-        { NFS3ERR_NOSPC,        "No space left on device"               },
-        { NFS3ERR_ROFS,         "Read-only file system"                 },
-        { NFS3ERR_MLINK,        "Too many hard links"                   },
-        { NFS3ERR_NAMETOOLONG,  "Filename in operation was too long"    },
-        { NFS3ERR_NOTEMPTY,     "Directory not empty"                   },
-        { NFS3ERR_DQUOT,        "Resource (quota) hard limit exceeded"  },
-        { NFS3ERR_STALE,        "Invalid file handle"                   },
-        { NFS3ERR_REMOTE,       "Too many levels of remote in path"     },
-        { NFS3ERR_BADHANDLE,    "Illegal NFS file handle"               },
-        { NFS3ERR_NOT_SYNC,     "Update synchronization mismatch detected" },
-        { NFS3ERR_BAD_COOKIE,   "READDIR or READDIRPLUS cookie is stale"},
-        { NFS3ERR_NOTSUPP,      "Operation is not supported"            },
-        { NFS3ERR_TOOSMALL,     "Buffer or request is too small"        },
-        { NFS3ERR_SERVERFAULT,  "Error occurred on the server or IO Error" },
-        { NFS3ERR_BADTYPE,      "Type not supported by the server"      },
-        { NFS3ERR_JUKEBOX,      "Cannot complete server initiated request" },
-        { NFS3ERR_END_OF_LIST,  "IO Error"                              },
+    {NFS3_OK, "Call completed successfully."},
+    {NFS3ERR_PERM, "Not owner"},
+    {NFS3ERR_NOENT, "No such file or directory"},
+    {NFS3ERR_IO, "I/O error"},
+    {NFS3ERR_NXIO, "I/O error"},
+    {NFS3ERR_ACCES, "Permission denied"},
+    {NFS3ERR_EXIST, "File exists"},
+    {NFS3ERR_XDEV, "Attempt to do a cross-device hard link"},
+    {NFS3ERR_NODEV, "No such device"},
+    {NFS3ERR_NOTDIR, "Not a directory"},
+    {NFS3ERR_ISDIR, "Is a directory"},
+    {NFS3ERR_INVAL, "Invalid argument for operation"},
+    {NFS3ERR_FBIG, "File too large"},
+    {NFS3ERR_NOSPC, "No space left on device"},
+    {NFS3ERR_ROFS, "Read-only file system"},
+    {NFS3ERR_MLINK, "Too many hard links"},
+    {NFS3ERR_NAMETOOLONG, "Filename in operation was too long"},
+    {NFS3ERR_NOTEMPTY, "Directory not empty"},
+    {NFS3ERR_DQUOT, "Resource (quota) hard limit exceeded"},
+    {NFS3ERR_STALE, "Invalid file handle"},
+    {NFS3ERR_REMOTE, "Too many levels of remote in path"},
+    {NFS3ERR_BADHANDLE, "Illegal NFS file handle"},
+    {NFS3ERR_NOT_SYNC, "Update synchronization mismatch detected"},
+    {NFS3ERR_BAD_COOKIE, "READDIR or READDIRPLUS cookie is stale"},
+    {NFS3ERR_NOTSUPP, "Operation is not supported"},
+    {NFS3ERR_TOOSMALL, "Buffer or request is too small"},
+    {NFS3ERR_SERVERFAULT, "Error occurred on the server or IO Error"},
+    {NFS3ERR_BADTYPE, "Type not supported by the server"},
+    {NFS3ERR_JUKEBOX, "Cannot complete server initiated request"},
+    {NFS3ERR_END_OF_LIST, "IO Error"},
 
 };
 
-
 uint64_t
-nfs3_iatt_gfid_to_ino (struct iatt *buf)
+nfs3_iatt_gfid_to_ino(struct iatt *buf)
 {
-        uint64_t ino  = 0;
+    uint64_t ino = 0;
 
-        if (!buf)
-                return 0;
+    if (!buf)
+        return 0;
 
-        if (gf_nfs_enable_ino32()) {
-                ino = (uint32_t )nfs_hash_gfid (buf->ia_gfid);
-                goto hashout;
-        }
+    if (gf_nfs_enable_ino32()) {
+        ino = (uint32_t)nfs_hash_gfid(buf->ia_gfid);
+        goto hashout;
+    }
 
-        /* from posix its guaranteed to send unique ino */
-        ino = buf->ia_ino;
+    /* from posix its guaranteed to send unique ino */
+    ino = buf->ia_ino;
 
 hashout:
-        return ino;
+    return ino;
 }
 
-
 void
-nfs3_map_deviceid_to_statdev (struct iatt *ia, uint64_t deviceid)
+nfs3_map_deviceid_to_statdev(struct iatt *ia, uint64_t deviceid)
 {
-        if (!ia)
-                return;
+    if (!ia)
+        return;
 
-        ia->ia_dev = deviceid;
+    ia->ia_dev = deviceid;
 }
 
-
 struct nfs3_fh
-nfs3_extract_nfs3_fh (nfs_fh3 fh)
+nfs3_extract_nfs3_fh(nfs_fh3 fh)
 {
-        struct nfs3_fh          gfh;
+    struct nfs3_fh gfh;
 
-        memcpy (&gfh, fh.data.data_val, fh.data.data_len);
-        return gfh;
+    memcpy(&gfh, fh.data.data_val, fh.data.data_len);
+    return gfh;
 }
 
-
 struct nfs3_fh
-nfs3_extract_lookup_fh (lookup3args *args)
+nfs3_extract_lookup_fh(lookup3args *args)
 {
-        return nfs3_extract_nfs3_fh(args->what.dir);
+    return nfs3_extract_nfs3_fh(args->what.dir);
 }
 
-
 char *
-nfs3_extract_lookup_name (lookup3args *args)
+nfs3_extract_lookup_name(lookup3args *args)
 {
-        return args->what.name;
+    return args->what.name;
 }
 
-
 nfsstat3
-nfs3_errno_to_nfsstat3 (int errnum)
+nfs3_errno_to_nfsstat3(int errnum)
 {
-        nfsstat3        stat = NFS3_OK;
-
-        switch (errnum) {
+    nfsstat3 stat = NFS3_OK;
 
+    switch (errnum) {
         case 0:
-                stat = NFS3_OK;
-                break;
+            stat = NFS3_OK;
+            break;
 
         case EPERM:
-                stat = NFS3ERR_PERM;
-                break;
+            stat = NFS3ERR_PERM;
+            break;
 
         case ENOENT:
-                stat = NFS3ERR_NOENT;
-                break;
+            stat = NFS3ERR_NOENT;
+            break;
 
         case EACCES:
-                stat = NFS3ERR_ACCES;
-                break;
+            stat = NFS3ERR_ACCES;
+            break;
 
         case EEXIST:
-                stat = NFS3ERR_EXIST;
-                break;
+            stat = NFS3ERR_EXIST;
+            break;
 
         case EXDEV:
-                stat = NFS3ERR_XDEV;
-                break;
+            stat = NFS3ERR_XDEV;
+            break;
 
         case ENODEV:
-                stat = NFS3ERR_NODEV;
-                break;
+            stat = NFS3ERR_NODEV;
+            break;
 
         case EIO:
-                stat = NFS3ERR_IO;
-                break;
+            stat = NFS3ERR_IO;
+            break;
 
         case ENXIO:
-                stat = NFS3ERR_NXIO;
-                break;
+            stat = NFS3ERR_NXIO;
+            break;
 
         case ENOTDIR:
-                stat = NFS3ERR_NOTDIR;
-                break;
+            stat = NFS3ERR_NOTDIR;
+            break;
 
         case EISDIR:
-                stat = NFS3ERR_ISDIR;
-                break;
+            stat = NFS3ERR_ISDIR;
+            break;
 
         case EINVAL:
-                stat = NFS3ERR_INVAL;
-                break;
+            stat = NFS3ERR_INVAL;
+            break;
 
         case ENOSPC:
-                stat = NFS3ERR_NOSPC;
-                break;
+            stat = NFS3ERR_NOSPC;
+            break;
 
         case EROFS:
-                stat = NFS3ERR_ROFS;
-                break;
+            stat = NFS3ERR_ROFS;
+            break;
 
         case EFBIG:
-                stat = NFS3ERR_FBIG;
-                break;
+            stat = NFS3ERR_FBIG;
+            break;
 
         case EMLINK:
-                stat = NFS3ERR_MLINK;
-                break;
+            stat = NFS3ERR_MLINK;
+            break;
 
         case ENAMETOOLONG:
-                stat = NFS3ERR_NAMETOOLONG;
-                break;
+            stat = NFS3ERR_NAMETOOLONG;
+            break;
 
         case ENOTEMPTY:
-                stat = NFS3ERR_NOTEMPTY;
-                break;
+            stat = NFS3ERR_NOTEMPTY;
+            break;
 
         case EFAULT:
-                stat = NFS3ERR_SERVERFAULT;
-                break;
+            stat = NFS3ERR_SERVERFAULT;
+            break;
 
         case ENOTSUP:
         case ENOSYS:
-                stat = NFS3ERR_NOTSUPP;
-                break;
+            stat = NFS3ERR_NOTSUPP;
+            break;
 
         case EBADF:
-                stat = NFS3ERR_BADTYPE;
-                break;
+            stat = NFS3ERR_BADTYPE;
+            break;
 
         case ESTALE:
-                stat = NFS3ERR_STALE;
-                break;
+            stat = NFS3ERR_STALE;
+            break;
 
         case ENOTCONN:
-                stat = NFS3ERR_IO;
-                break;
+            stat = NFS3ERR_IO;
+            break;
 
         case EDQUOT:
-                stat = NFS3ERR_DQUOT;
-                break;
+            stat = NFS3ERR_DQUOT;
+            break;
 
         default:
-                stat = NFS3ERR_SERVERFAULT;
-                break;
-        }
+            stat = NFS3ERR_SERVERFAULT;
+            break;
+    }
 
-        return stat;
+    return stat;
 }
 
 /*
@@ -260,3681 +251,3581 @@ nfs3_errno_to_nfsstat3 (int errnum)
  * happens by any means, then set NFS3 status to NFS3ERR_SERVERFAULT.
  */
 nfsstat3
-nfs3_cbk_errno_status (int32_t op_ret, int32_t op_errno)
+nfs3_cbk_errno_status(int32_t op_ret, int32_t op_errno)
 {
-        if ((op_ret == -1) && (op_errno == 0)) {
-                return NFS3ERR_SERVERFAULT;
-        }
+    if ((op_ret == -1) && (op_errno == 0)) {
+        return NFS3ERR_SERVERFAULT;
+    }
 
-        return nfs3_errno_to_nfsstat3 (op_errno);
+    return nfs3_errno_to_nfsstat3(op_errno);
 }
 
 void
-nfs3_fill_lookup3res_error (lookup3res *res, nfsstat3 stat,
-                            struct iatt *dirstat)
+nfs3_fill_lookup3res_error(lookup3res *res, nfsstat3 stat, struct iatt *dirstat)
 {
-
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (!dirstat) {
-                res->lookup3res_u.resfail.dir_attributes.attributes_follow = FALSE;
-        }
-
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (!dirstat) {
+        res->lookup3res_u.resfail.dir_attributes.attributes_follow = FALSE;
+    }
 }
 
 void
-nfs3_stat_to_fattr3 (struct iatt *buf, fattr3 *fa)
+nfs3_stat_to_fattr3(struct iatt *buf, fattr3 *fa)
 {
-        if (buf == NULL || fa == NULL) {
-                errno = EINVAL;
-                return;
-        }
-
-        if (IA_ISDIR (buf->ia_type))
-                fa->type = NF3DIR;
-        else if (IA_ISREG (buf->ia_type))
-                fa->type = NF3REG;
-        else if (IA_ISCHR (buf->ia_type))
-                fa->type = NF3CHR;
-        else if (IA_ISBLK (buf->ia_type))
-                fa->type = NF3BLK;
-        else if (IA_ISFIFO (buf->ia_type))
-                fa->type = NF3FIFO;
-        else if (IA_ISLNK (buf->ia_type))
-                fa->type = NF3LNK;
-        else if (IA_ISSOCK (buf->ia_type))
-                fa->type = NF3SOCK;
-
-        if (IA_PROT_RUSR (buf->ia_prot))
-                fa->mode |= NFS3MODE_ROWNER;
-        if (IA_PROT_WUSR (buf->ia_prot))
-                fa->mode |= NFS3MODE_WOWNER;
-        if (IA_PROT_XUSR (buf->ia_prot))
-                fa->mode |= NFS3MODE_XOWNER;
-
-        if (IA_PROT_RGRP (buf->ia_prot))
-                fa->mode |= NFS3MODE_RGROUP;
-        if (IA_PROT_WGRP (buf->ia_prot))
-                fa->mode |= NFS3MODE_WGROUP;
-        if (IA_PROT_XGRP (buf->ia_prot))
-                fa->mode |= NFS3MODE_XGROUP;
-
-        if (IA_PROT_ROTH (buf->ia_prot))
-                fa->mode |= NFS3MODE_ROTHER;
-        if (IA_PROT_WOTH (buf->ia_prot))
-                fa->mode |= NFS3MODE_WOTHER;
-        if (IA_PROT_XOTH (buf->ia_prot))
-                fa->mode |= NFS3MODE_XOTHER;
-
-        if (IA_PROT_SUID (buf->ia_prot))
-                fa->mode |= NFS3MODE_SETXUID;
-        if (IA_PROT_SGID (buf->ia_prot))
-                fa->mode |= NFS3MODE_SETXGID;
-        if (IA_PROT_STCKY (buf->ia_prot))
-                fa->mode |= NFS3MODE_SAVESWAPTXT;
-
-        fa->nlink = buf->ia_nlink;
-        fa->uid = buf->ia_uid;
-        fa->gid = buf->ia_gid;
-        fa->size = buf->ia_size;
-        fa->used = (buf->ia_blocks * 512);
-
-        if ((IA_ISCHR (buf->ia_type) || IA_ISBLK (buf->ia_type))) {
-                fa->rdev.specdata1 = ia_major (buf->ia_rdev);
-                fa->rdev.specdata2 = ia_minor (buf->ia_rdev);
-        } else {
-                fa->rdev.specdata1 = 0;
-                fa->rdev.specdata2 = 0;
-        }
-
-        fa->fsid = buf->ia_dev;
-        fa->fileid = nfs3_iatt_gfid_to_ino (buf);
-
-        fa->atime.seconds = buf->ia_atime;
-        fa->atime.nseconds = buf->ia_atime_nsec;
-
-        fa->ctime.seconds = buf->ia_ctime;
-        fa->ctime.nseconds = buf->ia_ctime_nsec;
-
-        fa->mtime.seconds = buf->ia_mtime;
-        fa->mtime.nseconds = buf->ia_mtime_nsec;
+    if (buf == NULL || fa == NULL) {
+        errno = EINVAL;
+        return;
+    }
+
+    if (IA_ISDIR(buf->ia_type))
+        fa->type = NF3DIR;
+    else if (IA_ISREG(buf->ia_type))
+        fa->type = NF3REG;
+    else if (IA_ISCHR(buf->ia_type))
+        fa->type = NF3CHR;
+    else if (IA_ISBLK(buf->ia_type))
+        fa->type = NF3BLK;
+    else if (IA_ISFIFO(buf->ia_type))
+        fa->type = NF3FIFO;
+    else if (IA_ISLNK(buf->ia_type))
+        fa->type = NF3LNK;
+    else if (IA_ISSOCK(buf->ia_type))
+        fa->type = NF3SOCK;
+
+    if (IA_PROT_RUSR(buf->ia_prot))
+        fa->mode |= NFS3MODE_ROWNER;
+    if (IA_PROT_WUSR(buf->ia_prot))
+        fa->mode |= NFS3MODE_WOWNER;
+    if (IA_PROT_XUSR(buf->ia_prot))
+        fa->mode |= NFS3MODE_XOWNER;
+
+    if (IA_PROT_RGRP(buf->ia_prot))
+        fa->mode |= NFS3MODE_RGROUP;
+    if (IA_PROT_WGRP(buf->ia_prot))
+        fa->mode |= NFS3MODE_WGROUP;
+    if (IA_PROT_XGRP(buf->ia_prot))
+        fa->mode |= NFS3MODE_XGROUP;
+
+    if (IA_PROT_ROTH(buf->ia_prot))
+        fa->mode |= NFS3MODE_ROTHER;
+    if (IA_PROT_WOTH(buf->ia_prot))
+        fa->mode |= NFS3MODE_WOTHER;
+    if (IA_PROT_XOTH(buf->ia_prot))
+        fa->mode |= NFS3MODE_XOTHER;
+
+    if (IA_PROT_SUID(buf->ia_prot))
+        fa->mode |= NFS3MODE_SETXUID;
+    if (IA_PROT_SGID(buf->ia_prot))
+        fa->mode |= NFS3MODE_SETXGID;
+    if (IA_PROT_STCKY(buf->ia_prot))
+        fa->mode |= NFS3MODE_SAVESWAPTXT;
+
+    fa->nlink = buf->ia_nlink;
+    fa->uid = buf->ia_uid;
+    fa->gid = buf->ia_gid;
+    fa->size = buf->ia_size;
+    fa->used = (buf->ia_blocks * 512);
+
+    if ((IA_ISCHR(buf->ia_type) || IA_ISBLK(buf->ia_type))) {
+        fa->rdev.specdata1 = ia_major(buf->ia_rdev);
+        fa->rdev.specdata2 = ia_minor(buf->ia_rdev);
+    } else {
+        fa->rdev.specdata1 = 0;
+        fa->rdev.specdata2 = 0;
+    }
+
+    fa->fsid = buf->ia_dev;
+    fa->fileid = nfs3_iatt_gfid_to_ino(buf);
+
+    fa->atime.seconds = buf->ia_atime;
+    fa->atime.nseconds = buf->ia_atime_nsec;
+
+    fa->ctime.seconds = buf->ia_ctime;
+    fa->ctime.nseconds = buf->ia_ctime_nsec;
+
+    fa->mtime.seconds = buf->ia_mtime;
+    fa->mtime.nseconds = buf->ia_mtime_nsec;
 }
 
-
 post_op_attr
-nfs3_stat_to_post_op_attr (struct iatt *buf)
+nfs3_stat_to_post_op_attr(struct iatt *buf)
 {
-        post_op_attr    attr = {0, };
-        if (!buf)
-                return attr;
+    post_op_attr attr = {
+        0,
+    };
+    if (!buf)
+        return attr;
 
-        /* Some performance translators return zero-filled stats when they
-         * do not have up-to-date attributes. Need to handle this by not
-         * returning these zeroed out attrs.
-         */
-        attr.attributes_follow = FALSE;
-        if (gf_is_zero_filled_stat (buf))
-                goto out;
+    /* Some performance translators return zero-filled stats when they
+     * do not have up-to-date attributes. Need to handle this by not
+     * returning these zeroed out attrs.
+     */
+    attr.attributes_follow = FALSE;
+    if (gf_is_zero_filled_stat(buf))
+        goto out;
 
-        nfs3_stat_to_fattr3 (buf, &(attr.post_op_attr_u.attributes));
-        attr.attributes_follow = TRUE;
+    nfs3_stat_to_fattr3(buf, &(attr.post_op_attr_u.attributes));
+    attr.attributes_follow = TRUE;
 
 out:
-        return attr;
+    return attr;
 }
 
-
 pre_op_attr
-nfs3_stat_to_pre_op_attr (struct iatt *pre)
-{
-        pre_op_attr     poa = {0, };
-
-        /* Some performance translators return zero-filled stats when they
-         * do not have up-to-date attributes. Need to handle this by not
-         * returning these zeroed out attrs.
-         */
-        poa.attributes_follow = FALSE;
-        if (gf_is_zero_filled_stat (pre))
-                goto out;
-
-        poa.attributes_follow = TRUE;
-        poa.pre_op_attr_u.attributes.size = pre->ia_size;
-        poa.pre_op_attr_u.attributes.mtime.seconds = pre->ia_mtime;
-        poa.pre_op_attr_u.attributes.mtime.nseconds = pre->ia_mtime_nsec;
-        poa.pre_op_attr_u.attributes.ctime.seconds = pre->ia_ctime;
-        poa.pre_op_attr_u.attributes.ctime.nseconds = pre->ia_ctime_nsec;
+nfs3_stat_to_pre_op_attr(struct iatt *pre)
+{
+    pre_op_attr poa = {
+        0,
+    };
+
+    /* Some performance translators return zero-filled stats when they
+     * do not have up-to-date attributes. Need to handle this by not
+     * returning these zeroed out attrs.
+     */
+    poa.attributes_follow = FALSE;
+    if (gf_is_zero_filled_stat(pre))
+        goto out;
+
+    poa.attributes_follow = TRUE;
+    poa.pre_op_attr_u.attributes.size = pre->ia_size;
+    poa.pre_op_attr_u.attributes.mtime.seconds = pre->ia_mtime;
+    poa.pre_op_attr_u.attributes.mtime.nseconds = pre->ia_mtime_nsec;
+    poa.pre_op_attr_u.attributes.ctime.seconds = pre->ia_ctime;
+    poa.pre_op_attr_u.attributes.ctime.nseconds = pre->ia_ctime_nsec;
 
 out:
-        return poa;
+    return poa;
 }
 
 void
-nfs3_fill_lookup3res_success (lookup3res *res, nfsstat3 stat,
-                              struct nfs3_fh *fh, struct iatt *buf,
-                              struct iatt *postparent)
+nfs3_fill_lookup3res_success(lookup3res *res, nfsstat3 stat, struct nfs3_fh *fh,
+                             struct iatt *buf, struct iatt *postparent)
 {
-        post_op_attr    obj, dir;
-        uint32_t        fhlen = 0;
+    post_op_attr obj, dir;
+    uint32_t fhlen = 0;
 
-        res->status = stat;
-        if (fh) {
-                res->lookup3res_u.resok.object.data.data_val = (void *)fh;
-                fhlen = nfs3_fh_compute_size ();
-                res->lookup3res_u.resok.object.data.data_len = fhlen;
-        }
+    res->status = stat;
+    if (fh) {
+        res->lookup3res_u.resok.object.data.data_val = (void *)fh;
+        fhlen = nfs3_fh_compute_size();
+        res->lookup3res_u.resok.object.data.data_len = fhlen;
+    }
 
-        obj.attributes_follow = FALSE;
-        dir.attributes_follow = FALSE;
-        obj = nfs3_stat_to_post_op_attr (buf);
-        dir = nfs3_stat_to_post_op_attr (postparent);
+    obj.attributes_follow = FALSE;
+    dir.attributes_follow = FALSE;
+    obj = nfs3_stat_to_post_op_attr(buf);
+    dir = nfs3_stat_to_post_op_attr(postparent);
 
-        res->lookup3res_u.resok.obj_attributes = obj;
-        res->lookup3res_u.resok.dir_attributes = dir;
+    res->lookup3res_u.resok.obj_attributes = obj;
+    res->lookup3res_u.resok.dir_attributes = dir;
 }
 
-
 void
-nfs3_fill_lookup3res (lookup3res *res, nfsstat3 stat, struct nfs3_fh *newfh,
-                      struct iatt *buf, struct iatt *postparent,
-                      uint64_t deviceid)
+nfs3_fill_lookup3res(lookup3res *res, nfsstat3 stat, struct nfs3_fh *newfh,
+                     struct iatt *buf, struct iatt *postparent,
+                     uint64_t deviceid)
 {
-
-        memset (res, 0, sizeof (*res));
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        if (stat != NFS3_OK)
-                nfs3_fill_lookup3res_error (res, stat, postparent);
-        else
-                nfs3_fill_lookup3res_success (res, stat, newfh, buf,
-                                              postparent);
+    memset(res, 0, sizeof(*res));
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    if (stat != NFS3_OK)
+        nfs3_fill_lookup3res_error(res, stat, postparent);
+    else
+        nfs3_fill_lookup3res_success(res, stat, newfh, buf, postparent);
 }
 
 struct nfs3_fh
-nfs3_extract_getattr_fh (getattr3args *args)
+nfs3_extract_getattr_fh(getattr3args *args)
 {
-        return nfs3_extract_nfs3_fh(args->object);
+    return nfs3_extract_nfs3_fh(args->object);
 }
 
-
 void
-nfs3_fill_getattr3res (getattr3res *res, nfsstat3 stat, struct iatt *buf,
-                       uint64_t deviceid)
+nfs3_fill_getattr3res(getattr3res *res, nfsstat3 stat, struct iatt *buf,
+                      uint64_t deviceid)
 {
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
-
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        nfs3_stat_to_fattr3 (buf, &(res->getattr3res_u.resok.obj_attributes));
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    nfs3_stat_to_fattr3(buf, &(res->getattr3res_u.resok.obj_attributes));
 }
 
-
 struct nfs3_fh
-nfs3_extract_fsinfo_fh (fsinfo3args *args)
+nfs3_extract_fsinfo_fh(fsinfo3args *args)
 {
-        return nfs3_extract_nfs3_fh (args->fsroot);
+    return nfs3_extract_nfs3_fh(args->fsroot);
 }
 
-
 void
-nfs3_fill_fsinfo3res (struct nfs3_state *nfs3, fsinfo3res *res,
-                      nfsstat3 status, struct iatt *fsroot, uint64_t deviceid)
+nfs3_fill_fsinfo3res(struct nfs3_state *nfs3, fsinfo3res *res, nfsstat3 status,
+                     struct iatt *fsroot, uint64_t deviceid)
 {
-        fsinfo3resok    resok = {{0}, };
-        nfstime3        tdelta = GF_NFS3_TIMEDELTA_SECS;
+    fsinfo3resok resok = {
+        {0},
+    };
+    nfstime3 tdelta = GF_NFS3_TIMEDELTA_SECS;
 
-        memset (res, 0, sizeof (*res));
-        res->status = status;
-        if (status != NFS3_OK)
-                return;
-
-        nfs3_map_deviceid_to_statdev (fsroot, deviceid);
-        resok.obj_attributes = nfs3_stat_to_post_op_attr (fsroot);
-        resok.rtmax = nfs3->readsize;
-        resok.rtpref = nfs3->readsize;
-        resok.rtmult = GF_NFS3_RTMULT;
-        resok.wtmax = nfs3->writesize;
-        resok.wtpref = nfs3->writesize;
-        resok.wtmult = GF_NFS3_WTMULT;
-        resok.dtpref = nfs3->readdirsize;
-        resok.maxfilesize = GF_NFS3_MAXFILESIZE;
-        resok.time_delta = tdelta;
-        resok.properties = GF_NFS3_FS_PROP;
+    memset(res, 0, sizeof(*res));
+    res->status = status;
+    if (status != NFS3_OK)
+        return;
 
-        res->fsinfo3res_u.resok = resok;
+    nfs3_map_deviceid_to_statdev(fsroot, deviceid);
+    resok.obj_attributes = nfs3_stat_to_post_op_attr(fsroot);
+    resok.rtmax = nfs3->readsize;
+    resok.rtpref = nfs3->readsize;
+    resok.rtmult = GF_NFS3_RTMULT;
+    resok.wtmax = nfs3->writesize;
+    resok.wtpref = nfs3->writesize;
+    resok.wtmult = GF_NFS3_WTMULT;
+    resok.dtpref = nfs3->readdirsize;
+    resok.maxfilesize = GF_NFS3_MAXFILESIZE;
+    resok.time_delta = tdelta;
+    resok.properties = GF_NFS3_FS_PROP;
 
+    res->fsinfo3res_u.resok = resok;
 }
 
-
 void
-nfs3_prep_lookup3args (lookup3args *args, struct nfs3_fh *fh, char *name)
+nfs3_prep_lookup3args(lookup3args *args, struct nfs3_fh *fh, char *name)
 {
-        memset (args, 0, sizeof (*args));
-        args->what.dir.data.data_val = (void *)fh;
-        args->what.name = name;
+    memset(args, 0, sizeof(*args));
+    args->what.dir.data.data_val = (void *)fh;
+    args->what.name = name;
 }
 
-
 void
-nfs3_prep_getattr3args (getattr3args *args, struct nfs3_fh *fh)
+nfs3_prep_getattr3args(getattr3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->object.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_prep_fsinfo3args (fsinfo3args *args, struct nfs3_fh *root)
+nfs3_prep_fsinfo3args(fsinfo3args *args, struct nfs3_fh *root)
 {
-        memset (args, 0, sizeof (*args));
-        args->fsroot.data.data_val = (void *)root;
+    memset(args, 0, sizeof(*args));
+    args->fsroot.data.data_val = (void *)root;
 }
 
-
 char *
 nfsstat3_strerror(int stat)
 {
-        int i;
-        for(i = 0; nfs3stat_strerror_table[i].stat != NFS3ERR_END_OF_LIST ; i++) {
-                if (nfs3stat_strerror_table[i].stat == stat)
-                        return nfs3stat_strerror_table[i].strerror;
-        }
+    int i;
+    for (i = 0; nfs3stat_strerror_table[i].stat != NFS3ERR_END_OF_LIST; i++) {
+        if (nfs3stat_strerror_table[i].stat == stat)
+            return nfs3stat_strerror_table[i].strerror;
+    }
 
-        return nfs3stat_strerror_table[i].strerror;
+    return nfs3stat_strerror_table[i].strerror;
 }
 
-
-
 void
-nfs3_prep_access3args (access3args *args, struct nfs3_fh *fh)
+nfs3_prep_access3args(access3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->object.data.data_val = (void *)fh;
 }
 
-#define POSIX_READ      4
-#define POSIX_WRITE     2
-#define POSIX_EXEC      1
+#define POSIX_READ 4
+#define POSIX_WRITE 2
+#define POSIX_EXEC 1
 
 uint32_t
-nfs3_accessbits (int32_t accbits)
+nfs3_accessbits(int32_t accbits)
 {
-        uint32_t        accresult = 0;
+    uint32_t accresult = 0;
 
-        if (accbits & POSIX_READ)
-                accresult |= ACCESS3_READ;
+    if (accbits & POSIX_READ)
+        accresult |= ACCESS3_READ;
 
-        if (accbits & POSIX_WRITE)
-                accresult |= (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE);
+    if (accbits & POSIX_WRITE)
+        accresult |= (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE);
 
-        /* lookup on directory allowed only in case of execute permission */
-        if (accbits & POSIX_EXEC)
-                accresult |= (ACCESS3_EXECUTE | ACCESS3_LOOKUP);
+    /* lookup on directory allowed only in case of execute permission */
+    if (accbits & POSIX_EXEC)
+        accresult |= (ACCESS3_EXECUTE | ACCESS3_LOOKUP);
 
-        return accresult;
+    return accresult;
 }
 
 uint32_t
-nfs3_request_to_accessbits (int32_t accbits)
+nfs3_request_to_accessbits(int32_t accbits)
 {
-        uint32_t        acc_request = 0;
+    uint32_t acc_request = 0;
 
-        if (accbits & ACCESS3_READ)
-                acc_request |= POSIX_READ;
+    if (accbits & ACCESS3_READ)
+        acc_request |= POSIX_READ;
 
-        if (accbits & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE))
-                acc_request |= POSIX_WRITE;
+    if (accbits & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE))
+        acc_request |= POSIX_WRITE;
 
-        /* For lookup on directory check for execute permission */
-        if (accbits & (ACCESS3_EXECUTE | ACCESS3_LOOKUP))
-                acc_request |= POSIX_EXEC;
+    /* For lookup on directory check for execute permission */
+    if (accbits & (ACCESS3_EXECUTE | ACCESS3_LOOKUP))
+        acc_request |= POSIX_EXEC;
 
-        return acc_request;
+    return acc_request;
 }
 void
-nfs3_fill_access3res (access3res *res, nfsstat3 status, int32_t accbits,
-		      int32_t reqaccbits)
+nfs3_fill_access3res(access3res *res, nfsstat3 status, int32_t accbits,
+                     int32_t reqaccbits)
 {
-        uint32_t        accres = 0;
+    uint32_t accres = 0;
 
-        memset (res, 0, sizeof (*res));
-        res->status = status;
-        if (status != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = status;
+    if (status != NFS3_OK)
+        return;
 
-        accres = nfs3_accessbits (accbits);
+    accres = nfs3_accessbits(accbits);
 
-	/* do not answer what was not asked */
-        res->access3res_u.resok.access = accres & reqaccbits;
+    /* do not answer what was not asked */
+    res->access3res_u.resok.access = accres & reqaccbits;
 }
 
 void
-nfs3_prep_readdir3args (readdir3args *ra, struct nfs3_fh *fh)
+nfs3_prep_readdir3args(readdir3args *ra, struct nfs3_fh *fh)
 {
-        memset (ra, 0, sizeof (*ra));
-        ra->dir.data.data_val = (void *)fh;
+    memset(ra, 0, sizeof(*ra));
+    ra->dir.data.data_val = (void *)fh;
 }
 
-
 int
-nfs3_is_dot_entry (char *entry)
+nfs3_is_dot_entry(char *entry)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        if (!entry)
-                return 0;
+    if (!entry)
+        return 0;
 
-        if (strcmp (entry, ".") == 0)
-                ret = 1;
+    if (strcmp(entry, ".") == 0)
+        ret = 1;
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_is_parentdir_entry (char *entry)
+nfs3_is_parentdir_entry(char *entry)
 {
-        int     ret = 0;
+    int ret = 0;
 
-        if (!entry)
-                return 0;
+    if (!entry)
+        return 0;
 
-        if (strcmp (entry, "..") == 0)
-                ret = 1;
+    if (strcmp(entry, "..") == 0)
+        ret = 1;
 
-        return ret;
+    return ret;
 }
 
-
 void
-nfs3_funge_root_dotdot_dirent (gf_dirent_t *ent, struct nfs3_fh *dfh)
+nfs3_funge_root_dotdot_dirent(gf_dirent_t *ent, struct nfs3_fh *dfh)
 {
-        if ((!ent) || (!dfh))
-                return;
-
-        if (nfs3_fh_is_root_fh (dfh) &&
-            nfs3_is_parentdir_entry (ent->d_name)) {
-                ent->d_ino = 1;
-                ent->d_stat.ia_ino = 1;
-        }
+    if ((!ent) || (!dfh))
+        return;
 
-        if (nfs3_fh_is_root_fh (dfh) &&
-            nfs3_is_dot_entry (ent->d_name)) {
-                ent->d_ino = 1;
-                ent->d_stat.ia_ino = 1;
-        }
+    if (nfs3_fh_is_root_fh(dfh) && nfs3_is_parentdir_entry(ent->d_name)) {
+        ent->d_ino = 1;
+        ent->d_stat.ia_ino = 1;
+    }
 
+    if (nfs3_fh_is_root_fh(dfh) && nfs3_is_dot_entry(ent->d_name)) {
+        ent->d_ino = 1;
+        ent->d_stat.ia_ino = 1;
+    }
 }
 
-
 entry3 *
-nfs3_fill_entry3 (gf_dirent_t *entry, struct nfs3_fh *dfh)
-{
-        entry3          *ent = NULL;
-        int              name_len = 0;
-        if ((!entry) || (!dfh))
-                return NULL;
-
-        ent = GF_CALLOC (1, sizeof (*ent), gf_nfs_mt_entry3);
-        if (!ent)
-                return NULL;
-
-        gf_msg_trace (GF_NFS3, 0, "Entry: %s", entry->d_name);
-
-        /* If the entry is . or .., we need to replace the physical ino and gen
-         * with 1 and 0 respectively if the directory is root. This funging is
-         * needed because there is no parent directory of the root. In that
-         * sense the behavior we provide is similar to the output of the
-         * command: "stat /.."
-         */
-        entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat);
-        nfs3_funge_root_dotdot_dirent (entry, dfh);
-        ent->fileid = entry->d_ino;
-        ent->cookie = entry->d_off;
-        name_len = strlen(entry->d_name);
-        ent->name = GF_MALLOC (name_len + 1, gf_nfs_mt_char);
-        if (!ent->name) {
-                GF_FREE (ent);
-                ent = NULL;
-                goto err;
-        }
-        strcpy (ent->name, entry->d_name);
-        ent->name[name_len] = '\0';
+nfs3_fill_entry3(gf_dirent_t *entry, struct nfs3_fh *dfh)
+{
+    entry3 *ent = NULL;
+    int name_len = 0;
+    if ((!entry) || (!dfh))
+        return NULL;
+
+    ent = GF_CALLOC(1, sizeof(*ent), gf_nfs_mt_entry3);
+    if (!ent)
+        return NULL;
+
+    gf_msg_trace(GF_NFS3, 0, "Entry: %s", entry->d_name);
+
+    /* If the entry is . or .., we need to replace the physical ino and gen
+     * with 1 and 0 respectively if the directory is root. This funging is
+     * needed because there is no parent directory of the root. In that
+     * sense the behavior we provide is similar to the output of the
+     * command: "stat /.."
+     */
+    entry->d_ino = nfs3_iatt_gfid_to_ino(&entry->d_stat);
+    nfs3_funge_root_dotdot_dirent(entry, dfh);
+    ent->fileid = entry->d_ino;
+    ent->cookie = entry->d_off;
+    name_len = strlen(entry->d_name);
+    ent->name = GF_MALLOC(name_len + 1, gf_nfs_mt_char);
+    if (!ent->name) {
+        GF_FREE(ent);
+        ent = NULL;
+        goto err;
+    }
+    strcpy(ent->name, entry->d_name);
+    ent->name[name_len] = '\0';
 
 err:
-        return ent;
+    return ent;
 }
 
-
 void
-nfs3_fill_post_op_fh3 (struct nfs3_fh *fh, post_op_fh3 *pfh)
+nfs3_fill_post_op_fh3(struct nfs3_fh *fh, post_op_fh3 *pfh)
 {
-        uint32_t        fhlen = 0;
+    uint32_t fhlen = 0;
 
-        if ((!fh) || (!pfh))
-                return;
+    if ((!fh) || (!pfh))
+        return;
 
-        pfh->handle_follows = 1;
-        fhlen = nfs3_fh_compute_size ();
-        pfh->post_op_fh3_u.handle.data.data_val = (void *)fh;
-        pfh->post_op_fh3_u.handle.data.data_len = fhlen;
+    pfh->handle_follows = 1;
+    fhlen = nfs3_fh_compute_size();
+    pfh->post_op_fh3_u.handle.data.data_val = (void *)fh;
+    pfh->post_op_fh3_u.handle.data.data_len = fhlen;
 }
 
-
 post_op_fh3
-nfs3_fh_to_post_op_fh3 (struct nfs3_fh *fh)
+nfs3_fh_to_post_op_fh3(struct nfs3_fh *fh)
 {
-        post_op_fh3     pfh = {0, };
-        char            *fhp = NULL;
+    post_op_fh3 pfh = {
+        0,
+    };
+    char *fhp = NULL;
 
-        if (!fh)
-                return pfh;
-
-        pfh.handle_follows = 1;
+    if (!fh)
+        return pfh;
 
-        fhp = GF_MALLOC (sizeof (*fh), gf_nfs_mt_char);
-        if (!fhp)
-                return pfh;
+    pfh.handle_follows = 1;
 
-        memcpy (fhp, fh, sizeof (*fh));
-        nfs3_fill_post_op_fh3 ((struct nfs3_fh *)fhp, &pfh);
+    fhp = GF_MALLOC(sizeof(*fh), gf_nfs_mt_char);
+    if (!fhp)
         return pfh;
-}
 
+    memcpy(fhp, fh, sizeof(*fh));
+    nfs3_fill_post_op_fh3((struct nfs3_fh *)fhp, &pfh);
+    return pfh;
+}
 
 entryp3 *
-nfs3_fill_entryp3 (gf_dirent_t *entry, struct nfs3_fh *dirfh, uint64_t devid)
+nfs3_fill_entryp3(gf_dirent_t *entry, struct nfs3_fh *dirfh, uint64_t devid)
+{
+    entryp3 *ent = NULL;
+    struct nfs3_fh newfh = {
+        {0},
+    };
+    int name_len = 0;
+
+    if ((!entry) || (!dirfh))
+        return NULL;
+
+    /* If the entry is . or .., we need to replace the physical ino and gen
+     * with 1 and 0 respectively if the directory is root. This funging is
+     * needed because there is no parent directory of the root. In that
+     * sense the behavior we provide is similar to the output of the
+     * command: "stat /.."
+     */
+    entry->d_ino = nfs3_iatt_gfid_to_ino(&entry->d_stat);
+    nfs3_funge_root_dotdot_dirent(entry, dirfh);
+    gf_msg_trace(GF_NFS3, 0, "Entry: %s, ino: %" PRIu64, entry->d_name,
+                 entry->d_ino);
+    ent = GF_CALLOC(1, sizeof(*ent), gf_nfs_mt_entryp3);
+    if (!ent)
+        return NULL;
+
+    ent->fileid = entry->d_ino;
+    ent->cookie = entry->d_off;
+    name_len = strlen(entry->d_name);
+    ent->name = GF_MALLOC(name_len + 1, gf_nfs_mt_char);
+    if (!ent->name) {
+        GF_FREE(ent);
+        ent = NULL;
+        goto err;
+    }
+    strcpy(ent->name, entry->d_name);
+    ent->name[name_len] = '\0';
+
+    nfs3_fh_build_child_fh(dirfh, &entry->d_stat, &newfh);
+    nfs3_map_deviceid_to_statdev(&entry->d_stat, devid);
+    /* *
+     * In tier volume, the readdirp send only to cold subvol
+     * which will populate in the 'T' file entries in the result.
+     * For such files an explicit stat call is required, by setting
+     * following argument client will perform the same.
+     *
+     * The inode value for 'T' files and directory is NULL, so just
+     * skip the check if it is directory.
+     */
+    if (!(IA_ISDIR(entry->d_stat.ia_type)) && (entry->inode == NULL))
+        ent->name_attributes.attributes_follow = FALSE;
+    else
+        ent->name_attributes = nfs3_stat_to_post_op_attr(&entry->d_stat);
+
+    ent->name_handle = nfs3_fh_to_post_op_fh3(&newfh);
+err:
+    return ent;
+}
+
+void
+nfs3_fill_readdir3res(readdir3res *res, nfsstat3 stat, struct nfs3_fh *dirfh,
+                      uint64_t cverf, struct iatt *dirstat,
+                      gf_dirent_t *entries, count3 count, int is_eof,
+                      uint64_t deviceid)
 {
-        entryp3         *ent = NULL;
-        struct nfs3_fh  newfh = {{0}, };
-        int             name_len = 0;
+    post_op_attr dirattr;
+    entry3 *ent = NULL;
+    entry3 *headentry = NULL;
+    entry3 *preventry = NULL;
+    count3 filled = 0;
+    gf_dirent_t *listhead = NULL;
 
-        if ((!entry) || (!dirfh))
-                return NULL;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        /* If the entry is . or .., we need to replace the physical ino and gen
-         * with 1 and 0 respectively if the directory is root. This funging is
-         * needed because there is no parent directory of the root. In that
-         * sense the behavior we provide is similar to the output of the
-         * command: "stat /.."
-         */
-        entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat);
-        nfs3_funge_root_dotdot_dirent (entry, dirfh);
-        gf_msg_trace (GF_NFS3, 0, "Entry: %s, ino: %"PRIu64,
-                      entry->d_name, entry->d_ino);
-        ent = GF_CALLOC (1, sizeof (*ent), gf_nfs_mt_entryp3);
+    nfs3_map_deviceid_to_statdev(dirstat, deviceid);
+    dirattr = nfs3_stat_to_post_op_attr(dirstat);
+    res->readdir3res_u.resok.dir_attributes = dirattr;
+    res->readdir3res_u.resok.reply.eof = (bool_t)is_eof;
+    memcpy(res->readdir3res_u.resok.cookieverf, &cverf, sizeof(cverf));
+
+    filled = NFS3_READDIR_RESOK_SIZE;
+    /* First entry is just the list head */
+    listhead = entries;
+    entries = entries->next;
+    while (((entries) && (entries != listhead)) && (filled < count)) {
+        /*
+        if ((strcmp (entries->d_name, ".") == 0) ||
+            (strcmp (entries->d_name, "..") == 0))
+                goto nextentry;
+                */
+        ent = nfs3_fill_entry3(entries, dirfh);
         if (!ent)
-                return NULL;
-
-        ent->fileid = entry->d_ino;
-        ent->cookie = entry->d_off;
-        name_len = strlen (entry->d_name);
-        ent->name = GF_MALLOC (name_len + 1, gf_nfs_mt_char);
-        if (!ent->name) {
-                GF_FREE (ent);
-                ent = NULL;
-                goto err;
-        }
-        strcpy (ent->name, entry->d_name);
-        ent->name[name_len] = '\0';
-
-        nfs3_fh_build_child_fh (dirfh, &entry->d_stat, &newfh);
-        nfs3_map_deviceid_to_statdev (&entry->d_stat, devid);
-        /* *
-         * In tier volume, the readdirp send only to cold subvol
-         * which will populate in the 'T' file entries in the result.
-         * For such files an explicit stat call is required, by setting
-         * following argument client will perform the same.
-         *
-         * The inode value for 'T' files and directory is NULL, so just
-         * skip the check if it is directory.
-         */
-        if (!(IA_ISDIR(entry->d_stat.ia_type)) && (entry->inode == NULL))
-                ent->name_attributes.attributes_follow = FALSE;
-        else
-                ent->name_attributes =
-                        nfs3_stat_to_post_op_attr (&entry->d_stat);
+            break;
 
-        ent->name_handle = nfs3_fh_to_post_op_fh3 (&newfh);
-err:
-        return ent;
-}
+        if (!headentry)
+            headentry = ent;
 
+        if (preventry) {
+            preventry->nextentry = ent;
+            preventry = ent;
+        } else
+            preventry = ent;
 
-void
-nfs3_fill_readdir3res (readdir3res *res, nfsstat3 stat, struct nfs3_fh *dirfh,
-                       uint64_t cverf, struct iatt *dirstat,
-                       gf_dirent_t *entries, count3 count, int is_eof,
-                       uint64_t deviceid)
-{
-        post_op_attr    dirattr;
-        entry3          *ent = NULL;
-        entry3          *headentry = NULL;
-        entry3          *preventry = NULL;
-        count3          filled = 0;
-        gf_dirent_t     *listhead = NULL;
-
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
-
-        nfs3_map_deviceid_to_statdev (dirstat, deviceid);
-        dirattr = nfs3_stat_to_post_op_attr (dirstat);
-        res->readdir3res_u.resok.dir_attributes = dirattr;
-        res->readdir3res_u.resok.reply.eof = (bool_t)is_eof;
-        memcpy (res->readdir3res_u.resok.cookieverf, &cverf, sizeof (cverf));
-
-        filled = NFS3_READDIR_RESOK_SIZE;
-        /* First entry is just the list head */
-        listhead = entries;
+        filled += NFS3_ENTRY3_FIXED_SIZE + strlen(ent->name);
+        // nextentry:
         entries = entries->next;
-        while (((entries) && (entries != listhead)) && (filled < count)) {
-                /*
-                if ((strcmp (entries->d_name, ".") == 0) ||
-                    (strcmp (entries->d_name, "..") == 0))
-                        goto nextentry;
-                        */
-                ent = nfs3_fill_entry3 (entries, dirfh);
-                if (!ent)
-                        break;
-
-                if (!headentry)
-                        headentry = ent;
-
-                if (preventry) {
-                        preventry->nextentry = ent;
-                        preventry = ent;
-                } else
-                        preventry = ent;
-
-                filled += NFS3_ENTRY3_FIXED_SIZE + strlen (ent->name);
-//nextentry:
-                entries = entries->next;
-        }
+    }
 
-        res->readdir3res_u.resok.reply.entries = headentry;
+    res->readdir3res_u.resok.reply.entries = headentry;
 
-        return;
+    return;
 }
 
-
 void
-nfs3_fill_readdirp3res (readdirp3res *res, nfsstat3 stat,
-                        struct nfs3_fh *dirfh, uint64_t cverf,
-                        struct iatt *dirstat, gf_dirent_t *entries,
-                        count3 dircount, count3 maxcount, int is_eof,
-                        uint64_t deviceid)
-{
-        post_op_attr    dirattr;
-        entryp3         *ent = NULL;
-        entryp3         *headentry = NULL;
-        entryp3         *preventry = NULL;
-        count3          filled = 0;
-        gf_dirent_t     *listhead = NULL;
-        int             fhlen = 0;
+nfs3_fill_readdirp3res(readdirp3res *res, nfsstat3 stat, struct nfs3_fh *dirfh,
+                       uint64_t cverf, struct iatt *dirstat,
+                       gf_dirent_t *entries, count3 dircount, count3 maxcount,
+                       int is_eof, uint64_t deviceid)
+{
+    post_op_attr dirattr;
+    entryp3 *ent = NULL;
+    entryp3 *headentry = NULL;
+    entryp3 *preventry = NULL;
+    count3 filled = 0;
+    gf_dirent_t *listhead = NULL;
+    int fhlen = 0;
+
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    nfs3_map_deviceid_to_statdev(dirstat, deviceid);
+    dirattr = nfs3_stat_to_post_op_attr(dirstat);
+    res->readdirp3res_u.resok.dir_attributes = dirattr;
+    res->readdirp3res_u.resok.reply.eof = (bool_t)is_eof;
+    memcpy(res->readdirp3res_u.resok.cookieverf, &cverf, sizeof(cverf));
+
+    filled = NFS3_READDIR_RESOK_SIZE;
+    /* First entry is just the list head */
+    listhead = entries;
+    entries = entries->next;
+    while (((entries) && (entries != listhead)) && (filled < maxcount)) {
+        /* Linux does not display . and .. entries unless we provide
+         * these entries here.
+         */
+        /*                if ((strcmp (entries->d_name, ".") == 0) ||
+                            (strcmp (entries->d_name, "..") == 0))
+                                goto nextentry;
+                                */
+        ent = nfs3_fill_entryp3(entries, dirfh, deviceid);
+        if (!ent)
+            break;
 
-        nfs3_map_deviceid_to_statdev (dirstat, deviceid);
-        dirattr = nfs3_stat_to_post_op_attr (dirstat);
-        res->readdirp3res_u.resok.dir_attributes = dirattr;
-        res->readdirp3res_u.resok.reply.eof = (bool_t)is_eof;
-        memcpy (res->readdirp3res_u.resok.cookieverf, &cverf, sizeof (cverf));
+        if (!headentry)
+            headentry = ent;
 
-        filled = NFS3_READDIR_RESOK_SIZE;
-        /* First entry is just the list head */
-        listhead = entries;
+        if (preventry) {
+            preventry->nextentry = ent;
+            preventry = ent;
+        } else
+            preventry = ent;
+
+        fhlen = ent->name_handle.post_op_fh3_u.handle.data.data_len;
+        filled += NFS3_ENTRYP3_FIXED_SIZE + fhlen + strlen(ent->name);
+        // nextentry:
         entries = entries->next;
-        while (((entries) && (entries != listhead)) && (filled < maxcount)) {
-                /* Linux does not display . and .. entries unless we provide
-                 * these entries here.
-                 */
-/*                if ((strcmp (entries->d_name, ".") == 0) ||
-                    (strcmp (entries->d_name, "..") == 0))
-                        goto nextentry;
-                        */
-                ent = nfs3_fill_entryp3 (entries, dirfh, deviceid);
-                if (!ent)
-                        break;
-
-                if (!headentry)
-                        headentry = ent;
-
-                if (preventry) {
-                        preventry->nextentry = ent;
-                        preventry = ent;
-                } else
-                        preventry = ent;
-
-                fhlen = ent->name_handle.post_op_fh3_u.handle.data.data_len;
-                filled += NFS3_ENTRYP3_FIXED_SIZE + fhlen + strlen (ent->name);
-//nextentry:
-                entries = entries->next;
-        }
+    }
 
-        res->readdirp3res_u.resok.reply.entries = headentry;
+    res->readdirp3res_u.resok.reply.entries = headentry;
 
-        return;
+    return;
 }
 
-
 void
-nfs3_prep_readdirp3args (readdirp3args *ra, struct nfs3_fh *fh)
+nfs3_prep_readdirp3args(readdirp3args *ra, struct nfs3_fh *fh)
 {
-        memset (ra, 0, sizeof (*ra));
-        ra->dir.data.data_val = (void *)fh;
+    memset(ra, 0, sizeof(*ra));
+    ra->dir.data.data_val = (void *)fh;
 }
 
 void
-nfs3_free_readdirp3res (readdirp3res *res)
+nfs3_free_readdirp3res(readdirp3res *res)
 {
-        entryp3 *ent = NULL;
-        entryp3 *next = NULL;
-
-        if (!res)
-                return;
+    entryp3 *ent = NULL;
+    entryp3 *next = NULL;
 
-        ent = res->readdirp3res_u.resok.reply.entries;
-        while (ent) {
+    if (!res)
+        return;
 
-                next = ent->nextentry;
-                GF_FREE (ent->name);
-                GF_FREE (ent->name_handle.post_op_fh3_u.handle.data.data_val);
-                GF_FREE (ent);
-                ent = next;
-        }
+    ent = res->readdirp3res_u.resok.reply.entries;
+    while (ent) {
+        next = ent->nextentry;
+        GF_FREE(ent->name);
+        GF_FREE(ent->name_handle.post_op_fh3_u.handle.data.data_val);
+        GF_FREE(ent);
+        ent = next;
+    }
 
-        return;
+    return;
 }
 
-
 void
-nfs3_free_readdir3res (readdir3res *res)
+nfs3_free_readdir3res(readdir3res *res)
 {
-        entry3 *ent = NULL;
-        entry3 *next = NULL;
+    entry3 *ent = NULL;
+    entry3 *next = NULL;
 
-        if (!res)
-                return;
-
-        ent = res->readdir3res_u.resok.reply.entries;
-        while (ent) {
+    if (!res)
+        return;
 
-                next = ent->nextentry;
-                GF_FREE (ent->name);
-                GF_FREE (ent);
-                ent = next;
-        }
+    ent = res->readdir3res_u.resok.reply.entries;
+    while (ent) {
+        next = ent->nextentry;
+        GF_FREE(ent->name);
+        GF_FREE(ent);
+        ent = next;
+    }
 
-        return;
+    return;
 }
 
 void
-nfs3_prep_fsstat3args (fsstat3args *args, struct nfs3_fh *fh)
+nfs3_prep_fsstat3args(fsstat3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->fsroot.data.data_val = (char *)fh;
+    memset(args, 0, sizeof(*args));
+    args->fsroot.data.data_val = (char *)fh;
 }
 
-
 void
-nfs3_fill_fsstat3res (fsstat3res *res, nfsstat3 stat, struct statvfs *fsbuf,
-                      struct iatt *postbuf, uint64_t deviceid)
+nfs3_fill_fsstat3res(fsstat3res *res, nfsstat3 stat, struct statvfs *fsbuf,
+                     struct iatt *postbuf, uint64_t deviceid)
 {
-        post_op_attr    poa;
-        fsstat3resok    resok;
+    post_op_attr poa;
+    fsstat3resok resok;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (postbuf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (postbuf);
-        resok.tbytes = (size3)(fsbuf->f_frsize * fsbuf->f_blocks);
-        resok.fbytes = (size3)(fsbuf->f_frsize * fsbuf->f_bfree);
-        resok.abytes = (size3)(fsbuf->f_frsize * fsbuf->f_bavail);
-        resok.tfiles = (size3)(fsbuf->f_files);
-        resok.ffiles = (size3)(fsbuf->f_ffree);
-        resok.afiles = (size3)(fsbuf->f_favail);
-        resok.invarsec = 0;
+    nfs3_map_deviceid_to_statdev(postbuf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(postbuf);
+    resok.tbytes = (size3)(fsbuf->f_frsize * fsbuf->f_blocks);
+    resok.fbytes = (size3)(fsbuf->f_frsize * fsbuf->f_bfree);
+    resok.abytes = (size3)(fsbuf->f_frsize * fsbuf->f_bavail);
+    resok.tfiles = (size3)(fsbuf->f_files);
+    resok.ffiles = (size3)(fsbuf->f_ffree);
+    resok.afiles = (size3)(fsbuf->f_favail);
+    resok.invarsec = 0;
 
-        resok.obj_attributes = poa;
-        res->fsstat3res_u.resok = resok;
+    resok.obj_attributes = poa;
+    res->fsstat3res_u.resok = resok;
 }
 
-
 int32_t
-nfs3_sattr3_to_setattr_valid (sattr3 *sattr, struct iatt *buf, mode_t *omode)
-{
-        int32_t         valid = 0;
-        ia_prot_t       prot = {0, };
-        mode_t          mode = 0;
-
-        if (!sattr)
-                return 0;
-
-        if (sattr->mode.set_it) {
-                valid |= GF_SET_ATTR_MODE;
-
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROWNER) {
-                        mode |= S_IRUSR;
-                        prot.owner.read = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOWNER) {
-                        mode |= S_IWUSR;
-                        prot.owner.write = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOWNER) {
-                        mode |= S_IXUSR;
-                        prot.owner.exec = 1;
-                }
-
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_RGROUP) {
-                        mode |= S_IRGRP;
-                        prot.group.read = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_WGROUP) {
-                        mode |= S_IWGRP;
-                        prot.group.write = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_XGROUP) {
-                        mode |= S_IXGRP;
-                        prot.group.exec = 1;
-                }
-
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROTHER) {
-                        mode |= S_IROTH;
-                        prot.other.read = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOTHER) {
-                        mode |= S_IWOTH;
-                        prot.other.write = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOTHER) {
-                        mode |= S_IXOTH;
-                        prot.other.exec = 1;
-                }
-
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXUID) {
-                        mode |= S_ISUID;
-                        prot.suid = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXGID) {
-                        mode |= S_ISGID;
-                        prot.sgid = 1;
-                }
-                if (sattr->mode.set_mode3_u.mode & NFS3MODE_SAVESWAPTXT) {
-                        mode |= S_ISVTX;
-                        prot.sticky = 1;
-                }
-
-                if (buf)
-                        buf->ia_prot = prot;
-                /* Create fop still requires the old mode_t style argument. */
-                if (omode)
-                        *omode = mode;
-        }
+nfs3_sattr3_to_setattr_valid(sattr3 *sattr, struct iatt *buf, mode_t *omode)
+{
+    int32_t valid = 0;
+    ia_prot_t prot = {
+        0,
+    };
+    mode_t mode = 0;
 
-        if (sattr->uid.set_it) {
-                valid |= GF_SET_ATTR_UID;
-                if (buf)
-                        buf->ia_uid = sattr->uid.set_uid3_u.uid;
-        }
+    if (!sattr)
+        return 0;
 
-        if (sattr->gid.set_it) {
-                valid |= GF_SET_ATTR_GID;
-                if (buf)
-                        buf->ia_gid = sattr->gid.set_gid3_u.gid;
-        }
+    if (sattr->mode.set_it) {
+        valid |= GF_SET_ATTR_MODE;
 
-        if (sattr->size.set_it) {
-                valid |= GF_SET_ATTR_SIZE;
-                if (buf)
-                        buf->ia_size = sattr->size.set_size3_u.size;
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROWNER) {
+            mode |= S_IRUSR;
+            prot.owner.read = 1;
         }
-
-        if (sattr->atime.set_it == SET_TO_CLIENT_TIME) {
-                valid |= GF_SET_ATTR_ATIME;
-                if (buf)
-                        buf->ia_atime = sattr->atime.set_atime_u.atime.seconds;
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOWNER) {
+            mode |= S_IWUSR;
+            prot.owner.write = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOWNER) {
+            mode |= S_IXUSR;
+            prot.owner.exec = 1;
         }
 
-        if (sattr->atime.set_it == SET_TO_SERVER_TIME) {
-                valid |= GF_SET_ATTR_ATIME;
-                if (buf)
-                        buf->ia_atime = time (NULL);
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_RGROUP) {
+            mode |= S_IRGRP;
+            prot.group.read = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_WGROUP) {
+            mode |= S_IWGRP;
+            prot.group.write = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_XGROUP) {
+            mode |= S_IXGRP;
+            prot.group.exec = 1;
         }
 
-        if (sattr->mtime.set_it == SET_TO_CLIENT_TIME) {
-                valid |= GF_SET_ATTR_MTIME;
-                if (buf)
-                        buf->ia_mtime = sattr->mtime.set_mtime_u.mtime.seconds;
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROTHER) {
+            mode |= S_IROTH;
+            prot.other.read = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOTHER) {
+            mode |= S_IWOTH;
+            prot.other.write = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOTHER) {
+            mode |= S_IXOTH;
+            prot.other.exec = 1;
         }
 
-        if (sattr->mtime.set_it == SET_TO_SERVER_TIME) {
-                valid |= GF_SET_ATTR_MTIME;
-                if (buf)
-                        buf->ia_mtime = time (NULL);
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXUID) {
+            mode |= S_ISUID;
+            prot.suid = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXGID) {
+            mode |= S_ISGID;
+            prot.sgid = 1;
+        }
+        if (sattr->mode.set_mode3_u.mode & NFS3MODE_SAVESWAPTXT) {
+            mode |= S_ISVTX;
+            prot.sticky = 1;
         }
 
-        return valid;
+        if (buf)
+            buf->ia_prot = prot;
+        /* Create fop still requires the old mode_t style argument. */
+        if (omode)
+            *omode = mode;
+    }
+
+    if (sattr->uid.set_it) {
+        valid |= GF_SET_ATTR_UID;
+        if (buf)
+            buf->ia_uid = sattr->uid.set_uid3_u.uid;
+    }
+
+    if (sattr->gid.set_it) {
+        valid |= GF_SET_ATTR_GID;
+        if (buf)
+            buf->ia_gid = sattr->gid.set_gid3_u.gid;
+    }
+
+    if (sattr->size.set_it) {
+        valid |= GF_SET_ATTR_SIZE;
+        if (buf)
+            buf->ia_size = sattr->size.set_size3_u.size;
+    }
+
+    if (sattr->atime.set_it == SET_TO_CLIENT_TIME) {
+        valid |= GF_SET_ATTR_ATIME;
+        if (buf)
+            buf->ia_atime = sattr->atime.set_atime_u.atime.seconds;
+    }
+
+    if (sattr->atime.set_it == SET_TO_SERVER_TIME) {
+        valid |= GF_SET_ATTR_ATIME;
+        if (buf)
+            buf->ia_atime = time(NULL);
+    }
+
+    if (sattr->mtime.set_it == SET_TO_CLIENT_TIME) {
+        valid |= GF_SET_ATTR_MTIME;
+        if (buf)
+            buf->ia_mtime = sattr->mtime.set_mtime_u.mtime.seconds;
+    }
+
+    if (sattr->mtime.set_it == SET_TO_SERVER_TIME) {
+        valid |= GF_SET_ATTR_MTIME;
+        if (buf)
+            buf->ia_mtime = time(NULL);
+    }
+
+    return valid;
 }
 
-
 wcc_data
-nfs3_stat_to_wcc_data (struct iatt *pre, struct iatt *post)
+nfs3_stat_to_wcc_data(struct iatt *pre, struct iatt *post)
 {
-        wcc_data        wd = {{0}, };
+    wcc_data wd = {
+        {0},
+    };
 
-        if (post)
-                wd.after = nfs3_stat_to_post_op_attr (post);
-        if (pre)
-                wd.before = nfs3_stat_to_pre_op_attr (pre);
+    if (post)
+        wd.after = nfs3_stat_to_post_op_attr(post);
+    if (pre)
+        wd.before = nfs3_stat_to_pre_op_attr(pre);
 
-        return wd;
+    return wd;
 }
 
 void
-nfs3_fill_create3res (create3res *res, nfsstat3 stat, struct nfs3_fh *newfh,
-                      struct iatt *newbuf, struct iatt *preparent,
-                      struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_create3res(create3res *res, nfsstat3 stat, struct nfs3_fh *newfh,
+                     struct iatt *newbuf, struct iatt *preparent,
+                     struct iatt *postparent, uint64_t deviceid)
 {
-        post_op_attr    poa = {0, };
-        wcc_data        dirwcc = {{0}, };
+    post_op_attr poa = {
+        0,
+    };
+    wcc_data dirwcc = {
+        {0},
+    };
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_fill_post_op_fh3 (newfh, &res->create3res_u.resok.obj);
-        nfs3_map_deviceid_to_statdev (newbuf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (newbuf);
-        res->create3res_u.resok.obj_attributes = poa;
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
+    nfs3_fill_post_op_fh3(newfh, &res->create3res_u.resok.obj);
+    nfs3_map_deviceid_to_statdev(newbuf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(newbuf);
+    res->create3res_u.resok.obj_attributes = poa;
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
 
-        res->create3res_u.resok.dir_wcc = dirwcc;
+    res->create3res_u.resok.dir_wcc = dirwcc;
 }
 
 void
-nfs3_prep_create3args (create3args *args, struct nfs3_fh *fh, char *name)
+nfs3_prep_create3args(create3args *args, struct nfs3_fh *fh, char *name)
 {
-
-        memset (args, 0, sizeof (*args));
-        args->where.dir.data.data_val = (void *)fh;
-        args->where.name = name;
+    memset(args, 0, sizeof(*args));
+    args->where.dir.data.data_val = (void *)fh;
+    args->where.name = name;
 }
 
 void
-nfs3_prep_setattr3args (setattr3args *args, struct nfs3_fh *fh)
+nfs3_prep_setattr3args(setattr3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->object.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_fill_setattr3res (setattr3res *res, nfsstat3 stat, struct iatt *preop,
-                       struct iatt *postop, uint64_t deviceid)
+nfs3_fill_setattr3res(setattr3res *res, nfsstat3 stat, struct iatt *preop,
+                      struct iatt *postop, uint64_t deviceid)
 {
-        wcc_data        wcc;
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    wcc_data wcc;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (preop, deviceid);
-        nfs3_map_deviceid_to_statdev (postop, deviceid);
-        wcc = nfs3_stat_to_wcc_data (preop, postop);
-        res->setattr3res_u.resok.obj_wcc = wcc;
+    nfs3_map_deviceid_to_statdev(preop, deviceid);
+    nfs3_map_deviceid_to_statdev(postop, deviceid);
+    wcc = nfs3_stat_to_wcc_data(preop, postop);
+    res->setattr3res_u.resok.obj_wcc = wcc;
 }
 
-
 void
-nfs3_prep_mkdir3args (mkdir3args *args, struct nfs3_fh *dirfh, char *name)
+nfs3_prep_mkdir3args(mkdir3args *args, struct nfs3_fh *dirfh, char *name)
 {
-
-        memset (args, 0, sizeof (*args));
-        args->where.dir.data.data_val = (void *)dirfh;
-        args->where.name = name;
+    memset(args, 0, sizeof(*args));
+    args->where.dir.data.data_val = (void *)dirfh;
+    args->where.name = name;
 }
 
-
 void
-nfs3_fill_mkdir3res (mkdir3res *res, nfsstat3 stat, struct nfs3_fh *fh,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_mkdir3res(mkdir3res *res, nfsstat3 stat, struct nfs3_fh *fh,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, uint64_t deviceid)
 {
-        wcc_data        dirwcc;
-        post_op_attr    poa;
-
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    wcc_data dirwcc;
+    post_op_attr poa;
 
-        nfs3_fill_post_op_fh3 (fh, &res->mkdir3res_u.resok.obj);
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (buf);
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->mkdir3res_u.resok.obj_attributes = poa;
-        res->mkdir3res_u.resok.dir_wcc = dirwcc;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
+    nfs3_fill_post_op_fh3(fh, &res->mkdir3res_u.resok.obj);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(buf);
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->mkdir3res_u.resok.obj_attributes = poa;
+    res->mkdir3res_u.resok.dir_wcc = dirwcc;
 }
 
-
 void
-nfs3_prep_symlink3args (symlink3args *args, struct nfs3_fh *dirfh, char *name,
-                        char *target)
+nfs3_prep_symlink3args(symlink3args *args, struct nfs3_fh *dirfh, char *name,
+                       char *target)
 {
-        memset (args, 0, sizeof (*args));
-        args->where.dir.data.data_val = (void *)dirfh;
-        args->where.name = name;
-        args->symlink.symlink_data = target;
+    memset(args, 0, sizeof(*args));
+    args->where.dir.data.data_val = (void *)dirfh;
+    args->where.name = name;
+    args->symlink.symlink_data = target;
 }
 
-
 void
-nfs3_fill_symlink3res (symlink3res *res, nfsstat3 stat, struct nfs3_fh *fh,
-                       struct iatt *buf, struct iatt *preparent,
-                       struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_symlink3res(symlink3res *res, nfsstat3 stat, struct nfs3_fh *fh,
+                      struct iatt *buf, struct iatt *preparent,
+                      struct iatt *postparent, uint64_t deviceid)
 {
-        wcc_data        dirwcc;
-        post_op_attr    poa;
+    wcc_data dirwcc;
+    post_op_attr poa;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
-
-        nfs3_fill_post_op_fh3 (fh, &res->symlink3res_u.resok.obj);
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (buf);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->symlink3res_u.resok.obj_attributes = poa;
-        res->symlink3res_u.resok.dir_wcc = dirwcc;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
+    nfs3_fill_post_op_fh3(fh, &res->symlink3res_u.resok.obj);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(buf);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->symlink3res_u.resok.obj_attributes = poa;
+    res->symlink3res_u.resok.dir_wcc = dirwcc;
 }
 
-
 void
-nfs3_prep_readlink3args (readlink3args *args, struct nfs3_fh *fh)
+nfs3_prep_readlink3args(readlink3args *args, struct nfs3_fh *fh)
 {
-
-        memset (args, 0, sizeof (*args));
-        args->symlink.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->symlink.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_fill_readlink3res (readlink3res *res, nfsstat3 stat, char *path,
-                        struct iatt *buf, uint64_t deviceid)
+nfs3_fill_readlink3res(readlink3res *res, nfsstat3 stat, char *path,
+                       struct iatt *buf, uint64_t deviceid)
 {
-        post_op_attr    poa;
+    post_op_attr poa;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
 
-        if (stat != NFS3_OK)
-                return;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (buf);
-        res->readlink3res_u.resok.data = (void *)path;
-        res->readlink3res_u.resok.symlink_attributes = poa;
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(buf);
+    res->readlink3res_u.resok.data = (void *)path;
+    res->readlink3res_u.resok.symlink_attributes = poa;
 }
 
-
 void
-nfs3_prep_mknod3args (mknod3args *args, struct nfs3_fh *fh, char *name)
+nfs3_prep_mknod3args(mknod3args *args, struct nfs3_fh *fh, char *name)
 {
-        memset (args, 0, sizeof (*args));
-        args->where.dir.data.data_val = (void *)fh;
-        args->where.name = name;
-
+    memset(args, 0, sizeof(*args));
+    args->where.dir.data.data_val = (void *)fh;
+    args->where.name = name;
 }
 
 void
-nfs3_fill_mknod3res (mknod3res *res, nfsstat3 stat, struct nfs3_fh *fh,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_mknod3res(mknod3res *res, nfsstat3 stat, struct nfs3_fh *fh,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, uint64_t deviceid)
 {
-        post_op_attr    poa;
-        wcc_data        wccdir;
-
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    post_op_attr poa;
+    wcc_data wccdir;
 
-        nfs3_fill_post_op_fh3 (fh, &res->mknod3res_u.resok.obj);
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        poa = nfs3_stat_to_post_op_attr (buf);
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        wccdir = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->mknod3res_u.resok.obj_attributes = poa;
-        res->mknod3res_u.resok.dir_wcc = wccdir;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
+    nfs3_fill_post_op_fh3(fh, &res->mknod3res_u.resok.obj);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(buf);
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    wccdir = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->mknod3res_u.resok.obj_attributes = poa;
+    res->mknod3res_u.resok.dir_wcc = wccdir;
 }
 
-
 void
-nfs3_fill_remove3res (remove3res *res, nfsstat3 stat, struct iatt *preparent,
-                      struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_remove3res(remove3res *res, nfsstat3 stat, struct iatt *preparent,
+                     struct iatt *postparent, uint64_t deviceid)
 {
-        wcc_data        dirwcc;
+    wcc_data dirwcc;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->remove3res_u.resok.dir_wcc = dirwcc;
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->remove3res_u.resok.dir_wcc = dirwcc;
 }
 
-
 void
-nfs3_prep_remove3args (remove3args *args, struct nfs3_fh *fh, char *name)
+nfs3_prep_remove3args(remove3args *args, struct nfs3_fh *fh, char *name)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.dir.data.data_val = (void *)fh;
-        args->object.name = name;
+    memset(args, 0, sizeof(*args));
+    args->object.dir.data.data_val = (void *)fh;
+    args->object.name = name;
 }
 
-
 void
-nfs3_prep_rmdir3args (rmdir3args *args, struct nfs3_fh *fh, char *name)
+nfs3_prep_rmdir3args(rmdir3args *args, struct nfs3_fh *fh, char *name)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.dir.data.data_val = (void *)fh;
-        args->object.name = name;
+    memset(args, 0, sizeof(*args));
+    args->object.dir.data.data_val = (void *)fh;
+    args->object.name = name;
 }
 
-
 void
-nfs3_fill_rmdir3res (rmdir3res *res, nfsstat3 stat, struct iatt *preparent,
-                     struct iatt *postparent, uint64_t deviceid)
+nfs3_fill_rmdir3res(rmdir3res *res, nfsstat3 stat, struct iatt *preparent,
+                    struct iatt *postparent, uint64_t deviceid)
 {
-        wcc_data        dirwcc;
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
+    wcc_data dirwcc;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
 
-        if (stat != NFS3_OK)
-                return;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->rmdir3res_u.resok.dir_wcc = dirwcc;
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->rmdir3res_u.resok.dir_wcc = dirwcc;
 }
 
-
 void
-nfs3_prep_link3args (link3args *args, struct nfs3_fh *target,
-                     struct nfs3_fh * dirfh, char *name)
+nfs3_prep_link3args(link3args *args, struct nfs3_fh *target,
+                    struct nfs3_fh *dirfh, char *name)
 {
-        memset (args, 0, sizeof (*args));
-        args->file.data.data_val = (void *)target;
-        args->link.dir.data.data_val = (void *)dirfh;
-        args->link.name = name;
+    memset(args, 0, sizeof(*args));
+    args->file.data.data_val = (void *)target;
+    args->link.dir.data.data_val = (void *)dirfh;
+    args->link.name = name;
 }
 
-
 void
-nfs3_fill_link3res (link3res *res, nfsstat3 stat, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent,
-                    uint64_t deviceid)
+nfs3_fill_link3res(link3res *res, nfsstat3 stat, struct iatt *buf,
+                   struct iatt *preparent, struct iatt *postparent,
+                   uint64_t deviceid)
 {
-        post_op_attr    poa;
-        wcc_data        dirwcc;
+    post_op_attr poa;
+    wcc_data dirwcc;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (preparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postparent, deviceid);
-        nfs3_map_deviceid_to_statdev (buf,deviceid);
-        poa = nfs3_stat_to_post_op_attr (buf);
-        dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
-        res->link3res_u.resok.file_attributes = poa;
-        res->link3res_u.resok.linkdir_wcc = dirwcc;
+    nfs3_map_deviceid_to_statdev(preparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postparent, deviceid);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    poa = nfs3_stat_to_post_op_attr(buf);
+    dirwcc = nfs3_stat_to_wcc_data(preparent, postparent);
+    res->link3res_u.resok.file_attributes = poa;
+    res->link3res_u.resok.linkdir_wcc = dirwcc;
 }
 
-
-
 void
-nfs3_prep_rename3args (rename3args *args, struct nfs3_fh *olddirfh,
-                       char *oldname, struct nfs3_fh *newdirfh, char *newname)
+nfs3_prep_rename3args(rename3args *args, struct nfs3_fh *olddirfh,
+                      char *oldname, struct nfs3_fh *newdirfh, char *newname)
 {
-        memset (args, 0, sizeof (*args));
-
-        args->from.name = oldname;
-        args->from.dir.data.data_val = (void *)olddirfh;
-        args->to.name = newname;
-        args->to.dir.data.data_val = (void *)newdirfh;
+    memset(args, 0, sizeof(*args));
 
+    args->from.name = oldname;
+    args->from.dir.data.data_val = (void *)olddirfh;
+    args->to.name = newname;
+    args->to.dir.data.data_val = (void *)newdirfh;
 }
 
-
 void
-nfs3_fill_rename3res (rename3res *res, nfsstat3 stat, struct iatt *buf,
-                      struct iatt *preoldparent, struct iatt *postoldparent,
-                      struct iatt *prenewparent, struct iatt *postnewparent,
-                      uint64_t deviceid)
+nfs3_fill_rename3res(rename3res *res, nfsstat3 stat, struct iatt *buf,
+                     struct iatt *preoldparent, struct iatt *postoldparent,
+                     struct iatt *prenewparent, struct iatt *postnewparent,
+                     uint64_t deviceid)
 
 {
-        wcc_data        dirwcc;
+    wcc_data dirwcc;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (preoldparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postoldparent, deviceid);
-        nfs3_map_deviceid_to_statdev (prenewparent, deviceid);
-        nfs3_map_deviceid_to_statdev (postnewparent, deviceid);
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        dirwcc = nfs3_stat_to_wcc_data (preoldparent, postoldparent);
-        res->rename3res_u.resok.fromdir_wcc = dirwcc;
-        dirwcc = nfs3_stat_to_wcc_data (prenewparent, postnewparent);
-        res->rename3res_u.resok.todir_wcc = dirwcc;
+    nfs3_map_deviceid_to_statdev(preoldparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postoldparent, deviceid);
+    nfs3_map_deviceid_to_statdev(prenewparent, deviceid);
+    nfs3_map_deviceid_to_statdev(postnewparent, deviceid);
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    dirwcc = nfs3_stat_to_wcc_data(preoldparent, postoldparent);
+    res->rename3res_u.resok.fromdir_wcc = dirwcc;
+    dirwcc = nfs3_stat_to_wcc_data(prenewparent, postnewparent);
+    res->rename3res_u.resok.todir_wcc = dirwcc;
 }
 
-
 void
-nfs3_prep_write3args (write3args *args, struct nfs3_fh *fh)
+nfs3_prep_write3args(write3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->file.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->file.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_fill_write3res (write3res *res, nfsstat3 stat, count3 count,
-                     stable_how stable, uint64_t wverf, struct iatt *prestat,
-                     struct iatt *poststat, uint64_t deviceid)
+nfs3_fill_write3res(write3res *res, nfsstat3 stat, count3 count,
+                    stable_how stable, uint64_t wverf, struct iatt *prestat,
+                    struct iatt *poststat, uint64_t deviceid)
 {
-        write3resok     resok;
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    write3resok resok;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (prestat, deviceid);
-        nfs3_map_deviceid_to_statdev (poststat, deviceid);
-        resok.file_wcc = nfs3_stat_to_wcc_data (prestat, poststat);
-        resok.count = count;
-        resok.committed = stable;
-        memcpy (resok.verf, &wverf, sizeof (wverf));
+    nfs3_map_deviceid_to_statdev(prestat, deviceid);
+    nfs3_map_deviceid_to_statdev(poststat, deviceid);
+    resok.file_wcc = nfs3_stat_to_wcc_data(prestat, poststat);
+    resok.count = count;
+    resok.committed = stable;
+    memcpy(resok.verf, &wverf, sizeof(wverf));
 
-        res->write3res_u.resok = resok;
+    res->write3res_u.resok = resok;
 }
 
-
 void
-nfs3_prep_commit3args (commit3args *args, struct nfs3_fh *fh)
+nfs3_prep_commit3args(commit3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->file.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->file.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_fill_commit3res (commit3res *res, nfsstat3 stat, uint64_t wverf,
-                      struct iatt *prestat, struct iatt *poststat,
-                      uint64_t deviceid)
+nfs3_fill_commit3res(commit3res *res, nfsstat3 stat, uint64_t wverf,
+                     struct iatt *prestat, struct iatt *poststat,
+                     uint64_t deviceid)
 {
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (poststat, deviceid);
-        nfs3_map_deviceid_to_statdev (prestat, deviceid);
-        res->commit3res_u.resok.file_wcc = nfs3_stat_to_wcc_data (prestat,
-                                                                  poststat);
-        memcpy (res->commit3res_u.resok.verf, &wverf, sizeof (wverf));
+    nfs3_map_deviceid_to_statdev(poststat, deviceid);
+    nfs3_map_deviceid_to_statdev(prestat, deviceid);
+    res->commit3res_u.resok.file_wcc = nfs3_stat_to_wcc_data(prestat, poststat);
+    memcpy(res->commit3res_u.resok.verf, &wverf, sizeof(wverf));
 }
 
 void
-nfs3_fill_read3res (read3res *res, nfsstat3 stat, count3 count,
-                    struct iatt *poststat, int is_eof, uint64_t deviceid)
+nfs3_fill_read3res(read3res *res, nfsstat3 stat, count3 count,
+                   struct iatt *poststat, int is_eof, uint64_t deviceid)
 {
-        post_op_attr    poa;
+    post_op_attr poa;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (poststat, deviceid);
-        poa = nfs3_stat_to_post_op_attr (poststat);
-        res->read3res_u.resok.file_attributes = poa;
-        res->read3res_u.resok.count = count;
-        res->read3res_u.resok.eof = is_eof;
-        res->read3res_u.resok.data.data_len = count;
+    nfs3_map_deviceid_to_statdev(poststat, deviceid);
+    poa = nfs3_stat_to_post_op_attr(poststat);
+    res->read3res_u.resok.file_attributes = poa;
+    res->read3res_u.resok.count = count;
+    res->read3res_u.resok.eof = is_eof;
+    res->read3res_u.resok.data.data_len = count;
 }
 
-
 void
-nfs3_prep_read3args (read3args *args, struct nfs3_fh *fh)
+nfs3_prep_read3args(read3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->file.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->file.data.data_val = (void *)fh;
 }
 
-
 void
-nfs3_fill_pathconf3res (pathconf3res *res, nfsstat3 stat, struct iatt *buf,
-                        uint64_t deviceid)
+nfs3_fill_pathconf3res(pathconf3res *res, nfsstat3 stat, struct iatt *buf,
+                       uint64_t deviceid)
 {
-        pathconf3resok  resok;
+    pathconf3resok resok;
 
-        memset (res, 0, sizeof (*res));
-        res->status = stat;
-        if (stat != NFS3_OK)
-                return;
+    memset(res, 0, sizeof(*res));
+    res->status = stat;
+    if (stat != NFS3_OK)
+        return;
 
-        nfs3_map_deviceid_to_statdev (buf, deviceid);
-        resok.obj_attributes = nfs3_stat_to_post_op_attr (buf);
-        resok.linkmax = 256;
-        resok.name_max = NFS_NAME_MAX;
-        resok.no_trunc = TRUE;
-        resok.chown_restricted = FALSE;
-        resok.case_insensitive = FALSE;
-        resok.case_preserving = TRUE;
+    nfs3_map_deviceid_to_statdev(buf, deviceid);
+    resok.obj_attributes = nfs3_stat_to_post_op_attr(buf);
+    resok.linkmax = 256;
+    resok.name_max = NFS_NAME_MAX;
+    resok.no_trunc = TRUE;
+    resok.chown_restricted = FALSE;
+    resok.case_insensitive = FALSE;
+    resok.case_preserving = TRUE;
 
-        res->pathconf3res_u.resok = resok;
+    res->pathconf3res_u.resok = resok;
 }
 
-
 void
-nfs3_prep_pathconf3args (pathconf3args *args, struct nfs3_fh *fh)
+nfs3_prep_pathconf3args(pathconf3args *args, struct nfs3_fh *fh)
 {
-        memset (args, 0, sizeof (*args));
-        args->object.data.data_val = (void *)fh;
+    memset(args, 0, sizeof(*args));
+    args->object.data.data_val = (void *)fh;
 }
 
-
 int
-nfs3_verify_dircookie (struct nfs3_state *nfs3, fd_t *dirfd, cookie3 cookie,
-                       uint64_t cverf, nfsstat3 *stat)
+nfs3_verify_dircookie(struct nfs3_state *nfs3, fd_t *dirfd, cookie3 cookie,
+                      uint64_t cverf, nfsstat3 *stat)
 {
-        int             ret = -1;
+    int ret = -1;
 
-        if ((!nfs3) || (!dirfd))
-                return -1;
+    if ((!nfs3) || (!dirfd))
+        return -1;
 
-        /* Can assume that this is first read on the dir, so cookie check
-         * is successful by default.
-         */
-        if (cookie == 0)
-                return 0;
-
-        gf_msg_trace (GF_NFS3, 0, "Verifying cookie: cverf: %"PRIu64
-                      ", cookie: %"PRIu64, cverf, cookie);
-        /* The cookie bad, no way cverf will be zero with a non-zero cookie. */
-        if ((cverf == 0) && (cookie != 0)) {
-                gf_msg_trace (GF_NFS3, 0, "Bad cookie requested");
-                if (stat)
-                        *stat = NFS3ERR_BAD_COOKIE;
-                goto err;
-        }
+    /* Can assume that this is first read on the dir, so cookie check
+     * is successful by default.
+     */
+    if (cookie == 0)
+        return 0;
 
-        /* Yes, its true, our cookie is simply the fd_t address.
-         * NOTE: We used have the check for cookieverf but VMWare client sends
-         * a readdirp requests even after we've told it that EOF has been
-         * reached on the directory. This causes a problem because we close a
-         * dir fd_t after reaching EOF. The next readdirp sent by VMWare
-         * contains the address of the closed fd_t as cookieverf. Since we
-         * closed that fd_t, this readdirp results in a new opendir which will
-         * give an fd_t that will fail this check below.
-         */
-/*        if ((cverf != (uint64_t)dirfd)) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Cookieverf does not match");
-                if (stat)
-                        *stat = NFS3ERR_BAD_COOKIE;
-                goto err;
-        }
-*/
-        gf_msg_trace (GF_NFS3, 0, "Cookie verified");
+    gf_msg_trace(GF_NFS3, 0,
+                 "Verifying cookie: cverf: %" PRIu64 ", cookie: %" PRIu64,
+                 cverf, cookie);
+    /* The cookie bad, no way cverf will be zero with a non-zero cookie. */
+    if ((cverf == 0) && (cookie != 0)) {
+        gf_msg_trace(GF_NFS3, 0, "Bad cookie requested");
         if (stat)
-                *stat = NFS3_OK;
-        ret = 0;
+            *stat = NFS3ERR_BAD_COOKIE;
+        goto err;
+    }
+
+    /* Yes, its true, our cookie is simply the fd_t address.
+     * NOTE: We used have the check for cookieverf but VMWare client sends
+     * a readdirp requests even after we've told it that EOF has been
+     * reached on the directory. This causes a problem because we close a
+     * dir fd_t after reaching EOF. The next readdirp sent by VMWare
+     * contains the address of the closed fd_t as cookieverf. Since we
+     * closed that fd_t, this readdirp results in a new opendir which will
+     * give an fd_t that will fail this check below.
+     */
+    /*        if ((cverf != (uint64_t)dirfd)) {
+                    gf_log (GF_NFS3, GF_LOG_TRACE, "Cookieverf does not match");
+                    if (stat)
+                            *stat = NFS3ERR_BAD_COOKIE;
+                    goto err;
+            }
+    */
+    gf_msg_trace(GF_NFS3, 0, "Cookie verified");
+    if (stat)
+        *stat = NFS3_OK;
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 void
-nfs3_stat_to_errstr (uint32_t xid, char *op, nfsstat3 stat, int pstat,
-                     char *errstr, size_t len)
+nfs3_stat_to_errstr(uint32_t xid, char *op, nfsstat3 stat, int pstat,
+                    char *errstr, size_t len)
 {
-        if ((!op) || (!errstr))
-                return;
+    if ((!op) || (!errstr))
+        return;
 
-        snprintf (errstr, len, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)",
-                  xid, op,stat, nfsstat3_strerror (stat), pstat,
-                  strerror (pstat));
+    snprintf(errstr, len, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", xid, op,
+             stat, nfsstat3_strerror(stat), pstat, strerror(pstat));
 }
 
 void
-nfs3_log_common_call (uint32_t xid, char *op, struct nfs3_fh *fh)
+nfs3_log_common_call(uint32_t xid, char *op, struct nfs3_fh *fh)
 {
-        char    fhstr[1024];
+    char fhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
 
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s", xid, op, fhstr);
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    gf_msg_debug(GF_NFS3, 0, "XID: %x, %s: args: %s", xid, op, fhstr);
 }
 
-
 void
-nfs3_log_fh_entry_call (uint32_t xid, char *op, struct nfs3_fh *fh,
-                        char *name)
+nfs3_log_fh_entry_call(uint32_t xid, char *op, struct nfs3_fh *fh, char *name)
 {
-        char    fhstr[1024];
+    char fhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, name: %s", xid,
-                      op, fhstr, name);
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    gf_msg_debug(GF_NFS3, 0, "XID: %x, %s: args: %s, name: %s", xid, op, fhstr,
+                 name);
 }
 
-
 void
-nfs3_log_rename_call (uint32_t xid, struct nfs3_fh *src, char *sname,
-                      struct nfs3_fh *dst, char *dname)
+nfs3_log_rename_call(uint32_t xid, struct nfs3_fh *src, char *sname,
+                     struct nfs3_fh *dst, char *dname)
 {
-        char    sfhstr[1024];
-        char    dfhstr[1024];
+    char sfhstr[1024];
+    char dfhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (src, sfhstr, sizeof (sfhstr));
-        nfs3_fh_to_str (dst, dfhstr, sizeof (dfhstr));
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, RENAME: args: Src: %s, "
-                      "name: %s, Dst: %s, name: %s", xid, sfhstr, sname,
-                      dfhstr, dname);
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(src, sfhstr, sizeof(sfhstr));
+    nfs3_fh_to_str(dst, dfhstr, sizeof(dfhstr));
+    gf_msg_debug(GF_NFS3, 0,
+                 "XID: %x, RENAME: args: Src: %s, "
+                 "name: %s, Dst: %s, name: %s",
+                 xid, sfhstr, sname, dfhstr, dname);
 }
 
-
-
 void
-nfs3_log_create_call (uint32_t xid, struct nfs3_fh *fh, char *name,
-                      createmode3 mode)
+nfs3_log_create_call(uint32_t xid, struct nfs3_fh *fh, char *name,
+                     createmode3 mode)
 {
-        char    fhstr[1024];
-        char    *modestr = NULL;
-        char    exclmode[] = "EXCLUSIVE";
-        char    unchkd[] = "UNCHECKED";
-        char    guarded[] = "GUARDED";
+    char fhstr[1024];
+    char *modestr = NULL;
+    char exclmode[] = "EXCLUSIVE";
+    char unchkd[] = "UNCHECKED";
+    char guarded[] = "GUARDED";
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        if (mode == EXCLUSIVE)
-                modestr = exclmode;
-        else if (mode == GUARDED)
-                modestr = guarded;
-        else
-                modestr = unchkd;
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    if (mode == EXCLUSIVE)
+        modestr = exclmode;
+    else if (mode == GUARDED)
+        modestr = guarded;
+    else
+        modestr = unchkd;
 
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, CREATE: args: %s, name: %s,"
-                      " mode: %s", xid, fhstr, name, modestr);
+    gf_msg_debug(GF_NFS3, 0,
+                 "XID: %x, CREATE: args: %s, name: %s,"
+                 " mode: %s",
+                 xid, fhstr, name, modestr);
 }
 
-
 void
-nfs3_log_mknod_call (uint32_t xid, struct nfs3_fh *fh, char *name, int type)
+nfs3_log_mknod_call(uint32_t xid, struct nfs3_fh *fh, char *name, int type)
 {
-        char    fhstr[1024];
-        char    *modestr = NULL;
-        char    chr[] = "CHAR";
-        char    blk[] = "BLK";
-        char    sock[] = "SOCK";
-        char    fifo[] = "FIFO";
+    char fhstr[1024];
+    char *modestr = NULL;
+    char chr[] = "CHAR";
+    char blk[] = "BLK";
+    char sock[] = "SOCK";
+    char fifo[] = "FIFO";
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        if (type == NF3CHR)
-                modestr = chr;
-        else if (type == NF3BLK)
-                modestr = blk;
-        else if (type == NF3SOCK)
-                modestr = sock;
-        else
-                modestr = fifo;
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    if (type == NF3CHR)
+        modestr = chr;
+    else if (type == NF3BLK)
+        modestr = blk;
+    else if (type == NF3SOCK)
+        modestr = sock;
+    else
+        modestr = fifo;
 
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, MKNOD: args: %s, name: %s,"
-                      " type: %s", xid, fhstr, name, modestr);
+    gf_msg_debug(GF_NFS3, 0,
+                 "XID: %x, MKNOD: args: %s, name: %s,"
+                 " type: %s",
+                 xid, fhstr, name, modestr);
 }
 
-
-
 void
-nfs3_log_symlink_call (uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt)
+nfs3_log_symlink_call(uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt)
 {
-        char    fhstr[1024];
+    char fhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, SYMLINK: args: %s, name: %s,"
-                      " target: %s", xid, fhstr, name, tgt);
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    gf_msg_debug(GF_NFS3, 0,
+                 "XID: %x, SYMLINK: args: %s, name: %s,"
+                 " target: %s",
+                 xid, fhstr, name, tgt);
 }
 
-
 void
-nfs3_log_link_call (uint32_t xid, struct nfs3_fh *fh, char *name,
-                    struct nfs3_fh *tgt)
+nfs3_log_link_call(uint32_t xid, struct nfs3_fh *fh, char *name,
+                   struct nfs3_fh *tgt)
 {
-        char    dfhstr[1024];
-        char    tfhstr[1024];
+    char dfhstr[1024];
+    char tfhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, dfhstr, sizeof (dfhstr));
-        nfs3_fh_to_str (tgt, tfhstr, sizeof (tfhstr));
-        gf_msg_debug (GF_NFS3, 0, "XID: %x, LINK: args: %s, name: %s,"
-                      " target: %s", xid, dfhstr, name, tfhstr);
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, dfhstr, sizeof(dfhstr));
+    nfs3_fh_to_str(tgt, tfhstr, sizeof(tfhstr));
+    gf_msg_debug(GF_NFS3, 0,
+                 "XID: %x, LINK: args: %s, name: %s,"
+                 " target: %s",
+                 xid, dfhstr, name, tfhstr);
 }
 
-
 void
-nfs3_log_rw_call (uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt,
-                  count3 count, int stablewrite)
+nfs3_log_rw_call(uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt,
+                 count3 count, int stablewrite)
 {
-        char    fhstr[1024];
-
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
-        if (stablewrite == -1)
-                gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, offset:"
-                              " %"PRIu64",  count: %"PRIu32, xid, op, fhstr,
-                              offt, count);
-        else
-                gf_msg_debug (GF_NFS3, 0, "XID: %x, %s: args: %s, offset:"
-                              " %"PRIu64",  count: %"PRIu32", %s", xid, op,
-                              fhstr, offt, count,
-                              (stablewrite == UNSTABLE)?"UNSTABLE":"STABLE");
+    char fhstr[1024];
 
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
+    if (stablewrite == -1)
+        gf_msg_debug(GF_NFS3, 0,
+                     "XID: %x, %s: args: %s, offset:"
+                     " %" PRIu64 ",  count: %" PRIu32,
+                     xid, op, fhstr, offt, count);
+    else
+        gf_msg_debug(GF_NFS3, 0,
+                     "XID: %x, %s: args: %s, offset:"
+                     " %" PRIu64 ",  count: %" PRIu32 ", %s",
+                     xid, op, fhstr, offt, count,
+                     (stablewrite == UNSTABLE) ? "UNSTABLE" : "STABLE");
 }
 
-
 int
-nfs3_getattr_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_getattr_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_PERM:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ACCES:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_setattr_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_setattr_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_lookup_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_lookup_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_PERM:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ACCES:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_access_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_access_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_readlink_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_readlink_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
 int
-nfs3_read_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_read_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_write_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_write_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_create_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_create_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_mkdir_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_mkdir_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_symlink_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_symlink_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_mknod_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_mknod_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
 int
-nfs3_remove_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_remove_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_rmdir_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_rmdir_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_rename_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_rename_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_link_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_link_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_readdir_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_readdir_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
-
 int
-nfs3_fsstat_loglevel (nfsstat3 stat) {
-
-	int ll = GF_LOG_DEBUG;
-
-	switch (stat) {
+nfs3_fsstat_loglevel(nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
+    switch (stat) {
         case NFS3ERR_PERM:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOENT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ACCES:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_EXIST:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_XDEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NODEV:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_IO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NXIO:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ISDIR:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_INVAL:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOSPC:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_ROFS:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_FBIG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_MLINK:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NAMETOOLONG:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTEMPTY:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_SERVERFAULT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_NOTSUPP:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_BADHANDLE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_STALE:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         case NFS3ERR_DQUOT:
-		ll = GF_LOG_WARNING;
-                break;
+            ll = GF_LOG_WARNING;
+            break;
 
         default:
-		ll = GF_LOG_DEBUG;
-                break;
-        }
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-        return ll;
+    return ll;
 }
 
 struct nfs3op_str {
-	int	op;
-	char	str[100];
+    int op;
+    char str[100];
 };
 
 struct nfs3op_str nfs3op_strings[] = {
-	{ NFS3_NULL, "NULL"},
-	{ NFS3_GETATTR, "GETATTR"},
-	{ NFS3_SETATTR, "SETATTR"},
-	{ NFS3_LOOKUP, "LOOKUP"},
-	{ NFS3_ACCESS, "ACCESS"},
-	{ NFS3_READLINK, "READLINK"},
-	{ NFS3_READ, "READ"},
-	{ NFS3_WRITE, "WRITE"},
-	{ NFS3_CREATE, "CREATE"},
-	{ NFS3_MKDIR, "MKDIR"},
-	{ NFS3_SYMLINK, "SYMLINK"},
-	{ NFS3_MKNOD, "MKNOD"},
-	{ NFS3_REMOVE, "REMOVE"},
-	{ NFS3_RMDIR, "RMDIR"},
-	{ NFS3_RENAME, "RENAME"},
-	{ NFS3_LINK, "LINK"},
-	{ NFS3_READDIR, "READDIR"},
-	{ NFS3_READDIRP, "READDIRP"},
-	{ NFS3_FSSTAT, "FSSTAT"},
-	{ NFS3_FSINFO, "FSINFO"},
-	{ NFS3_PATHCONF, "PATHCONF"},
-	{ NFS3_COMMIT, "COMMIT"},
+    {NFS3_NULL, "NULL"},         {NFS3_GETATTR, "GETATTR"},
+    {NFS3_SETATTR, "SETATTR"},   {NFS3_LOOKUP, "LOOKUP"},
+    {NFS3_ACCESS, "ACCESS"},     {NFS3_READLINK, "READLINK"},
+    {NFS3_READ, "READ"},         {NFS3_WRITE, "WRITE"},
+    {NFS3_CREATE, "CREATE"},     {NFS3_MKDIR, "MKDIR"},
+    {NFS3_SYMLINK, "SYMLINK"},   {NFS3_MKNOD, "MKNOD"},
+    {NFS3_REMOVE, "REMOVE"},     {NFS3_RMDIR, "RMDIR"},
+    {NFS3_RENAME, "RENAME"},     {NFS3_LINK, "LINK"},
+    {NFS3_READDIR, "READDIR"},   {NFS3_READDIRP, "READDIRP"},
+    {NFS3_FSSTAT, "FSSTAT"},     {NFS3_FSINFO, "FSINFO"},
+    {NFS3_PATHCONF, "PATHCONF"}, {NFS3_COMMIT, "COMMIT"},
 };
 
 int
-nfs3_loglevel (int nfs_op, nfsstat3 stat) {
-
-	int	ll = GF_LOG_DEBUG;
+nfs3_loglevel(int nfs_op, nfsstat3 stat)
+{
+    int ll = GF_LOG_DEBUG;
 
-	switch (nfs_op) {
-	case NFS3_GETATTR:
-		ll = nfs3_getattr_loglevel (stat);
-		break;
+    switch (nfs_op) {
+        case NFS3_GETATTR:
+            ll = nfs3_getattr_loglevel(stat);
+            break;
 
-	case NFS3_SETATTR:
-		ll = nfs3_setattr_loglevel (stat);
-		break;
+        case NFS3_SETATTR:
+            ll = nfs3_setattr_loglevel(stat);
+            break;
 
-	case NFS3_LOOKUP:
-		ll = nfs3_lookup_loglevel (stat);
-		break;
+        case NFS3_LOOKUP:
+            ll = nfs3_lookup_loglevel(stat);
+            break;
 
-	case NFS3_ACCESS:
-		ll = nfs3_access_loglevel (stat);
-		break;
+        case NFS3_ACCESS:
+            ll = nfs3_access_loglevel(stat);
+            break;
 
-	case NFS3_READLINK:
-		ll = nfs3_readlink_loglevel (stat);
-		break;
+        case NFS3_READLINK:
+            ll = nfs3_readlink_loglevel(stat);
+            break;
 
-	case NFS3_READ:
-		ll = nfs3_read_loglevel (stat);
-		break;
+        case NFS3_READ:
+            ll = nfs3_read_loglevel(stat);
+            break;
 
-	case NFS3_WRITE:
-		ll = nfs3_write_loglevel (stat);
-		break;
+        case NFS3_WRITE:
+            ll = nfs3_write_loglevel(stat);
+            break;
 
-	case NFS3_CREATE:
-		ll = nfs3_create_loglevel (stat);
-		break;
+        case NFS3_CREATE:
+            ll = nfs3_create_loglevel(stat);
+            break;
 
-	case NFS3_MKDIR:
-		ll = nfs3_mkdir_loglevel (stat);
-		break;
+        case NFS3_MKDIR:
+            ll = nfs3_mkdir_loglevel(stat);
+            break;
 
-	case NFS3_SYMLINK:
-		ll = nfs3_symlink_loglevel (stat);
-		break;
+        case NFS3_SYMLINK:
+            ll = nfs3_symlink_loglevel(stat);
+            break;
 
-	case NFS3_MKNOD:
-		ll = nfs3_mknod_loglevel (stat);
-		break;
+        case NFS3_MKNOD:
+            ll = nfs3_mknod_loglevel(stat);
+            break;
 
-	case NFS3_REMOVE:
-		ll = nfs3_remove_loglevel (stat);
-		break;
+        case NFS3_REMOVE:
+            ll = nfs3_remove_loglevel(stat);
+            break;
 
-	case NFS3_RMDIR:
-		ll = nfs3_rmdir_loglevel (stat);
-		break;
+        case NFS3_RMDIR:
+            ll = nfs3_rmdir_loglevel(stat);
+            break;
 
-	case NFS3_RENAME:
-		ll = nfs3_rename_loglevel (stat);
-		break;
+        case NFS3_RENAME:
+            ll = nfs3_rename_loglevel(stat);
+            break;
 
-	case NFS3_LINK:
-		ll = nfs3_link_loglevel (stat);
-		break;
+        case NFS3_LINK:
+            ll = nfs3_link_loglevel(stat);
+            break;
 
-	case NFS3_READDIR:
-		ll = nfs3_readdir_loglevel (stat);
-		break;
+        case NFS3_READDIR:
+            ll = nfs3_readdir_loglevel(stat);
+            break;
 
-	case NFS3_READDIRP:
-		ll = nfs3_readdir_loglevel (stat);
-		break;
+        case NFS3_READDIRP:
+            ll = nfs3_readdir_loglevel(stat);
+            break;
 
-	case NFS3_FSSTAT:
-		ll = nfs3_fsstat_loglevel (stat);
-		break;
+        case NFS3_FSSTAT:
+            ll = nfs3_fsstat_loglevel(stat);
+            break;
 
-	case NFS3_FSINFO:
-		ll = nfs3_fsstat_loglevel (stat);
-		break;
+        case NFS3_FSINFO:
+            ll = nfs3_fsstat_loglevel(stat);
+            break;
 
-	case NFS3_PATHCONF:
-		ll = nfs3_fsstat_loglevel (stat);
-		break;
+        case NFS3_PATHCONF:
+            ll = nfs3_fsstat_loglevel(stat);
+            break;
 
-	case NFS3_COMMIT:
-		ll = nfs3_write_loglevel (stat);
-		break;
+        case NFS3_COMMIT:
+            ll = nfs3_write_loglevel(stat);
+            break;
 
-	default:
-		ll = GF_LOG_DEBUG;
-		break;
-	}
+        default:
+            ll = GF_LOG_DEBUG;
+            break;
+    }
 
-	return ll;
+    return ll;
 }
 
 void
-nfs3_log_common_res (uint32_t xid, int op, nfsstat3 stat, int pstat,
-                     const char *path)
+nfs3_log_common_res(uint32_t xid, int op, nfsstat3 stat, int pstat,
+                    const char *path)
 {
-        char    errstr[1024];
-        int     ll = nfs3_loglevel (op, stat);
-
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr, sizeof (errstr));
-                if (ll == GF_LOG_DEBUG)
-                        gf_msg_debug (GF_NFS3, 0, "%s => (%s)", path,
-                                      errstr);
-                else
-                        gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                                "%s => (%s)", path, errstr);
+    char errstr[1024];
+    int ll = nfs3_loglevel(op, stat);
 
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, nfs3op_strings[op].str, stat, pstat, errstr,
+                        sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0, "%s => (%s)", path, errstr);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, "%s => (%s)", path,
+               errstr);
 }
 
 void
-nfs3_log_readlink_res (uint32_t xid, nfsstat3 stat, int pstat, char *linkpath,
-                       const char *path)
+nfs3_log_readlink_res(uint32_t xid, nfsstat3 stat, int pstat, char *linkpath,
+                      const char *path)
 {
-        char    errstr[1024];
-        int     ll = nfs3_loglevel (NFS3_READLINK, stat);
-
-        if (THIS->ctx->log.loglevel < ll)
-                return;
+    char errstr[1024];
+    int ll = nfs3_loglevel(NFS3_READLINK, stat);
 
-        nfs3_stat_to_errstr (xid, "READLINK", stat, pstat, errstr, sizeof (errstr));
-        if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0, "%s => (%s), target: %s", path,
-                              errstr, linkpath);
-        else
-                gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s) target: %s" , path,
-                        errstr, linkpath);
-}
-
-void
-nfs3_log_read_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
-                   int is_eof, struct iovec *vec,
-                   int32_t veccount, const char *path)
-{
-        char    errstr[1024];
-        int     ll = GF_LOG_DEBUG;
-
-        ll = nfs3_loglevel (NFS3_READ, stat);
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, "READ", stat, pstat, errstr, sizeof (errstr));
-        if (vec)
-                if (ll == GF_LOG_DEBUG)
-                        gf_msg_debug (GF_NFS3, 0,
-                                      "%s => (%s), count: %"PRIu32", is_eof:"
-                                      " %d, vector: count: %d, len: %zd", path,
-                                      errstr, count, is_eof, veccount,
-                                      vec->iov_len);
-                else
-                        gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                                "%s => (%s), count: %"PRIu32", is_eof:"
-                                " %d, vector: count: %d, len: %zd", path,
-                                errstr, count, is_eof, veccount, vec->iov_len);
-        else
-                if (ll == GF_LOG_DEBUG)
-                        gf_msg_debug (GF_NFS3, 0,
-                                      "%s => (%s), count: %"PRIu32", is_eof:"
-                                      " %d", path, errstr, count, is_eof);
-                else
-                        gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                                "%s => (%s), count: %"PRIu32", is_eof:"
-                                " %d", path, errstr, count, is_eof);
+    if (THIS->ctx->log.loglevel < ll)
+        return;
 
+    nfs3_stat_to_errstr(xid, "READLINK", stat, pstat, errstr, sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0, "%s => (%s), target: %s", path, errstr,
+                     linkpath);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR, "%s => (%s) target: %s",
+               path, errstr, linkpath);
 }
 
 void
-nfs3_log_write_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
-                    int stable, uint64_t wverf, const char *path)
+nfs3_log_read_res(uint32_t xid, nfsstat3 stat, int pstat, count3 count,
+                  int is_eof, struct iovec *vec, int32_t veccount,
+                  const char *path)
 {
-        char    errstr[1024];
-        int     ll = nfs3_loglevel (NFS3_WRITE, stat);
-
-        if (THIS->ctx->log.loglevel < ll)
-                return;
+    char errstr[1024];
+    int ll = GF_LOG_DEBUG;
 
-        nfs3_stat_to_errstr (xid, "WRITE", stat, pstat, errstr, sizeof (errstr));
+    ll = nfs3_loglevel(NFS3_READ, stat);
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, "READ", stat, pstat, errstr, sizeof(errstr));
+    if (vec)
         if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0,
-                              "%s => (%s), count: %"PRIu32", %s,wverf: "
-                              "%"PRIu64, path, errstr, count,
-                              (stable == UNSTABLE)?"UNSTABLE":"STABLE", wverf);
+            gf_msg_debug(GF_NFS3, 0,
+                         "%s => (%s), count: %" PRIu32
+                         ", is_eof:"
+                         " %d, vector: count: %d, len: %zd",
+                         path, errstr, count, is_eof, veccount, vec->iov_len);
         else
-                gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s), count: %"PRIu32", %s,wverf: %"PRIu64
-                        , path, errstr, count,
-                        (stable == UNSTABLE)?"UNSTABLE":"STABLE", wverf);
+            gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+                   "%s => (%s), count: %" PRIu32
+                   ", is_eof:"
+                   " %d, vector: count: %d, len: %zd",
+                   path, errstr, count, is_eof, veccount, vec->iov_len);
+    else if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0,
+                     "%s => (%s), count: %" PRIu32
+                     ", is_eof:"
+                     " %d",
+                     path, errstr, count, is_eof);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), count: %" PRIu32
+               ", is_eof:"
+               " %d",
+               path, errstr, count, is_eof);
+}
+
+void
+nfs3_log_write_res(uint32_t xid, nfsstat3 stat, int pstat, count3 count,
+                   int stable, uint64_t wverf, const char *path)
+{
+    char errstr[1024];
+    int ll = nfs3_loglevel(NFS3_WRITE, stat);
+
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+
+    nfs3_stat_to_errstr(xid, "WRITE", stat, pstat, errstr, sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0,
+                     "%s => (%s), count: %" PRIu32
+                     ", %s,wverf: "
+                     "%" PRIu64,
+                     path, errstr, count,
+                     (stable == UNSTABLE) ? "UNSTABLE" : "STABLE", wverf);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), count: %" PRIu32 ", %s,wverf: %" PRIu64, path,
+               errstr, count, (stable == UNSTABLE) ? "UNSTABLE" : "STABLE",
+               wverf);
 }
 
 void
-nfs3_log_newfh_res (uint32_t xid, int op, nfsstat3 stat, int pstat,
-                    struct nfs3_fh *newfh, const char *path)
+nfs3_log_newfh_res(uint32_t xid, int op, nfsstat3 stat, int pstat,
+                   struct nfs3_fh *newfh, const char *path)
 {
-        char    errstr[1024];
-        char    fhstr[1024];
-        int     ll = nfs3_loglevel (op, stat);
+    char errstr[1024];
+    char fhstr[1024];
+    int ll = nfs3_loglevel(op, stat);
 
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr, sizeof (errstr));
-        nfs3_fh_to_str (newfh, fhstr, sizeof (fhstr));
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, nfs3op_strings[op].str, stat, pstat, errstr,
+                        sizeof(errstr));
+    nfs3_fh_to_str(newfh, fhstr, sizeof(fhstr));
 
-        if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0, "%s => (%s), %s", path, errstr,
-                              fhstr);
-        else
-                gf_msg (GF_NFS3, nfs3_loglevel (op, stat), errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s), %s", path, errstr, fhstr);
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0, "%s => (%s), %s", path, errstr, fhstr);
+    else
+        gf_msg(GF_NFS3, nfs3_loglevel(op, stat), errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), %s", path, errstr, fhstr);
 }
 
 void
-nfs3_log_readdir_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
-                      count3 count, int is_eof, const char *path)
+nfs3_log_readdir_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
+                     count3 count, int is_eof, const char *path)
 {
-        char    errstr[1024];
-        int     ll = nfs3_loglevel (NFS3_READDIR, stat);
+    char errstr[1024];
+    int ll = nfs3_loglevel(NFS3_READDIR, stat);
 
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, "READDIR", stat, pstat, errstr, sizeof (errstr));
-        if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0,
-                              "%s => (%s), count: %"PRIu32", cverf: %"PRIu64
-                              ", is_eof: %d", path, errstr, count, cverf,
-                              is_eof);
-        else
-                gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s), count: %"PRIu32", cverf: %"PRIu64
-                        ", is_eof: %d", path, errstr, count, cverf, is_eof);
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, "READDIR", stat, pstat, errstr, sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0,
+                     "%s => (%s), count: %" PRIu32 ", cverf: %" PRIu64
+                     ", is_eof: %d",
+                     path, errstr, count, cverf, is_eof);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), count: %" PRIu32 ", cverf: %" PRIu64 ", is_eof: %d",
+               path, errstr, count, cverf, is_eof);
 }
 
 void
-nfs3_log_readdirp_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
-                       count3 dircount, count3 maxcount, int is_eof,
-                       const char *path)
+nfs3_log_readdirp_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
+                      count3 dircount, count3 maxcount, int is_eof,
+                      const char *path)
 {
-        char    errstr[1024];
-        int	ll = nfs3_loglevel (NFS3_READDIRP, stat);
-
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, "READDIRPLUS", stat, pstat, errstr, sizeof (errstr));
-        if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0,
-                              "%s => (%s), dircount: %"PRIu32", maxcount: %"
-                              PRIu32", cverf: %"PRIu64", is_eof: %d", path,
-                              errstr, dircount, maxcount, cverf, is_eof);
-        else
-                gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s), dircount: %"PRIu32", maxcount: %"
-                        PRIu32", cverf: %"PRIu64", is_eof: %d", path, errstr,
-                        dircount, maxcount, cverf, is_eof);
+    char errstr[1024];
+    int ll = nfs3_loglevel(NFS3_READDIRP, stat);
 
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, "READDIRPLUS", stat, pstat, errstr,
+                        sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0,
+                     "%s => (%s), dircount: %" PRIu32 ", maxcount: %" PRIu32
+                     ", cverf: %" PRIu64 ", is_eof: %d",
+                     path, errstr, dircount, maxcount, cverf, is_eof);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), dircount: %" PRIu32 ", maxcount: %" PRIu32
+               ", cverf: %" PRIu64 ", is_eof: %d",
+               path, errstr, dircount, maxcount, cverf, is_eof);
 }
 
 void
-nfs3_log_commit_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf,
-                     const char *path)
+nfs3_log_commit_res(uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf,
+                    const char *path)
 {
-        char    errstr[1024];
-        int	ll = nfs3_loglevel (NFS3_COMMIT, stat);
-
-        if (THIS->ctx->log.loglevel < ll)
-                return;
-        nfs3_stat_to_errstr (xid, "COMMIT", stat, pstat, errstr, sizeof (errstr));
-        if (ll == GF_LOG_DEBUG)
-                gf_msg_debug (GF_NFS3, 0, "%s => (%s), wverf: %"PRIu64,
-                              path, errstr, wverf);
-        else
-                gf_msg (GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
-                        "%s => (%s), wverf: %"PRIu64, path, errstr, wverf);
+    char errstr[1024];
+    int ll = nfs3_loglevel(NFS3_COMMIT, stat);
 
+    if (THIS->ctx->log.loglevel < ll)
+        return;
+    nfs3_stat_to_errstr(xid, "COMMIT", stat, pstat, errstr, sizeof(errstr));
+    if (ll == GF_LOG_DEBUG)
+        gf_msg_debug(GF_NFS3, 0, "%s => (%s), wverf: %" PRIu64, path, errstr,
+                     wverf);
+    else
+        gf_msg(GF_NFS3, ll, errno, NFS_MSG_STAT_ERROR,
+               "%s => (%s), wverf: %" PRIu64, path, errstr, wverf);
 }
 
 void
-nfs3_log_readdir_call (uint32_t xid, struct nfs3_fh *fh, count3 dircount,
-                       count3 maxcount)
+nfs3_log_readdir_call(uint32_t xid, struct nfs3_fh *fh, count3 dircount,
+                      count3 maxcount)
 {
-        char    fhstr[1024];
+    char fhstr[1024];
 
-        if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
-                return;
+    if (THIS->ctx->log.loglevel < GF_LOG_DEBUG)
+        return;
 
-        nfs3_fh_to_str (fh, fhstr, sizeof (fhstr));
+    nfs3_fh_to_str(fh, fhstr, sizeof(fhstr));
 
-        if (maxcount == 0)
-                gf_msg_debug (GF_NFS3, 0, "XID: %x, READDIR: args: %s,"
-                                " count: %d", xid, fhstr, (uint32_t)dircount);
-        else
-                gf_msg_debug (GF_NFS3, 0, "XID: %x, READDIRPLUS: args: %s,"
-                                " dircount: %d, maxcount: %d", xid, fhstr,
-                                (uint32_t)dircount, (uint32_t)maxcount);
+    if (maxcount == 0)
+        gf_msg_debug(GF_NFS3, 0,
+                     "XID: %x, READDIR: args: %s,"
+                     " count: %d",
+                     xid, fhstr, (uint32_t)dircount);
+    else
+        gf_msg_debug(GF_NFS3, 0,
+                     "XID: %x, READDIRPLUS: args: %s,"
+                     " dircount: %d, maxcount: %d",
+                     xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount);
 }
 
 int
-nfs3_fh_resolve_inode_done (nfs3_call_state_t *cs, inode_t *inode)
+nfs3_fh_resolve_inode_done(nfs3_call_state_t *cs, inode_t *inode)
 {
-        int             ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!cs) || (!inode))
-                return ret;
+    if ((!cs) || (!inode))
+        return ret;
 
-        gf_msg_trace (GF_NFS3, 0, "FH inode resolved");
-        ret = nfs_inode_loc_fill (inode, &cs->resolvedloc, NFS_RESOLVE_EXIST);
-        if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                                NFS_MSG_INODE_LOC_FILL_ERROR,
-                                "inode loc fill failed");
-                goto err;
-        }
+    gf_msg_trace(GF_NFS3, 0, "FH inode resolved");
+    ret = nfs_inode_loc_fill(inode, &cs->resolvedloc, NFS_RESOLVE_EXIST);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR,
+               "inode loc fill failed");
+        goto err;
+    }
 
-        nfs3_call_resume (cs);
+    nfs3_call_resume(cs);
 
 err:
-        return ret;
+    return ret;
 }
 
 int32_t
-nfs3_fh_resolve_entry_lookup_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)
-{
-        nfs3_call_state_t       *cs = NULL;
-        inode_t                 *linked_inode = NULL;
-
-        cs = frame->local;
-        cs->resolve_ret = op_ret;
-        cs->resolve_errno = op_errno;
-
-        if (op_ret == -1) {
-                if (op_errno == ENOENT) {
-                        gf_msg_trace (GF_NFS3, 0, "Lookup failed: %s: %s",
-                                        cs->resolvedloc.path,
-                                        strerror (op_errno));
-                } else {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno,
-                                        NFS_MSG_LOOKUP_FAIL, "Lookup failed: %s: %s",
-                                        cs->resolvedloc.path, strerror (op_errno));
-                }
-                goto err;
-        } else
-                gf_msg_trace (GF_NFS3, 0, "Entry looked up: %s",
-                                cs->resolvedloc.path);
-
-       memcpy (&cs->stbuf, buf, sizeof (*buf));
-       memcpy (&cs->postparent, postparent, sizeof (*postparent));
-        linked_inode = inode_link (inode, cs->resolvedloc.parent,
-                        cs->resolvedloc.name, buf);
-        if (linked_inode) {
-                nfs_fix_generation (this, linked_inode);
-                inode_lookup (linked_inode);
-                inode_unref (cs->resolvedloc.inode);
-                cs->resolvedloc.inode = linked_inode;
+nfs3_fh_resolve_entry_lookup_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)
+{
+    nfs3_call_state_t *cs = NULL;
+    inode_t *linked_inode = NULL;
+
+    cs = frame->local;
+    cs->resolve_ret = op_ret;
+    cs->resolve_errno = op_errno;
+
+    if (op_ret == -1) {
+        if (op_errno == ENOENT) {
+            gf_msg_trace(GF_NFS3, 0, "Lookup failed: %s: %s",
+                         cs->resolvedloc.path, strerror(op_errno));
+        } else {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_FAIL,
+                   "Lookup failed: %s: %s", cs->resolvedloc.path,
+                   strerror(op_errno));
         }
+        goto err;
+    } else
+        gf_msg_trace(GF_NFS3, 0, "Entry looked up: %s", cs->resolvedloc.path);
+
+    memcpy(&cs->stbuf, buf, sizeof(*buf));
+    memcpy(&cs->postparent, postparent, sizeof(*postparent));
+    linked_inode = inode_link(inode, cs->resolvedloc.parent,
+                              cs->resolvedloc.name, buf);
+    if (linked_inode) {
+        nfs_fix_generation(this, linked_inode);
+        inode_lookup(linked_inode);
+        inode_unref(cs->resolvedloc.inode);
+        cs->resolvedloc.inode = linked_inode;
+    }
 err:
-        nfs3_call_resume (cs);
-        return 0;
+    nfs3_call_resume(cs);
+    return 0;
 }
 
 int32_t
-nfs3_fh_resolve_inode_lookup_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)
-{
-        nfs3_call_state_t       *cs = NULL;
-        inode_t                 *linked_inode = NULL;
-
-        cs = frame->local;
-        cs->resolve_ret = op_ret;
-        cs->resolve_errno = op_errno;
-
-        if (op_ret == -1) {
-                if (op_errno == ENOENT) {
-                        gf_msg_trace (GF_NFS3, 0, "Lookup failed: %s: %s",
-                                        cs->resolvedloc.path,
-                                        strerror (op_errno));
-                } else {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno,
-                                        NFS_MSG_LOOKUP_FAIL, "Lookup failed: %s: %s",
-                                        cs->resolvedloc.path, strerror (op_errno));
-                }
-                nfs3_call_resume (cs);
-                goto err;
-        }
+nfs3_fh_resolve_inode_lookup_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)
+{
+    nfs3_call_state_t *cs = NULL;
+    inode_t *linked_inode = NULL;
 
-        memcpy (&cs->stbuf, buf, sizeof(*buf));
-        memcpy (&cs->postparent, buf, sizeof(*postparent));
-        linked_inode = inode_link (inode, cs->resolvedloc.parent,
-                                   cs->resolvedloc.name, buf);
-        if (linked_inode) {
-                nfs_fix_generation (this, linked_inode);
-                inode_lookup (linked_inode);
-		inode_unref (cs->resolvedloc.inode);
-		cs->resolvedloc.inode = linked_inode;
-        }
+    cs = frame->local;
+    cs->resolve_ret = op_ret;
+    cs->resolve_errno = op_errno;
 
-        /* If it is an entry lookup and we landed in the callback for hard
-         * inode resolution, it means the parent inode was not available and
-         * had to be resolved first. Now that is done, lets head back into
-         * entry resolution.
-         */
-        if (cs->resolventry)
-                nfs3_fh_resolve_entry_hard (cs);
-	else
-		nfs3_call_resume (cs);
+    if (op_ret == -1) {
+        if (op_errno == ENOENT) {
+            gf_msg_trace(GF_NFS3, 0, "Lookup failed: %s: %s",
+                         cs->resolvedloc.path, strerror(op_errno));
+        } else {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_FAIL,
+                   "Lookup failed: %s: %s", cs->resolvedloc.path,
+                   strerror(op_errno));
+        }
+        nfs3_call_resume(cs);
+        goto err;
+    }
+
+    memcpy(&cs->stbuf, buf, sizeof(*buf));
+    memcpy(&cs->postparent, buf, sizeof(*postparent));
+    linked_inode = inode_link(inode, cs->resolvedloc.parent,
+                              cs->resolvedloc.name, buf);
+    if (linked_inode) {
+        nfs_fix_generation(this, linked_inode);
+        inode_lookup(linked_inode);
+        inode_unref(cs->resolvedloc.inode);
+        cs->resolvedloc.inode = linked_inode;
+    }
+
+    /* If it is an entry lookup and we landed in the callback for hard
+     * inode resolution, it means the parent inode was not available and
+     * had to be resolved first. Now that is done, lets head back into
+     * entry resolution.
+     */
+    if (cs->resolventry)
+        nfs3_fh_resolve_entry_hard(cs);
+    else
+        nfs3_call_resume(cs);
 err:
-        return 0;
+    return 0;
 }
 
-
 /* Needs no extra argument since it knows that the fh to be resolved is in
  * resolvefh and that it needs to start looking from the root.
  */
 int
-nfs3_fh_resolve_inode_hard (nfs3_call_state_t *cs)
-{
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-
-        if (!cs)
-                return ret;
-
-        gf_msg_trace (GF_NFS3, 0, "FH hard resolution for: gfid 0x%s",
-                      uuid_utoa (cs->resolvefh.gfid));
-	cs->hardresolved = 1;
-        nfs_loc_wipe (&cs->resolvedloc);
-        ret = nfs_gfid_loc_fill (cs->vol->itable, cs->resolvefh.gfid,
-                                 &cs->resolvedloc, NFS_RESOLVE_CREATE);
-        if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_INODE_LOC_FILL_ERROR,
-                        "Failed to fill loc using gfid: "
-                        "%s", strerror (-ret));
-                goto out;
-        }
+nfs3_fh_resolve_inode_hard(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        nfs_user_root_create (&nfu);
-        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          nfs3_fh_resolve_inode_lookup_cbk, cs);
+    if (!cs)
+        return ret;
+
+    gf_msg_trace(GF_NFS3, 0, "FH hard resolution for: gfid 0x%s",
+                 uuid_utoa(cs->resolvefh.gfid));
+    cs->hardresolved = 1;
+    nfs_loc_wipe(&cs->resolvedloc);
+    ret = nfs_gfid_loc_fill(cs->vol->itable, cs->resolvefh.gfid,
+                            &cs->resolvedloc, NFS_RESOLVE_CREATE);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR,
+               "Failed to fill loc using gfid: "
+               "%s",
+               strerror(-ret));
+        goto out;
+    }
+
+    nfs_user_root_create(&nfu);
+    ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                     nfs3_fh_resolve_inode_lookup_cbk, cs);
 
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_fh_resolve_entry_hard (nfs3_call_state_t *cs)
-{
-        int                     ret             = -EFAULT;
-        nfs_user_t              nfu             = {0, };
-        gf_boolean_t            freshlookup     = _gf_false;
-
-        if (!cs)
-                return ret;
-
-        nfs_loc_wipe (&cs->resolvedloc);
-        nfs_user_root_create (&nfu);
-        gf_msg_trace (GF_NFS3, 0, "FH hard resolution: gfid: %s "
-                      ", entry: %s", uuid_utoa (cs->resolvefh.gfid),
-                      cs->resolventry);
-
-        ret = nfs_entry_loc_fill (cs->nfsx, cs->vol->itable, cs->resolvefh.gfid,
-                                  cs->resolventry, &cs->resolvedloc,
-                                  NFS_RESOLVE_CREATE, &freshlookup);
-
-        if (ret == -2) {
-                gf_msg_trace (GF_NFS3, 0, "Entry needs lookup: %s",
-                              cs->resolvedloc.path);
-		/* If the NFS op is lookup, let the resume callback
-		 * handle the sending of the lookup fop. Similarly,
-		 * if the NFS op is create, let the create call
-		 * go ahead in the resume callback so that an EEXIST gets
-		 * handled at posix without an extra fop at this point.
-		 */
-                if (freshlookup && (nfs3_lookup_op (cs) ||
-		    (nfs3_create_op (cs) && !nfs3_create_exclusive_op (cs)))) {
-                        cs->lookuptype = GF_NFS3_FRESH;
-                        cs->resolve_ret = 0;
-                        cs->hardresolved = 0;
-                        nfs3_call_resume (cs);
-                } else {
-			cs->hardresolved = 1;
-                        nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                    nfs3_fh_resolve_entry_lookup_cbk, cs);
-		}
-                ret = 0;
-        } else if (ret == -1) {
-                gf_msg_trace (GF_NFS3, 0, "Entry needs parent lookup: %s",
-                              cs->resolvedloc.path);
-                ret = nfs3_fh_resolve_inode_hard (cs);
-        } else if (ret == 0) {
-                cs->resolve_ret = 0;
-                nfs3_call_resume (cs);
-        }
+nfs3_fh_resolve_entry_hard(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    gf_boolean_t freshlookup = _gf_false;
 
+    if (!cs)
         return ret;
+
+    nfs_loc_wipe(&cs->resolvedloc);
+    nfs_user_root_create(&nfu);
+    gf_msg_trace(GF_NFS3, 0,
+                 "FH hard resolution: gfid: %s "
+                 ", entry: %s",
+                 uuid_utoa(cs->resolvefh.gfid), cs->resolventry);
+
+    ret = nfs_entry_loc_fill(cs->nfsx, cs->vol->itable, cs->resolvefh.gfid,
+                             cs->resolventry, &cs->resolvedloc,
+                             NFS_RESOLVE_CREATE, &freshlookup);
+
+    if (ret == -2) {
+        gf_msg_trace(GF_NFS3, 0, "Entry needs lookup: %s",
+                     cs->resolvedloc.path);
+        /* If the NFS op is lookup, let the resume callback
+         * handle the sending of the lookup fop. Similarly,
+         * if the NFS op is create, let the create call
+         * go ahead in the resume callback so that an EEXIST gets
+         * handled at posix without an extra fop at this point.
+         */
+        if (freshlookup &&
+            (nfs3_lookup_op(cs) ||
+             (nfs3_create_op(cs) && !nfs3_create_exclusive_op(cs)))) {
+            cs->lookuptype = GF_NFS3_FRESH;
+            cs->resolve_ret = 0;
+            cs->hardresolved = 0;
+            nfs3_call_resume(cs);
+        } else {
+            cs->hardresolved = 1;
+            nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                       nfs3_fh_resolve_entry_lookup_cbk, cs);
+        }
+        ret = 0;
+    } else if (ret == -1) {
+        gf_msg_trace(GF_NFS3, 0, "Entry needs parent lookup: %s",
+                     cs->resolvedloc.path);
+        ret = nfs3_fh_resolve_inode_hard(cs);
+    } else if (ret == 0) {
+        cs->resolve_ret = 0;
+        nfs3_call_resume(cs);
+    }
+
+    return ret;
 }
 
 int
-nfs3_fh_resolve_inode (nfs3_call_state_t *cs)
+nfs3_fh_resolve_inode(nfs3_call_state_t *cs)
 {
-        inode_t         *inode = NULL;
-        int             ret = -EFAULT;
-        xlator_t        *this = NULL;
+    inode_t *inode = NULL;
+    int ret = -EFAULT;
+    xlator_t *this = NULL;
 
-        if (!cs)
-                return ret;
+    if (!cs)
+        return ret;
 
-        this = cs->nfsx;
-        gf_msg_trace (GF_NFS3, 0, "FH needs inode resolution");
-        gf_uuid_copy (cs->resolvedloc.gfid, cs->resolvefh.gfid);
+    this = cs->nfsx;
+    gf_msg_trace(GF_NFS3, 0, "FH needs inode resolution");
+    gf_uuid_copy(cs->resolvedloc.gfid, cs->resolvefh.gfid);
 
-        inode = inode_find (cs->vol->itable, cs->resolvefh.gfid);
-        if (!inode || inode_ctx_get (inode, this, NULL))
-                ret = nfs3_fh_resolve_inode_hard (cs);
-        else
-                ret = nfs3_fh_resolve_inode_done (cs, inode);
+    inode = inode_find(cs->vol->itable, cs->resolvefh.gfid);
+    if (!inode || inode_ctx_get(inode, this, NULL))
+        ret = nfs3_fh_resolve_inode_hard(cs);
+    else
+        ret = nfs3_fh_resolve_inode_done(cs, inode);
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        return ret;
+    return ret;
 }
 
 int
-nfs3_fh_resolve_entry (nfs3_call_state_t *cs)
+nfs3_fh_resolve_entry(nfs3_call_state_t *cs)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if (!cs)
-                return ret;
+    if (!cs)
+        return ret;
 
-        return nfs3_fh_resolve_entry_hard (cs);
+    return nfs3_fh_resolve_entry_hard(cs);
 }
 
-
 int
-nfs3_fh_resolve_resume (nfs3_call_state_t *cs)
+nfs3_fh_resolve_resume(nfs3_call_state_t *cs)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if (!cs)
-                return ret;
+    if (!cs)
+        return ret;
 
-        if (cs->resolve_ret < 0)
-                goto err_resume_call;
+    if (cs->resolve_ret < 0)
+        goto err_resume_call;
 
-        if (!cs->resolventry)
-                ret = nfs3_fh_resolve_inode (cs);
-        else
-                ret = nfs3_fh_resolve_entry (cs);
+    if (!cs->resolventry)
+        ret = nfs3_fh_resolve_inode(cs);
+    else
+        ret = nfs3_fh_resolve_entry(cs);
 
 err_resume_call:
-        if (ret < 0) {
-                cs->resolve_ret = -1;
-                cs->resolve_errno = EFAULT;
-                nfs3_call_resume (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        cs->resolve_ret = -1;
+        cs->resolve_errno = EFAULT;
+        nfs3_call_resume(cs);
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int32_t
-nfs3_fh_resolve_root_lookup_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)
-{
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        cs->resolve_ret = op_ret;
-        cs->resolve_errno = op_errno;
-
-        if (op_ret == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, op_errno,
-                        NFS_MSG_LOOKUP_ROOT_FAIL, "Root lookup failed: %s",
-                        strerror (op_errno));
-                goto err;
-        } else
-                gf_msg_trace (GF_NFS3, 0, "Root looked up: %s",
-                              cs->resolvedloc.path);
-
-        nfs3_set_root_looked_up (cs->nfs3state, &cs->resolvefh);
+nfs3_fh_resolve_root_lookup_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)
+{
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    cs->resolve_ret = op_ret;
+    cs->resolve_errno = op_errno;
+
+    if (op_ret == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, op_errno, NFS_MSG_LOOKUP_ROOT_FAIL,
+               "Root lookup failed: %s", strerror(op_errno));
+        goto err;
+    } else
+        gf_msg_trace(GF_NFS3, 0, "Root looked up: %s", cs->resolvedloc.path);
+
+    nfs3_set_root_looked_up(cs->nfs3state, &cs->resolvefh);
 err:
-        nfs3_fh_resolve_resume (cs);
-        return 0;
+    nfs3_fh_resolve_resume(cs);
+    return 0;
 }
 
-
 int
-nfs3_fh_resolve_root (nfs3_call_state_t *cs)
+nfs3_fh_resolve_root(nfs3_call_state_t *cs)
 {
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!cs)
-                return ret;
+    if (!cs)
+        return ret;
 
-        if (nfs3_is_root_looked_up (cs->nfs3state, &cs->resolvefh)) {
-                ret = nfs3_fh_resolve_resume (cs);
-                goto out;
-        }
+    if (nfs3_is_root_looked_up(cs->nfs3state, &cs->resolvefh)) {
+        ret = nfs3_fh_resolve_resume(cs);
+        goto out;
+    }
 
-        nfs_user_root_create (&nfu);
-        gf_msg_trace (GF_NFS3, 0, "Root needs lookup");
-        ret = nfs_root_loc_fill (cs->vol->itable, &cs->resolvedloc);
-	if (ret < 0) {
-		gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_ROOT_FAIL,
-                        "Failed to lookup root from itable: %s",
-                        strerror (-ret));
-		goto out;
-	}
+    nfs_user_root_create(&nfu);
+    gf_msg_trace(GF_NFS3, 0, "Root needs lookup");
+    ret = nfs_root_loc_fill(cs->vol->itable, &cs->resolvedloc);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_ROOT_FAIL,
+               "Failed to lookup root from itable: %s", strerror(-ret));
+        goto out;
+    }
 
-        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          nfs3_fh_resolve_root_lookup_cbk, cs);
+    ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                     nfs3_fh_resolve_root_lookup_cbk, cs);
 
 out:
-        return ret;
+    return ret;
 }
 
 /**
@@ -3944,25 +3835,27 @@ out:
  * @req : The request to get host/peer from
  */
 int
-__nfs3_fh_auth_get_peer (const rpcsvc_request_t *req, char *peer)
-{
-        struct sockaddr_storage sastorage       = {0, };
-        rpc_transport_t         *trans          = NULL;
-        int                     ret             = 0;
-
-        /* Why do we pass in the peer here and then
-         * store it rather than malloc() and return a char * ? We want to avoid
-         * heap allocations in the IO path as much as possible for speed
-         * so we try to keep all allocations on the stack.
-         */
-        trans = rpcsvc_request_transport (req);
-        ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN,
-                                         &sastorage, sizeof (sastorage));
-        if (ret != 0) {
-                gf_msg (GF_NFS3, GF_LOG_WARNING, 0, NFS_MSG_GET_PEER_ADDR_FAIL,
-                        "Failed to get peer addr: %s", gai_strerror (ret));
-        }
-        return ret;
+__nfs3_fh_auth_get_peer(const rpcsvc_request_t *req, char *peer)
+{
+    struct sockaddr_storage sastorage = {
+        0,
+    };
+    rpc_transport_t *trans = NULL;
+    int ret = 0;
+
+    /* Why do we pass in the peer here and then
+     * store it rather than malloc() and return a char * ? We want to avoid
+     * heap allocations in the IO path as much as possible for speed
+     * so we try to keep all allocations on the stack.
+     */
+    trans = rpcsvc_request_transport(req);
+    ret = rpcsvc_transport_peeraddr(trans, peer, RPCSVC_PEER_STRLEN, &sastorage,
+                                    sizeof(sastorage));
+    if (ret != 0) {
+        gf_msg(GF_NFS3, GF_LOG_WARNING, 0, NFS_MSG_GET_PEER_ADDR_FAIL,
+               "Failed to get peer addr: %s", gai_strerror(ret));
+    }
+    return ret;
 }
 
 /*
@@ -3975,44 +3868,44 @@ __nfs3_fh_auth_get_peer (const rpcsvc_request_t *req, char *peer)
  *          -EROFS  for unauthorized write operations (rm, mkdir, write)
  */
 int
-nfs3_fh_auth_nfsop (nfs3_call_state_t *cs, gf_boolean_t is_write_op)
+nfs3_fh_auth_nfsop(nfs3_call_state_t *cs, gf_boolean_t is_write_op)
 {
-        struct nfs_state    *nfs = NULL;
-        struct mount3_state *ms  = NULL;
+    struct nfs_state *nfs = NULL;
+    struct mount3_state *ms = NULL;
 
-        nfs = (struct nfs_state *)cs->nfsx->private;
-        ms  = (struct mount3_state *)nfs->mstate;
-        return  mnt3_authenticate_request (ms, cs->req, &cs->resolvefh, NULL,
-                                           NULL, NULL, NULL, is_write_op);
+    nfs = (struct nfs_state *)cs->nfsx->private;
+    ms = (struct mount3_state *)nfs->mstate;
+    return mnt3_authenticate_request(ms, cs->req, &cs->resolvefh, NULL, NULL,
+                                     NULL, NULL, is_write_op);
 }
 
 int
-nfs3_fh_resolve_and_resume (nfs3_call_state_t *cs, struct nfs3_fh *fh,
-                            char *entry, nfs3_resume_fn_t resum_fn)
+nfs3_fh_resolve_and_resume(nfs3_call_state_t *cs, struct nfs3_fh *fh,
+                           char *entry, nfs3_resume_fn_t resum_fn)
 {
-        int     ret = -EFAULT;
+    int ret = -EFAULT;
 
-        if ((!cs) || (!fh))
-                return ret;
-
-        cs->resume_fn = resum_fn;
-        cs->resolvefh = *fh;
-        cs->hashidx = 0;
+    if ((!cs) || (!fh))
+        return ret;
 
-        /* Check if the resolution is:
-         * a. fh resolution
-         *
-         * or
-         *
-         * b. (fh, basename) resolution
-         */
-        if (entry) {    /* b */
-                cs->resolventry = gf_strdup (entry);
-                if (!cs->resolventry)
-                        goto err;
-        }
+    cs->resume_fn = resum_fn;
+    cs->resolvefh = *fh;
+    cs->hashidx = 0;
+
+    /* Check if the resolution is:
+     * a. fh resolution
+     *
+     * or
+     *
+     * b. (fh, basename) resolution
+     */
+    if (entry) { /* b */
+        cs->resolventry = gf_strdup(entry);
+        if (!cs->resolventry)
+            goto err;
+    }
 
-        ret = nfs3_fh_resolve_root (cs);
+    ret = nfs3_fh_resolve_root(cs);
 err:
-        return ret;
+    return ret;
 }
diff --git a/xlators/nfs/server/src/nfs3.c b/xlators/nfs/server/src/nfs3.c
index e9a52ba9392..42799bdfd38 100644
--- a/xlators/nfs/server/src/nfs3.c
+++ b/xlators/nfs/server/src/nfs3.c
@@ -35,391 +35,370 @@
 #include <sys/statvfs.h>
 #include <time.h>
 
-#define nfs3_validate_strlen_or_goto(str, len, label, status, retval)   \
-        do      {                                                       \
-                if ((str)) {                                            \
-                        if (strlen ((str)) > (len)) {                   \
-                                gf_msg (GF_NFS3, GF_LOG_ERROR,          \
-                                        ENAMETOOLONG,                   \
-                                        NFS_MSG_STR_TOO_LONG,           \
-                                        "strlen too long");             \
-                                status = NFS3ERR_NAMETOOLONG;           \
-                                retval = -ENAMETOOLONG;                 \
-                                goto label;                             \
-                        }                                               \
-                }                                                       \
-        } while (0);                                                    \
-
-#define nfs3_validate_nfs3_state(request, state, status, label, retval) \
-        do      {                                                       \
-                state = rpcsvc_request_program_private (request);       \
-                if (!state) {                                           \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, EFAULT,          \
-                                NFS_MSG_STATE_MISSING, "NFSv3 state "   \
-                                "missing from RPC request");            \
-                        status = NFS3ERR_SERVERFAULT;                   \
-                        ret = -EFAULT;                                  \
-                        goto label;                                     \
-                }                                                       \
-        } while (0);                                                    \
-
+#define nfs3_validate_strlen_or_goto(str, len, label, status, retval)          \
+    do {                                                                       \
+        if ((str)) {                                                           \
+            if (strlen((str)) > (len)) {                                       \
+                gf_msg(GF_NFS3, GF_LOG_ERROR, ENAMETOOLONG,                    \
+                       NFS_MSG_STR_TOO_LONG, "strlen too long");               \
+                status = NFS3ERR_NAMETOOLONG;                                  \
+                retval = -ENAMETOOLONG;                                        \
+                goto label;                                                    \
+            }                                                                  \
+        }                                                                      \
+    } while (0);
+
+#define nfs3_validate_nfs3_state(request, state, status, label, retval)        \
+    do {                                                                       \
+        state = rpcsvc_request_program_private(request);                       \
+        if (!state) {                                                          \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, EFAULT, NFS_MSG_STATE_MISSING,       \
+                   "NFSv3 state "                                              \
+                   "missing from RPC request");                                \
+            status = NFS3ERR_SERVERFAULT;                                      \
+            ret = -EFAULT;                                                     \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0);
 
 struct nfs3_export *
-__nfs3_get_export_by_index (struct nfs3_state *nfs3, uuid_t exportid)
+__nfs3_get_export_by_index(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        struct nfs3_export      *exp = NULL;
-        int                     index = 0;
-        int                     searchindex = 0;
+    struct nfs3_export *exp = NULL;
+    int index = 0;
+    int searchindex = 0;
 
-        searchindex = nfs3_fh_exportid_to_index (exportid);
-        list_for_each_entry (exp, &nfs3->exports, explist) {
-                if (searchindex == index)
-                        goto found;
+    searchindex = nfs3_fh_exportid_to_index(exportid);
+    list_for_each_entry(exp, &nfs3->exports, explist)
+    {
+        if (searchindex == index)
+            goto found;
 
-                ++index;
-        }
+        ++index;
+    }
 
-        exp = NULL;
-        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INDEX_NOT_FOUND,
-                "searchindex=%d not found", searchindex);
+    exp = NULL;
+    gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INDEX_NOT_FOUND,
+           "searchindex=%d not found", searchindex);
 found:
-        return exp;
+    return exp;
 }
 
-
 struct nfs3_export *
-__nfs3_get_export_by_volumeid (struct nfs3_state *nfs3, uuid_t exportid)
+__nfs3_get_export_by_volumeid(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        struct nfs3_export      *exp = NULL;
+    struct nfs3_export *exp = NULL;
 
-        list_for_each_entry (exp, &nfs3->exports, explist) {
-                if (!gf_uuid_compare (exportid, exp->volumeid))
-                        goto found;
-        }
+    list_for_each_entry(exp, &nfs3->exports, explist)
+    {
+        if (!gf_uuid_compare(exportid, exp->volumeid))
+            goto found;
+    }
 
-        exp = NULL;
+    exp = NULL;
 found:
-        return exp;
+    return exp;
 }
 
-
 struct nfs3_export *
-__nfs3_get_export_by_exportid (struct nfs3_state *nfs3, uuid_t exportid)
+__nfs3_get_export_by_exportid(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        struct nfs3_export      *exp = NULL;
+    struct nfs3_export *exp = NULL;
 
-        if (!nfs3)
-                return exp;
+    if (!nfs3)
+        return exp;
 
-        if (gf_nfs_dvm_off (nfs_state(nfs3->nfsx)))
-                exp = __nfs3_get_export_by_index (nfs3, exportid);
-        else
-                exp = __nfs3_get_export_by_volumeid (nfs3, exportid);
+    if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx)))
+        exp = __nfs3_get_export_by_index(nfs3, exportid);
+    else
+        exp = __nfs3_get_export_by_volumeid(nfs3, exportid);
 
-        return exp;
+    return exp;
 }
 
-
 int
-nfs3_export_access (struct nfs3_state *nfs3, uuid_t exportid)
+nfs3_export_access(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        int                     ret = GF_NFS3_VOLACCESS_RO;
-        struct nfs3_export      *exp = NULL;
+    int ret = GF_NFS3_VOLACCESS_RO;
+    struct nfs3_export *exp = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, exportid);
+    exp = __nfs3_get_export_by_exportid(nfs3, exportid);
 
-        if (!exp) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_EXPORT_ID_FAIL,
-                        "Failed to get export by ID");
-                goto err;
-        }
+    if (!exp) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_EXPORT_ID_FAIL,
+               "Failed to get export by ID");
+        goto err;
+    }
 
-        ret = exp->access;
+    ret = exp->access;
 
 err:
-        return ret;
+    return ret;
 }
 
-#define nfs3_check_rw_volaccess(nfs3state, exid, status, label)         \
-        do {                                                            \
-                if (nfs3_export_access (nfs3state,exid)!=GF_NFS3_VOLACCESS_RW){\
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, EACCES,          \
-                                NFS_MSG_NO_RW_ACCESS,                   \
-                                "No read-write access");                \
-                        status = NFS3ERR_ROFS;                          \
-                        goto label;                                     \
-                }                                                       \
-        } while (0)                                                     \
-
-
+#define nfs3_check_rw_volaccess(nfs3state, exid, status, label)                \
+    do {                                                                       \
+        if (nfs3_export_access(nfs3state, exid) != GF_NFS3_VOLACCESS_RW) {     \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, EACCES, NFS_MSG_NO_RW_ACCESS,        \
+                   "No read-write access");                                    \
+            status = NFS3ERR_ROFS;                                             \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 xlator_t *
-nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh)
+nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh)
 {
-        xlator_t                *vol = NULL;
-        struct nfs3_export      *exp = NULL;
+    xlator_t *vol = NULL;
+    struct nfs3_export *exp = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, fh->exportid);
-        if (!exp)
-                goto out;
+    exp = __nfs3_get_export_by_exportid(nfs3, fh->exportid);
+    if (!exp)
+        goto out;
 
-        vol = exp->subvol;
+    vol = exp->subvol;
 out:
-        return vol;
+    return vol;
 }
 
-
 int
-nfs3_is_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh)
+nfs3_is_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh)
 {
-        struct nfs3_export      *exp = NULL;
-        int                     ret = 0;
+    struct nfs3_export *exp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, rootfh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, rootfh, out);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, rootfh->exportid);
-        if (!exp)
-                goto out;
+    exp = __nfs3_get_export_by_exportid(nfs3, rootfh->exportid);
+    if (!exp)
+        goto out;
 
-        ret = exp->rootlookedup;
+    ret = exp->rootlookedup;
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_set_root_looked_up (struct nfs3_state *nfs3, struct nfs3_fh *rootfh)
+nfs3_set_root_looked_up(struct nfs3_state *nfs3, struct nfs3_fh *rootfh)
 {
-        struct nfs3_export      *exp = NULL;
-        int                     ret = 0;
+    struct nfs3_export *exp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, rootfh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, rootfh, out);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, rootfh->exportid);
-        if (!exp)
-                goto out;
+    exp = __nfs3_get_export_by_exportid(nfs3, rootfh->exportid);
+    if (!exp)
+        goto out;
 
-        exp->rootlookedup = 1;
+    exp->rootlookedup = 1;
 out:
-        return ret;
-}
-
-
-#define nfs3_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \
-        do {                                                            \
-                char exportid[256], gfid[256];                          \
-                rpc_transport_t *trans = NULL;                          \
-                volume = nfs3_fh_to_xlator ((nfs3state), handle);       \
-                if (!volume) {                                          \
-                        gf_uuid_unparse (handle->exportid, exportid);   \
-                        gf_uuid_unparse (handle->gfid, gfid);           \
-                        trans = rpcsvc_request_transport (req);         \
-                        GF_LOG_OCCASIONALLY (nfs3state->occ_logger,     \
-                                GF_NFS3, GF_LOG_ERROR, "Failed to map " \
-                                "FH to vol: client=%s, exportid=%s, "   \
-                                "gfid=%s", trans->peerinfo.identifier,  \
-                                exportid, gfid);                        \
-                        GF_LOG_OCCASIONALLY (nfs3state->occ_logger,     \
-                                GF_NFS3, GF_LOG_ERROR, "Stale nfs "     \
-                                "client %s must be trying to connect to"\
-                                " a deleted volume, please unmount it.",\
-                                trans->peerinfo.identifier);            \
-                        status = NFS3ERR_STALE;                         \
-                        goto label;                                     \
-                } else {                                                \
-                        gf_msg_trace (GF_NFS3, 0, "FH to Volume:"       \
-                                "%s", volume->name);                    \
-                        rpcsvc_request_set_private (req, volume);       \
-                }                                                       \
-        } while (0);                                                    \
-
-
-#define nfs3_validate_gluster_fh(handle, status, errlabel)              \
-        do {                                                            \
-                if (!nfs3_fh_validate (handle)) {                       \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_BAD_HANDLE,                     \
-                                "Bad Handle");                          \
-                        status = NFS3ERR_BADHANDLE;                     \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
-
-
-#define nfs3_check_fh_auth_status(cst, nfstat, is_write_op, erlabl)     \
-        do {                                                            \
-                int auth_ret = 0;                                       \
-                int auth_errno = 0;                                     \
-                xlator_t *xlatorp = NULL;                               \
-                char buf[256], gfid[GF_UUID_BUF_SIZE];                  \
-                rpc_transport_t *trans = NULL;                          \
-                                                                        \
-                auth_ret = auth_errno =                                 \
-                        nfs3_fh_auth_nfsop (cst, is_write_op);          \
-                if (auth_ret < 0) {                                     \
-                        trans = rpcsvc_request_transport (cst->req);    \
-                        xlatorp = nfs3_fh_to_xlator (cst->nfs3state,    \
-                                                     &cst->resolvefh);  \
-                        gf_uuid_unparse (cst->resolvefh.gfid, gfid);    \
-                        sprintf (buf, "(%s) %s : %s",                   \
-                                 trans->peerinfo.identifier,            \
-                        xlatorp ? xlatorp->name : "ERR", gfid);         \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_RESOLVE_FH_FAIL, "Unable to "   \
-                                        "resolve FH: %s", buf);         \
-                        nfstat = nfs3_errno_to_nfsstat3 (-auth_errno);  \
-                        goto erlabl;                                    \
-                }                                                       \
-        } while (0)                                                     \
-
-#define nfs3_check_fh_resolve_status(cst, nfstat, erlabl)               \
-        do {                                                            \
-                xlator_t *xlatorp = NULL;                               \
-                char buf[256], gfid[GF_UUID_BUF_SIZE];                  \
-                rpc_transport_t *trans = NULL;                          \
-                if ((cst)->resolve_ret < 0) {                           \
-                        trans = rpcsvc_request_transport (cst->req);    \
-                        xlatorp = nfs3_fh_to_xlator (cst->nfs3state,    \
-                                                     &cst->resolvefh);  \
-                        gf_uuid_unparse (cst->resolvefh.gfid, gfid);    \
-                        snprintf (buf, sizeof (buf), "(%s) %s : %s",    \
-                                  trans->peerinfo.identifier,           \
-                                  xlatorp ? xlatorp->name : "ERR",      \
-                                  gfid);                                \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_RESOLVE_STAT,                   \
-                                "%s: %s", strerror(cst->resolve_errno), \
-                                buf);                                   \
-                        nfstat = nfs3_errno_to_nfsstat3 (cst->resolve_errno);\
-                        goto erlabl;                                    \
-                }                                                       \
-        } while (0)                                                     \
-
-#define nfs3_check_new_fh_resolve_status(cst, nfstat, erlabl)           \
-        do {                                                            \
-                xlator_t *xlatorp = NULL;                               \
-                char buf[256], gfid[GF_UUID_BUF_SIZE];                  \
-                rpc_transport_t *trans = NULL;                          \
-                if (((cst)->resolve_ret < 0) &&                         \
-                    ((cst)->resolve_errno != ENOENT)) {                 \
-                        trans = rpcsvc_request_transport (cst->req);    \
-                        xlatorp = nfs3_fh_to_xlator (cst->nfs3state,    \
-                                                     &cst->resolvefh);  \
-                        gf_uuid_unparse (cst->resolvefh.gfid, gfid);    \
-                        snprintf (buf, sizeof (buf), "(%s) %s : %s",    \
-                                  trans->peerinfo.identifier,           \
-                                  xlatorp ? xlatorp->name : "ERR",      \
-                                  gfid);                                \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_RESOLVE_STAT, "%s: %s",         \
-                                strerror(cst->resolve_errno), buf);     \
-                        nfstat = nfs3_errno_to_nfsstat3 (cs->resolve_errno);\
-                        goto erlabl;                                    \
-                }                                                       \
-        } while (0)                                                     \
-
+    return ret;
+}
+
+#define nfs3_map_fh_to_volume(nfs3state, handle, req, volume, status, label)   \
+    do {                                                                       \
+        char exportid[256], gfid[256];                                         \
+        rpc_transport_t *trans = NULL;                                         \
+        volume = nfs3_fh_to_xlator((nfs3state), handle);                       \
+        if (!volume) {                                                         \
+            gf_uuid_unparse(handle->exportid, exportid);                       \
+            gf_uuid_unparse(handle->gfid, gfid);                               \
+            trans = rpcsvc_request_transport(req);                             \
+            GF_LOG_OCCASIONALLY(nfs3state->occ_logger, GF_NFS3, GF_LOG_ERROR,  \
+                                "Failed to map "                               \
+                                "FH to vol: client=%s, exportid=%s, "          \
+                                "gfid=%s",                                     \
+                                trans->peerinfo.identifier, exportid, gfid);   \
+            GF_LOG_OCCASIONALLY(nfs3state->occ_logger, GF_NFS3, GF_LOG_ERROR,  \
+                                "Stale nfs "                                   \
+                                "client %s must be trying to connect to"       \
+                                " a deleted volume, please unmount it.",       \
+                                trans->peerinfo.identifier);                   \
+            status = NFS3ERR_STALE;                                            \
+            goto label;                                                        \
+        } else {                                                               \
+            gf_msg_trace(GF_NFS3, 0,                                           \
+                         "FH to Volume:"                                       \
+                         "%s",                                                 \
+                         volume->name);                                        \
+            rpcsvc_request_set_private(req, volume);                           \
+        }                                                                      \
+    } while (0);
+
+#define nfs3_validate_gluster_fh(handle, status, errlabel)                     \
+    do {                                                                       \
+        if (!nfs3_fh_validate(handle)) {                                       \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_BAD_HANDLE,               \
+                   "Bad Handle");                                              \
+            status = NFS3ERR_BADHANDLE;                                        \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
+
+#define nfs3_check_fh_auth_status(cst, nfstat, is_write_op, erlabl)            \
+    do {                                                                       \
+        int auth_ret = 0;                                                      \
+        int auth_errno = 0;                                                    \
+        xlator_t *xlatorp = NULL;                                              \
+        char buf[256], gfid[GF_UUID_BUF_SIZE];                                 \
+        rpc_transport_t *trans = NULL;                                         \
+                                                                               \
+        auth_ret = auth_errno = nfs3_fh_auth_nfsop(cst, is_write_op);          \
+        if (auth_ret < 0) {                                                    \
+            trans = rpcsvc_request_transport(cst->req);                        \
+            xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh);      \
+            gf_uuid_unparse(cst->resolvefh.gfid, gfid);                        \
+            sprintf(buf, "(%s) %s : %s", trans->peerinfo.identifier,           \
+                    xlatorp ? xlatorp->name : "ERR", gfid);                    \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_FH_FAIL,          \
+                   "Unable to "                                                \
+                   "resolve FH: %s",                                           \
+                   buf);                                                       \
+            nfstat = nfs3_errno_to_nfsstat3(-auth_errno);                      \
+            goto erlabl;                                                       \
+        }                                                                      \
+    } while (0)
+
+#define nfs3_check_fh_resolve_status(cst, nfstat, erlabl)                      \
+    do {                                                                       \
+        xlator_t *xlatorp = NULL;                                              \
+        char buf[256], gfid[GF_UUID_BUF_SIZE];                                 \
+        rpc_transport_t *trans = NULL;                                         \
+        if ((cst)->resolve_ret < 0) {                                          \
+            trans = rpcsvc_request_transport(cst->req);                        \
+            xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh);      \
+            gf_uuid_unparse(cst->resolvefh.gfid, gfid);                        \
+            snprintf(buf, sizeof(buf), "(%s) %s : %s",                         \
+                     trans->peerinfo.identifier,                               \
+                     xlatorp ? xlatorp->name : "ERR", gfid);                   \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_STAT, "%s: %s",   \
+                   strerror(cst->resolve_errno), buf);                         \
+            nfstat = nfs3_errno_to_nfsstat3(cst->resolve_errno);               \
+            goto erlabl;                                                       \
+        }                                                                      \
+    } while (0)
+
+#define nfs3_check_new_fh_resolve_status(cst, nfstat, erlabl)                  \
+    do {                                                                       \
+        xlator_t *xlatorp = NULL;                                              \
+        char buf[256], gfid[GF_UUID_BUF_SIZE];                                 \
+        rpc_transport_t *trans = NULL;                                         \
+        if (((cst)->resolve_ret < 0) && ((cst)->resolve_errno != ENOENT)) {    \
+            trans = rpcsvc_request_transport(cst->req);                        \
+            xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh);      \
+            gf_uuid_unparse(cst->resolvefh.gfid, gfid);                        \
+            snprintf(buf, sizeof(buf), "(%s) %s : %s",                         \
+                     trans->peerinfo.identifier,                               \
+                     xlatorp ? xlatorp->name : "ERR", gfid);                   \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_STAT, "%s: %s",   \
+                   strerror(cst->resolve_errno), buf);                         \
+            nfstat = nfs3_errno_to_nfsstat3(cs->resolve_errno);                \
+            goto erlabl;                                                       \
+        }                                                                      \
+    } while (0)
 
 int
-__nfs3_get_volume_id (struct nfs3_state *nfs3, xlator_t *xl,
-                      uuid_t volumeid)
+__nfs3_get_volume_id(struct nfs3_state *nfs3, xlator_t *xl, uuid_t volumeid)
 {
-        int                     ret = -1;
-        struct nfs3_export      *exp = NULL;
+    int ret = -1;
+    struct nfs3_export *exp = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, xl, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, xl, out);
 
-        list_for_each_entry (exp, &nfs3->exports, explist) {
-                if (exp->subvol == xl) {
-                        gf_uuid_copy (volumeid, exp->volumeid);
-                        ret = 0;
-                        goto out;
-                }
+    list_for_each_entry(exp, &nfs3->exports, explist)
+    {
+        if (exp->subvol == xl) {
+            gf_uuid_copy(volumeid, exp->volumeid);
+            ret = 0;
+            goto out;
         }
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
-
 static int
-nfs3_funge_webnfs_zerolen_fh (rpcsvc_request_t *req, struct nfs3_state *nfs3st,
-                              struct nfs3_fh *fhd, char *name)
-{
-        xlator_t           *fungexl           = NULL;
-        struct nfs_state   *nfs               = NULL;
-        glfs_t             *fs                = NULL;
-        loc_t               loc               = { 0, };
-        int                 ret               = -1;
-        char               *subdir            = NULL;
-        char                volname[NAME_MAX] = { 0, };
-
-        fungexl = nfs_mntpath_to_xlator (nfs3st->exportslist, name);
-        if (!fungexl) {
-                gf_msg_trace (GF_NFS3, 0, "failed to find xlator for volume");
-                ret = -ENOENT;
-                goto out;
-        }
-        /* fungexl is valid, set for nfs3_request_xlator_deviceid() */
-        rpcsvc_request_set_private (req, fungexl);
-
-        /* Permission checks are done through mnt3_parse_dir_exports(). The
-         * "nfs.export-dir" option gets checked as well. */
-        nfs = nfs_state (nfs3st->nfsx);
-        ret = mnt3_parse_dir_exports (req, nfs->mstate, name, _gf_false);
-        if (ret) {
-                gf_msg_trace (GF_NFS3, -ret, "mounting not possible");
-                goto out;
-        }
-
-        /* glfs_resolve_at copied from UDP MNT support */
-        fs = glfs_new_from_ctx (fungexl->ctx);
-        if (!fs) {
-                gf_msg_trace (GF_NFS3, 0, "failed to create glfs instance");
-                ret = -ENOENT;
-                goto out;
-        }
-
-        /* split name "volname/sub/dir/s" into pieces */
-        subdir = mnt3_get_volume_subdir (name, (char**) &volname);
-
-        ret = glfs_resolve_at (fs, fungexl, NULL, subdir, &loc, NULL, 1, 0);
-        if (ret != 0) {
-                gf_msg_trace (GF_NFS3, 0, "failed to resolve %s", subdir);
-                ret = -ENOENT;
-                goto out;
-        }
-
-        /* resolved subdir, copy gfid for the fh */
-        gf_uuid_copy (fhd->gfid, loc.gfid);
-        loc_wipe (&loc);
-
-        if (gf_nfs_dvm_off (nfs_state (nfs3st->nfsx)))
-                fhd->exportid[15] = nfs_xlator_to_xlid (nfs3st->exportslist,
-                                                        fungexl);
-        else {
-                if (__nfs3_get_volume_id (nfs3st, fungexl, fhd->exportid) < 0) {
-                        ret = -ESTALE;
-                        goto out;
-                }
-        }
-
-        ret = 0;
+nfs3_funge_webnfs_zerolen_fh(rpcsvc_request_t *req, struct nfs3_state *nfs3st,
+                             struct nfs3_fh *fhd, char *name)
+{
+    xlator_t *fungexl = NULL;
+    struct nfs_state *nfs = NULL;
+    glfs_t *fs = NULL;
+    loc_t loc = {
+        0,
+    };
+    int ret = -1;
+    char *subdir = NULL;
+    char volname[NAME_MAX] = {
+        0,
+    };
+
+    fungexl = nfs_mntpath_to_xlator(nfs3st->exportslist, name);
+    if (!fungexl) {
+        gf_msg_trace(GF_NFS3, 0, "failed to find xlator for volume");
+        ret = -ENOENT;
+        goto out;
+    }
+    /* fungexl is valid, set for nfs3_request_xlator_deviceid() */
+    rpcsvc_request_set_private(req, fungexl);
+
+    /* Permission checks are done through mnt3_parse_dir_exports(). The
+     * "nfs.export-dir" option gets checked as well. */
+    nfs = nfs_state(nfs3st->nfsx);
+    ret = mnt3_parse_dir_exports(req, nfs->mstate, name, _gf_false);
+    if (ret) {
+        gf_msg_trace(GF_NFS3, -ret, "mounting not possible");
+        goto out;
+    }
+
+    /* glfs_resolve_at copied from UDP MNT support */
+    fs = glfs_new_from_ctx(fungexl->ctx);
+    if (!fs) {
+        gf_msg_trace(GF_NFS3, 0, "failed to create glfs instance");
+        ret = -ENOENT;
+        goto out;
+    }
+
+    /* split name "volname/sub/dir/s" into pieces */
+    subdir = mnt3_get_volume_subdir(name, (char **)&volname);
+
+    ret = glfs_resolve_at(fs, fungexl, NULL, subdir, &loc, NULL, 1, 0);
+    if (ret != 0) {
+        gf_msg_trace(GF_NFS3, 0, "failed to resolve %s", subdir);
+        ret = -ENOENT;
+        goto out;
+    }
+
+    /* resolved subdir, copy gfid for the fh */
+    gf_uuid_copy(fhd->gfid, loc.gfid);
+    loc_wipe(&loc);
+
+    if (gf_nfs_dvm_off(nfs_state(nfs3st->nfsx)))
+        fhd->exportid[15] = nfs_xlator_to_xlid(nfs3st->exportslist, fungexl);
+    else {
+        if (__nfs3_get_volume_id(nfs3st, fungexl, fhd->exportid) < 0) {
+            ret = -ESTALE;
+            goto out;
+        }
+    }
+
+    ret = 0;
 out:
-        if (fs)
-                glfs_free_from_ctx (fs);
+    if (fs)
+        glfs_free_from_ctx(fs);
 
-        return ret;
+    return ret;
 }
 
-
 /*
  * This macro checks if the volume is started or not.
  * If it is not started, it closes the client connection & logs it.
@@ -442,1802 +421,1758 @@ out:
  *
  */
 
-#define nfs3_volume_started_check(nf3stt, vlm, rtval, erlbl)            \
-        do {                                                            \
-              if ((!nfs_subvolume_started (nfs_state (nf3stt->nfsx), vlm))){\
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_VOL_DISABLE,                    \
-                                "Volume is disabled: %s",               \
-                                vlm->name);                             \
-                      nfs3_disconnect_transport (req->trans);           \
-                      rtval = RPCSVC_ACTOR_IGNORE;                      \
-                      goto erlbl;                                       \
-              }                                                         \
-        } while (0)                                                     \
+#define nfs3_volume_started_check(nf3stt, vlm, rtval, erlbl)                   \
+    do {                                                                       \
+        if ((!nfs_subvolume_started(nfs_state(nf3stt->nfsx), vlm))) {          \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE,              \
+                   "Volume is disabled: %s", vlm->name);                       \
+            nfs3_disconnect_transport(req->trans);                             \
+            rtval = RPCSVC_ACTOR_IGNORE;                                       \
+            goto erlbl;                                                        \
+        }                                                                      \
+    } while (0)
 
 void
-nfs3_disconnect_transport (rpc_transport_t *transport)
+nfs3_disconnect_transport(rpc_transport_t *transport)
 {
-        int ret = 0;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, transport, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, transport, out);
 
-        ret = rpc_transport_disconnect (transport, _gf_false);
-        if (ret != 0) {
-                gf_log (GF_NFS3, GF_LOG_WARNING,
-                        "Unable to close client connection to %s.",
-                        transport->peerinfo.identifier);
-        } else {
-                gf_log (GF_NFS3, GF_LOG_WARNING,
-                        "Closed client connection to %s.",
-                        transport->peerinfo.identifier);
-        }
+    ret = rpc_transport_disconnect(transport, _gf_false);
+    if (ret != 0) {
+        gf_log(GF_NFS3, GF_LOG_WARNING,
+               "Unable to close client connection to %s.",
+               transport->peerinfo.identifier);
+    } else {
+        gf_log(GF_NFS3, GF_LOG_WARNING, "Closed client connection to %s.",
+               transport->peerinfo.identifier);
+    }
 out:
-        return;
+    return;
 }
 
 int
-nfs3_export_sync_trusted (struct nfs3_state *nfs3, uuid_t exportid)
+nfs3_export_sync_trusted(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        struct nfs3_export      *exp = NULL;
-        int                     ret = 0;
+    struct nfs3_export *exp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, exportid);
-        if (!exp)
-                goto err;
+    exp = __nfs3_get_export_by_exportid(nfs3, exportid);
+    if (!exp)
+        goto err;
 
-        ret = exp->trusted_sync;
+    ret = exp->trusted_sync;
 err:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_export_write_trusted (struct nfs3_state *nfs3, uuid_t exportid)
+nfs3_export_write_trusted(struct nfs3_state *nfs3, uuid_t exportid)
 {
-        struct nfs3_export      *exp = NULL;
-        int                     ret = 0;
+    struct nfs3_export *exp = NULL;
+    int ret = 0;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, nfs3, err);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, nfs3, err);
 
-        exp = __nfs3_get_export_by_exportid (nfs3, exportid);
-        if (!exp)
-                goto err;
+    exp = __nfs3_get_export_by_exportid(nfs3, exportid);
+    if (!exp)
+        goto err;
 
-        ret = exp->trusted_write;
+    ret = exp->trusted_write;
 err:
-        return ret;
+    return ret;
 }
 
 int
-nfs3_solaris_zerolen_fh (struct nfs3_fh *fh, int fhlen)
+nfs3_solaris_zerolen_fh(struct nfs3_fh *fh, int fhlen)
 {
-        if (!fh)
-                return 0;
+    if (!fh)
+        return 0;
 
-        if (nfs3_fh_validate (fh))
-                return 0;
+    if (nfs3_fh_validate(fh))
+        return 0;
 
-        if (fhlen == 0) {
-                gf_msg_trace (GF_NFS3, 0, "received WebNFS request");
-                return 1;
-        }
+    if (fhlen == 0) {
+        gf_msg_trace(GF_NFS3, 0, "received WebNFS request");
+        return 1;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 /* Function pointer that represents the generic prototypes of functions used
  * to serialize NFS3 message structures into the XDR format.
  * For usage, see the nfs3svc_XXX_cbk functions.
  */
-typedef ssize_t (*nfs3_serializer) (struct iovec outmsg, void *args);
+typedef ssize_t (*nfs3_serializer)(struct iovec outmsg, void *args);
 
 static void
-__nfs3_call_state_wipe (nfs3_call_state_t *cs)
+__nfs3_call_state_wipe(nfs3_call_state_t *cs)
 {
-        if (cs->fd) {
-                gf_msg_trace (GF_NFS3, 0, "fd 0x%lx ref: %"PRId64,
-                        (long)cs->fd, GF_ATOMIC_GET (cs->fd->refcount));
-                fd_unref (cs->fd);
-        }
+    if (cs->fd) {
+        gf_msg_trace(GF_NFS3, 0, "fd 0x%lx ref: %" PRId64, (long)cs->fd,
+                     GF_ATOMIC_GET(cs->fd->refcount));
+        fd_unref(cs->fd);
+    }
 
-        GF_FREE (cs->resolventry);
+    GF_FREE(cs->resolventry);
 
-        GF_FREE (cs->pathname);
+    GF_FREE(cs->pathname);
 
-        if (!list_empty (&cs->entries.list))
-                gf_dirent_free (&cs->entries);
+    if (!list_empty(&cs->entries.list))
+        gf_dirent_free(&cs->entries);
 
-        nfs_loc_wipe (&cs->oploc);
-        nfs_loc_wipe (&cs->resolvedloc);
-        if (cs->iob)
-                iobuf_unref (cs->iob);
-        if (cs->iobref)
-                iobref_unref (cs->iobref);
-        if (cs->trans)
-                rpc_transport_unref (cs->trans);
-        memset (cs, 0, sizeof (*cs));
-        mem_put (cs);
-        /* Already refd by fd_lookup, so no need to ref again. */
+    nfs_loc_wipe(&cs->oploc);
+    nfs_loc_wipe(&cs->resolvedloc);
+    if (cs->iob)
+        iobuf_unref(cs->iob);
+    if (cs->iobref)
+        iobref_unref(cs->iobref);
+    if (cs->trans)
+        rpc_transport_unref(cs->trans);
+    memset(cs, 0, sizeof(*cs));
+    mem_put(cs);
+    /* Already refd by fd_lookup, so no need to ref again. */
 }
 
 nfs3_call_state_t *
-nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v)
-{
-        nfs3_call_state_t       *cs = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS3, s, err);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, req, err);
-        /* GF_VALIDATE_OR_GOTO (GF_NFS3, v, err); NLM sets this later */
-
-        cs = (nfs3_call_state_t *) mem_get (s->localpool);
-        if (!cs) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "out of memory");
-                return NULL;
-        }
-
-        memset (cs, 0, sizeof (*cs));
-        GF_REF_INIT (cs, __nfs3_call_state_wipe);
-        INIT_LIST_HEAD (&cs->entries.list);
-        INIT_LIST_HEAD (&cs->openwait_q);
-        cs->operrno = EINVAL;
-        cs->req = req;
-        cs->vol = v;
-        cs->nfsx = s->nfsx;
-        cs->nfs3state = s;
+nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v)
+{
+    nfs3_call_state_t *cs = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS3, s, err);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, req, err);
+    /* GF_VALIDATE_OR_GOTO (GF_NFS3, v, err); NLM sets this later */
+
+    cs = (nfs3_call_state_t *)mem_get(s->localpool);
+    if (!cs) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "out of memory");
+        return NULL;
+    }
+
+    memset(cs, 0, sizeof(*cs));
+    GF_REF_INIT(cs, __nfs3_call_state_wipe);
+    INIT_LIST_HEAD(&cs->entries.list);
+    INIT_LIST_HEAD(&cs->openwait_q);
+    cs->operrno = EINVAL;
+    cs->req = req;
+    cs->vol = v;
+    cs->nfsx = s->nfsx;
+    cs->nfs3state = s;
 err:
-        return cs;
+    return cs;
 }
 
 void
-nfs3_call_state_wipe (nfs3_call_state_t *cs)
+nfs3_call_state_wipe(nfs3_call_state_t *cs)
 {
-        if (!cs) {
-                gf_log_callingfn ("nfs", GF_LOG_WARNING, "nfs calling state NULL");
-                return;
-        }
-        GF_REF_PUT (cs);
-}
-
-
-#define nfs3_handle_call_state_init(nfs3state, calls, rq, vl ,opstat, errlabel)\
-        do {                                                            \
-                calls = nfs3_call_state_init ((nfs3state), (rq), (vl)); \
-                if (!calls) {                                           \
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,               \
-                                NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to"\
-                                " init call state");                    \
-                        opstat = NFS3ERR_SERVERFAULT;                   \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
-
-
+    if (!cs) {
+        gf_log_callingfn("nfs", GF_LOG_WARNING, "nfs calling state NULL");
+        return;
+    }
+    GF_REF_PUT(cs);
+}
+
+#define nfs3_handle_call_state_init(nfs3state, calls, rq, vl, opstat,          \
+                                    errlabel)                                  \
+    do {                                                                       \
+        calls = nfs3_call_state_init((nfs3state), (rq), (vl));                 \
+        if (!calls) {                                                          \
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_INIT_CALL_STAT_FAIL,      \
+                   "Failed to"                                                 \
+                   " init call state");                                        \
+            opstat = NFS3ERR_SERVERFAULT;                                      \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 struct iobuf *
-nfs3_serialize_reply (rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc,
-                      struct iovec *outmsg)
-{
-        struct nfs3_state       *nfs3 = NULL;
-        struct iobuf            *iob = NULL;
-        ssize_t                 retlen = -1;
-
-        nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req);
-        if (!nfs3) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_STATE_MISSING,
-                        "NFSv3 state not found in RPC request");
-                goto ret;
-        }
-
-        /* First, get the io buffer into which the reply in arg will
-         * be serialized.
-         */
-        /* TODO: get rid of 'sfunc' and use 'xdrproc_t' so we
-           can have 'xdr_sizeof' */
-        iob = iobuf_get (nfs3->iobpool);
-        if (!iob) {
-                gf_msg (GF_NFS3, 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.
-         */
-        /* retlen is used to received the error since size_t is unsigned and we
-         * need -1 for error notification during encoding.
-         */
-        retlen = sfunc (*outmsg, arg);
-        if (retlen == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_FAIL,
-                        "Failed to encode message");
-                goto ret;
-        }
-
-        outmsg->iov_len = retlen;
+nfs3_serialize_reply(rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc,
+                     struct iovec *outmsg)
+{
+    struct nfs3_state *nfs3 = NULL;
+    struct iobuf *iob = NULL;
+    ssize_t retlen = -1;
+
+    nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req);
+    if (!nfs3) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_STATE_MISSING,
+               "NFSv3 state not found in RPC request");
+        goto ret;
+    }
+
+    /* First, get the io buffer into which the reply in arg will
+     * be serialized.
+     */
+    /* TODO: get rid of 'sfunc' and use 'xdrproc_t' so we
+       can have 'xdr_sizeof' */
+    iob = iobuf_get(nfs3->iobpool);
+    if (!iob) {
+        gf_msg(GF_NFS3, 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.
+     */
+    /* retlen is used to received the error since size_t is unsigned and we
+     * need -1 for error notification during encoding.
+     */
+    retlen = sfunc(*outmsg, arg);
+    if (retlen == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_FAIL,
+               "Failed to encode message");
+        goto ret;
+    }
+
+    outmsg->iov_len = retlen;
 ret:
-        if (retlen == -1) {
-                iobuf_unref (iob);
-                iob = NULL;
-        }
+    if (retlen == -1) {
+        iobuf_unref(iob);
+        iob = NULL;
+    }
 
-        return iob;
+    return iob;
 }
 
-
-
 /* Generic reply function for NFSv3 specific replies. */
 int
-nfs3svc_submit_reply (rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc)
-{
-        struct iovec            outmsg = {0, };
-        struct iobuf            *iob = NULL;
-        int                     ret = -1;
-        struct iobref           *iobref = NULL;
-
-        if (!req)
-                return -1;
-
-        iob = nfs3_serialize_reply (req, arg, sfunc, &outmsg);
-        if (!iob) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL,
-                        "Failed to serialize reply");
-                goto ret;
-        }
-
-        iobref = iobref_new ();
-        if (!iobref) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "failed on iobref_new()");
-                goto ret;
-        }
-
-        ret = iobref_add (iobref, iob);
-        if (ret) {
-                gf_msg (GF_NFS3, 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_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL,
-                        "Reply submission failed");
-                goto ret;
-        }
-
-        ret = 0;
+nfs3svc_submit_reply(rpcsvc_request_t *req, void *arg, nfs3_serializer sfunc)
+{
+    struct iovec outmsg = {
+        0,
+    };
+    struct iobuf *iob = NULL;
+    int ret = -1;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        return -1;
+
+    iob = nfs3_serialize_reply(req, arg, sfunc, &outmsg);
+    if (!iob) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL,
+               "Failed to serialize reply");
+        goto ret;
+    }
+
+    iobref = iobref_new();
+    if (!iobref) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "failed on iobref_new()");
+        goto ret;
+    }
+
+    ret = iobref_add(iobref, iob);
+    if (ret) {
+        gf_msg(GF_NFS3, 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_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL,
+               "Reply submission failed");
+        goto ret;
+    }
+
+    ret = 0;
 ret:
-        /* Now that we've done our job of handing the message to the RPC layer
-         * we can safely unref the iob in the hope that RPC layer must have
-         * ref'ed the iob on receiving into the txlist.
-         */
-        if (NULL != iob)
-                iobuf_unref (iob);
-        if (NULL != iobref)
-                iobref_unref (iobref);
-        return ret;
+    /* Now that we've done our job of handing the message to the RPC layer
+     * we can safely unref the iob in the hope that RPC layer must have
+     * ref'ed the iob on receiving into the txlist.
+     */
+    if (NULL != iob)
+        iobuf_unref(iob);
+    if (NULL != iobref)
+        iobref_unref(iobref);
+    return ret;
 }
 
-
 int
-nfs3svc_submit_vector_reply (rpcsvc_request_t *req, void *arg,
-                             nfs3_serializer sfunc, struct iovec *payload,
-                             int vcount, struct iobref *iobref)
-{
-        struct iovec            outmsg = {0, };
-        struct iobuf            *iob = NULL;
-        int                     ret = -1;
-        int                     new_iobref = 0;
-
-        if (!req)
-                return -1;
-
-        iob = nfs3_serialize_reply (req, arg, sfunc, &outmsg);
-        if (!iob) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL,
-                        "Failed to serialize reply");
-                goto ret;
-        }
-        if (iobref == NULL) {
-                iobref = iobref_new ();
-                if (!iobref) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "failed on iobref_new");
-                        goto ret;
-                }
-                new_iobref = 1;
-        }
-
-        ret = iobref_add (iobref, iob);
-        if (ret) {
-                gf_msg (GF_NFS3, 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, payload, vcount, iobref);
-        if (ret == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL,
-                        "Reply submission failed");
-                goto ret;
-        }
-
-        ret = 0;
+nfs3svc_submit_vector_reply(rpcsvc_request_t *req, void *arg,
+                            nfs3_serializer sfunc, struct iovec *payload,
+                            int vcount, struct iobref *iobref)
+{
+    struct iovec outmsg = {
+        0,
+    };
+    struct iobuf *iob = NULL;
+    int ret = -1;
+    int new_iobref = 0;
+
+    if (!req)
+        return -1;
+
+    iob = nfs3_serialize_reply(req, arg, sfunc, &outmsg);
+    if (!iob) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SERIALIZE_REPLY_FAIL,
+               "Failed to serialize reply");
+        goto ret;
+    }
+    if (iobref == NULL) {
+        iobref = iobref_new();
+        if (!iobref) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "failed on iobref_new");
+            goto ret;
+        }
+        new_iobref = 1;
+    }
+
+    ret = iobref_add(iobref, iob);
+    if (ret) {
+        gf_msg(GF_NFS3, 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, payload, vcount, iobref);
+    if (ret == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBMIT_REPLY_FAIL,
+               "Reply submission failed");
+        goto ret;
+    }
+
+    ret = 0;
 ret:
-        /* Now that we've done our job of handing the message to the RPC layer
-         * we can safely unref the iob in the hope that RPC layer must have
-         * ref'ed the iob on receiving into the txlist.
-         */
-        if (NULL != iob)
-                iobuf_unref (iob);
-        if (new_iobref)
-                iobref_unref (iobref);
-        return ret;
+    /* Now that we've done our job of handing the message to the RPC layer
+     * we can safely unref the iob in the hope that RPC layer must have
+     * ref'ed the iob on receiving into the txlist.
+     */
+    if (NULL != iob)
+        iobuf_unref(iob);
+    if (new_iobref)
+        iobref_unref(iobref);
+    return ret;
 }
 
 uint64_t
-nfs3_request_xlator_deviceid (rpcsvc_request_t *rq)
-{
-        struct nfs3_state       *nfs3 = NULL;
-        xlator_t                *xl = NULL;
-        uint64_t                devid = 0;
-        uuid_t                  volumeid = {0, };
-
-        if (!rq)
-                return 0;
-
-        xl = rpcsvc_request_private (rq);
-        nfs3 = rpcsvc_request_program_private (rq);
-        if (gf_nfs_dvm_off (nfs_state (nfs3->nfsx)))
-                devid = (uint64_t)nfs_xlator_to_xlid (nfs3->exportslist, xl);
-        else {
-                __nfs3_get_volume_id (nfs3, xl, volumeid);
-                memcpy (&devid, &volumeid[8], sizeof (devid));
-        }
+nfs3_request_xlator_deviceid(rpcsvc_request_t *rq)
+{
+    struct nfs3_state *nfs3 = NULL;
+    xlator_t *xl = NULL;
+    uint64_t devid = 0;
+    uuid_t volumeid = {
+        0,
+    };
 
-        return devid;
-}
+    if (!rq)
+        return 0;
+
+    xl = rpcsvc_request_private(rq);
+    nfs3 = rpcsvc_request_program_private(rq);
+    if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx)))
+        devid = (uint64_t)nfs_xlator_to_xlid(nfs3->exportslist, xl);
+    else {
+        __nfs3_get_volume_id(nfs3, xl, volumeid);
+        memcpy(&devid, &volumeid[8], sizeof(devid));
+    }
 
+    return devid;
+}
 
 int
-nfs3svc_null (rpcsvc_request_t *req)
+nfs3svc_null(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
-        if (!req)
-                return RPCSVC_ACTOR_ERROR;
-        rpcsvc_submit_generic (req, &dummyvec, 1,  NULL, 0, NULL);
-        return RPCSVC_ACTOR_SUCCESS;
+    struct iovec dummyvec = {
+        0,
+    };
+    if (!req)
+        return RPCSVC_ACTOR_ERROR;
+    rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL);
+    return RPCSVC_ACTOR_SUCCESS;
 }
 
-
 int
-nfs3_getattr_reply (rpcsvc_request_t *req, nfsstat3 status, struct iatt *buf)
+nfs3_getattr_reply(rpcsvc_request_t *req, nfsstat3 status, struct iatt *buf)
 {
-        getattr3res     res;
-        uint64_t        deviceid = 0;
+    getattr3res res;
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_getattr3res (&res, status, buf, deviceid);
-        nfs3svc_submit_reply (req, &res,
-                              (nfs3_serializer)xdr_serialize_getattr3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_getattr3res(&res, status, buf, deviceid);
+    nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_getattr3res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_getattr_lookup_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)
+nfs3svc_getattr_lookup_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)
 {
-        nfsstat3                status = NFS3_OK;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 status = NFS3_OK;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
+    cs = frame->local;
 
-        /*
-         * Somewhat counter-intuitively, we don't need to look for sh-failed
-         * here. Failing this getattr will generate a new lookup from the
-         * client, and nfs_fop_lookup_cbk will detect any self-heal failures.
-         */
+    /*
+     * Somewhat counter-intuitively, we don't need to look for sh-failed
+     * here. Failing this getattr will generate a new lookup from the
+     * client, and nfs_fop_lookup_cbk will detect any self-heal failures.
+     */
 
-        if (op_ret == -1) {
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
-        }
-        else {
-                nfs_fix_generation(this,inode);
-        }
+    if (op_ret == -1) {
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else {
+        nfs_fix_generation(this, inode);
+    }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_GETATTR, status, op_errno,
-                             cs->resolvedloc.path);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, status,
+                        op_errno, cs->resolvedloc.path);
 
-        nfs3_getattr_reply (cs->req, status, buf);
-        nfs3_call_state_wipe (cs);
+    nfs3_getattr_reply(cs->req, status, buf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_getattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                          dict_t *xdata)
+nfs3svc_getattr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                         dict_t *xdata)
 {
-        nfsstat3                status = NFS3_OK;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 status = NFS3_OK;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
+    cs = frame->local;
 
-        if (op_ret == -1) {
-                /* Prevent crashes for the case where this call fails
-                 * and buf is left in a NULL state, yet the op_errno == 0.
-                 */
-                if (!buf && op_errno == 0) {
-                        op_errno = EIO;
-                }
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
+    if (op_ret == -1) {
+        /* Prevent crashes for the case where this call fails
+         * and buf is left in a NULL state, yet the op_errno == 0.
+         */
+        if (!buf && op_errno == 0) {
+            op_errno = EIO;
         }
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+    }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_GETATTR, status, op_errno,
-                             cs->resolvedloc.path);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, status,
+                        op_errno, cs->resolvedloc.path);
 
-        nfs3_getattr_reply (cs->req, status, buf);
-        nfs3_call_state_wipe (cs);
+    nfs3_getattr_reply(cs->req, status, buf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_getattr_resume (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        uint64_t                         raw_ctx = 0;
-        struct nfs_inode_ctx            *ictx = NULL;
-        struct nfs_state                *priv = NULL;
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        /* If inode which is to be getattr'd is the root, we need to do a
-         * lookup instead because after a server reboot, it is not necessary
-         * for the root to have been looked up when the getattr on the root is
-         * sent. AND, this causes a problem for stat-prefetch in that it
-         * expects even the root inode to have been looked up.
-
-        if (__is_root_gfid (cs->resolvedloc.inode->gfid))
-                ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  nfs3svc_getattr_lookup_cbk, cs);
-        else
-                ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-        */
-
-        if (cs->hardresolved) {
-                ret = -EFAULT;
-                stat = NFS3_OK;
-                goto nfs3err;
-        }
-
-        /*
-         * If brick state changed, we need to force a proper lookup cycle (as
-         * would happen in native protocol) to do self-heal checks. We detect
-         * this by comparing the generation number for the last successful
-         * creation/lookup on the inode to the current number, so inodes that
-         * haven't been validated since the state change are affected.
-         */
-        if (inode_ctx_get(cs->resolvedloc.inode,cs->nfsx,&raw_ctx) == 0) {
-                ictx = (struct nfs_inode_ctx *)raw_ctx;
-                priv = cs->nfsx->private;
-                if (ictx->generation != priv->generation) {
-                        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu,
-                                          &cs->resolvedloc,
-                                          nfs3svc_getattr_lookup_cbk, cs);
-                        goto check_err;
-                }
-        }
+nfs3_getattr_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    uint64_t raw_ctx = 0;
+    struct nfs_inode_ctx *ictx = NULL;
+    struct nfs_state *priv = NULL;
+
+    if (!carg)
+        return ret;
 
-        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                        nfs3svc_getattr_stat_cbk, cs);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    /* If inode which is to be getattr'd is the root, we need to do a
+     * lookup instead because after a server reboot, it is not necessary
+     * for the root to have been looked up when the getattr on the root is
+     * sent. AND, this causes a problem for stat-prefetch in that it
+     * expects even the root inode to have been looked up.
+
+    if (__is_root_gfid (cs->resolvedloc.inode->gfid))
+            ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                              nfs3svc_getattr_lookup_cbk, cs);
+    else
+            ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+    */
+
+    if (cs->hardresolved) {
+        ret = -EFAULT;
+        stat = NFS3_OK;
+        goto nfs3err;
+    }
+
+    /*
+     * If brick state changed, we need to force a proper lookup cycle (as
+     * would happen in native protocol) to do self-heal checks. We detect
+     * this by comparing the generation number for the last successful
+     * creation/lookup on the inode to the current number, so inodes that
+     * haven't been validated since the state change are affected.
+     */
+    if (inode_ctx_get(cs->resolvedloc.inode, cs->nfsx, &raw_ctx) == 0) {
+        ictx = (struct nfs_inode_ctx *)raw_ctx;
+        priv = cs->nfsx->private;
+        if (ictx->generation != priv->generation) {
+            ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                             nfs3svc_getattr_lookup_cbk, cs);
+            goto check_err;
+        }
+    }
+
+    ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                   nfs3svc_getattr_stat_cbk, cs);
 
 check_err:
-        if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_STAT_FOP_FAIL,
-                        "Stat fop failed: %s: %s", cs->oploc.path,
-                        strerror (-ret));
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-        }
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_STAT_FOP_FAIL,
+               "Stat fop failed: %s: %s", cs->oploc.path, strerror(-ret));
+        stat = nfs3_errno_to_nfsstat3(-ret);
+    }
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_GETATTR, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_getattr_reply (cs->req, stat, &cs->stbuf);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_GETATTR, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_getattr_reply(cs->req, stat, &cs->stbuf);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_getattr (rpcsvc_request_t *req, struct nfs3_fh *fh)
+nfs3_getattr(rpcsvc_request_t *req, struct nfs3_fh *fh)
 {
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cstate = NULL;
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cstate = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NFS3, req, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, req, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out);
 
-        nfs3_log_common_call (rpcsvc_request_xid (req), "GETATTR", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cstate, req, vol, stat, nfs3err);
+    nfs3_log_common_call(rpcsvc_request_xid(req), "GETATTR", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cstate, req, vol, stat, nfs3err);
 
-        ret = nfs3_fh_resolve_and_resume (cstate, fh, NULL,nfs3_getattr_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs3_fh_resolve_and_resume(cstate, fh, NULL, nfs3_getattr_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_GETATTR, stat, -ret,
-                                     NULL);
-                nfs3_getattr_reply (req, stat, NULL);
-                ret = 0;
-                nfs3_call_state_wipe (cstate);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_GETATTR, stat, -ret,
+                            NULL);
+        nfs3_getattr_reply(req, stat, NULL);
+        ret = 0;
+        nfs3_call_state_wipe(cstate);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_getattr (rpcsvc_request_t *req)
+nfs3svc_getattr(rpcsvc_request_t *req)
 {
-        struct nfs3_fh          fh = {{0}, };
-        getattr3args            args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    getattr3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        if (!req)
-                return ret;
+    if (!req)
+        return ret;
 
-        nfs3_prep_getattr3args (&args, &fh);
-        if (xdr_to_getattr3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_getattr (req, &fh);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_GETATTR_FAIL,
-                        "GETATTR procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_getattr3args(&args, &fh);
+    if (xdr_to_getattr3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_getattr(req, &fh);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_GETATTR_FAIL,
+               "GETATTR procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_setattr_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preop,
-                    struct iatt *postop)
+nfs3_setattr_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preop,
+                   struct iatt *postop)
 {
-        setattr3res     res = {0, };
-        uint64_t        deviceid = 0;
+    setattr3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_setattr3res (&res, stat, preop, postop, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer) xdr_serialize_setattr3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_setattr3res(&res, stat, preop, postop, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_setattr3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf, dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        struct iatt             *prestat = NULL;
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
-
-        /* If the first stat was got from the guarded setattr callback, or
-         * from an earlier setattr call then we'll need to use that stat
-         * instead of the preop returned here.
-         */
-        if (cs->preparent.ia_ino != 0)
-                prestat = &cs->preparent;
-        else
-                prestat = prebuf;
-
-        stat = NFS3_OK;
+nfs3svc_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                     struct iatt *postbuf, dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    struct iatt *prestat = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    /* If the first stat was got from the guarded setattr callback, or
+     * from an earlier setattr call then we'll need to use that stat
+     * instead of the preop returned here.
+     */
+    if (cs->preparent.ia_ino != 0)
+        prestat = &cs->preparent;
+    else
+        prestat = prebuf;
+
+    stat = NFS3_OK;
 nfs3err:
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_SETATTR, stat, op_errno,
-                             cs->resolvedloc.path);
-        nfs3_setattr_reply (cs->req, stat, prestat, postbuf);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat,
+                        op_errno, cs->resolvedloc.path);
+    nfs3_setattr_reply(cs->req, stat, prestat, postbuf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *preop,
-                     struct iatt *postop, dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -1;
-        struct iatt             *prebuf = NULL;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
-
-        prebuf = preop;
-        /* Store the current preop in case we need to send a truncate,
-         * in which case the preop to be returned will be this one.
-         */
-        cs->preparent = *preop;
+nfs3svc_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                    struct iatt *postop, dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -1;
+    struct iatt *prebuf = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    prebuf = preop;
+    /* Store the current preop in case we need to send a truncate,
+     * in which case the preop to be returned will be this one.
+     */
+    cs->preparent = *preop;
+
+    /* Only truncate if the size is not already same as the requested
+     * truncation and also only if this is not a directory.
+     */
+    if ((gf_attr_size_set(cs->setattr_valid)) && (!IA_ISDIR(postop->ia_type)) &&
+        (preop->ia_size != cs->attr_in.ia_size)) {
+        nfs_request_user_init(&nfu, cs->req);
+        ret = nfs_truncate(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                           cs->attr_in.ia_size, nfs3svc_truncate_cbk, cs);
 
-        /* Only truncate if the size is not already same as the requested
-         * truncation and also only if this is not a directory.
-         */
-        if ((gf_attr_size_set (cs->setattr_valid)) &&
-            (!IA_ISDIR (postop->ia_type)) &&
-            (preop->ia_size != cs->attr_in.ia_size)) {
-                nfs_request_user_init (&nfu, cs->req);
-                ret = nfs_truncate (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                    cs->attr_in.ia_size, nfs3svc_truncate_cbk,
-                                    cs);
-
-                if (ret < 0)
-                        stat = nfs3_errno_to_nfsstat3 (-ret);
-        } else {
-                ret = -1;       /* Force a reply in the branch below. */
-                stat = NFS3_OK;
-        }
+        if (ret < 0)
+            stat = nfs3_errno_to_nfsstat3(-ret);
+    } else {
+        ret = -1; /* Force a reply in the branch below. */
+        stat = NFS3_OK;
+    }
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_SETATTR, stat, op_errno,
-                                     cs->resolvedloc.path);
-                nfs3_setattr_reply (cs->req, stat, prebuf, postop);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat,
+                            op_errno, cs->resolvedloc.path);
+        nfs3_setattr_reply(cs->req, stat, prebuf, postop);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
-
 int32_t
-nfs3svc_setattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                          dict_t *xdata)
+nfs3svc_setattr_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                         dict_t *xdata)
 {
-
-        int                     ret = -EFAULT;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
-
-        if (buf->ia_ctime != cs->timestamp.seconds) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_TIMESTAMP_NO_SYNC,
-                        "Timestamps not in sync");
-                stat = NFS3ERR_NOT_SYNC;
-                goto nfs3err;
-        }
-
-        /* Not a clean way but no motivation to add a new member to local. */
-        cs->preparent = *buf;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf,
-                           cs->setattr_valid, nfs3svc_setattr_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    int ret = -EFAULT;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    if (buf->ia_ctime != cs->timestamp.seconds) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_TIMESTAMP_NO_SYNC,
+               "Timestamps not in sync");
+        stat = NFS3ERR_NOT_SYNC;
+        goto nfs3err;
+    }
+
+    /* Not a clean way but no motivation to add a new member to local. */
+    cs->preparent = *buf;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf,
+                      cs->setattr_valid, nfs3svc_setattr_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_SETATTR, stat, op_errno,
-                                     cs->resolvedloc.path);
-                nfs3_setattr_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat,
+                            op_errno, cs->resolvedloc.path);
+        nfs3_setattr_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_setattr_resume (void *carg)
+nfs3_setattr_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                           &cs->attr_in, cs->setattr_valid,
-                           nfs3svc_setattr_cbk, cs);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->attr_in,
+                      cs->setattr_valid, nfs3svc_setattr_cbk, cs);
 
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_SETATTR, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_setattr_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SETATTR, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_setattr_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_setattr (rpcsvc_request_t *req, struct nfs3_fh *fh, sattr3 *sattr,
-              sattrguard3 *guard)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS3, req, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, sattr, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, guard, out);
-
-        nfs3_log_common_call (rpcsvc_request_xid (req), "SETATTR", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, &cs->attr_in,
-                                                          NULL);
-        if (guard->check) {
-                gf_msg_trace (GF_NFS3, 0, "Guard check required");
-                cs->timestamp = guard->sattrguard3_u.obj_ctime;
-                cs->sattrguardcheck = 1;
-        } else {
-                gf_msg_trace (GF_NFS3, 0, "Guard check not required");
-                cs->sattrguardcheck = 0;
-        }
-
-        if (!cs->setattr_valid) {
-                ret = -EINVAL;  /* Force a reply */
-                stat = NFS3_OK;
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_SETATTR_INVALID,
-                        "cs->setattr_valid is invalid");
-                goto nfs3err;
-        }
+nfs3_setattr(rpcsvc_request_t *req, struct nfs3_fh *fh, sattr3 *sattr,
+             sattrguard3 *guard)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS3, req, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, sattr, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, guard, out);
+
+    nfs3_log_common_call(rpcsvc_request_xid(req), "SETATTR", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->attr_in, NULL);
+    if (guard->check) {
+        gf_msg_trace(GF_NFS3, 0, "Guard check required");
+        cs->timestamp = guard->sattrguard3_u.obj_ctime;
+        cs->sattrguardcheck = 1;
+    } else {
+        gf_msg_trace(GF_NFS3, 0, "Guard check not required");
+        cs->sattrguardcheck = 0;
+    }
+
+    if (!cs->setattr_valid) {
+        ret = -EINVAL; /* Force a reply */
+        stat = NFS3_OK;
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_SETATTR_INVALID,
+               "cs->setattr_valid is invalid");
+        goto nfs3err;
+    }
 
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_setattr_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_setattr_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_SETATTR, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_setattr_reply (req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_SETATTR, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_setattr_reply(req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-nfs3svc_setattr (rpcsvc_request_t *req)
-{
-        struct nfs3_fh          fh = {{0}, };
-        setattr3args            args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS3, req, rpcerr);
-
-        nfs3_prep_setattr3args (&args, &fh);
-        if (xdr_to_setattr3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0,
-                        NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_setattr (req, &fh, &args.new_attributes, &args.guard);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_SETATTR_FAIL,
-                        "SETATTR procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_setattr(rpcsvc_request_t *req)
+{
+    struct nfs3_fh fh = {
+        {0},
+    };
+    setattr3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS3, req, rpcerr);
+
+    nfs3_prep_setattr3args(&args, &fh);
+    if (xdr_to_setattr3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_setattr(req, &fh, &args.new_attributes, &args.guard);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_SETATTR_FAIL,
+               "SETATTR procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
-
+    return ret;
 }
 
-
 int
-nfs3_lookup_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh,
-                   struct iatt *stbuf, struct iatt *postparent)
+nfs3_lookup_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh,
+                  struct iatt *stbuf, struct iatt *postparent)
 {
-        lookup3res      res = {0, };
-        uint64_t        deviceid = 0;
+    lookup3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_lookup3res (&res, stat, newfh, stbuf, postparent, deviceid);
-        return nfs3svc_submit_reply (req, &res,
-                                     (nfs3_serializer)xdr_serialize_lookup3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_lookup3res(&res, stat, newfh, stbuf, postparent, deviceid);
+    return nfs3svc_submit_reply(req, &res,
+                                (nfs3_serializer)xdr_serialize_lookup3res);
 }
 
 int
-nfs3_lookup_resume (void *carg);
-
+nfs3_lookup_resume(void *carg);
 
 int
-nfs3_fresh_lookup (nfs3_call_state_t *cs)
-{
-        int     ret = -EFAULT;
-        char    *oldresolventry = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS3, cs, err);
-        gf_msg_debug (GF_NFS3, 0, "inode needs fresh lookup");
-        inode_unlink (cs->resolvedloc.inode, cs->resolvedloc.parent,
-                      cs->resolventry);
-        nfs_loc_wipe (&cs->resolvedloc);
-
-        /* Store pointer to currently allocated resolventry because it gets over
-         * written in fh_resolve_and_resume.
-         */
-        oldresolventry = cs->resolventry;
-        cs->lookuptype = GF_NFS3_FRESH;
-        ret = nfs3_fh_resolve_and_resume (cs, &cs->resolvefh, cs->resolventry,
-                                          nfs3_lookup_resume);
-        /* Allocated in the previous call to fh_resolve_and_resume using the
-         * same call_state.
-         */
-        GF_FREE (oldresolventry);
+nfs3_fresh_lookup(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    char *oldresolventry = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS3, cs, err);
+    gf_msg_debug(GF_NFS3, 0, "inode needs fresh lookup");
+    inode_unlink(cs->resolvedloc.inode, cs->resolvedloc.parent,
+                 cs->resolventry);
+    nfs_loc_wipe(&cs->resolvedloc);
+
+    /* Store pointer to currently allocated resolventry because it gets over
+     * written in fh_resolve_and_resume.
+     */
+    oldresolventry = cs->resolventry;
+    cs->lookuptype = GF_NFS3_FRESH;
+    ret = nfs3_fh_resolve_and_resume(cs, &cs->resolvefh, cs->resolventry,
+                                     nfs3_lookup_resume);
+    /* Allocated in the previous call to fh_resolve_and_resume using the
+     * same call_state.
+     */
+    GF_FREE(oldresolventry);
 err:
-        return ret;
+    return ret;
 }
 
 int
-nfs3svc_lookup_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)
-{
-        struct nfs3_fh                  newfh = {{0}, };
-        nfsstat3                        status = NFS3_OK;
-        nfs3_call_state_t               *cs = NULL;
-        inode_t                         *oldinode = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto xmit_res;
-        }
-
-        nfs3_fh_build_child_fh (&cs->parent, buf, &newfh);
-        oldinode = inode_link (inode, cs->resolvedloc.parent,
-                               cs->resolvedloc.name, buf);
+nfs3svc_lookup_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)
+{
+    struct nfs3_fh newfh = {
+        {0},
+    };
+    nfsstat3 status = NFS3_OK;
+    nfs3_call_state_t *cs = NULL;
+    inode_t *oldinode = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto xmit_res;
+    }
+
+    nfs3_fh_build_child_fh(&cs->parent, buf, &newfh);
+    oldinode = inode_link(inode, cs->resolvedloc.parent, cs->resolvedloc.name,
+                          buf);
 xmit_res:
-        /* Only send fresh lookup if it was a revalidate that failed. */
-        if ((op_ret ==  -1) && (nfs3_is_revalidate_lookup (cs))) {
-                op_ret = nfs3_fresh_lookup (cs);
-                goto out;
-        }
-
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP,
-                            status, op_errno, &newfh,
-                            cs->resolvedloc.path);
-        nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent);
-        nfs3_call_state_wipe (cs);
+    /* Only send fresh lookup if it was a revalidate that failed. */
+    if ((op_ret == -1) && (nfs3_is_revalidate_lookup(cs))) {
+        op_ret = nfs3_fresh_lookup(cs);
+        goto out;
+    }
+
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, status,
+                       op_errno, &newfh, cs->resolvedloc.path);
+    nfs3_lookup_reply(cs->req, status, &newfh, buf, postparent);
+    nfs3_call_state_wipe(cs);
 out:
-        if (oldinode) {
-                inode_lookup (oldinode);
-                inode_unref (oldinode);
-        }
-        return 0;
+    if (oldinode) {
+        inode_lookup(oldinode);
+        inode_unref(oldinode);
+    }
+    return 0;
 }
 
-
 int
-nfs3svc_lookup_parentdir_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)
-{
-        struct nfs3_fh                  newfh = {{0}, };
-        nfsstat3                        status = NFS3_OK;
-        nfs3_call_state_t               *cs = NULL;
-        uuid_t                          volumeid = {0, };
-        uuid_t                          mountid = {1, };
-        struct nfs3_state               *nfs3 = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto xmit_res;
-        }
-
-        nfs3 = cs->nfs3state;
-        /* If the buf inode shows that this is a root dir's buf, then the file
-         * handle needs to be specially crafted, in all other cases, we'll just
-         * create the handle normally using the buffer of the parent dir.
-         */
-        if (buf->ia_ino != 1) {
-                nfs3_fh_build_parent_fh (&cs->fh, buf, &newfh);
-                goto xmit_res;
-        }
-
-        if (gf_nfs_dvm_off (nfs_state (nfs3->nfsx)))
-                newfh = nfs3_fh_build_indexed_root_fh (nfs3->exportslist,
-                                                       cs->vol);
-        else {
-                __nfs3_get_volume_id (nfs3, cs->vol, volumeid);
-                newfh = nfs3_fh_build_uuid_root_fh (volumeid, mountid);
-        }
+nfs3svc_lookup_parentdir_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)
+{
+    struct nfs3_fh newfh = {
+        {0},
+    };
+    nfsstat3 status = NFS3_OK;
+    nfs3_call_state_t *cs = NULL;
+    uuid_t volumeid = {
+        0,
+    };
+    uuid_t mountid = {
+        1,
+    };
+    struct nfs3_state *nfs3 = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto xmit_res;
+    }
+
+    nfs3 = cs->nfs3state;
+    /* If the buf inode shows that this is a root dir's buf, then the file
+     * handle needs to be specially crafted, in all other cases, we'll just
+     * create the handle normally using the buffer of the parent dir.
+     */
+    if (buf->ia_ino != 1) {
+        nfs3_fh_build_parent_fh(&cs->fh, buf, &newfh);
+        goto xmit_res;
+    }
+
+    if (gf_nfs_dvm_off(nfs_state(nfs3->nfsx)))
+        newfh = nfs3_fh_build_indexed_root_fh(nfs3->exportslist, cs->vol);
+    else {
+        __nfs3_get_volume_id(nfs3, cs->vol, volumeid);
+        newfh = nfs3_fh_build_uuid_root_fh(volumeid, mountid);
+    }
 
 xmit_res:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP,
-                            status, op_errno, &newfh,
-                            cs->resolvedloc.path);
-        nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, status,
+                       op_errno, &newfh, cs->resolvedloc.path);
+    nfs3_lookup_reply(cs->req, status, &newfh, buf, postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
-
 int
-nfs3_lookup_parentdir_resume (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        inode_t                         *parent = NULL;
-
-        if (!carg) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, carg value NULL");
-                return EINVAL;
-        }
+nfs3_lookup_parentdir_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    inode_t *parent = NULL;
+
+    if (!carg) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, carg value NULL");
+        return EINVAL;
+    }
+
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+
+    /* At this point now, the loc in cs is for the directory file handle
+     * sent by the client. This loc needs to be transformed into a loc that
+     * represents the parent dir of cs->resolvedloc.inode.
+     *
+     * EXCEPT in the case where the .. is a parent of the root directory.
+     * In this case we'll be returning the file handle and attributes of the
+     * root itself.
+     */
+    nfs_request_user_init(&nfu, cs->req);
+
+    /* Save the file handle from the LOOKUP request. We'll use this to
+     * build the file handle of the parent directory in case the parent is
+     * not root dir.
+     */
+    cs->fh = cs->resolvefh;
+
+    /* If fh is that of the root, the resolvedloc will already contain
+     * the loc for root. After that, we'll send lookup for the root dir
+     * itself since we cannot send the lookup on the parent of root.
+     *
+     * For all other cases, we'll send the lookup on the parent of the
+     * given directory file handle.
+     */
+    if (!nfs3_fh_is_root_fh(&cs->fh)) {
+        parent = inode_ref(cs->resolvedloc.parent);
+        nfs_loc_wipe(&cs->resolvedloc);
+        ret = nfs_inode_loc_fill(parent, &cs->resolvedloc, NFS_RESOLVE_CREATE);
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-
-        /* At this point now, the loc in cs is for the directory file handle
-         * sent by the client. This loc needs to be transformed into a loc that
-         * represents the parent dir of cs->resolvedloc.inode.
-         *
-         * EXCEPT in the case where the .. is a parent of the root directory.
-         * In this case we'll be returning the file handle and attributes of the
-         * root itself.
-         */
-        nfs_request_user_init (&nfu, cs->req);
-
-        /* Save the file handle from the LOOKUP request. We'll use this to
-         * build the file handle of the parent directory in case the parent is
-         * not root dir.
-         */
-        cs->fh = cs->resolvefh;
-
-        /* If fh is that of the root, the resolvedloc will already contain
-         * the loc for root. After that, we'll send lookup for the root dir
-         * itself since we cannot send the lookup on the parent of root.
-         *
-         * For all other cases, we'll send the lookup on the parent of the
-         * given directory file handle.
-         */
-        if (!nfs3_fh_is_root_fh (&cs->fh)) {
-                parent = inode_ref (cs->resolvedloc.parent);
-                nfs_loc_wipe (&cs->resolvedloc);
-                ret = nfs_inode_loc_fill (parent, &cs->resolvedloc,
-                                          NFS_RESOLVE_CREATE);
-
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                                NFS_MSG_INODE_LOC_FILL_ERROR,
-                                "nfs_inode_loc_fill"
-                                " error");
-                        goto errtostat;
-                }
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_INODE_LOC_FILL_ERROR,
+                   "nfs_inode_loc_fill"
+                   " error");
+            goto errtostat;
         }
+    }
 
-        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          nfs3svc_lookup_parentdir_cbk, cs);
+    ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                     nfs3svc_lookup_parentdir_cbk, cs);
 errtostat:
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_LOOKUP, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_lookup_reply (cs->req, stat, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_lookup_reply(cs->req, stat, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        if (parent)
-                inode_unref (parent);
+    if (parent)
+        inode_unref(parent);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_lookup_resume (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        struct nfs3_fh                  newfh = {{0},};
-
-        if (!carg) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, carg value NULL");
-                return EINVAL;
-        }
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        cs->parent = cs->resolvefh;
-
-	if (cs->hardresolved) {
-		stat = NFS3_OK;
-		nfs3_fh_build_child_fh (&cs->parent, &cs->stbuf, &newfh);
-		goto nfs3err;
-	}
+nfs3_lookup_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    struct nfs3_fh newfh = {
+        {0},
+    };
+
+    if (!carg) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, carg value NULL");
+        return EINVAL;
+    }
+
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    cs->parent = cs->resolvefh;
+
+    if (cs->hardresolved) {
+        stat = NFS3_OK;
+        nfs3_fh_build_child_fh(&cs->parent, &cs->stbuf, &newfh);
+        goto nfs3err;
+    }
 
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          nfs3svc_lookup_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_lookup(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                     nfs3svc_lookup_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_LOOKUP, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_lookup_reply (cs->req, stat, &newfh, &cs->stbuf,
-                                   &cs->postparent);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LOOKUP, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_lookup_reply(cs->req, stat, &newfh, &cs->stbuf, &cs->postparent);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_lookup (rpcsvc_request_t *req, struct nfs3_fh *fh, int fhlen, char *name)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS3, req, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, fh, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS3, name, out);
-
-        nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "LOOKUP", fh,
-                                name);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        if (nfs3_solaris_zerolen_fh (fh, fhlen)) {
-                ret = nfs3_funge_webnfs_zerolen_fh (req, nfs3, fh, name);
-                if (ret < 0)
-                        goto nfs3err;
-
-                /* this fh means we're doing a mount, name is no more useful */
-                name = NULL;
-        } else
-                nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
+nfs3_lookup(rpcsvc_request_t *req, struct nfs3_fh *fh, int fhlen, char *name)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS3, req, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, fh, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS3, name, out);
+
+    nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "LOOKUP", fh, name);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    if (nfs3_solaris_zerolen_fh(fh, fhlen)) {
+        ret = nfs3_funge_webnfs_zerolen_fh(req, nfs3, fh, name);
+        if (ret < 0)
+            goto nfs3err;
 
-        cs->lookuptype = GF_NFS3_REVALIDATE;
-        ret = nfs3_fh_resolve_and_resume (cs, fh, name,
-                                          nfs3_lookup_resume);
+        /* this fh means we're doing a mount, name is no more useful */
+        name = NULL;
+    } else
+        nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
 
-        if (ret < 0) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
-                        NFS_MSG_HARD_RESOLVE_FAIL,
-                        "failed to start hard resolve");
-        }
+    cs->lookuptype = GF_NFS3_REVALIDATE;
+    ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_lookup_resume);
+
+    if (ret < 0) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, -ret, NFS_MSG_HARD_RESOLVE_FAIL,
+               "failed to start hard resolve");
+    }
 
 nfs3err:
-        if (ret < 0) {
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_LOOKUP, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_lookup_reply (req, stat, NULL, NULL, NULL);
-                if (cs)
-                        nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        stat = nfs3_errno_to_nfsstat3(-ret);
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_LOOKUP, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_lookup_reply(req, stat, NULL, NULL, NULL);
+        if (cs)
+            nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_lookup (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          fh = {{0}, };
-        lookup3args             args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, req, rpcerr);
-
-        nfs3_prep_lookup3args (&args, &fh, name);
-        if (xdr_to_lookup3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_lookup (req, &fh, args.what.dir.data.data_len, name);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_LOOKUP_PROC_FAIL,
-                        "LOOKUP procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_lookup(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh fh = {
+        {0},
+    };
+    lookup3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, req, rpcerr);
+
+    nfs3_prep_lookup3args(&args, &fh, name);
+    if (xdr_to_lookup3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_lookup(req, &fh, args.what.dir.data.data_len, name);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_LOOKUP_PROC_FAIL,
+               "LOOKUP procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_access_reply (rpcsvc_request_t *req, nfsstat3 status, int32_t accbits,
-		   int32_t reqaccbits)
+nfs3_access_reply(rpcsvc_request_t *req, nfsstat3 status, int32_t accbits,
+                  int32_t reqaccbits)
 {
-        access3res      res;
+    access3res res;
 
-        nfs3_fill_access3res (&res, status, accbits, reqaccbits);
-        nfs3svc_submit_reply (req, &res,
-                              (nfs3_serializer)xdr_serialize_access3res);
-        return 0;
+    nfs3_fill_access3res(&res, status, accbits, reqaccbits);
+    nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_access3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+nfs3svc_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        nfsstat3                status = NFS3_OK;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 status = NFS3_OK;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
+    cs = frame->local;
 
-        if (op_ret == -1) {
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
-        }
+    if (op_ret == -1) {
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+    }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_ACCESS, status, op_errno,
-                             cs->resolvedloc.path);
-        nfs3_access_reply (cs->req, status, op_errno, cs->accessbits);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_ACCESS, status,
+                        op_errno, cs->resolvedloc.path);
+    nfs3_access_reply(cs->req, status, op_errno, cs->accessbits);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
 int
-nfs3_access_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-
-        if (!carg) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Invalid argument, carg value NULL");
-                return EINVAL;
-        }
-
-        cs = (nfs3_call_state_t *)carg;
-
-        /* Additional checks on the NFS file handle
-         * go here. The path for an NFS ACCESS call
-         * goes like this:
-         * nfs3_access -> nfs3_fh_resolve_and_resume -> nfs3_resolve_resume ->
-         * nfs3_access_resume -> <macro/function performs check on FH> ->
-         * <continue or return from function based on check.> ('goto nfs3err'
-         * terminates this function and writes the appropriate response to the
-         * client). It is important that you do NOT stick any sort of check
-         * on the file handle outside of the nfs3_##OP_resume functions.
-         */
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        cs->fh = cs->resolvefh;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_access (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          cs->accessbits, nfs3svc_access_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_access_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+
+    if (!carg) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Invalid argument, carg value NULL");
+        return EINVAL;
+    }
+
+    cs = (nfs3_call_state_t *)carg;
+
+    /* Additional checks on the NFS file handle
+     * go here. The path for an NFS ACCESS call
+     * goes like this:
+     * nfs3_access -> nfs3_fh_resolve_and_resume -> nfs3_resolve_resume ->
+     * nfs3_access_resume -> <macro/function performs check on FH> ->
+     * <continue or return from function based on check.> ('goto nfs3err'
+     * terminates this function and writes the appropriate response to the
+     * client). It is important that you do NOT stick any sort of check
+     * on the file handle outside of the nfs3_##OP_resume functions.
+     */
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    cs->fh = cs->resolvefh;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_access(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->accessbits,
+                     nfs3svc_access_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_ACCESS, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_access_reply (cs->req, stat, 0, 0);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_ACCESS, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_access_reply(cs->req, stat, 0, 0);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_access (rpcsvc_request_t *req, struct nfs3_fh *fh, uint32_t accbits)
-{
-        xlator_t                *vol = NULL;
-        struct nfs3_state       *nfs3 = NULL;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-
-        GF_VALIDATE_OR_GOTO (GF_NFS, req, out);
-        GF_VALIDATE_OR_GOTO (GF_NFS, fh, out);
-        nfs3_log_common_call (rpcsvc_request_xid (req), "ACCESS", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-        cs->accessbits = accbits;
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_access_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_access(rpcsvc_request_t *req, struct nfs3_fh *fh, uint32_t accbits)
+{
+    xlator_t *vol = NULL;
+    struct nfs3_state *nfs3 = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+
+    GF_VALIDATE_OR_GOTO(GF_NFS, req, out);
+    GF_VALIDATE_OR_GOTO(GF_NFS, fh, out);
+    nfs3_log_common_call(rpcsvc_request_xid(req), "ACCESS", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+    cs->accessbits = accbits;
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_access_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_ACCESS, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_access_reply (req, stat, 0, 0);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_ACCESS, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_access_reply(req, stat, 0, 0);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_access (rpcsvc_request_t *req)
+nfs3svc_access(rpcsvc_request_t *req)
 {
-        struct nfs3_fh  fh = {{0}, };
-        access3args     args;
-        int             ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    access3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        if (!req)
-                return ret;
-
-        nfs3_prep_access3args (&args, &fh);
-        if (xdr_to_access3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+    if (!req)
+        return ret;
 
-        ret = nfs3_access (req, &fh, args.access);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_ACCESS_PROC_FAIL,
-                        "ACCESS procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_access3args(&args, &fh);
+    if (xdr_to_access3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_access(req, &fh, args.access);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_ACCESS_PROC_FAIL,
+               "ACCESS procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_readlink_reply (rpcsvc_request_t *req, nfsstat3 stat, char *path,
-                     struct iatt *buf)
+nfs3_readlink_reply(rpcsvc_request_t *req, nfsstat3 stat, char *path,
+                    struct iatt *buf)
 {
-        readlink3res    res = {0, };
-        uint64_t        deviceid = 0;
+    readlink3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_readlink3res (&res, stat, path, buf, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_readlink3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_readlink3res(&res, stat, path, buf, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_readlink3res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_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)
+nfs3svc_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)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    stat = NFS3_OK;
 
 nfs3err:
-        nfs3_log_readlink_res (rpcsvc_request_xid (cs->req),
-                               stat, op_errno, (char *)path,
-                               cs->resolvedloc.path);
-        nfs3_readlink_reply (cs->req, stat, (char *)path, buf);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_readlink_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                          (char *)path, cs->resolvedloc.path);
+    nfs3_readlink_reply(cs->req, stat, (char *)path, buf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_readlink_resume (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        nfs_user_t                      nfu = {0, };
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_readlink (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                            nfs3svc_readlink_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-
-nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_READLINK, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_readlink_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+nfs3_readlink_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
+    if (!carg)
         return ret;
-}
 
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_readlink(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                       nfs3svc_readlink_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
-int
-nfs3_readlink (rpcsvc_request_t *req, struct nfs3_fh *fh)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
+nfs3err:
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READLINK, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_readlink_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        nfs3_log_common_call (rpcsvc_request_xid (req), "READLINK", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
+    return ret;
+}
 
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_readlink_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+int
+nfs3_readlink(rpcsvc_request_t *req, struct nfs3_fh *fh)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_common_call(rpcsvc_request_xid(req), "READLINK", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_readlink_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_READLINK, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_readlink_reply (req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READLINK, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_readlink_reply(req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_readlink (rpcsvc_request_t *req)
+nfs3svc_readlink(rpcsvc_request_t *req)
 {
-        struct nfs3_fh          fh = {{0}, };
-        readlink3args           args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    readlink3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        if (!req)
-                return ret;
-
-        nfs3_prep_readlink3args (&args, &fh);
-        if (xdr_to_readlink3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+    if (!req)
+        return ret;
 
-        ret = nfs3_readlink (req, &fh);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_READLINK_PROC_FAIL,
-                        "READLINK procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_readlink3args(&args, &fh);
+    if (xdr_to_readlink3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_readlink(req, &fh);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READLINK_PROC_FAIL,
+               "READLINK procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_read_reply (rpcsvc_request_t *req, nfsstat3 stat, count3 count,
-                 struct iovec *vec, int vcount, struct iobref *iobref,
-                 struct iatt *poststat, int is_eof)
-{
-        read3res                res = {0, };
-        uint64_t                deviceid = 0;
-
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_read3res (&res, stat, count, poststat, is_eof, deviceid);
-        if (stat == NFS3_OK) {
-                xdr_vector_round_up (vec, vcount, count);
-                /* iob can be zero if the file size was zero. If so, op_ret
-                 * would be 0 and count = 0.
-                 */
-
-                if (count != 0) {
-                        nfs3svc_submit_vector_reply (req, (void *)&res,
-                                                     (nfs3_serializer)
-                                                  xdr_serialize_read3res_nocopy,
-                                                    vec, vcount, iobref);
-                } else
-
-                nfs3svc_submit_reply (req, (void *)&res,
-                                              (nfs3_serializer)
-                                              xdr_serialize_read3res_nocopy);
+nfs3_read_reply(rpcsvc_request_t *req, nfsstat3 stat, count3 count,
+                struct iovec *vec, int vcount, struct iobref *iobref,
+                struct iatt *poststat, int is_eof)
+{
+    read3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
+
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_read3res(&res, stat, count, poststat, is_eof, deviceid);
+    if (stat == NFS3_OK) {
+        xdr_vector_round_up(vec, vcount, count);
+        /* iob can be zero if the file size was zero. If so, op_ret
+         * would be 0 and count = 0.
+         */
+
+        if (count != 0) {
+            nfs3svc_submit_vector_reply(
+                req, (void *)&res,
+                (nfs3_serializer)xdr_serialize_read3res_nocopy, vec, vcount,
+                iobref);
         } else
-                nfs3svc_submit_reply (req, (void *)&res,
-                                      (nfs3_serializer)
-                                      xdr_serialize_read3res_nocopy);
 
-        return 0;
-}
+            nfs3svc_submit_reply(
+                req, (void *)&res,
+                (nfs3_serializer)xdr_serialize_read3res_nocopy);
+    } else
+        nfs3svc_submit_reply(req, (void *)&res,
+                             (nfs3_serializer)xdr_serialize_read3res_nocopy);
 
+    return 0;
+}
 
 int32_t
-nfs3svc_read_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                  dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     is_eof = 0;
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        } else
-                stat = NFS3_OK;
+nfs3svc_read_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                 int32_t count, struct iatt *stbuf, struct iobref *iobref,
+                 dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int is_eof = 0;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    } else
+        stat = NFS3_OK;
 
-        if (op_errno == ENOENT)
-                is_eof = 1;
+    if (op_errno == ENOENT)
+        is_eof = 1;
 
 err:
-        nfs3_log_read_res (rpcsvc_request_xid (cs->req),
-                           stat, op_errno,
-                           op_ret, is_eof, vector, count,
-                           cs->resolvedloc.path);
-        nfs3_read_reply (cs->req, stat, op_ret, vector, count, iobref, stbuf,
-                         is_eof);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_read_res(rpcsvc_request_xid(cs->req), stat, op_errno, op_ret,
+                      is_eof, vector, count, cs->resolvedloc.path);
+    nfs3_read_reply(cs->req, stat, op_ret, vector, count, iobref, stbuf,
+                    is_eof);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_read_fd_resume (void *carg)
+nfs3_read_fd_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_read (cs->nfsx, cs->vol, &nfu, cs->fd, cs->datacount,
-                        cs->dataoffset, nfs3svc_read_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_read(cs->nfsx, cs->vol, &nfu, cs->fd, cs->datacount,
+                   cs->dataoffset, nfs3svc_read_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_READ, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_read_reply (cs->req, stat, 0, NULL, 0, NULL, NULL, 0);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READ, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_read_reply(cs->req, stat, 0, NULL, 0, NULL, NULL, 0);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_read_resume (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        fd_t                            *fd = NULL;
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_false, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        fd = fd_anonymous (cs->resolvedloc.inode);
-        if (!fd) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
-                        "Failed to create anonymous fd");
-                goto nfs3err;
-        }
+nfs3_read_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    fd_t *fd = NULL;
 
-        cs->fd = fd;
-        nfs3_read_fd_resume (cs);
-        ret = 0;
+    if (!carg)
+        return ret;
+
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_false, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    fd = fd_anonymous(cs->resolvedloc.inode);
+    if (!fd) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
+               "Failed to create anonymous fd");
+        goto nfs3err;
+    }
+
+    cs->fd = fd;
+    nfs3_read_fd_resume(cs);
+    ret = 0;
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_READ, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_read_reply (cs->req, stat, 0, NULL,0, NULL, NULL, 0);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READ, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_read_reply(cs->req, stat, 0, NULL, 0, NULL, NULL, 0);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nfs3_read (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
-           count3 count)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_rw_call (rpcsvc_request_xid (req), "READ", fh, offset,
-                          count, -1);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->datacount = count;
-        cs->dataoffset = offset;
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_read_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_read(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
+          count3 count)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_rw_call(rpcsvc_request_xid(req), "READ", fh, offset, count, -1);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->datacount = count;
+    cs->dataoffset = offset;
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_read_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_READ, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_read_reply (req, stat, 0, NULL,0, NULL, NULL, 0);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READ, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_read_reply(req, stat, 0, NULL, 0, NULL, NULL, 0);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_read (rpcsvc_request_t *req)
+nfs3svc_read(rpcsvc_request_t *req)
 {
-        struct nfs3_fh          fh = {{0}, };
-        read3args               args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    read3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        if (!req)
-                return ret;
-
-        nfs3_prep_read3args (&args, &fh);
-        if (xdr_to_read3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+    if (!req)
+        return ret;
 
-        ret = nfs3_read (req, &fh, args.offset, args.count);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_READ_FAIL,
-                        "READ procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_read3args(&args, &fh);
+    if (xdr_to_read3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_read(req, &fh, args.offset, args.count);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READ_FAIL,
+               "READ procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_write_reply (rpcsvc_request_t *req, nfsstat3 stat, count3 count,
-                  stable_how stable, uint64_t wverf, struct iatt *prestat,
-                  struct iatt *poststat)
+nfs3_write_reply(rpcsvc_request_t *req, nfsstat3 stat, count3 count,
+                 stable_how stable, uint64_t wverf, struct iatt *prestat,
+                 struct iatt *poststat)
 {
-        write3res       res = {0, };
-        uint64_t        deviceid = 0;
+    write3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_write3res (&res, stat, count, stable, wverf, prestat,
-                             poststat, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_write3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_write3res(&res, stat, count, stable, wverf, prestat, poststat,
+                        deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_write3res);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-nfs3svc_write_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                         struct iatt *postbuf, dict_t *xdata)
+nfs3svc_write_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        struct nfs3_state       *nfs3 = NULL;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    struct nfs3_state *nfs3 = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        nfs3 = rpcsvc_request_program_private (cs->req);
+    cs = frame->local;
+    nfs3 = rpcsvc_request_program_private(cs->req);
 
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else
-                stat = NFS3_OK;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else
+        stat = NFS3_OK;
 
-        nfs3_log_write_res (rpcsvc_request_xid (cs->req),
-                            stat, op_errno,
-                            cs->maxcount, cs->writetype, nfs3->serverstart,
-                            cs->resolvedloc.path);
-        nfs3_write_reply (cs->req, stat, cs->maxcount, cs->writetype,
-                          nfs3->serverstart, &cs->stbuf, postbuf);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_log_write_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                       cs->maxcount, cs->writetype, nfs3->serverstart,
+                       cs->resolvedloc.path);
+    nfs3_write_reply(cs->req, stat, cs->maxcount, cs->writetype,
+                     nfs3->serverstart, &cs->stbuf, postbuf);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
-
 /*
  * Before going into the write reply logic, here is a matrix that shows the
  * requirements for a write reply as given by RFC1813.
@@ -2270,3118 +2205,3028 @@ nfs3svc_write_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
  *
  */
 int32_t
-nfs3svc_write_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        struct nfs3_state       *nfs3 = NULL;
-
-        cs = frame->local;
-        nfs3 = rpcsvc_request_program_private (cs->req);
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        }
+nfs3svc_write_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                  struct iatt *postbuf, dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs3_state *nfs3 = NULL;
 
-        stat = NFS3_OK;
-        cs->maxcount = op_ret;
+    cs = frame->local;
+    nfs3 = rpcsvc_request_program_private(cs->req);
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    }
+
+    stat = NFS3_OK;
+    cs->maxcount = op_ret;
 
 err:
-	nfs3_log_write_res (rpcsvc_request_xid (cs->req),
-                            stat, op_errno, cs->maxcount, cs->writetype,
-			    nfs3->serverstart, cs->resolvedloc.path);
-	nfs3_write_reply (cs->req, stat, cs->maxcount,
-			  cs->writetype, nfs3->serverstart, prebuf,
-			  postbuf);
-	nfs3_call_state_wipe (cs);
+    nfs3_log_write_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                       cs->maxcount, cs->writetype, nfs3->serverstart,
+                       cs->resolvedloc.path);
+    nfs3_write_reply(cs->req, stat, cs->maxcount, cs->writetype,
+                     nfs3->serverstart, prebuf, postbuf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-__nfs3_write_resume (nfs3_call_state_t *cs)
-{
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-
-        if (!cs)
-                return ret;
-
-        nfs_request_user_init (&nfu, cs->req);
-        /* It is possible that the RPC record contains more bytes than
-         * than the size of write requested in this request. This means,
-         * that in the RPC message buffer, there could be more bytes
-         * beyind the @count bytes. Since @payload is referring to the write
-         * data directly inside the RPC request buffer(..since we performed a
-         * no-copy deXDRing..), we might end up writing more data than
-         * requested, because till now payload.iov_len accounts for all the
-         * bytes not just the write request bytes. These extra bytes are present
-         * as a requirement of the XDR encoding to round up the all string and
-         * opaque data buffers to multiples of 4 bytes.
-         */
-        cs->datavec.iov_len = cs->datacount;
-        ret = nfs_write (cs->nfsx, cs->vol, &nfu, cs->fd, cs->iobref,
-                         &cs->datavec, 1, cs->dataoffset, nfs3svc_write_cbk,
-                         cs);
+__nfs3_write_resume(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
+    if (!cs)
         return ret;
-}
 
+    nfs_request_user_init(&nfu, cs->req);
+    /* It is possible that the RPC record contains more bytes than
+     * than the size of write requested in this request. This means,
+     * that in the RPC message buffer, there could be more bytes
+     * beyind the @count bytes. Since @payload is referring to the write
+     * data directly inside the RPC request buffer(..since we performed a
+     * no-copy deXDRing..), we might end up writing more data than
+     * requested, because till now payload.iov_len accounts for all the
+     * bytes not just the write request bytes. These extra bytes are present
+     * as a requirement of the XDR encoding to round up the all string and
+     * opaque data buffers to multiples of 4 bytes.
+     */
+    cs->datavec.iov_len = cs->datacount;
+    ret = nfs_write(cs->nfsx, cs->vol, &nfu, cs->fd, cs->iobref, &cs->datavec,
+                    1, cs->dataoffset, nfs3svc_write_cbk, cs);
+
+    return ret;
+}
 
 int
-nfs3_write_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        fd_t                    *fd = NULL;
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_true, nfs3err);
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        fd = fd_anonymous (cs->resolvedloc.inode);
-        if (!fd) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
-                        "Failed to create anonymous fd");
-                goto nfs3err;
-        }
+nfs3_write_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    fd_t *fd = NULL;
 
-        cs->fd = fd;    /* Gets unrefd when the call state is wiped. */
+    if (!carg)
+        return ret;
 
-        ret = __nfs3_write_resume (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_true, nfs3err);
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    fd = fd_anonymous(cs->resolvedloc.inode);
+    if (!fd) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
+               "Failed to create anonymous fd");
+        goto nfs3err;
+    }
+
+    cs->fd = fd; /* Gets unrefd when the call state is wiped. */
+
+    ret = __nfs3_write_resume(cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_WRITE, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_write_reply (cs->req, stat, 0, cs->writetype, 0, NULL,
-                                  NULL);
-                nfs3_call_state_wipe (cs);
-        }
-        return ret;
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_WRITE, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_write_reply(cs->req, stat, 0, cs->writetype, 0, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
+    return ret;
 }
 
-
 int
-nfs3_write (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
-            count3 count, stable_how stable, struct iovec payload,
-            struct iobref *iobref)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh) || (!payload.iov_base)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_rw_call (rpcsvc_request_xid (req), "WRITE", fh, offset,
-                          count, stable);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-        cs->datacount = count;
-        cs->dataoffset = offset;
-        cs->writetype = stable;
-        cs->iobref = iobref;
-        cs->datavec = payload;
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_write_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_write(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
+           count3 count, stable_how stable, struct iovec payload,
+           struct iobref *iobref)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh) || (!payload.iov_base)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_rw_call(rpcsvc_request_xid(req), "WRITE", fh, offset, count,
+                     stable);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+    cs->datacount = count;
+    cs->dataoffset = offset;
+    cs->writetype = stable;
+    cs->iobref = iobref;
+    cs->datavec = payload;
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_write_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_WRITE, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_write_reply (req, stat, 0, stable, 0, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_WRITE, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_write_reply(req, stat, 0, stable, 0, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-#define NFS3_VECWRITE_READFHLEN         1
-#define NFS3_VECWRITE_READFH            2
-#define NFS3_VECWRITE_READREST          3
-
-#define NFS3_WRITE_POSTFH_SIZE          20
+#define NFS3_VECWRITE_READFHLEN 1
+#define NFS3_VECWRITE_READFH 2
+#define NFS3_VECWRITE_READREST 3
 
+#define NFS3_WRITE_POSTFH_SIZE 20
 
 int
-nfs3svc_write_vecsizer (int state, ssize_t *readsize, char *base_addr,
-                        char *curr_addr)
-{
-        int      ret     = 0;
-        uint32_t fhlen   = 0;
-        uint32_t fhlen_n = 0;
-
-        if (state == 0) {
-                ret = NFS3_VECWRITE_READFHLEN;
-                *readsize = 4;
-        } else if (state == NFS3_VECWRITE_READFHLEN) {
-                fhlen_n = *(uint32_t *)(curr_addr - 4);
-                fhlen = ntohl (fhlen_n);
-                *readsize = xdr_length_round_up (fhlen, NFS3_FHSIZE);
-                ret = NFS3_VECWRITE_READFH;
-        } else if (state == NFS3_VECWRITE_READFH) {
-                *readsize = NFS3_WRITE_POSTFH_SIZE;
-                ret = NFS3_VECWRITE_READREST;
-        } else if (state == NFS3_VECWRITE_READREST) {
-                ret = 0;
-                *readsize = 0;
-        } else
-                gf_msg ("nfs", GF_LOG_ERROR, 0, NFS_MSG_STATE_WRONG,
-                        "state wrong");
+nfs3svc_write_vecsizer(int state, ssize_t *readsize, char *base_addr,
+                       char *curr_addr)
+{
+    int ret = 0;
+    uint32_t fhlen = 0;
+    uint32_t fhlen_n = 0;
+
+    if (state == 0) {
+        ret = NFS3_VECWRITE_READFHLEN;
+        *readsize = 4;
+    } else if (state == NFS3_VECWRITE_READFHLEN) {
+        fhlen_n = *(uint32_t *)(curr_addr - 4);
+        fhlen = ntohl(fhlen_n);
+        *readsize = xdr_length_round_up(fhlen, NFS3_FHSIZE);
+        ret = NFS3_VECWRITE_READFH;
+    } else if (state == NFS3_VECWRITE_READFH) {
+        *readsize = NFS3_WRITE_POSTFH_SIZE;
+        ret = NFS3_VECWRITE_READREST;
+    } else if (state == NFS3_VECWRITE_READREST) {
+        ret = 0;
+        *readsize = 0;
+    } else
+        gf_msg("nfs", GF_LOG_ERROR, 0, NFS_MSG_STATE_WRONG, "state wrong");
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_write (rpcsvc_request_t *req)
-{
-        struct nfs3_fh          fh = {{0}, };
-        write3args              args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_write3args (&args, &fh);
-        if (xdr_to_write3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        /* To ensure that the iobuf for the current record does not
-         * get returned to the iobpool, we need to keep a reference for
-         * ourselves because the RPC call handler who called us will unref its
-         * own ref of the record's iobuf when it is done handling the request.
-         */
+nfs3svc_write(rpcsvc_request_t *req)
+{
+    struct nfs3_fh fh = {
+        {0},
+    };
+    write3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_write (req, &fh, args.offset, args.count, args.stable,
-                          req->msg[1], rpcsvc_request_iobref_ref (req));
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_WRITE_FAIL,
-                        "WRITE procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_write3args(&args, &fh);
+    if (xdr_to_write3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    /* To ensure that the iobuf for the current record does not
+     * get returned to the iobpool, we need to keep a reference for
+     * ourselves because the RPC call handler who called us will unref its
+     * own ref of the record's iobuf when it is done handling the request.
+     */
+
+    ret = nfs3_write(req, &fh, args.offset, args.count, args.stable,
+                     req->msg[1], rpcsvc_request_iobref_ref(req));
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_WRITE_FAIL,
+               "WRITE procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_create_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh,
-                   struct iatt *newbuf, struct iatt *preparent,
-                   struct iatt *postparent)
+nfs3_create_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *newfh,
+                  struct iatt *newbuf, struct iatt *preparent,
+                  struct iatt *postparent)
 {
-        create3res      res = {0, };
-        uint64_t        deviceid = 0;
+    create3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_create3res (&res, stat, newfh, newbuf, preparent, postparent,
-                              deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_create3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_create3res(&res, stat, newfh, newbuf, preparent, postparent,
+                         deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_create3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_create_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                            int32_t op_ret, int32_t op_errno,
-                            struct iatt *preop, struct iatt *postop, dict_t *xdata)
+nfs3svc_create_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                           int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                           struct iatt *postop, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                            NFS3_CREATE, stat, op_errno,
-                            &cs->fh, cs->resolvedloc.path);
-        nfs3_create_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
-                           &cs->postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat, op_errno,
+                       &cs->fh, cs->resolvedloc.path);
+    nfs3_create_reply(cs->req, stat, &cs->fh, postop, &cs->preparent,
+                      &cs->postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+nfs3svc_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-        inode_t                 *oldinode = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
-
-        nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
-        oldinode = inode_link (inode, cs->resolvedloc.parent,
-                               cs->resolvedloc.name, buf);
-
-        /* Means no attributes were required to be set. */
-        if (!cs->setattr_valid) {
-                stat = NFS3_OK;
-                ret = -1;
-                goto nfs3err;
-        }
-
-        cs->preparent = *preparent;
-        cs->postparent = *postparent;
-        nfs_request_user_init (&nfu, cs->req);
-        gf_uuid_copy (cs->resolvedloc.gfid, oldinode->gfid);
-        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf,
-                           cs->setattr_valid, nfs3svc_create_setattr_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    inode_t *oldinode = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh);
+    oldinode = inode_link(inode, cs->resolvedloc.parent, cs->resolvedloc.name,
+                          buf);
+
+    /* Means no attributes were required to be set. */
+    if (!cs->setattr_valid) {
+        stat = NFS3_OK;
+        ret = -1;
+        goto nfs3err;
+    }
+
+    cs->preparent = *preparent;
+    cs->postparent = *postparent;
+    nfs_request_user_init(&nfu, cs->req);
+    gf_uuid_copy(cs->resolvedloc.gfid, oldinode->gfid);
+    ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf,
+                      cs->setattr_valid, nfs3svc_create_setattr_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (oldinode) {
-                inode_lookup (oldinode);
-                inode_unref (oldinode);
-        }
+    if (oldinode) {
+        inode_lookup(oldinode);
+        inode_unref(oldinode);
+    }
 
-        if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                                    NFS3_CREATE, stat, op_errno, &cs->fh,
-                                    cs->resolvedloc.path);
-                nfs3_create_reply (cs->req, stat, &cs->fh, buf, preparent,
-                                   postparent);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat,
+                           op_errno, &cs->fh, cs->resolvedloc.path);
+        nfs3_create_reply(cs->req, stat, &cs->fh, buf, preparent, postparent);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-nfs3_create_common (nfs3_call_state_t *cs)
+nfs3_create_common(nfs3_call_state_t *cs)
 {
-        int                     ret = -EFAULT;
-        int                     flags = 0;
-        nfs_user_t              nfu = {0, };
-        uid_t                   uid = 0;
-        gid_t                   gid = 0;
-
-        if (!cs)
-                return ret;
-
-        if (cs->createmode == GUARDED)
-                flags = (O_RDWR | O_EXCL);
-        else
-                flags = O_RDWR;
-
-        if (gf_attr_uid_set (cs->setattr_valid)) {
-                uid = cs->stbuf.ia_uid;
-                cs->setattr_valid &= ~GF_SET_ATTR_UID;
-        } else
-                uid = rpcsvc_request_uid (cs->req);
-
-        if (gf_attr_gid_set (cs->setattr_valid)) {
-                gid = cs->stbuf.ia_gid;
-                cs->setattr_valid &= ~GF_SET_ATTR_GID;
-        } else
-                gid = rpcsvc_request_gid (cs->req);
-
-        nfs_request_primary_user_init (&nfu, cs->req, uid, gid);
-        /* We can avoid sending the setattr call later if only the mode is
-         * required to be set. This is possible because the create fop allows
-         * us to specify a mode arg.
-         */
-        if (cs->setattr_valid & GF_SET_ATTR_MODE) {
-                cs->setattr_valid &= ~GF_SET_ATTR_MODE;
-                ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  flags, cs->mode, nfs3svc_create_cbk, cs);
-        } else
-                ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  flags, NFS_DEFAULT_CREATE_MODE,
-                                  nfs3svc_create_cbk, cs);
+    int ret = -EFAULT;
+    int flags = 0;
+    nfs_user_t nfu = {
+        0,
+    };
+    uid_t uid = 0;
+    gid_t gid = 0;
 
+    if (!cs)
         return ret;
-}
 
+    if (cs->createmode == GUARDED)
+        flags = (O_RDWR | O_EXCL);
+    else
+        flags = O_RDWR;
+
+    if (gf_attr_uid_set(cs->setattr_valid)) {
+        uid = cs->stbuf.ia_uid;
+        cs->setattr_valid &= ~GF_SET_ATTR_UID;
+    } else
+        uid = rpcsvc_request_uid(cs->req);
+
+    if (gf_attr_gid_set(cs->setattr_valid)) {
+        gid = cs->stbuf.ia_gid;
+        cs->setattr_valid &= ~GF_SET_ATTR_GID;
+    } else
+        gid = rpcsvc_request_gid(cs->req);
+
+    nfs_request_primary_user_init(&nfu, cs->req, uid, gid);
+    /* We can avoid sending the setattr call later if only the mode is
+     * required to be set. This is possible because the create fop allows
+     * us to specify a mode arg.
+     */
+    if (cs->setattr_valid & GF_SET_ATTR_MODE) {
+        cs->setattr_valid &= ~GF_SET_ATTR_MODE;
+        ret = nfs_create(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, flags,
+                         cs->mode, nfs3svc_create_cbk, cs);
+    } else
+        ret = nfs_create(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, flags,
+                         NFS_DEFAULT_CREATE_MODE, nfs3svc_create_cbk, cs);
+
+    return ret;
+}
 
 int32_t
-nfs3svc_create_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                         dict_t *xdata)
+nfs3svc_create_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                        dict_t *xdata)
 {
-        int                     ret = -EFAULT;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        nfs_request_user_init (&nfu, cs->req);
-        if (op_ret == -1) {
-                ret = -op_errno;
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
-
-        if ((cs->stbuf.ia_mtime == buf->ia_mtime) &&
-            (cs->stbuf.ia_atime == buf->ia_atime)) {
-                gf_msg_debug (GF_NFS3, 0,
-                        "Create req retransmitted verf %ld %ld",
-                        cs->stbuf.ia_mtime, cs->stbuf.ia_atime);
-                stat = NFS3_OK;
-                nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
-        } else {
-                gf_msg_debug (GF_NFS3, 0,
-                        "File already exist new_verf %ld %ld"
-                        "old_verf %ld %ld", cs->stbuf.ia_mtime,
-                        cs->stbuf.ia_atime,
-                        buf->ia_mtime, buf->ia_atime);
-                stat = NFS3ERR_EXIST;
-        }
+    int ret = -EFAULT;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    nfs_request_user_init(&nfu, cs->req);
+    if (op_ret == -1) {
+        ret = -op_errno;
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    if ((cs->stbuf.ia_mtime == buf->ia_mtime) &&
+        (cs->stbuf.ia_atime == buf->ia_atime)) {
+        gf_msg_debug(GF_NFS3, 0, "Create req retransmitted verf %ld %ld",
+                     cs->stbuf.ia_mtime, cs->stbuf.ia_atime);
+        stat = NFS3_OK;
+        nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh);
+    } else {
+        gf_msg_debug(GF_NFS3, 0,
+                     "File already exist new_verf %ld %ld"
+                     "old_verf %ld %ld",
+                     cs->stbuf.ia_mtime, cs->stbuf.ia_atime, buf->ia_mtime,
+                     buf->ia_atime);
+        stat = NFS3ERR_EXIST;
+    }
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_CREATE, stat, op_errno,
-                                     cs->resolvedloc.path);
-                nfs3_create_reply (cs->req, stat, &cs->fh, buf, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat,
+                            op_errno, cs->resolvedloc.path);
+        nfs3_create_reply(cs->req, stat, &cs->fh, buf, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_create_exclusive (nfs3_call_state_t *cs)
-{
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-
-        if (!cs)
-                return ret;
-
-        /* Storing verifier as a mtime and atime attribute, to store it
-         * in stable storage */
-        memcpy (&cs->stbuf.ia_atime, &cs->cookieverf,
-                sizeof (cs->stbuf.ia_atime));
-        memcpy (&cs->stbuf.ia_mtime,
-                ((char *) &cs->cookieverf) + sizeof (cs->stbuf.ia_atime),
-                sizeof (cs->stbuf.ia_mtime));
-        cs->setattr_valid |= GF_SET_ATTR_ATIME;
-        cs->setattr_valid |= GF_SET_ATTR_MTIME;
-        nfs_request_user_init (&nfu, cs->req);
-
-        /* If the file already existed we need to get that attributes so we can
-         * compare and check whether a previous create operation was
-         * interrupted due to server failure or dropped packets.
-         */
-        if ((cs->resolve_ret == 0) ||
-            ((cs->resolve_ret == -1) && (cs->resolve_errno != ENOENT))) {
-                ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                nfs3svc_create_stat_cbk, cs);
-                goto nfs3err;
-        }
+nfs3_create_exclusive(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        ret = nfs3_create_common (cs);
-nfs3err:
+    if (!cs)
         return ret;
-}
 
+    /* Storing verifier as a mtime and atime attribute, to store it
+     * in stable storage */
+    memcpy(&cs->stbuf.ia_atime, &cs->cookieverf, sizeof(cs->stbuf.ia_atime));
+    memcpy(&cs->stbuf.ia_mtime,
+           ((char *)&cs->cookieverf) + sizeof(cs->stbuf.ia_atime),
+           sizeof(cs->stbuf.ia_mtime));
+    cs->setattr_valid |= GF_SET_ATTR_ATIME;
+    cs->setattr_valid |= GF_SET_ATTR_MTIME;
+    nfs_request_user_init(&nfu, cs->req);
+
+    /* If the file already existed we need to get that attributes so we can
+     * compare and check whether a previous create operation was
+     * interrupted due to server failure or dropped packets.
+     */
+    if ((cs->resolve_ret == 0) ||
+        ((cs->resolve_ret == -1) && (cs->resolve_errno != ENOENT))) {
+        ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                       nfs3svc_create_stat_cbk, cs);
+        goto nfs3err;
+    }
+
+    ret = nfs3_create_common(cs);
+nfs3err:
+    return ret;
+}
 
 int
-nfs3_create_resume (void *carg)
+nfs3_create_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_auth_status (cs, stat, _gf_true, nfs3err);
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
-        if (cs->createmode == EXCLUSIVE)
-                ret = nfs3_create_exclusive (cs);
-        else
-                ret = nfs3_create_common (cs);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_auth_status(cs, stat, _gf_true, nfs3err);
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
+    if (cs->createmode == EXCLUSIVE)
+        ret = nfs3_create_exclusive(cs);
+    else
+        ret = nfs3_create_common(cs);
 
-        /* Handle a failure return from either of the create functions above. */
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    /* Handle a failure return from either of the create functions above. */
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_CREATE, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_create_reply (cs->req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_CREATE, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_create_reply(cs->req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nfs3_create (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
-             createmode3 mode, sattr3 *sattr, uint64_t cverf)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!dirfh) || (!name) || (!sattr))
-                return -1;
-
-        nfs3_log_create_call (rpcsvc_request_xid (req), dirfh, name, mode);
-        nfs3_validate_gluster_fh (dirfh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->cookieverf = cverf;
-        /*In Exclusive create client is supposed to send cverf instead of
-         * sattr*/
-        if (mode != EXCLUSIVE)
-                cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr,
-                                                                  &cs->stbuf,
-                                                                  &cs->mode);
-        cs->createmode = mode;
-        cs->parent = *dirfh;
-
-        ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_create_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_create(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
+            createmode3 mode, sattr3 *sattr, uint64_t cverf)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!dirfh) || (!name) || (!sattr))
+        return -1;
+
+    nfs3_log_create_call(rpcsvc_request_xid(req), dirfh, name, mode);
+    nfs3_validate_gluster_fh(dirfh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->cookieverf = cverf;
+    /*In Exclusive create client is supposed to send cverf instead of
+     * sattr*/
+    if (mode != EXCLUSIVE)
+        cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf,
+                                                         &cs->mode);
+    cs->createmode = mode;
+    cs->parent = *dirfh;
+
+    ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_create_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_CREATE, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_create_reply (req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_CREATE, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_create_reply(req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_create (rpcsvc_request_t *req)
-{
-        char            name[NFS_PATH_MAX];
-        struct nfs3_fh  dirfh = {{0}, };
-        create3args     args;
-        int             ret   = RPCSVC_ACTOR_ERROR;
-        uint64_t        cverf = 0;
-        uint64_t       *cval;
-
-        if (!req)
-                return ret;
-
-        nfs3_prep_create3args (&args, &dirfh, name);
-        if (xdr_to_create3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        cval = (uint64_t *)args.how.createhow3_u.verf;
-        cverf = *cval;
+nfs3svc_create(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh dirfh = {
+        {0},
+    };
+    create3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
+    uint64_t cverf = 0;
+    uint64_t *cval;
+
+    if (!req)
+        return ret;
 
-        ret = nfs3_create (req, &dirfh, name, args.how.mode,
-                           &args.how.createhow3_u.obj_attributes, cverf);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_CREATE_FAIL,
-                        "CREATE procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_create3args(&args, &dirfh, name);
+    if (xdr_to_create3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    cval = (uint64_t *)args.how.createhow3_u.verf;
+    cverf = *cval;
+
+    ret = nfs3_create(req, &dirfh, name, args.how.mode,
+                      &args.how.createhow3_u.obj_attributes, cverf);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_CREATE_FAIL,
+               "CREATE procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_mkdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent)
+nfs3_mkdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent)
 {
-        mkdir3res       res = {0, };
-        uint64_t        deviceid = 0;
+    mkdir3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_mkdir3res (&res, stat, fh, buf, preparent, postparent,
-                             deviceid);
-        nfs3svc_submit_reply (req, &res,
-                              (nfs3_serializer)xdr_serialize_mkdir3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_mkdir3res(&res, stat, fh, buf, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_mkdir3res);
+    return 0;
 }
 
 int32_t
-nfs3svc_mkdir_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno,
-                           struct iatt *preop, struct iatt *postop, dict_t *xdata)
+nfs3svc_mkdir_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                          struct iatt *postop, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                            NFS3_MKDIR, stat, op_errno, &cs->fh,
-                            cs->resolvedloc.path);
-        nfs3_mkdir_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
-                          &cs->postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat, op_errno,
+                       &cs->fh, cs->resolvedloc.path);
+    nfs3_mkdir_reply(cs->req, stat, &cs->fh, postop, &cs->preparent,
+                     &cs->postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs3svc_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
+    nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh);
 
-        /* Means no attributes were required to be set. */
-        if (!cs->setattr_valid) {
-                stat = NFS3_OK;
-                goto nfs3err;
-        }
+    /* Means no attributes were required to be set. */
+    if (!cs->setattr_valid) {
+        stat = NFS3_OK;
+        goto nfs3err;
+    }
 
-        cs->preparent = *preparent;
-        cs->postparent = *postparent;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf,
-                           cs->setattr_valid, nfs3svc_mkdir_setattr_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs->preparent = *preparent;
+    cs->postparent = *postparent;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf,
+                      cs->setattr_valid, nfs3svc_mkdir_setattr_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                                    NFS3_MKDIR, stat, op_errno, &cs->fh,
-                                    cs->resolvedloc.path);
-                nfs3_mkdir_reply (cs->req, stat, &cs->fh, buf, preparent,
-                                  postparent);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat,
+                           op_errno, &cs->fh, cs->resolvedloc.path);
+        nfs3_mkdir_reply(cs->req, stat, &cs->fh, buf, preparent, postparent);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_mkdir_resume (void *carg)
+nfs3_mkdir_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
 
-        if (gf_attr_mode_set (cs->setattr_valid)) {
-                cs->setattr_valid &= ~GF_SET_ATTR_MODE;
-                ret = nfs_mkdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 cs->mode, nfs3svc_mkdir_cbk, cs);
-        } else
-                ret = nfs_mkdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 cs->mode, nfs3svc_mkdir_cbk, cs);
+    if (gf_attr_mode_set(cs->setattr_valid)) {
+        cs->setattr_valid &= ~GF_SET_ATTR_MODE;
+        ret = nfs_mkdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->mode,
+                        nfs3svc_mkdir_cbk, cs);
+    } else
+        ret = nfs_mkdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, cs->mode,
+                        nfs3svc_mkdir_cbk, cs);
 
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_MKDIR, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_mkdir_reply (cs->req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_MKDIR, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_mkdir_reply(cs->req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
-
 int
-nfs3_mkdir (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
-            sattr3 *sattr)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!dirfh) || (!name) || (!sattr)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "MKDIR", dirfh,
-                                name);
-        nfs3_validate_gluster_fh (dirfh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->parent = *dirfh;
-        cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr, &cs->stbuf,
-                                                          &cs->mode);
-        ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_mkdir_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_mkdir(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
+           sattr3 *sattr)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!dirfh) || (!name) || (!sattr)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "MKDIR", dirfh, name);
+    nfs3_validate_gluster_fh(dirfh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->parent = *dirfh;
+    cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf,
+                                                     &cs->mode);
+    ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_mkdir_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_MKDIR, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_mkdir_reply (req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_MKDIR, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_mkdir_reply(req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_mkdir (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          dirfh = {{0}, };
-        mkdir3args              args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_mkdir3args (&args, &dirfh, name);
-        if (xdr_to_mkdir3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_mkdir(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh dirfh = {
+        {0},
+    };
+    mkdir3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_mkdir (req, &dirfh, name, &args.attributes);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL,
-                        "MKDIR procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_mkdir3args(&args, &dirfh, name);
+    if (xdr_to_mkdir3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_mkdir(req, &dirfh, name, &args.attributes);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL,
+               "MKDIR procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_symlink_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
-                    struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent)
+nfs3_symlink_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
+                   struct iatt *buf, struct iatt *preparent,
+                   struct iatt *postparent)
 {
-        symlink3res     res = {0, };
-        uint64_t        deviceid = 0;
+    symlink3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_symlink3res (&res, stat, fh, buf, preparent, postparent,
-                               deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_symlink3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_symlink3res(&res, stat, fh, buf, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_symlink3res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, inode_t *inode,
-                     struct iatt *buf, struct iatt *preparent,
-                     struct iatt *postparent, dict_t *xdata)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t               *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+nfs3svc_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *buf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
-        stat = NFS3_OK;
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
+
+    nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh);
+    stat = NFS3_OK;
 
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                            NFS3_SYMLINK, stat, op_errno, &cs->fh,
-                            cs->resolvedloc.path);
-        nfs3_symlink_reply (cs->req, stat, &cs->fh, buf, preparent,
-                            postparent);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_SYMLINK, stat,
+                       op_errno, &cs->fh, cs->resolvedloc.path);
+    nfs3_symlink_reply(cs->req, stat, &cs->fh, buf, preparent, postparent);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int
-nfs3_symlink_resume (void *carg)
+nfs3_symlink_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        nfs_user_t                      nfu = {0, };
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_symlink (cs->nfsx, cs->vol, &nfu, cs->pathname,
-                           &cs->resolvedloc, nfs3svc_symlink_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_symlink(cs->nfsx, cs->vol, &nfu, cs->pathname, &cs->resolvedloc,
+                      nfs3svc_symlink_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_SYMLINK, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_symlink_reply (cs->req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_SYMLINK, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_symlink_reply(cs->req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_symlink (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
-              char *target, sattr3 *sattr)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!dirfh) || (!name) || (!target) || (!sattr)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_symlink_call (rpcsvc_request_xid (req), dirfh, name,
-                               target);
-        nfs3_validate_gluster_fh (dirfh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->parent = *dirfh;
-        cs->pathname = gf_strdup (target);
-        if (!cs->pathname) {
-                ret = -1;
-                stat = NFS3ERR_SERVERFAULT;
-                goto nfs3err;
-        }
-
-        ret = nfs3_fh_resolve_and_resume (cs, dirfh, name, nfs3_symlink_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_symlink(rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
+             char *target, sattr3 *sattr)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!dirfh) || (!name) || (!target) || (!sattr)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_symlink_call(rpcsvc_request_xid(req), dirfh, name, target);
+    nfs3_validate_gluster_fh(dirfh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->parent = *dirfh;
+    cs->pathname = gf_strdup(target);
+    if (!cs->pathname) {
+        ret = -1;
+        stat = NFS3ERR_SERVERFAULT;
+        goto nfs3err;
+    }
+
+    ret = nfs3_fh_resolve_and_resume(cs, dirfh, name, nfs3_symlink_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_SYMLINK, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_symlink_reply (req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_SYMLINK, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_symlink_reply(req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_symlink (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          dirfh = {{0}, };
-        char                    target[NFS_PATH_MAX];
-        symlink3args            args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_symlink3args (&args, &dirfh, name, target);
-        if (xdr_to_symlink3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_symlink(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh dirfh = {
+        {0},
+    };
+    char target[NFS_PATH_MAX];
+    symlink3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_symlink (req, &dirfh, name, target,
-                            &args.symlink.symlink_attributes);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_SYMLINK_FAIL,
-                        "SYMLINK procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_symlink3args(&args, &dirfh, name, target);
+    if (xdr_to_symlink3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_symlink(req, &dirfh, name, target,
+                       &args.symlink.symlink_attributes);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_SYMLINK_FAIL,
+               "SYMLINK procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 static int
-nfs3_mknod_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent)
+nfs3_mknod_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *fh,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent)
 {
-        mknod3res       res = {0, };
-        uint64_t        deviceid = 0;
+    mknod3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_mknod3res (&res, stat, fh, buf, preparent, postparent,
-                             deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_mknod3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_mknod3res(&res, stat, fh, buf, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_mknod3res);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-nfs3svc_mknod_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno,
-                           struct iatt *preop, struct iatt *postop, dict_t *xdata)
+nfs3svc_mknod_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *preop,
+                          struct iatt *postop, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                            NFS3_MKNOD, stat, op_errno, &cs->fh,
-                            cs->resolvedloc.path);
-        nfs3_mknod_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
-                          &cs->postparent);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat, op_errno,
+                       &cs->fh, cs->resolvedloc.path);
+    nfs3_mknod_reply(cs->req, stat, &cs->fh, postop, &cs->preparent,
+                     &cs->postparent);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
-
 int32_t
-nfs3svc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, inode_t *inode,
-                   struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs3svc_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *buf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -1;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -1;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
+    nfs3_fh_build_child_fh(&cs->parent, buf, &cs->fh);
 
-        /* Means no attributes were required to be set. */
-        if (!cs->setattr_valid) {
-                stat = NFS3_OK;
-                ret = -1;
-                goto nfs3err;
-        }
-
-        cs->preparent = *preparent;
-        cs->postparent = *postparent;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf,
-                           cs->setattr_valid, nfs3svc_mknod_setattr_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    /* Means no attributes were required to be set. */
+    if (!cs->setattr_valid) {
+        stat = NFS3_OK;
+        ret = -1;
+        goto nfs3err;
+    }
+
+    cs->preparent = *preparent;
+    cs->postparent = *postparent;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_setattr(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, &cs->stbuf,
+                      cs->setattr_valid, nfs3svc_mknod_setattr_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req),
-                                    NFS3_MKNOD, stat, op_errno, &cs->fh,
-                                    cs->resolvedloc.path);
-                nfs3_mknod_reply (cs->req, stat, &cs->fh, buf, preparent,
-                                  postparent);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_newfh_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat,
+                           op_errno, &cs->fh, cs->resolvedloc.path);
+        nfs3_mknod_reply(cs->req, stat, &cs->fh, buf, preparent, postparent);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 static int
-nfs3_mknod_device (nfs3_call_state_t *cs)
-{
-        int                             ret = -EFAULT;
-        dev_t                           devnum = 0;
-        mode_t                          mode = 0;
-        nfs_user_t                      nfu = {0, };
-
-        if (!cs)
-                return ret;
-
-        devnum = makedev (cs->devnums.specdata1, cs->devnums.specdata2);
-        if (cs->mknodtype == NF3CHR)
-                mode = S_IFCHR;
-        else
-                mode = S_IFBLK;
-
-        nfs_request_user_init (&nfu, cs->req);
-        if (gf_attr_mode_set (cs->setattr_valid)) {
-                cs->setattr_valid &= ~GF_SET_ATTR_MODE;
-                mode |= cs->mode;
-                ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 mode, devnum, nfs3svc_mknod_cbk, cs);
-        } else
-                ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 mode, devnum, nfs3svc_mknod_cbk, cs);
+nfs3_mknod_device(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    dev_t devnum = 0;
+    mode_t mode = 0;
+    nfs_user_t nfu = {
+        0,
+    };
 
+    if (!cs)
         return ret;
-}
 
+    devnum = makedev(cs->devnums.specdata1, cs->devnums.specdata2);
+    if (cs->mknodtype == NF3CHR)
+        mode = S_IFCHR;
+    else
+        mode = S_IFBLK;
+
+    nfs_request_user_init(&nfu, cs->req);
+    if (gf_attr_mode_set(cs->setattr_valid)) {
+        cs->setattr_valid &= ~GF_SET_ATTR_MODE;
+        mode |= cs->mode;
+        ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, devnum,
+                        nfs3svc_mknod_cbk, cs);
+    } else
+        ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, devnum,
+                        nfs3svc_mknod_cbk, cs);
+
+    return ret;
+}
 
 static int
-nfs3_mknod_fifo (nfs3_call_state_t *cs, mode_t mode)
+nfs3_mknod_fifo(nfs3_call_state_t *cs, mode_t mode)
 {
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!cs)
-                return ret;
+    if (!cs)
+        return ret;
 
-        nfs_request_user_init (&nfu, cs->req);
-        if (gf_attr_mode_set (cs->setattr_valid)) {
-                cs->setattr_valid &= ~GF_SET_ATTR_MODE;
-                mode |= cs->mode;
-                ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 mode, 0, nfs3svc_mknod_cbk, cs);
-        } else
-                ret = nfs_mknod (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 mode, 0, nfs3svc_mknod_cbk, cs);
+    nfs_request_user_init(&nfu, cs->req);
+    if (gf_attr_mode_set(cs->setattr_valid)) {
+        cs->setattr_valid &= ~GF_SET_ATTR_MODE;
+        mode |= cs->mode;
+        ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, 0,
+                        nfs3svc_mknod_cbk, cs);
+    } else
+        ret = nfs_mknod(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, mode, 0,
+                        nfs3svc_mknod_cbk, cs);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-nfs3_mknod_resume (void *carg)
+nfs3_mknod_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-
-        if (!carg)
-                return ret;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
-        switch (cs->mknodtype) {
+    if (!carg)
+        return ret;
 
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
+    switch (cs->mknodtype) {
         case NF3CHR:
         case NF3BLK:
-                ret = nfs3_mknod_device (cs);
-                break;
+            ret = nfs3_mknod_device(cs);
+            break;
         case NF3SOCK:
-                ret = nfs3_mknod_fifo (cs, S_IFSOCK);
-                break;
+            ret = nfs3_mknod_fifo(cs, S_IFSOCK);
+            break;
         case NF3FIFO:
-                ret = nfs3_mknod_fifo (cs, S_IFIFO);
-                break;
+            ret = nfs3_mknod_fifo(cs, S_IFIFO);
+            break;
         default:
-                ret = -EBADF;
-                break;
-        }
+            ret = -EBADF;
+            break;
+    }
 
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_MKNOD, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_mknod_reply (cs->req, stat, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_MKNOD, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_mknod_reply(cs->req, stat, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-nfs3_mknod (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name,
-            mknoddata3 *nodedata)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-        sattr3                          *sattr = NULL;
-
-        if ((!req) || (!fh) || (!name) || (!nodedata)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_mknod_call (rpcsvc_request_xid (req), fh, name,
-                             nodedata->type);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->mknodtype = nodedata->type;
-        switch (nodedata->type) {
+nfs3_mknod(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name,
+           mknoddata3 *nodedata)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    sattr3 *sattr = NULL;
+
+    if ((!req) || (!fh) || (!name) || (!nodedata)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_mknod_call(rpcsvc_request_xid(req), fh, name, nodedata->type);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->mknodtype = nodedata->type;
+    switch (nodedata->type) {
         case NF3CHR:
         case NF3BLK:
-                cs->devnums = nodedata->mknoddata3_u.device.spec;
-                sattr = &nodedata->mknoddata3_u.device.dev_attributes;
-                cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr,
-                                                                  &cs->stbuf,
-                                                                  &cs->mode);
-                break;
+            cs->devnums = nodedata->mknoddata3_u.device.spec;
+            sattr = &nodedata->mknoddata3_u.device.dev_attributes;
+            cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf,
+                                                             &cs->mode);
+            break;
         case NF3SOCK:
         case NF3FIFO:
-                sattr = &nodedata->mknoddata3_u.pipe_attributes;
-                cs->setattr_valid = nfs3_sattr3_to_setattr_valid (sattr,
-                                                                  &cs->stbuf,
-                                                                  &cs->mode);
-                break;
+            sattr = &nodedata->mknoddata3_u.pipe_attributes;
+            cs->setattr_valid = nfs3_sattr3_to_setattr_valid(sattr, &cs->stbuf,
+                                                             &cs->mode);
+            break;
         default:
-                ret = -EBADF;
-                break;
-        }
+            ret = -EBADF;
+            break;
+    }
 
-        cs->parent = *fh;
-        ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_mknod_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs->parent = *fh;
+    ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_mknod_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_MKNOD, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_mknod_reply (req, stat, NULL, NULL, NULL, NULL);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_MKNOD, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_mknod_reply(req, stat, NULL, NULL, NULL, NULL);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_mknod (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          fh = {{0}, };
-        mknod3args              args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_mknod3args (&args, &fh, name);
-        if (xdr_to_mknod3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_mknod(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh fh = {
+        {0},
+    };
+    mknod3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_mknod (req, &fh, name, &args.what);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_MKNOD_FAIL,
-                        "MKNOD procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_mknod3args(&args, &fh, name);
+    if (xdr_to_mknod3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_mknod(req, &fh, name, &args.what);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_MKNOD_FAIL,
+               "MKNOD procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
 int
-nfs3_remove_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent
-                   , struct iatt *postparent)
+nfs3_remove_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent,
+                  struct iatt *postparent)
 {
-        remove3res      res = {0, };
-        uint64_t        deviceid = 0;
+    remove3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_remove3res (&res, stat, preparent, postparent, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_remove3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_remove3res(&res, stat, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_remove3res);
+    return 0;
 }
 
-
-
 int32_t
-nfs3svc_remove_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
+nfs3svc_remove_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    }
 
-        if (op_ret == 0)
-                stat = NFS3_OK;
+    if (op_ret == 0)
+        stat = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_REMOVE, stat, op_errno,
-                             cs->resolvedloc.path);
-        nfs3_remove_reply (cs->req, stat, preparent, postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_REMOVE, stat,
+                        op_errno, cs->resolvedloc.path);
+    nfs3_remove_reply(cs->req, stat, preparent, postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-__nfs3_remove (nfs3_call_state_t *cs)
-{
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        ia_type_t                       type = 0;
-
-        if (!cs)
-                return ret;
-        type = cs->resolvedloc.inode->ia_type;
-        nfs_request_user_init (&nfu, cs->req);
-        if (IA_ISDIR (type))
-                ret = nfs_rmdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                 nfs3svc_remove_cbk, cs);
-        else
-                ret = nfs_unlink (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  nfs3svc_remove_cbk, cs);
+__nfs3_remove(nfs3_call_state_t *cs)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    ia_type_t type = 0;
 
+    if (!cs)
         return ret;
-}
+    type = cs->resolvedloc.inode->ia_type;
+    nfs_request_user_init(&nfu, cs->req);
+    if (IA_ISDIR(type))
+        ret = nfs_rmdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                        nfs3svc_remove_cbk, cs);
+    else
+        ret = nfs_unlink(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                         nfs3svc_remove_cbk, cs);
 
+    return ret;
+}
 
 int
-nfs3_remove_resume (void *carg)
+nfs3_remove_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        ret = __nfs3_remove (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    ret = __nfs3_remove(cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_REMOVE, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_remove_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_REMOVE, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_remove_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_remove (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh) || (!name)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "REMOVE", fh,
-                                name);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_remove_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_remove(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh) || (!name)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "REMOVE", fh, name);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_remove_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_REMOVE, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_remove_reply (req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_REMOVE, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_remove_reply(req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_remove (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          fh = {{0}, };
-        remove3args             args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_remove3args (&args, &fh, name);
-        if (xdr_to_remove3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_remove(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh fh = {
+        {0},
+    };
+    remove3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_remove (req, &fh, name);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_REMOVE_FAIL,
-                        "REMOVE procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_remove3args(&args, &fh, name);
+    if (xdr_to_remove3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_remove(req, &fh, name);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_REMOVE_FAIL,
+               "REMOVE procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_rmdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent,
-                  struct iatt *postparent)
+nfs3_rmdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *preparent,
+                 struct iatt *postparent)
 {
-        rmdir3res       res = {0, };
-        uint64_t        deviceid = 0;
+    rmdir3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_rmdir3res (&res, stat, preparent, postparent, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_rmdir3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_rmdir3res(&res, stat, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_rmdir3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent, dict_t *xdata)
+nfs3svc_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_WARNING, op_errno, NFS_MSG_RMDIR_CBK,
-                        "%x: %s => -1 (%s)", rpcsvc_request_xid (cs->req),
-                        cs->resolvedloc.path, strerror (op_errno));
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else {
-                stat = NFS3_OK;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_WARNING, op_errno, NFS_MSG_RMDIR_CBK,
+               "%x: %s => -1 (%s)", rpcsvc_request_xid(cs->req),
+               cs->resolvedloc.path, strerror(op_errno));
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else {
+        stat = NFS3_OK;
+    }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_RMDIR, stat, op_errno,
-                             cs->resolvedloc.path);
-        nfs3_rmdir_reply (cs->req, stat, preparent, postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RMDIR, stat, op_errno,
+                        cs->resolvedloc.path);
+    nfs3_rmdir_reply(cs->req, stat, preparent, postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
 int
-nfs3_rmdir_resume (void *carg)
+nfs3_rmdir_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        nfs_user_t                      nfu = {0, };
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_rmdir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                         nfs3svc_rmdir_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_rmdir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                    nfs3svc_rmdir_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_RMDIR, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_rmdir_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RMDIR, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_rmdir_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-nfs3_rmdir (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh) || (!name)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_fh_entry_call (rpcsvc_request_xid (req), "RMDIR", fh,
-                                name);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto (name, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, name, nfs3_rmdir_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_rmdir(rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh) || (!name)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_fh_entry_call(rpcsvc_request_xid(req), "RMDIR", fh, name);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(name, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, name, nfs3_rmdir_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_RMDIR, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_rmdir_reply (req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_RMDIR, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_rmdir_reply(req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_rmdir (rpcsvc_request_t *req)
-{
-        char                    name[NFS_PATH_MAX];
-        struct nfs3_fh          fh = {{0}, };
-        rmdir3args              args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_rmdir3args (&args, &fh, name);
-        if (xdr_to_rmdir3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_rmdir(rpcsvc_request_t *req)
+{
+    char name[NFS_PATH_MAX];
+    struct nfs3_fh fh = {
+        {0},
+    };
+    rmdir3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_rmdir (req, &fh, name);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL,
-                        "RMDIR procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_rmdir3args(&args, &fh, name);
+    if (xdr_to_rmdir3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_rmdir(req, &fh, name);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL,
+               "RMDIR procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_rename_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf,
-                   struct iatt *preoldparent, struct iatt *postoldparent,
-                   struct iatt *prenewparent, struct iatt *postnewparent)
+nfs3_rename_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf,
+                  struct iatt *preoldparent, struct iatt *postoldparent,
+                  struct iatt *prenewparent, struct iatt *postnewparent)
 {
-        rename3res      res = {0, };
-        uint64_t        deviceid = 0;
+    rename3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_rename3res (&res, stat, buf, preoldparent, postoldparent,
-                              prenewparent, postnewparent, deviceid);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_rename3res(&res, stat, buf, preoldparent, postoldparent,
+                         prenewparent, postnewparent, deviceid);
 
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer) xdr_serialize_rename3res);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_rename3res);
 
-        return 0;
+    return 0;
 }
 
-
-
 int32_t
-nfs3svc_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    struct iatt *preoldparent, struct iatt *postoldparent,
-                    struct iatt *prenewparent, struct iatt *postnewparent,
-                    dict_t *xdata)
+nfs3svc_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
 {
-        int                     ret = -EFAULT;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    int ret = -EFAULT;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    stat = NFS3_OK;
 nfs3err:
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_RENAME, stat,
-                             -ret, cs->resolvedloc.path);
-        nfs3_rename_reply (cs->req, stat, buf, preoldparent, postoldparent,
-                           prenewparent, postnewparent);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat, -ret,
+                        cs->resolvedloc.path);
+    nfs3_rename_reply(cs->req, stat, buf, preoldparent, postoldparent,
+                      prenewparent, postnewparent);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int
-nfs3_rename_resume_dst (void *carg)
-{
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        nfs_user_t                      nfu = {0, };
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
-        cs->parent = cs->resolvefh;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_rename (cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc,
-                          nfs3svc_rename_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-
-nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_RENAME, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+nfs3_rename_resume_dst(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
+    if (!carg)
         return ret;
-}
 
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
+    cs->parent = cs->resolvefh;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_rename(cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc,
+                     nfs3svc_rename_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
+nfs3err:
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_rename_reply(cs->req, stat, NULL, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
+
+    return ret;
+}
 
 int
-nfs3_rename_resume_src (void *carg)
+nfs3_rename_resume_src(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        /* Copy the resolved loc for the source file into another loc
-         * for safekeeping till we resolve the dest loc.
-         */
-        nfs_loc_copy (&cs->oploc, &cs->resolvedloc);
-        nfs_loc_wipe (&cs->resolvedloc);
-        GF_FREE (cs->resolventry);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    /* Copy the resolved loc for the source file into another loc
+     * for safekeeping till we resolve the dest loc.
+     */
+    nfs_loc_copy(&cs->oploc, &cs->resolvedloc);
+    nfs_loc_wipe(&cs->resolvedloc);
+    GF_FREE(cs->resolventry);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &cs->fh, cs->pathname,
-                                          nfs3_rename_resume_dst);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs3_fh_resolve_and_resume(cs, &cs->fh, cs->pathname,
+                                     nfs3_rename_resume_dst);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_RENAME, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_RENAME, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_rename_reply(cs->req, stat, NULL, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_rename (rpcsvc_request_t *req, struct nfs3_fh *olddirfh, char *oldname,
-             struct nfs3_fh *newdirfh, char *newname)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!olddirfh) || (!oldname) || (!newdirfh) || (!newname)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_rename_call (rpcsvc_request_xid (req), olddirfh, oldname,
-                              newdirfh, newname);
-        nfs3_validate_gluster_fh (olddirfh, stat, nfs3err);
-        nfs3_validate_gluster_fh (newdirfh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto(oldname, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, olddirfh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, olddirfh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        /* While we resolve the source (fh, name) pair, we need to keep a copy
-         * of the dest (fh,name) pair.
-         */
-        cs->fh = *newdirfh;
-        cs->pathname = gf_strdup (newname);
-        if (!cs->pathname) {
-                stat = NFS3ERR_SERVERFAULT;
-                ret = -1;
-                goto nfs3err;
-        }
-
-        ret = nfs3_fh_resolve_and_resume (cs, olddirfh, oldname,
-                                          nfs3_rename_resume_src);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_rename(rpcsvc_request_t *req, struct nfs3_fh *olddirfh, char *oldname,
+            struct nfs3_fh *newdirfh, char *newname)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!olddirfh) || (!oldname) || (!newdirfh) || (!newname)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_rename_call(rpcsvc_request_xid(req), olddirfh, oldname, newdirfh,
+                         newname);
+    nfs3_validate_gluster_fh(olddirfh, stat, nfs3err);
+    nfs3_validate_gluster_fh(newdirfh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(oldname, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, olddirfh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, olddirfh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    /* While we resolve the source (fh, name) pair, we need to keep a copy
+     * of the dest (fh,name) pair.
+     */
+    cs->fh = *newdirfh;
+    cs->pathname = gf_strdup(newname);
+    if (!cs->pathname) {
+        stat = NFS3ERR_SERVERFAULT;
+        ret = -1;
+        goto nfs3err;
+    }
+
+    ret = nfs3_fh_resolve_and_resume(cs, olddirfh, oldname,
+                                     nfs3_rename_resume_src);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_RENAME, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_rename_reply (req, stat, NULL, NULL, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_RENAME, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_rename_reply(req, stat, NULL, NULL, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_rename (rpcsvc_request_t *req)
-{
-        char                    newname[NFS_PATH_MAX];
-        char                    oldname[NFS_PATH_MAX];
-        struct nfs3_fh          olddirfh = {{0}, };
-        struct nfs3_fh          newdirfh = {{0}, };
-        rename3args             args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_rename3args (&args, &olddirfh, oldname, &newdirfh, newname);
-        if (xdr_to_rename3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_rename (req, &olddirfh, oldname, &newdirfh, newname);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RENAME_FAIL,
-                        "RENAME procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_rename(rpcsvc_request_t *req)
+{
+    char newname[NFS_PATH_MAX];
+    char oldname[NFS_PATH_MAX];
+    struct nfs3_fh olddirfh = {
+        {0},
+    };
+    struct nfs3_fh newdirfh = {
+        {0},
+    };
+    rename3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    if (!req)
+        return ret;
+    nfs3_prep_rename3args(&args, &olddirfh, oldname, &newdirfh, newname);
+    if (xdr_to_rename3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_rename(req, &olddirfh, oldname, &newdirfh, newname);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RENAME_FAIL,
+               "RENAME procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_link_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf,
-                 struct iatt *preparent, struct iatt *postparent)
+nfs3_link_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf,
+                struct iatt *preparent, struct iatt *postparent)
 {
-        link3res        res = {0, };
-        uint64_t        deviceid = 0;
+    link3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_link3res (&res, stat, buf, preparent, postparent, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_link3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_link3res(&res, stat, buf, preparent, postparent, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_link3res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else
-                stat = NFS3_OK;
+nfs3svc_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *buf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else
+        stat = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_LINK, stat, op_errno,
-                             cs->resolvedloc.path);
-        nfs3_link_reply (cs->req, stat, buf, preparent, postparent);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, op_errno,
+                        cs->resolvedloc.path);
+    nfs3_link_reply(cs->req, stat, buf, preparent, postparent);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_link_resume_lnk (void *carg)
+nfs3_link_resume_lnk(void *carg)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        nfs_user_t              nfu = {0, };
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_new_fh_resolve_status (cs, stat, nfs3err);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_new_fh_resolve_status(cs, stat, nfs3err);
 
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_link (cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc,
-                        nfs3svc_link_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_link(cs->nfsx, cs->vol, &nfu, &cs->oploc, &cs->resolvedloc,
+                   nfs3svc_link_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_LINK, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_link_reply (cs->req, stat, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
-        return ret;
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_link_reply(cs->req, stat, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
+    return ret;
 }
 
-
 int
-nfs3_link_resume_tgt (void *carg)
+nfs3_link_resume_tgt(void *carg)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_loc_copy (&cs->oploc, &cs->resolvedloc);
-        nfs_loc_wipe (&cs->resolvedloc);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_loc_copy(&cs->oploc, &cs->resolvedloc);
+    nfs_loc_wipe(&cs->resolvedloc);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &cs->fh, cs->pathname,
-                                          nfs3_link_resume_lnk);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs3_fh_resolve_and_resume(cs, &cs->fh, cs->pathname,
+                                     nfs3_link_resume_lnk);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_LINK, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_link_reply (cs->req, stat, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_LINK, stat, -ret,
+                            cs->resolvedloc.path);
+        nfs3_link_reply(cs->req, stat, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_link (rpcsvc_request_t *req, struct nfs3_fh *targetfh,
-           struct nfs3_fh *dirfh, char *newname)
-{
-        xlator_t                *vol = NULL;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        struct nfs3_state       *nfs3 = NULL;
-        nfs3_call_state_t       *cs = NULL;
-
-        if ((!req) || (!targetfh) || (!dirfh) || (!newname)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_validate_gluster_fh (dirfh, stat, nfs3err);
-        nfs3_validate_gluster_fh (targetfh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret);
-        nfs3_map_fh_to_volume (nfs3, dirfh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, dirfh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->fh = *dirfh;
-        cs->pathname = gf_strdup (newname);
-        if (!cs->pathname) {
-                stat = NFS3ERR_SERVERFAULT;
-                ret = -1;
-                goto nfs3err;
-        }
-
-        ret = nfs3_fh_resolve_and_resume (cs, targetfh, NULL,
-                                          nfs3_link_resume_tgt);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_link(rpcsvc_request_t *req, struct nfs3_fh *targetfh,
+          struct nfs3_fh *dirfh, char *newname)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!targetfh) || (!dirfh) || (!newname)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_validate_gluster_fh(dirfh, stat, nfs3err);
+    nfs3_validate_gluster_fh(targetfh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_validate_strlen_or_goto(newname, NFS_NAME_MAX, nfs3err, stat, ret);
+    nfs3_map_fh_to_volume(nfs3, dirfh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, dirfh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->fh = *dirfh;
+    cs->pathname = gf_strdup(newname);
+    if (!cs->pathname) {
+        stat = NFS3ERR_SERVERFAULT;
+        ret = -1;
+        goto nfs3err;
+    }
+
+    ret = nfs3_fh_resolve_and_resume(cs, targetfh, NULL, nfs3_link_resume_tgt);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_LINK, stat,
-                                     -ret, cs ? cs->pathname : NULL);
-                nfs3_link_reply (req, stat, NULL, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_LINK, stat, -ret,
+                            cs ? cs->pathname : NULL);
+        nfs3_link_reply(req, stat, NULL, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
 int
-nfs3svc_link (rpcsvc_request_t *req)
-{
-        char                    newpath[NFS_PATH_MAX];
-        struct nfs3_fh          dirfh = {{0}, };
-        struct nfs3_fh          targetfh = {{0}, };
-        link3args               args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_link3args (&args, &targetfh, &dirfh, newpath);
-        if (xdr_to_link3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_link (req, &targetfh, &dirfh, newpath);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_LINK_FAIL,
-                        "LINK procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_link(rpcsvc_request_t *req)
+{
+    char newpath[NFS_PATH_MAX];
+    struct nfs3_fh dirfh = {
+        {0},
+    };
+    struct nfs3_fh targetfh = {
+        {0},
+    };
+    link3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    if (!req)
+        return ret;
+    nfs3_prep_link3args(&args, &targetfh, &dirfh, newpath);
+    if (xdr_to_link3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_link(req, &targetfh, &dirfh, newpath);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EXDEV, NFS_MSG_LINK_FAIL,
+               "LINK procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_readdirp_reply (rpcsvc_request_t *req, nfsstat3 stat,struct nfs3_fh *dirfh,
-                     uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries,
-                     count3 dircount, count3 maxcount, int is_eof)
+nfs3_readdirp_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh,
+                    uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries,
+                    count3 dircount, count3 maxcount, int is_eof)
 {
-        readdirp3res    res = {0, };
-        uint64_t        deviceid = 0;
+    readdirp3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_readdirp3res (&res, stat, dirfh, cverf, dirstat, entries,
-                                dircount, maxcount, is_eof, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer) xdr_serialize_readdirp3res);
-        nfs3_free_readdirp3res (&res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_readdirp3res(&res, stat, dirfh, cverf, dirstat, entries, dircount,
+                           maxcount, is_eof, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_readdirp3res);
+    nfs3_free_readdirp3res(&res);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_readdir_reply (rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh,
-                    uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries,
-                    count3 count, int is_eof)
+nfs3_readdir_reply(rpcsvc_request_t *req, nfsstat3 stat, struct nfs3_fh *dirfh,
+                   uint64_t cverf, struct iatt *dirstat, gf_dirent_t *entries,
+                   count3 count, int is_eof)
 {
-        readdir3res     res = {0, };
-        uint64_t        deviceid = 0;
+    readdir3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_readdir3res (&res, stat, dirfh, cverf, dirstat, entries, count
-                               , is_eof, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer) xdr_serialize_readdir3res);
-        nfs3_free_readdir3res (&res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_readdir3res(&res, stat, dirfh, cverf, dirstat, entries, count,
+                          is_eof, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_readdir3res);
+    nfs3_free_readdir3res(&res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_readdir_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                           dict_t *xdata)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     is_eof = 0;
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto nfs3err;
-        }
+nfs3svc_readdir_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                          dict_t *xdata)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int is_eof = 0;
+    nfs3_call_state_t *cs = NULL;
 
-        /* Check whether we encountered a end of directory stream while
-         * readdir'ing.
-         */
-        if (cs->operrno == ENOENT) {
-                gf_msg_trace (GF_NFS3, 0, "Reached end-of-directory");
-                is_eof = 1;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto nfs3err;
+    }
 
-        stat = NFS3_OK;
+    /* Check whether we encountered a end of directory stream while
+     * readdir'ing.
+     */
+    if (cs->operrno == ENOENT) {
+        gf_msg_trace(GF_NFS3, 0, "Reached end-of-directory");
+        is_eof = 1;
+    }
 
-        /* do inode linking here */
-        gf_link_inodes_from_dirent (this, cs->fd->inode, &cs->entries);
+    stat = NFS3_OK;
+
+    /* do inode linking here */
+    gf_link_inodes_from_dirent(this, cs->fd->inode, &cs->entries);
 
 nfs3err:
-        if (cs->maxcount == 0) {
-                nfs3_log_readdir_res (rpcsvc_request_xid (cs->req),
-                                      stat, op_errno, (uintptr_t)cs->fd,
-                                      cs->dircount, is_eof,
-                                      cs->resolvedloc.path);
-                nfs3_readdir_reply (cs->req, stat, &cs->parent,
-                                    (uintptr_t)cs->fd, buf, &cs->entries,
-                                    cs->dircount, is_eof);
-        } else {
-                nfs3_log_readdirp_res (rpcsvc_request_xid (cs->req),
-                                       stat, op_errno, (uintptr_t)cs->fd,
-                                       cs->dircount, cs->maxcount, is_eof,
-                                       cs->resolvedloc.path);
-                nfs3_readdirp_reply (cs->req, stat, &cs->parent,
-                                     (uintptr_t)cs->fd, buf,
-                                     &cs->entries, cs->dircount,
-                                     cs->maxcount, is_eof);
-        }
+    if (cs->maxcount == 0) {
+        nfs3_log_readdir_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                             (uintptr_t)cs->fd, cs->dircount, is_eof,
+                             cs->resolvedloc.path);
+        nfs3_readdir_reply(cs->req, stat, &cs->parent, (uintptr_t)cs->fd, buf,
+                           &cs->entries, cs->dircount, is_eof);
+    } else {
+        nfs3_log_readdirp_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                              (uintptr_t)cs->fd, cs->dircount, cs->maxcount,
+                              is_eof, cs->resolvedloc.path);
+        nfs3_readdirp_reply(cs->req, stat, &cs->parent, (uintptr_t)cs->fd, buf,
+                            &cs->entries, cs->dircount, cs->maxcount, is_eof);
+    }
 
-        if (is_eof) {
-                /* do nothing */
-        }
+    if (is_eof) {
+        /* do nothing */
+    }
 
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                     dict_t *xdata)
+nfs3svc_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        }
-
-        cs->operrno = op_errno;
-        list_splice_init (&entries->list, &cs->entries.list);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_fstat (cs->nfsx, cs->vol, &nfu, cs->fd,
-                         nfs3svc_readdir_fstat_cbk, cs);
-        if (ret < 0) {
-                op_ret = -1;
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-                op_errno = -ret;
-        }
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    }
+
+    cs->operrno = op_errno;
+    list_splice_init(&entries->list, &cs->entries.list);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_fstat(cs->nfsx, cs->vol, &nfu, cs->fd, nfs3svc_readdir_fstat_cbk,
+                    cs);
+    if (ret < 0) {
+        op_ret = -1;
+        stat = nfs3_errno_to_nfsstat3(-ret);
+        op_errno = -ret;
+    }
 
 err:
-        if (op_ret >= 0)
-                goto ret;
-
-        if (cs->maxcount == 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_READDIR, stat, op_errno,
-                                     cs->resolvedloc.path);
-                nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL, 0, 0);
-        } else {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_READDIRP, stat, op_errno,
-                                     cs->resolvedloc.path);
-                nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
-                                     0, 0, 0);
-        }
-
-        /* For directories, we force a purge from the fd cache on close
-         * so that next time the dir is read, we'll get any changed directory
-         * entries.
-         */
-        nfs3_call_state_wipe (cs);
+    if (op_ret >= 0)
+        goto ret;
+
+    if (cs->maxcount == 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat,
+                            op_errno, cs->resolvedloc.path);
+        nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0);
+    } else {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP, stat,
+                            op_errno, cs->resolvedloc.path);
+        nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0);
+    }
+
+    /* For directories, we force a purge from the fd cache on close
+     * so that next time the dir is read, we'll get any changed directory
+     * entries.
+     */
+    nfs3_call_state_wipe(cs);
 ret:
-        return 0;
+    return 0;
 }
 
 int
-nfs3_readdir_process (nfs3_call_state_t *cs)
+nfs3_readdir_process(nfs3_call_state_t *cs)
 {
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        if (!cs)
-                return ret;
-
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_readdirp (cs->nfsx, cs->vol, &nfu, cs->fd, cs->dircount,
-                            cs->cookie, nfs3svc_readdir_cbk, cs);
+    if (!cs)
         return ret;
-}
 
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_readdirp(cs->nfsx, cs->vol, &nfu, cs->fd, cs->dircount,
+                       cs->cookie, nfs3svc_readdir_cbk, cs);
+    return ret;
+}
 
 int
-nfs3_readdir_read_resume (void *carg)
+nfs3_readdir_read_resume(void *carg)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        struct nfs3_state       *nfs3 = NULL;
-
-        if (!carg)
-                return ret;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs3_state *nfs3 = NULL;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs3 = rpcsvc_request_program_private (cs->req);
-        ret = nfs3_verify_dircookie (nfs3, cs->fd, cs->cookie, cs->cookieverf,
-                                     &stat);
-        if (ret < 0)    /* Stat already set by verifier function above. */
-                goto nfs3err;
+    if (!carg)
+        return ret;
 
-        ret = nfs3_readdir_process (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs3 = rpcsvc_request_program_private(cs->req);
+    ret = nfs3_verify_dircookie(nfs3, cs->fd, cs->cookie, cs->cookieverf,
+                                &stat);
+    if (ret < 0) /* Stat already set by verifier function above. */
+        goto nfs3err;
+
+    ret = nfs3_readdir_process(cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 nfs3err:
-        if (ret < 0) {
-                if (cs->maxcount == 0) {
-                        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             NFS3_READDIR, stat, -ret,
-                                             cs->resolvedloc.path);
-                        nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL,
-                                            0, 0);
-                } else {
-                        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             NFS3_READDIRP, stat, -ret,
-                                             cs->resolvedloc.path);
-                        nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
-                                             0, 0, 0);
-                }
-                nfs3_call_state_wipe (cs);
+    if (ret < 0) {
+        if (cs->maxcount == 0) {
+            nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat,
+                                -ret, cs->resolvedloc.path);
+            nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0);
+        } else {
+            nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP,
+                                stat, -ret, cs->resolvedloc.path);
+            nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0);
         }
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_readdir_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, fd_t *fd,
-                             dict_t *xdata)
+nfs3svc_readdir_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                            int32_t op_ret, int32_t op_errno, fd_t *fd,
+                            dict_t *xdata)
 {
-        /*
-         * We don't really need this, it's just an artifact of forcing the
-         * opendir to happen.
-         */
-        if (fd) {
-                fd_unref(fd);
-        }
+    /*
+     * We don't really need this, it's just an artifact of forcing the
+     * opendir to happen.
+     */
+    if (fd) {
+        fd_unref(fd);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_readdir_open_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        nfs_user_t               nfu = {0, };
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        cs->fd = fd_anonymous (cs->resolvedloc.inode);
-        if (!cs->fd) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
-                        "Fail to create anonymous fd");
-                goto nfs3err;
-        }
+nfs3_readdir_open_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
-        /*
-         * NFS client will usually send us a readdirp without an opendir,
-         * which would cause us to skip our usual self-heal checks which occur
-         * in opendir for native protocol. To make sure those checks do happen,
-         * our most reliable option is to do our own opendir for any readdirp
-         * at the beginning of the directory.
-         */
-        if (cs->cookie == 0) {
-                nfs_request_user_init (&nfu, cs->req);
-                ret = nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                   nfs3svc_readdir_opendir_cbk, cs);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                                NFS_MSG_DIR_OP_FAIL,
-                                "auto-opendir failed");
-                }
+    if (!carg)
+        return ret;
+
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    cs->fd = fd_anonymous(cs->resolvedloc.inode);
+    if (!cs->fd) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
+               "Fail to create anonymous fd");
+        goto nfs3err;
+    }
+
+    /*
+     * NFS client will usually send us a readdirp without an opendir,
+     * which would cause us to skip our usual self-heal checks which occur
+     * in opendir for native protocol. To make sure those checks do happen,
+     * our most reliable option is to do our own opendir for any readdirp
+     * at the beginning of the directory.
+     */
+    if (cs->cookie == 0) {
+        nfs_request_user_init(&nfu, cs->req);
+        ret = nfs_opendir(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                          nfs3svc_readdir_opendir_cbk, cs);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_DIR_OP_FAIL,
+                   "auto-opendir failed");
         }
+    }
 
-        ret = nfs3_readdir_read_resume (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs3_readdir_read_resume(cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                if (cs->maxcount == 0) {
-                        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             NFS3_READDIR, stat, -ret,
-                                             cs->resolvedloc.path);
-                        nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL,
-                                            0, 0);
-                } else {
-                        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             NFS3_READDIRP, stat, -ret,
-                                             cs->resolvedloc.path);
-                        nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
-                                             0, 0, 0);
-                }
-                nfs3_call_state_wipe (cs);
+    if (ret < 0) {
+        if (cs->maxcount == 0) {
+            nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIR, stat,
+                                -ret, cs->resolvedloc.path);
+            nfs3_readdir_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0);
+        } else {
+            nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_READDIRP,
+                                stat, -ret, cs->resolvedloc.path);
+            nfs3_readdirp_reply(cs->req, stat, NULL, 0, NULL, NULL, 0, 0, 0);
         }
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
-
 int
-nfs3_readdir (rpcsvc_request_t *req, struct nfs3_fh *fh, cookie3 cookie,
-              uint64_t cverf, count3 dircount, count3 maxcount)
-{
-        xlator_t                *vol = NULL;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        struct nfs3_state       *nfs3 = NULL;
-        nfs3_call_state_t       *cs = NULL;
-        struct nfs_state        *nfs = NULL;
-        gf_boolean_t            is_readdirp = !!maxcount;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_readdir_call (rpcsvc_request_xid (req), fh, dircount,
-                               maxcount);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-        nfs = nfs_state (nfs3->nfsx);
-
-        if (is_readdirp && !nfs->rdirplus) {
-                ret = -ENOTSUP;
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-                goto nfs3err;
-        }
-
-        cs->cookieverf = cverf;
-        cs->dircount = dircount;
-        cs->maxcount = maxcount;
-        cs->cookie = cookie;
-        cs->parent = *fh;
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL,
-                                          nfs3_readdir_open_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_readdir(rpcsvc_request_t *req, struct nfs3_fh *fh, cookie3 cookie,
+             uint64_t cverf, count3 dircount, count3 maxcount)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs_state *nfs = NULL;
+    gf_boolean_t is_readdirp = !!maxcount;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_readdir_call(rpcsvc_request_xid(req), fh, dircount, maxcount);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+    nfs = nfs_state(nfs3->nfsx);
+
+    if (is_readdirp && !nfs->rdirplus) {
+        ret = -ENOTSUP;
+        stat = nfs3_errno_to_nfsstat3(-ret);
+        goto nfs3err;
+    }
+
+    cs->cookieverf = cverf;
+    cs->dircount = dircount;
+    cs->maxcount = maxcount;
+    cs->cookie = cookie;
+    cs->parent = *fh;
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_readdir_open_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                if (!is_readdirp) {
-                        nfs3_log_common_res (rpcsvc_request_xid (req),
-                                             NFS3_READDIR, stat, -ret,
-                                             cs ? cs->resolvedloc.path : NULL);
-                        nfs3_readdir_reply (req, stat, NULL, 0, NULL, NULL, 0,
-                                            0);
-                } else {
-                        nfs3_log_common_res (rpcsvc_request_xid (req),
-                                             NFS3_READDIRP, stat, -ret,
-                                             cs ? cs->resolvedloc.path : NULL);
-                        nfs3_readdirp_reply (req, stat, NULL, 0, NULL, NULL, 0,
-                                             0, 0);
-                }
-                /* Ret must be NULL after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-                nfs3_call_state_wipe (cs);
+    if (ret < 0) {
+        if (!is_readdirp) {
+            nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READDIR, stat,
+                                -ret, cs ? cs->resolvedloc.path : NULL);
+            nfs3_readdir_reply(req, stat, NULL, 0, NULL, NULL, 0, 0);
+        } else {
+            nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_READDIRP, stat,
+                                -ret, cs ? cs->resolvedloc.path : NULL);
+            nfs3_readdirp_reply(req, stat, NULL, 0, NULL, NULL, 0, 0, 0);
         }
+        /* Ret must be NULL after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+        nfs3_call_state_wipe(cs);
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_readdir (rpcsvc_request_t *req)
-{
-        readdir3args    ra;
-        struct nfs3_fh  fh = {{0},};
-        int             ret = RPCSVC_ACTOR_ERROR;
-        uint64_t        verf = 0;
-        uint64_t       *cval;
-
-        if (!req)
-                return ret;
-        nfs3_prep_readdir3args (&ra, &fh);
-        if (xdr_to_readdir3args (req->msg[0], &ra) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-        cval = (uint64_t *) ra.cookieverf;
-        verf =  *cval;
-
-        ret = nfs3_readdir (req, &fh, ra.cookie, verf, ra.count, 0);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_READDIR_FAIL,
-                        "READDIR procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_readdir(rpcsvc_request_t *req)
+{
+    readdir3args ra;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    int ret = RPCSVC_ACTOR_ERROR;
+    uint64_t verf = 0;
+    uint64_t *cval;
 
-rpcerr:
+    if (!req)
         return ret;
-}
+    nfs3_prep_readdir3args(&ra, &fh);
+    if (xdr_to_readdir3args(req->msg[0], &ra) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+    cval = (uint64_t *)ra.cookieverf;
+    verf = *cval;
+
+    ret = nfs3_readdir(req, &fh, ra.cookie, verf, ra.count, 0);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READDIR_FAIL,
+               "READDIR procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
+rpcerr:
+    return ret;
+}
 
 int
-nfs3svc_readdirp (rpcsvc_request_t *req)
-{
-        readdirp3args   ra;
-        struct nfs3_fh  fh = {{0},};
-        int             ret = RPCSVC_ACTOR_ERROR;
-        uint64_t        cverf = 0;
-        uint64_t       *cval;
-
-        if (!req)
-                return ret;
-        nfs3_prep_readdirp3args (&ra, &fh);
-        if (xdr_to_readdirp3args (req->msg[0], &ra) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-        cval = (uint64_t *) ra.cookieverf;
-        cverf = *cval;
-
-        ret = nfs3_readdir (req, &fh, ra.cookie, cverf, ra.dircount,
-                            ra.maxcount);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_READDIRP_FAIL,
-                        "READDIRP procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_readdirp(rpcsvc_request_t *req)
+{
+    readdirp3args ra;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    int ret = RPCSVC_ACTOR_ERROR;
+    uint64_t cverf = 0;
+    uint64_t *cval;
 
-rpcerr:
+    if (!req)
         return ret;
-}
+    nfs3_prep_readdirp3args(&ra, &fh);
+    if (xdr_to_readdirp3args(req->msg[0], &ra) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+    cval = (uint64_t *)ra.cookieverf;
+    cverf = *cval;
+
+    ret = nfs3_readdir(req, &fh, ra.cookie, cverf, ra.dircount, ra.maxcount);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_READDIRP_FAIL,
+               "READDIRP procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
+rpcerr:
+    return ret;
+}
 
 int
-nfs3_fsstat_reply (rpcsvc_request_t *req, nfsstat3 stat, struct statvfs *fsbuf,
-                   struct iatt *postbuf)
+nfs3_fsstat_reply(rpcsvc_request_t *req, nfsstat3 stat, struct statvfs *fsbuf,
+                  struct iatt *postbuf)
 {
-        fsstat3res      res = {0, };
-        uint64_t        deviceid = 0;
-
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_fsstat3res (&res, stat, fsbuf, postbuf, deviceid);
-        return nfs3svc_submit_reply (req, &res,
-                                     (nfs3_serializer)xdr_serialize_fsstat3res);
+    fsstat3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_fsstat3res(&res, stat, fsbuf, postbuf, deviceid);
+    return nfs3svc_submit_reply(req, &res,
+                                (nfs3_serializer)xdr_serialize_fsstat3res);
 }
 
-
 int32_t
-nfs3_fsstat_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                      dict_t *xdata)
+nfs3_fsstat_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                     dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else
-                stat = NFS3_OK;
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else
+        stat = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_FSSTAT, stat,
-                             op_errno, cs->resolvedloc.path);
-        nfs3_fsstat_reply (cs->req, stat, &cs->fsstat, buf);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat,
+                        op_errno, cs->resolvedloc.path);
+    nfs3_fsstat_reply(cs->req, stat, &cs->fsstat, buf);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
-
 int32_t
-nfs3_fsstat_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct statvfs *buf,
-                        dict_t *xdata)
-{
-        nfs_user_t              nfu = {0, };
-        int                     ret = -EFAULT;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                ret = -op_errno;
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-                goto err;
-        }
-
-        /* Then get the stat for the fs root in order to fill in the
-         * post_op_attr.
-         */
-        cs->fsstat = *buf;
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                        nfs3_fsstat_stat_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_fsstat_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                       dict_t *xdata)
+{
+    nfs_user_t nfu = {
+        0,
+    };
+    int ret = -EFAULT;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        ret = -op_errno;
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+        goto err;
+    }
+
+    /* Then get the stat for the fs root in order to fill in the
+     * post_op_attr.
+     */
+    cs->fsstat = *buf;
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                   nfs3_fsstat_stat_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_FSSTAT, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_fsstat_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_fsstat_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_fsstat_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        nfs_user_t              nfu = {0, };
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        /* First, we need to get the statvfs for the subvol */
-        ret = nfs_statfs (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                          nfs3_fsstat_statfs_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-
-nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_FSSTAT, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_fsstat_reply (cs->req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+nfs3_fsstat_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nfs_user_t nfu = {
+        0,
+    };
 
+    if (!carg)
         return ret;
-}
-
 
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    /* First, we need to get the statvfs for the subvol */
+    ret = nfs_statfs(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                     nfs3_fsstat_statfs_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
-int
-nfs3_fsstat (rpcsvc_request_t *req, struct nfs3_fh *fh)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
+nfs3err:
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSSTAT, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_fsstat_reply(cs->req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        nfs3_log_common_call (rpcsvc_request_xid (req), "FSSTAT", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
+    return ret;
+}
 
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_fsstat_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+int
+nfs3_fsstat(rpcsvc_request_t *req, struct nfs3_fh *fh)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_common_call(rpcsvc_request_xid(req), "FSSTAT", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_fsstat_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_FSSTAT, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_fsstat_reply (req, stat, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_FSSTAT, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_fsstat_reply(req, stat, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_fsstat (rpcsvc_request_t *req)
-{
-        struct nfs3_fh          fh = {{0}, };
-        fsstat3args             args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_fsstat3args (&args, &fh);
-        if (xdr_to_fsstat3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_fsstat(rpcsvc_request_t *req)
+{
+    struct nfs3_fh fh = {
+        {0},
+    };
+    fsstat3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_fsstat (req, &fh);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSTAT_FAIL,
-                        "FSTAT procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_fsstat3args(&args, &fh);
+    if (xdr_to_fsstat3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_fsstat(req, &fh);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSTAT_FAIL,
+               "FSTAT procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_fsinfo_reply (rpcsvc_request_t *req, nfsstat3 status, struct iatt *fsroot)
+nfs3_fsinfo_reply(rpcsvc_request_t *req, nfsstat3 status, struct iatt *fsroot)
 {
-        fsinfo3res              res;
-        struct nfs3_state       *nfs3 = NULL;
-        uint64_t                deviceid = 0;
+    fsinfo3res res;
+    struct nfs3_state *nfs3 = NULL;
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3 = rpcsvc_request_program_private (req);
-        nfs3_fill_fsinfo3res (nfs3, &res, status, fsroot, deviceid);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3 = rpcsvc_request_program_private(req);
+    nfs3_fill_fsinfo3res(nfs3, &res, status, fsroot, deviceid);
 
-        nfs3svc_submit_reply (req, &res,
-                              (nfs3_serializer)xdr_serialize_fsinfo3res);
-        return 0;
+    nfs3svc_submit_reply(req, &res, (nfs3_serializer)xdr_serialize_fsinfo3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_fsinfo_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                    dict_t *xdata)
+nfs3svc_fsinfo_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   dict_t *xdata)
 {
-        nfsstat3                status = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 status = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
+    cs = frame->local;
 
-        if (op_ret == -1) {
-                status = nfs3_cbk_errno_status (op_ret, op_errno);
-        }else
-                status = NFS3_OK;
+    if (op_ret == -1) {
+        status = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else
+        status = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_FSINFO, status,
-                             op_errno, cs->resolvedloc.path);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSINFO, status,
+                        op_errno, cs->resolvedloc.path);
 
-        nfs3_fsinfo_reply (cs->req, status, buf);
-        nfs3_call_state_wipe (cs);
+    nfs3_fsinfo_reply(cs->req, status, buf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_fsinfo_resume (void *carg)
+nfs3_fsinfo_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
+    if (!carg)
+        return ret;
 
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
 
-        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                        nfs3svc_fsinfo_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                   nfs3svc_fsinfo_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_FSINFO, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_fsinfo_reply (cs->req, stat, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_FSINFO, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_fsinfo_reply(cs->req, stat, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_fsinfo (rpcsvc_request_t *req, struct nfs3_fh *fh)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_common_call (rpcsvc_request_xid (req), "FSINFO", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_fsinfo_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_fsinfo(rpcsvc_request_t *req, struct nfs3_fh *fh)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_common_call(rpcsvc_request_xid(req), "FSINFO", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_fsinfo_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_FSINFO, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_fsinfo_reply (req, stat, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_FSINFO, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_fsinfo_reply(req, stat, NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_fsinfo (rpcsvc_request_t *req)
+nfs3svc_fsinfo(rpcsvc_request_t *req)
 {
-        int             ret = RPCSVC_ACTOR_ERROR;
-        fsinfo3args     args;
-        struct nfs3_fh  root = {{0}, };
-
-        if (!req)
-                return ret;
+    int ret = RPCSVC_ACTOR_ERROR;
+    fsinfo3args args;
+    struct nfs3_fh root = {
+        {0},
+    };
 
-        nfs3_prep_fsinfo3args (&args, &root);
-        if (xdr_to_fsinfo3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding arguments");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+    if (!req)
+        return ret;
 
-        ret = nfs3_fsinfo (req, &root);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSINFO_FAIL,
-                        "FSINFO procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    nfs3_prep_fsinfo3args(&args, &root);
+    if (xdr_to_fsinfo3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding arguments");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_fsinfo(req, &root);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FSINFO_FAIL,
+               "FSINFO procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3_pathconf_reply (rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf)
+nfs3_pathconf_reply(rpcsvc_request_t *req, nfsstat3 stat, struct iatt *buf)
 {
-        pathconf3res    res = {0, };
-        uint64_t        deviceid = 0;
+    pathconf3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_pathconf3res (&res, stat, buf, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_pathconf3res);
-        return 0;
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_pathconf3res(&res, stat, buf, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_pathconf3res);
+    return 0;
 }
 
-
 int32_t
-nfs3svc_pathconf_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                      dict_t *xdata)
+nfs3svc_pathconf_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                     dict_t *xdata)
 {
-        struct iatt             *sbuf = NULL;
-        nfs3_call_state_t       *cs = NULL;
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
+    struct iatt *sbuf = NULL;
+    nfs3_call_state_t *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else {
-                /* If stat fop failed, we can still send the other components
-                 * in a pathconf reply.
-                 */
-                sbuf = buf;
-                stat = NFS3_OK;
-        }
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else {
+        /* If stat fop failed, we can still send the other components
+         * in a pathconf reply.
+         */
+        sbuf = buf;
+        stat = NFS3_OK;
+    }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                             NFS3_PATHCONF, stat,
-                             op_errno, cs->resolvedloc.path);
-        nfs3_pathconf_reply (cs->req, stat, sbuf);
-        nfs3_call_state_wipe (cs);
+    nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_PATHCONF, stat,
+                        op_errno, cs->resolvedloc.path);
+    nfs3_pathconf_reply(cs->req, stat, sbuf);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_pathconf_resume (void *carg)
+nfs3_pathconf_resume(void *carg)
 {
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                        nfs3svc_pathconf_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_stat(cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                   nfs3svc_pathconf_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_PATHCONF, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_pathconf_reply (cs->req, stat, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_PATHCONF, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_pathconf_reply(cs->req, stat, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nfs3_pathconf (rpcsvc_request_t *req, struct nfs3_fh *fh)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_common_call (rpcsvc_request_xid (req), "PATHCONF", fh);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_pathconf_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_pathconf(rpcsvc_request_t *req, struct nfs3_fh *fh)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_common_call(rpcsvc_request_xid(req), "PATHCONF", fh);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_pathconf_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_PATHCONF, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_pathconf_reply (req, stat, NULL);
-                nfs3_call_state_wipe (cs);
-                /* Ret must be 0 after this so that the caller does not
-                 * also send an RPC reply.
-                 */
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_PATHCONF, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_pathconf_reply(req, stat, NULL);
+        nfs3_call_state_wipe(cs);
+        /* Ret must be 0 after this so that the caller does not
+         * also send an RPC reply.
+         */
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-nfs3svc_pathconf (rpcsvc_request_t *req)
-{
-        struct nfs3_fh          fh = {{0}, };
-        pathconf3args           args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_pathconf3args (&args, &fh);
-        if (xdr_to_pathconf3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nfs3svc_pathconf(rpcsvc_request_t *req)
+{
+    struct nfs3_fh fh = {
+        {0},
+    };
+    pathconf3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-        ret = nfs3_pathconf (req, &fh);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, -ret,
-                        NFS_MSG_PATHCONF_FAIL,
-                        "PATHCONF procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+    if (!req)
+        return ret;
+    nfs3_prep_pathconf3args(&args, &fh);
+    if (xdr_to_pathconf3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_pathconf(req, &fh);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, -ret, NFS_MSG_PATHCONF_FAIL,
+               "PATHCONF procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
 rpcerr:
-        return ret;
+    return ret;
 }
 
 int
-nfs3_commit_reply (rpcsvc_request_t *req, nfsstat3 stat, uint64_t wverf,
-                   struct iatt *prestat, struct iatt *poststat)
+nfs3_commit_reply(rpcsvc_request_t *req, nfsstat3 stat, uint64_t wverf,
+                  struct iatt *prestat, struct iatt *poststat)
 {
-        commit3res      res = {0, };
-        uint64_t        deviceid = 0;
+    commit3res res = {
+        0,
+    };
+    uint64_t deviceid = 0;
 
-        deviceid = nfs3_request_xlator_deviceid (req);
-        nfs3_fill_commit3res (&res, stat, wverf, prestat, poststat, deviceid);
-        nfs3svc_submit_reply (req, (void *)&res,
-                              (nfs3_serializer)xdr_serialize_commit3res);
+    deviceid = nfs3_request_xlator_deviceid(req);
+    nfs3_fill_commit3res(&res, stat, wverf, prestat, poststat, deviceid);
+    nfs3svc_submit_reply(req, (void *)&res,
+                         (nfs3_serializer)xdr_serialize_commit3res);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-nfs3svc_commit_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+nfs3svc_commit_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        nfs3_call_state_t       *cs = NULL;
-        struct nfs3_state       *nfs3 = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs3_state *nfs3 = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nfs3_cbk_errno_status (op_ret, op_errno);
-        } else
-                stat = NFS3_OK;
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nfs3_cbk_errno_status(op_ret, op_errno);
+    } else
+        stat = NFS3_OK;
 
-        nfs3 = rpcsvc_request_program_private (cs->req);
-        nfs3_log_commit_res (rpcsvc_request_xid (cs->req),
-                             stat, op_errno, nfs3->serverstart,
-                             cs->resolvedloc.path);
-        nfs3_commit_reply (cs->req, stat, nfs3->serverstart, NULL, NULL);
-        nfs3_call_state_wipe (cs);
+    nfs3 = rpcsvc_request_program_private(cs->req);
+    nfs3_log_commit_res(rpcsvc_request_xid(cs->req), stat, op_errno,
+                        nfs3->serverstart, cs->resolvedloc.path);
+    nfs3_commit_reply(cs->req, stat, nfs3->serverstart, NULL, NULL);
+    nfs3_call_state_wipe(cs);
 
-        return 0;
+    return 0;
 }
 
 int
-nfs3_commit_resume (void *carg)
+nfs3_commit_resume(void *carg)
 {
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-        nfs3_call_state_t       *cs = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
 
-        if (nfs3_export_sync_trusted (cs->nfs3state, cs->resolvefh.exportid)) {
-                ret = -1;
-                stat = NFS3_OK;
-                goto nfs3err;
-        }
+    if (nfs3_export_sync_trusted(cs->nfs3state, cs->resolvefh.exportid)) {
+        ret = -1;
+        stat = NFS3_OK;
+        goto nfs3err;
+    }
 
-        nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_flush (cs->nfsx, cs->vol, &nfu, cs->fd,
-                         nfs3svc_commit_cbk, cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+    nfs_request_user_init(&nfu, cs->req);
+    ret = nfs_flush(cs->nfsx, cs->vol, &nfu, cs->fd, nfs3svc_commit_cbk, cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_COMMIT, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_commit_reply (cs->req, stat, cs->nfs3state->serverstart,
-                                   NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_COMMIT, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_commit_reply(cs->req, stat, cs->nfs3state->serverstart, NULL,
+                          NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-nfs3_commit_open_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        cs->fd = fd_anonymous (cs->resolvedloc.inode);
-        if (!cs->fd) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
-                        "Failed to create anonymous fd.");
-                goto nfs3err;
-        }
-
-        ret = nfs3_commit_resume (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     NFS3_COMMIT, stat, -ret,
-                                     cs->resolvedloc.path);
-                nfs3_commit_reply (cs->req, stat, 0, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+nfs3_commit_open_resume(void *carg)
+{
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
 
+    if (!carg)
         return ret;
-}
 
+    cs = (nfs3_call_state_t *)carg;
+    nfs3_check_fh_resolve_status(cs, stat, nfs3err);
+    cs->fd = fd_anonymous(cs->resolvedloc.inode);
+    if (!cs->fd) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ANONYMOUS_FD_FAIL,
+               "Failed to create anonymous fd.");
+        goto nfs3err;
+    }
+
+    ret = nfs3_commit_resume(cs);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
+nfs3err:
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(cs->req), NFS3_COMMIT, stat,
+                            -ret, cs->resolvedloc.path);
+        nfs3_commit_reply(cs->req, stat, 0, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
+    return ret;
+}
 
 int
-nfs3_commit (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
-             count3 count)
-{
-        xlator_t                        *vol = NULL;
-        nfsstat3                        stat = NFS3ERR_SERVERFAULT;
-        int                             ret = -EFAULT;
-        struct nfs3_state               *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-
-        if ((!req) || (!fh)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "Bad arguments");
-                return -1;
-        }
-
-        nfs3_log_rw_call (rpcsvc_request_xid (req), "COMMIT", fh, offset,
-                          count, -1);
-        nfs3_validate_gluster_fh (fh, stat, nfs3err);
-        nfs3_validate_nfs3_state (req, nfs3, stat, nfs3err, ret);
-        nfs3_map_fh_to_volume (nfs3, fh, req, vol, stat, nfs3err);
-        nfs3_volume_started_check (nfs3, vol, ret, out);
-        nfs3_check_rw_volaccess (nfs3, fh->exportid, stat, nfs3err);
-        nfs3_handle_call_state_init (nfs3, cs, req, vol, stat, nfs3err);
-
-        cs->datacount = count;
-        cs->dataoffset = offset;
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL,
-                                          nfs3_commit_open_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+nfs3_commit(rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
+            count3 count)
+{
+    xlator_t *vol = NULL;
+    nfsstat3 stat = NFS3ERR_SERVERFAULT;
+    int ret = -EFAULT;
+    struct nfs3_state *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+
+    if ((!req) || (!fh)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Bad arguments");
+        return -1;
+    }
+
+    nfs3_log_rw_call(rpcsvc_request_xid(req), "COMMIT", fh, offset, count, -1);
+    nfs3_validate_gluster_fh(fh, stat, nfs3err);
+    nfs3_validate_nfs3_state(req, nfs3, stat, nfs3err, ret);
+    nfs3_map_fh_to_volume(nfs3, fh, req, vol, stat, nfs3err);
+    nfs3_volume_started_check(nfs3, vol, ret, out);
+    nfs3_check_rw_volaccess(nfs3, fh->exportid, stat, nfs3err);
+    nfs3_handle_call_state_init(nfs3, cs, req, vol, stat, nfs3err);
+
+    cs->datacount = count;
+    cs->dataoffset = offset;
+    ret = nfs3_fh_resolve_and_resume(cs, fh, NULL, nfs3_commit_open_resume);
+    if (ret < 0)
+        stat = nfs3_errno_to_nfsstat3(-ret);
 
 nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req),
-                                     NFS3_COMMIT, stat, -ret,
-                                     cs ? cs->resolvedloc.path : NULL);
-                nfs3_commit_reply (req, stat, 0, NULL, NULL);
-                nfs3_call_state_wipe (cs);
-                ret = 0;
-        }
+    if (ret < 0) {
+        nfs3_log_common_res(rpcsvc_request_xid(req), NFS3_COMMIT, stat, -ret,
+                            cs ? cs->resolvedloc.path : NULL);
+        nfs3_commit_reply(req, stat, 0, NULL, NULL);
+        nfs3_call_state_wipe(cs);
+        ret = 0;
+    }
 out:
-        return ret;
+    return ret;
 }
 
-
-
 int
-nfs3svc_commit (rpcsvc_request_t *req)
-{
-        struct nfs3_fh          fh = {{0}, };
-        commit3args             args;
-        int                     ret = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-        nfs3_prep_commit3args (&args, &fh);
-        if (xdr_to_commit3args (req->msg[0], &args) <= 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        ret = nfs3_commit (req, &fh, args.offset, args.count);
-        if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_COMMIT_FAIL,
-                        "COMMIT procedure failed");
-                rpcsvc_request_seterr (req, SYSTEM_ERR);
-                ret = RPCSVC_ACTOR_ERROR;
-        }
+nfs3svc_commit(rpcsvc_request_t *req)
+{
+    struct nfs3_fh fh = {
+        {0},
+    };
+    commit3args args;
+    int ret = RPCSVC_ACTOR_ERROR;
 
-rpcerr:
+    if (!req)
         return ret;
-}
-
+    nfs3_prep_commit3args(&args, &fh);
+    if (xdr_to_commit3args(req->msg[0], &args) <= 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    ret = nfs3_commit(req, &fh, args.offset, args.count);
+    if ((ret < 0) && (ret != RPCSVC_ACTOR_IGNORE)) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_COMMIT_FAIL,
+               "COMMIT procedure failed");
+        rpcsvc_request_seterr(req, SYSTEM_ERR);
+        ret = RPCSVC_ACTOR_ERROR;
+    }
 
-rpcsvc_actor_t          nfs3svc_actors[NFS3_PROC_COUNT] = {
-        {"NULL",        NFS3_NULL,      nfs3svc_null,      NULL,   0, DRC_IDEMPOTENT},
-        {"GETATTR",     NFS3_GETATTR,   nfs3svc_getattr,   NULL,   0, DRC_IDEMPOTENT},
-        {"SETATTR",     NFS3_SETATTR,   nfs3svc_setattr,   NULL,   0, DRC_NON_IDEMPOTENT},
-        {"LOOKUP",      NFS3_LOOKUP,    nfs3svc_lookup,    NULL,   0, DRC_IDEMPOTENT},
-        {"ACCESS",      NFS3_ACCESS,    nfs3svc_access,    NULL,   0, DRC_IDEMPOTENT},
-        {"READLINK",    NFS3_READLINK,  nfs3svc_readlink,  NULL,   0, DRC_IDEMPOTENT},
-        {"READ",        NFS3_READ,      nfs3svc_read,      NULL,   0, DRC_IDEMPOTENT},
-        {"WRITE",       NFS3_WRITE,     nfs3svc_write,     nfs3svc_write_vecsizer, 0, DRC_NON_IDEMPOTENT},
-        {"CREATE",      NFS3_CREATE,    nfs3svc_create,    NULL,   0, DRC_NON_IDEMPOTENT},
-        {"MKDIR",       NFS3_MKDIR,     nfs3svc_mkdir,     NULL,   0, DRC_NON_IDEMPOTENT},
-        {"SYMLINK",     NFS3_SYMLINK,   nfs3svc_symlink,   NULL,   0, DRC_NON_IDEMPOTENT},
-        {"MKNOD",       NFS3_MKNOD,     nfs3svc_mknod,     NULL,   0, DRC_NON_IDEMPOTENT},
-        {"REMOVE",      NFS3_REMOVE,    nfs3svc_remove,    NULL,   0, DRC_NON_IDEMPOTENT},
-        {"RMDIR",       NFS3_RMDIR,     nfs3svc_rmdir,     NULL,   0, DRC_NON_IDEMPOTENT},
-        {"RENAME",      NFS3_RENAME,    nfs3svc_rename,    NULL,   0, DRC_NON_IDEMPOTENT},
-        {"LINK",        NFS3_LINK,      nfs3svc_link,      NULL,   0, DRC_NON_IDEMPOTENT},
-        {"READDIR",     NFS3_READDIR,   nfs3svc_readdir,   NULL,   0, DRC_IDEMPOTENT},
-        {"READDIRPLUS", NFS3_READDIRP,  nfs3svc_readdirp,  NULL,   0, DRC_IDEMPOTENT},
-        {"FSSTAT",      NFS3_FSSTAT,    nfs3svc_fsstat,    NULL,   0, DRC_IDEMPOTENT},
-        {"FSINFO",      NFS3_FSINFO,    nfs3svc_fsinfo,    NULL,   0, DRC_IDEMPOTENT},
-        {"PATHCONF",    NFS3_PATHCONF,  nfs3svc_pathconf,  NULL,   0, DRC_IDEMPOTENT},
-        {"COMMIT",      NFS3_COMMIT,    nfs3svc_commit,    NULL,   0, DRC_IDEMPOTENT}
-};
-
-
-rpcsvc_program_t        nfs3prog = {
-                        .progname       = "NFS3",
-                        .prognum        = NFS_PROGRAM,
-                        .progver        = NFS_V3,
-                        .progport       = GF_NFS3_PORT,
-                        .actors         = nfs3svc_actors,
-                        .numactors      = NFS3_PROC_COUNT,
-
-                        /* Requests like FSINFO are sent before an auth scheme
-                         * is inited by client. See RFC 2623, Section 2.3.2. */
-                        .min_auth       = AUTH_NULL,
+rpcerr:
+    return ret;
+}
+
+rpcsvc_actor_t nfs3svc_actors[NFS3_PROC_COUNT] = {
+    {"NULL", NFS3_NULL, nfs3svc_null, NULL, 0, DRC_IDEMPOTENT},
+    {"GETATTR", NFS3_GETATTR, nfs3svc_getattr, NULL, 0, DRC_IDEMPOTENT},
+    {"SETATTR", NFS3_SETATTR, nfs3svc_setattr, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"LOOKUP", NFS3_LOOKUP, nfs3svc_lookup, NULL, 0, DRC_IDEMPOTENT},
+    {"ACCESS", NFS3_ACCESS, nfs3svc_access, NULL, 0, DRC_IDEMPOTENT},
+    {"READLINK", NFS3_READLINK, nfs3svc_readlink, NULL, 0, DRC_IDEMPOTENT},
+    {"READ", NFS3_READ, nfs3svc_read, NULL, 0, DRC_IDEMPOTENT},
+    {"WRITE", NFS3_WRITE, nfs3svc_write, nfs3svc_write_vecsizer, 0,
+     DRC_NON_IDEMPOTENT},
+    {"CREATE", NFS3_CREATE, nfs3svc_create, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"MKDIR", NFS3_MKDIR, nfs3svc_mkdir, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"SYMLINK", NFS3_SYMLINK, nfs3svc_symlink, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"MKNOD", NFS3_MKNOD, nfs3svc_mknod, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"REMOVE", NFS3_REMOVE, nfs3svc_remove, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"RMDIR", NFS3_RMDIR, nfs3svc_rmdir, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"RENAME", NFS3_RENAME, nfs3svc_rename, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"LINK", NFS3_LINK, nfs3svc_link, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"READDIR", NFS3_READDIR, nfs3svc_readdir, NULL, 0, DRC_IDEMPOTENT},
+    {"READDIRPLUS", NFS3_READDIRP, nfs3svc_readdirp, NULL, 0, DRC_IDEMPOTENT},
+    {"FSSTAT", NFS3_FSSTAT, nfs3svc_fsstat, NULL, 0, DRC_IDEMPOTENT},
+    {"FSINFO", NFS3_FSINFO, nfs3svc_fsinfo, NULL, 0, DRC_IDEMPOTENT},
+    {"PATHCONF", NFS3_PATHCONF, nfs3svc_pathconf, NULL, 0, DRC_IDEMPOTENT},
+    {"COMMIT", NFS3_COMMIT, nfs3svc_commit, NULL, 0, DRC_IDEMPOTENT}};
+
+rpcsvc_program_t nfs3prog = {
+    .progname = "NFS3",
+    .prognum = NFS_PROGRAM,
+    .progver = NFS_V3,
+    .progport = GF_NFS3_PORT,
+    .actors = nfs3svc_actors,
+    .numactors = NFS3_PROC_COUNT,
+
+    /* Requests like FSINFO are sent before an auth scheme
+     * is inited by client. See RFC 2623, Section 2.3.2. */
+    .min_auth = AUTH_NULL,
 };
 
 /*
@@ -5390,504 +5235,503 @@ rpcsvc_program_t        nfs3prog = {
  * 1MB (GF_NFS3_FILE_IO_SIZE_MAX).
  */
 void
-nfs3_iosize_roundup_4KB (uint64_t *ioszptr)
+nfs3_iosize_roundup_4KB(uint64_t *ioszptr)
 {
-        uint64_t iosize;
-        uint64_t iopages;
-
-        if (!ioszptr)
-                return;
-
-        iosize  = *ioszptr;
-        iopages = (iosize + GF_NFS3_IO_SIZE -1) >> GF_NFS3_IO_SHIFT;
-        iosize  = (iopages * GF_NFS3_IO_SIZE);
-
-        /* Double check - boundary conditions */
-        if (iosize < GF_NFS3_FILE_IO_SIZE_MIN) {
-                iosize = GF_NFS3_FILE_IO_SIZE_MIN;
-        } else if (iosize > GF_NFS3_FILE_IO_SIZE_MAX) {
-                iosize = GF_NFS3_FILE_IO_SIZE_MAX;
-        }
+    uint64_t iosize;
+    uint64_t iopages;
 
-        *ioszptr = iosize;
-}
-
-int
-nfs3_init_options (struct nfs3_state *nfs3, dict_t *options)
-{
-        int      ret = -1;
-        char     *optstr = NULL;
-        uint64_t size64 = 0;
-
-        if ((!nfs3) || (!options))
-                return -1;
-
-        /* nfs3.read-size */
-        nfs3->readsize = GF_NFS3_RTPREF;
-        if (dict_get (options, "nfs3.read-size")) {
-                ret = dict_get_str (options, "nfs3.read-size", &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: nfs3.read-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = gf_string2uint64 (optstr, &size64);
-                if (ret == -1) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
-                                "Failed to format option: nfs3.read-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                nfs3_iosize_roundup_4KB (&size64);
-                nfs3->readsize = size64;
-        }
-
-        /* nfs3.write-size */
-        nfs3->writesize = GF_NFS3_WTPREF;
-        if (dict_get (options, "nfs3.write-size")) {
-                ret = dict_get_str (options, "nfs3.write-size", &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read  option: nfs3.write-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = gf_string2uint64 (optstr, &size64);
-                if (ret == -1) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
-                                "Failed to format option: nfs3.write-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                nfs3_iosize_roundup_4KB (&size64);
-                nfs3->writesize = size64;
-        }
+    if (!ioszptr)
+        return;
 
-        /* nfs3.readdir.size */
-        nfs3->readdirsize = GF_NFS3_DTPREF;
-        if (dict_get (options, "nfs3.readdir-size")) {
-                ret = dict_get_str (options,"nfs3.readdir-size", &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: nfs3.readdir-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = gf_string2uint64 (optstr, &size64);
-                if (ret == -1) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
-                                "Failed to format option: nfs3.readdir-size");
-                        ret = -1;
-                        goto err;
-                }
-
-                nfs3_iosize_roundup_4KB (&size64);
-                nfs3->readdirsize = size64;
-        }
+    iosize = *ioszptr;
+    iopages = (iosize + GF_NFS3_IO_SIZE - 1) >> GF_NFS3_IO_SHIFT;
+    iosize = (iopages * GF_NFS3_IO_SIZE);
 
-        /* We want to use the size of the biggest param for the io buffer size.
-         */
-        nfs3->iobsize = nfs3->readsize;
-        if (nfs3->iobsize < nfs3->writesize)
-                nfs3->iobsize = nfs3->writesize;
-        if (nfs3->iobsize < nfs3->readdirsize)
-                nfs3->iobsize = nfs3->readdirsize;
+    /* Double check - boundary conditions */
+    if (iosize < GF_NFS3_FILE_IO_SIZE_MIN) {
+        iosize = GF_NFS3_FILE_IO_SIZE_MIN;
+    } else if (iosize > GF_NFS3_FILE_IO_SIZE_MAX) {
+        iosize = GF_NFS3_FILE_IO_SIZE_MAX;
+    }
 
-        /* But this is the true size of each iobuf. We need this size to
-         * accommodate the NFS headers also in the same buffer. */
-        nfs3->iobsize = nfs3->iobsize * 2;
-
-        ret = 0;
-err:
-        return ret;
+    *ioszptr = iosize;
 }
 
 int
-nfs3_init_subvolume_options (xlator_t *nfsx,
-                             struct nfs3_export *exp,
-                             dict_t *options)
+nfs3_init_options(struct nfs3_state *nfs3, dict_t *options)
 {
-        int             ret = -1;
-        char            *optstr = NULL;
-        char            searchkey[1024];
-        char            *name = NULL;
-        gf_boolean_t    boolt = _gf_false;
-        uuid_t          volumeid = {0, };
+    int ret = -1;
+    char *optstr = NULL;
+    uint64_t size64 = 0;
 
-        if ((!nfsx) || (!exp))
-                return -1;
+    if ((!nfs3) || (!options))
+        return -1;
 
-        /* For init, fetch options from xlator but for
-         * reconfigure, take the parameter */
-        if (!options)
-                options = nfsx->options;
-
-        if (!options)
-                return (-1);
-
-        gf_uuid_clear (volumeid);
-        if (gf_nfs_dvm_off (nfs_state (nfsx)))
-                goto no_dvm;
-
-        ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.volume-id",exp->subvol->name);
+    /* nfs3.read-size */
+    nfs3->readsize = GF_NFS3_RTPREF;
+    if (dict_get(options, "nfs3.read-size")) {
+        ret = dict_get_str(options, "nfs3.read-size", &optstr);
         if (ret < 0) {
-                gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: nfs3.read-size");
+            ret = -1;
+            goto err;
         }
 
-        if (dict_get (options, searchkey)) {
-                ret = dict_get_str (options, searchkey, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: %s", searchkey);
-                        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",
-                        exp->subvol->name);
-                ret = -1;
-                goto err;
+        ret = gf_string2uint64(optstr, &size64);
+        if (ret == -1) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
+                   "Failed to format option: nfs3.read-size");
+            ret = -1;
+            goto err;
         }
 
-        if (optstr) {
-                ret = gf_uuid_parse (optstr, volumeid);
-                if (ret < 0) {
-                        gf_msg (GF_MNT, GF_LOG_ERROR, 0,
-                                NFS_MSG_PARSE_VOL_UUID_FAIL,
-                                "Failed to parse volume UUID");
-                        ret = -1;
-                        goto err;
-                }
-                gf_uuid_copy (exp->volumeid, volumeid);
-        }
+        nfs3_iosize_roundup_4KB(&size64);
+        nfs3->readsize = size64;
+    }
 
-no_dvm:
-        /* Volume Access */
-        name = exp->subvol->name;
-        ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.volume-access", name);
+    /* nfs3.write-size */
+    nfs3->writesize = GF_NFS3_WTPREF;
+    if (dict_get(options, "nfs3.write-size")) {
+        ret = dict_get_str(options, "nfs3.write-size", &optstr);
         if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read  option: nfs3.write-size");
+            ret = -1;
+            goto err;
         }
 
-        exp->access = GF_NFS3_DEFAULT_VOLACCESS;
-        if (dict_get (options, searchkey)) {
-                ret = dict_get_str (options, searchkey, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: %s", searchkey);
-                        ret = -1;
-                        goto err;
-                }
-
-                if (strcmp (optstr, "read-only") == 0)
-                        exp->access = GF_NFS3_VOLACCESS_RO;
+        ret = gf_string2uint64(optstr, &size64);
+        if (ret == -1) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
+                   "Failed to format option: nfs3.write-size");
+            ret = -1;
+            goto err;
         }
 
-        ret = snprintf (searchkey, sizeof (searchkey), "rpc-auth.%s.unix", name);
+        nfs3_iosize_roundup_4KB(&size64);
+        nfs3->writesize = size64;
+    }
+
+    /* nfs3.readdir.size */
+    nfs3->readdirsize = GF_NFS3_DTPREF;
+    if (dict_get(options, "nfs3.readdir-size")) {
+        ret = dict_get_str(options, "nfs3.readdir-size", &optstr);
         if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: nfs3.readdir-size");
+            ret = -1;
+            goto err;
         }
 
-        if (dict_get (options, searchkey)) {
-                ret = dict_get_str (options, searchkey, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: %s", searchkey);
-                        ret = -1;
-                        goto err;
-                }
+        ret = gf_string2uint64(optstr, &size64);
+        if (ret == -1) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_FORMAT_FAIL,
+                   "Failed to format option: nfs3.readdir-size");
+            ret = -1;
+            goto err;
         }
 
-        exp->trusted_sync = 0;
-        ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.trusted-sync", name);
-        if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
-        }
+        nfs3_iosize_roundup_4KB(&size64);
+        nfs3->readdirsize = size64;
+    }
 
-        if (dict_get (options, searchkey)) {
-                ret = dict_get_str (options, searchkey, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: %s", searchkey);
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,
-                                NFS_MSG_STR2BOOL_FAIL, "Failed to convert str "
-                                "to gf_boolean_t");
-                        ret = -1;
-                        goto err;
-                }
-
-                if (boolt == _gf_true)
-                        exp->trusted_sync = 1;
-        }
+    /* We want to use the size of the biggest param for the io buffer size.
+     */
+    nfs3->iobsize = nfs3->readsize;
+    if (nfs3->iobsize < nfs3->writesize)
+        nfs3->iobsize = nfs3->writesize;
+    if (nfs3->iobsize < nfs3->readdirsize)
+        nfs3->iobsize = nfs3->readdirsize;
 
-        exp->trusted_write = 0;
-        ret = snprintf (searchkey, sizeof (searchkey), "nfs3.%s.trusted-write", name);
+    /* But this is the true size of each iobuf. We need this size to
+     * accommodate the NFS headers also in the same buffer. */
+    nfs3->iobsize = nfs3->iobsize * 2;
+
+    ret = 0;
+err:
+    return ret;
+}
+
+int
+nfs3_init_subvolume_options(xlator_t *nfsx, struct nfs3_export *exp,
+                            dict_t *options)
+{
+    int ret = -1;
+    char *optstr = NULL;
+    char searchkey[1024];
+    char *name = NULL;
+    gf_boolean_t boolt = _gf_false;
+    uuid_t volumeid = {
+        0,
+    };
+
+    if ((!nfsx) || (!exp))
+        return -1;
+
+    /* For init, fetch options from xlator but for
+     * reconfigure, take the parameter */
+    if (!options)
+        options = nfsx->options;
+
+    if (!options)
+        return (-1);
+
+    gf_uuid_clear(volumeid);
+    if (gf_nfs_dvm_off(nfs_state(nfsx)))
+        goto no_dvm;
+
+    ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.volume-id",
+                   exp->subvol->name);
+    if (ret < 0) {
+        gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    if (dict_get(options, searchkey)) {
+        ret = dict_get_str(options, searchkey, &optstr);
         if (ret < 0) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
-                        "snprintf failed");
-                ret = -1;
-                goto err;
+            gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: %s", searchkey);
+            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",
+               exp->subvol->name);
+        ret = -1;
+        goto err;
+    }
+
+    if (optstr) {
+        ret = gf_uuid_parse(optstr, volumeid);
+        if (ret < 0) {
+            gf_msg(GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PARSE_VOL_UUID_FAIL,
+                   "Failed to parse volume UUID");
+            ret = -1;
+            goto err;
         }
+        gf_uuid_copy(exp->volumeid, volumeid);
+    }
 
-        if (dict_get (options, searchkey)) {
-                ret = dict_get_str (options, searchkey, &optstr);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
-                                "Failed to read option: %s", searchkey);
-                        ret = -1;
-                        goto err;
-                }
-
-                ret = gf_string2boolean (optstr, &boolt);
-                if (ret < 0) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,
-                                NFS_MSG_STR2BOOL_FAIL, "Failed to convert str"
-                                " to gf_boolean_t");
-                        ret = -1;
-                        goto err;
-                }
-
-                if (boolt == _gf_true)
-                        exp->trusted_write = 1;
+no_dvm:
+    /* Volume Access */
+    name = exp->subvol->name;
+    ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.volume-access", name);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    exp->access = GF_NFS3_DEFAULT_VOLACCESS;
+    if (dict_get(options, searchkey)) {
+        ret = dict_get_str(options, searchkey, &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: %s", searchkey);
+            ret = -1;
+            goto err;
+        }
+
+        if (strcmp(optstr, "read-only") == 0)
+            exp->access = GF_NFS3_VOLACCESS_RO;
+    }
+
+    ret = snprintf(searchkey, sizeof(searchkey), "rpc-auth.%s.unix", name);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    if (dict_get(options, searchkey)) {
+        ret = dict_get_str(options, searchkey, &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: %s", searchkey);
+            ret = -1;
+            goto err;
+        }
+    }
+
+    exp->trusted_sync = 0;
+    ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.trusted-sync", name);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    if (dict_get(options, searchkey)) {
+        ret = dict_get_str(options, searchkey, &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: %s", searchkey);
+            ret = -1;
+            goto err;
         }
 
-        /* If trusted-sync is on, then we also switch on trusted-write because
-         * tw is included in ts. In write logic, we're then only checking for
-         * tw.
-         */
-        if (exp->trusted_sync)
-                exp->trusted_write = 1;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STR2BOOL_FAIL,
+                   "Failed to convert str "
+                   "to gf_boolean_t");
+            ret = -1;
+            goto err;
+        }
+
+        if (boolt == _gf_true)
+            exp->trusted_sync = 1;
+    }
+
+    exp->trusted_write = 0;
+    ret = snprintf(searchkey, sizeof(searchkey), "nfs3.%s.trusted-write", name);
+    if (ret < 0) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SNPRINTF_FAIL,
+               "snprintf failed");
+        ret = -1;
+        goto err;
+    }
+
+    if (dict_get(options, searchkey)) {
+        ret = dict_get_str(options, searchkey, &optstr);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_READ_FAIL,
+                   "Failed to read option: %s", searchkey);
+            ret = -1;
+            goto err;
+        }
 
-        gf_msg_trace (GF_NFS3, 0, "%s: %s, %s, %s", exp->subvol->name,
-                (exp->access == GF_NFS3_VOLACCESS_RO)?"read-only":"read-write",
-                (exp->trusted_sync == 0)?"no trusted_sync":"trusted_sync",
-                (exp->trusted_write == 0)?"no trusted_write":"trusted_write");
-        ret = 0;
+        ret = gf_string2boolean(optstr, &boolt);
+        if (ret < 0) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STR2BOOL_FAIL,
+                   "Failed to convert str"
+                   " to gf_boolean_t");
+            ret = -1;
+            goto err;
+        }
+
+        if (boolt == _gf_true)
+            exp->trusted_write = 1;
+    }
+
+    /* If trusted-sync is on, then we also switch on trusted-write because
+     * tw is included in ts. In write logic, we're then only checking for
+     * tw.
+     */
+    if (exp->trusted_sync)
+        exp->trusted_write = 1;
+
+    gf_msg_trace(
+        GF_NFS3, 0, "%s: %s, %s, %s", exp->subvol->name,
+        (exp->access == GF_NFS3_VOLACCESS_RO) ? "read-only" : "read-write",
+        (exp->trusted_sync == 0) ? "no trusted_sync" : "trusted_sync",
+        (exp->trusted_write == 0) ? "no trusted_write" : "trusted_write");
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
-
 struct nfs3_export *
-nfs3_init_subvolume (struct nfs3_state *nfs3, xlator_t *subvol)
+nfs3_init_subvolume(struct nfs3_state *nfs3, xlator_t *subvol)
 {
-        int                     ret = -1;
-        struct nfs3_export      *exp = NULL;
+    int ret = -1;
+    struct nfs3_export *exp = NULL;
 
-        if ((!nfs3) || (!subvol))
-                return NULL;
+    if ((!nfs3) || (!subvol))
+        return NULL;
 
-        exp = GF_CALLOC (1, sizeof (*exp), gf_nfs_mt_nfs3_export);
-        exp->subvol = subvol;
-        INIT_LIST_HEAD (&exp->explist);
-        gf_msg_trace (GF_NFS3, 0, "Initing state: %s", exp->subvol->name);
+    exp = GF_CALLOC(1, sizeof(*exp), gf_nfs_mt_nfs3_export);
+    exp->subvol = subvol;
+    INIT_LIST_HEAD(&exp->explist);
+    gf_msg_trace(GF_NFS3, 0, "Initing state: %s", exp->subvol->name);
 
-        ret = nfs3_init_subvolume_options (nfs3->nfsx, exp, NULL);
-        if (ret == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL,
-                        "Failed to init subvol");
-                goto exp_free;
-        }
+    ret = nfs3_init_subvolume_options(nfs3->nfsx, exp, NULL);
+    if (ret == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL,
+               "Failed to init subvol");
+        goto exp_free;
+    }
 
-        ret = 0;
+    ret = 0;
 exp_free:
-        if (ret < 0) {
-                GF_FREE (exp);
-                exp = NULL;
-        }
+    if (ret < 0) {
+        GF_FREE(exp);
+        exp = NULL;
+    }
 
-        return exp;
+    return exp;
 }
 
-
 int
-nfs3_init_subvolumes (struct nfs3_state *nfs3)
-{
-        int                     ret = -1;
-        struct xlator_list      *xl_list = NULL;
-        struct nfs3_export      *exp = NULL;
-
-        if (!nfs3)
-                return -1;
-
-        xl_list = nfs3->nfsx->children;
-
-        while (xl_list) {
-                exp = nfs3_init_subvolume (nfs3, xl_list->xlator);
-                if (!exp) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,
-                                NFS_MSG_SUBVOL_INIT_FAIL, "Failed to init "
-                                "subvol: %s", xl_list->xlator->name);
-                        goto err;
-                }
-                list_add_tail (&exp->explist, &nfs3->exports);
-                xl_list = xl_list->next;
-        }
-
-        ret = 0;
-err:
-        return ret;
-}
-
-
-struct nfs3_state *
-nfs3_init_state (xlator_t *nfsx)
-{
-        struct nfs3_state       *nfs3 = NULL;
-        int                     ret = -1;
-        unsigned int            localpool = 0;
-        struct nfs_state        *nfs = NULL;
-
-        if ((!nfsx) || (!nfsx->private))
-                return NULL;
-
-        nfs3 = (struct nfs3_state *)GF_CALLOC (1, sizeof (*nfs3),
-                                    gf_nfs_mt_nfs3_state);
-        if (!nfs3) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Memory allocation failed");
-                return NULL;
-        }
+nfs3_init_subvolumes(struct nfs3_state *nfs3)
+{
+    int ret = -1;
+    struct xlator_list *xl_list = NULL;
+    struct nfs3_export *exp = NULL;
 
-        nfs = nfsx->private;
-        ret = nfs3_init_options (nfs3, nfsx->options);
-        if (ret == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL,
-                        "Failed to init options");
-                goto ret;
-        }
+    if (!nfs3)
+        return -1;
 
-        nfs3->iobpool = nfsx->ctx->iobuf_pool;
-
-        localpool = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT;
-        gf_msg_trace (GF_NFS3, 0, "local pool: %d", localpool);
-        nfs3->localpool = mem_pool_new_ctx (nfsx->ctx, nfs3_call_state_t,
-                                            localpool);
-        if (!nfs3->localpool) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "local mempool creation failed");
-                ret = -1;
-                goto ret;
-        }
+    xl_list = nfs3->nfsx->children;
 
-        nfs3->nfsx = nfsx;
-        nfs3->exportslist = nfsx->children;
-        INIT_LIST_HEAD (&nfs3->exports);
-        ret = nfs3_init_subvolumes (nfs3);
-        if (ret == -1) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL,
-                        "Failed to init per-subvolume state");
-                goto free_localpool;
+    while (xl_list) {
+        exp = nfs3_init_subvolume(nfs3, xl_list->xlator);
+        if (!exp) {
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL,
+                   "Failed to init "
+                   "subvol: %s",
+                   xl_list->xlator->name);
+            goto err;
         }
+        list_add_tail(&exp->explist, &nfs3->exports);
+        xl_list = xl_list->next;
+    }
 
-        nfs3->serverstart = (uint64_t)time (NULL);
-        INIT_LIST_HEAD (&nfs3->fdlru);
-        LOCK_INIT (&nfs3->fdlrulock);
-        nfs3->fdcount = 0;
-
-        ret = rpcsvc_create_listeners (nfs->rpcsvc, nfsx->options, nfsx->name);
-        if (ret == -1) {
-                gf_msg (GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_LISTENERS_CREATE_FAIL,
-                        "Unable to create listeners");
-                goto free_localpool;
-        }
+    ret = 0;
+err:
+    return ret;
+}
 
-        nfs->nfs3state = nfs3;
-        ret = 0;
+struct nfs3_state *
+nfs3_init_state(xlator_t *nfsx)
+{
+    struct nfs3_state *nfs3 = NULL;
+    int ret = -1;
+    unsigned int localpool = 0;
+    struct nfs_state *nfs = NULL;
+
+    if ((!nfsx) || (!nfsx->private))
+        return NULL;
+
+    nfs3 = (struct nfs3_state *)GF_CALLOC(1, sizeof(*nfs3),
+                                          gf_nfs_mt_nfs3_state);
+    if (!nfs3) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Memory allocation failed");
+        return NULL;
+    }
+
+    nfs = nfsx->private;
+    ret = nfs3_init_options(nfs3, nfsx->options);
+    if (ret == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_OPT_INIT_FAIL,
+               "Failed to init options");
+        goto ret;
+    }
+
+    nfs3->iobpool = nfsx->ctx->iobuf_pool;
+
+    localpool = nfs->memfactor * GF_NFS_CONCURRENT_OPS_MULT;
+    gf_msg_trace(GF_NFS3, 0, "local pool: %d", localpool);
+    nfs3->localpool = mem_pool_new_ctx(nfsx->ctx, nfs3_call_state_t, localpool);
+    if (!nfs3->localpool) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "local mempool creation failed");
+        ret = -1;
+        goto ret;
+    }
+
+    nfs3->nfsx = nfsx;
+    nfs3->exportslist = nfsx->children;
+    INIT_LIST_HEAD(&nfs3->exports);
+    ret = nfs3_init_subvolumes(nfs3);
+    if (ret == -1) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_SUBVOL_INIT_FAIL,
+               "Failed to init per-subvolume state");
+        goto free_localpool;
+    }
+
+    nfs3->serverstart = (uint64_t)time(NULL);
+    INIT_LIST_HEAD(&nfs3->fdlru);
+    LOCK_INIT(&nfs3->fdlrulock);
+    nfs3->fdcount = 0;
+
+    ret = rpcsvc_create_listeners(nfs->rpcsvc, nfsx->options, nfsx->name);
+    if (ret == -1) {
+        gf_msg(GF_NFS, GF_LOG_ERROR, 0, NFS_MSG_LISTENERS_CREATE_FAIL,
+               "Unable to create listeners");
+        goto free_localpool;
+    }
+
+    nfs->nfs3state = nfs3;
+    ret = 0;
 
 free_localpool:
-        if (ret == -1)
-                mem_pool_destroy (nfs3->localpool);
+    if (ret == -1)
+        mem_pool_destroy(nfs3->localpool);
 
 ret:
-        if (ret == -1) {
-                GF_FREE (nfs3);
-                nfs3 = NULL;
-        }
+    if (ret == -1) {
+        GF_FREE(nfs3);
+        nfs3 = NULL;
+    }
 
-        return nfs3;
+    return nfs3;
 }
 
-
 rpcsvc_program_t *
-nfs3svc_init (xlator_t *nfsx)
+nfs3svc_init(xlator_t *nfsx)
 {
-        struct nfs3_state       *nfs3 = NULL;
+    struct nfs3_state *nfs3 = NULL;
 
-        if (!nfsx)
-                return NULL;
+    if (!nfsx)
+        return NULL;
 
-        nfs3 = nfs3_init_state (nfsx);
-        if (!nfs3) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STATE_INIT_FAIL,
-                        "NFSv3 state init failed");
-                return NULL;
-        }
+    nfs3 = nfs3_init_state(nfsx);
+    if (!nfs3) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_STATE_INIT_FAIL,
+               "NFSv3 state init failed");
+        return NULL;
+    }
 
-        nfs3prog.private = nfs3;
+    nfs3prog.private = nfs3;
 
-        return &nfs3prog;
+    return &nfs3prog;
 }
 
 int
-nfs3_reconfigure_state (xlator_t *nfsx, dict_t *options)
-{
-        int                   ret   = -1;
-        struct nfs3_export    *exp  = NULL;
-        struct nfs_state      *nfs  = NULL;
-        struct nfs3_state     *nfs3 = NULL;
-
-        if ((!nfsx) || (!nfsx->private) || (!options))
-                goto out;
-
-        nfs = (struct nfs_state *)nfsx->private;
-        nfs3 = nfs->nfs3state;
-        if (!nfs3)
-                goto out;
-
-        ret = nfs3_init_options (nfs3, options);
+nfs3_reconfigure_state(xlator_t *nfsx, dict_t *options)
+{
+    int ret = -1;
+    struct nfs3_export *exp = NULL;
+    struct nfs_state *nfs = NULL;
+    struct nfs3_state *nfs3 = NULL;
+
+    if ((!nfsx) || (!nfsx->private) || (!options))
+        goto out;
+
+    nfs = (struct nfs_state *)nfsx->private;
+    nfs3 = nfs->nfs3state;
+    if (!nfs3)
+        goto out;
+
+    ret = nfs3_init_options(nfs3, options);
+    if (ret) {
+        gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_FAIL,
+               "Failed to reconfigure options");
+        goto out;
+    }
+
+    list_for_each_entry(exp, &nfs3->exports, explist)
+    {
+        ret = nfs3_init_subvolume_options(nfsx, exp, options);
         if (ret) {
-                gf_msg (GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_FAIL,
-                        "Failed to reconfigure options");
-                goto out;
+            gf_msg(GF_NFS3, GF_LOG_ERROR, 0, NFS_MSG_RECONF_SUBVOL_FAIL,
+                   "Failed to reconfigure subvol options");
+            goto out;
         }
+    }
 
-        list_for_each_entry (exp, &nfs3->exports, explist) {
-                ret = nfs3_init_subvolume_options (nfsx, exp, options);
-                if (ret) {
-                        gf_msg (GF_NFS3, GF_LOG_ERROR, 0,
-                                NFS_MSG_RECONF_SUBVOL_FAIL,
-                                "Failed to reconfigure subvol options");
-                        goto out;
-                }
-        }
-
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
diff --git a/xlators/nfs/server/src/nlm4.c b/xlators/nfs/server/src/nlm4.c
index 0c810689021..0989f47f926 100644
--- a/xlators/nfs/server/src/nlm4.c
+++ b/xlators/nfs/server/src/nlm4.c
@@ -43,12 +43,13 @@
  * 2) use GF_REF_* for nlm_clnt_t
  */
 
-typedef ssize_t (*nlm4_serializer) (struct iovec outmsg, void *args);
+typedef ssize_t (*nlm4_serializer)(struct iovec outmsg, void *args);
 
-extern void nfs3_call_state_wipe (nfs3_call_state_t *cs);
+extern void
+nfs3_call_state_wipe(nfs3_call_state_t *cs);
 
 nfs3_call_state_t *
-nfs3_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v);
+nfs3_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req, xlator_t *v);
 
 struct list_head nlm_client_list;
 gf_lock_t nlm_client_list_lk;
@@ -56,2038 +57,2034 @@ gf_lock_t nlm_client_list_lk;
 /* race on this is harmless */
 int nlm_grace_period = 50;
 
-#define nlm4_validate_nfs3_state(request, state, status, label, retval) \
-        do      {                                                       \
-                state = rpcsvc_request_program_private (request);       \
-                if (!state) {                                           \
-                        gf_msg (GF_NLM, GF_LOG_ERROR, errno,            \
-                                NFS_MSG_STATE_MISSING, "NFSv3 state "   \
-                                "missing from RPC request");            \
-                        rpcsvc_request_seterr (req, SYSTEM_ERR);        \
-                        status = nlm4_failed;                           \
-                        goto label;                                     \
-                }                                                       \
-        } while (0);                                                    \
-
-#define nlm4_handle_call_state_init(nfs3state, calls, rq, opstat, errlabel)\
-        do {                                                            \
-                calls = nlm4_call_state_init ((nfs3state), (rq));       \
-                if (!calls) {                                           \
-                        gf_msg (GF_NLM, GF_LOG_ERROR, errno,            \
-                                NFS_MSG_INIT_CALL_STAT_FAIL, "Failed to "\
-                                "init call state");                     \
-                        opstat = nlm4_failed;                           \
-                        rpcsvc_request_seterr (req, SYSTEM_ERR);        \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
-
-#define nlm4_validate_gluster_fh(handle, status, errlabel)              \
-        do {                                                            \
-                if (!nfs3_fh_validate (handle)) {                       \
-                        status = nlm4_stale_fh;                         \
-                        goto errlabel;                                  \
-                }                                                       \
-        } while (0)                                                     \
+#define nlm4_validate_nfs3_state(request, state, status, label, retval)        \
+    do {                                                                       \
+        state = rpcsvc_request_program_private(request);                       \
+        if (!state) {                                                          \
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_STATE_MISSING,         \
+                   "NFSv3 state "                                              \
+                   "missing from RPC request");                                \
+            rpcsvc_request_seterr(req, SYSTEM_ERR);                            \
+            status = nlm4_failed;                                              \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0);
+
+#define nlm4_handle_call_state_init(nfs3state, calls, rq, opstat, errlabel)    \
+    do {                                                                       \
+        calls = nlm4_call_state_init((nfs3state), (rq));                       \
+        if (!calls) {                                                          \
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_INIT_CALL_STAT_FAIL,   \
+                   "Failed to "                                                \
+                   "init call state");                                         \
+            opstat = nlm4_failed;                                              \
+            rpcsvc_request_seterr(req, SYSTEM_ERR);                            \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
+
+#define nlm4_validate_gluster_fh(handle, status, errlabel)                     \
+    do {                                                                       \
+        if (!nfs3_fh_validate(handle)) {                                       \
+            status = nlm4_stale_fh;                                            \
+            goto errlabel;                                                     \
+        }                                                                      \
+    } while (0)
 
 xlator_t *
-nfs3_fh_to_xlator (struct nfs3_state *nfs3, struct nfs3_fh *fh);
-
-#define nlm4_map_fh_to_volume(nfs3state, handle, req, volume, status, label) \
-        do {                                                            \
-                char exportid[256], gfid[256];                          \
-                rpc_transport_t *trans = NULL;                          \
-                volume = nfs3_fh_to_xlator ((nfs3state), &handle);      \
-                if (!volume) {                                          \
-                        gf_uuid_unparse (handle.exportid, exportid);       \
-                        gf_uuid_unparse (handle.gfid, gfid);               \
-                        trans = rpcsvc_request_transport (req);         \
-                        gf_msg (GF_NLM, GF_LOG_ERROR, errno,             \
-                                NFS_MSG_FH_TO_VOL_FAIL, "Failed to map "  \
-                                "FH to vol: client=%s, exportid=%s, gfid=%s",\
-                                trans->peerinfo.identifier, exportid,   \
-                                gfid);                                  \
-                        gf_msg (GF_NLM, GF_LOG_ERROR, errno,            \
-                                NFS_MSG_VOLUME_ERROR,                   \
-                                "Stale nfs client %s must be trying to "\
-                                "connect to a deleted volume, please "  \
-                                "unmount it.", trans->peerinfo.identifier);\
-                        status = nlm4_stale_fh;                         \
-                        goto label;                                     \
-                } else {                                                \
-                        gf_msg_trace (GF_NLM, 0, "FH to Volume: %s"     \
-                                      , volume->name);                  \
-                        rpcsvc_request_set_private (req, volume);       \
-                }                                                       \
-        } while (0);                                                    \
-
-#define nlm4_volume_started_check(nfs3state, vlm, rtval, erlbl)         \
-        do {                                                            \
-              if ((!nfs_subvolume_started (nfs_state (nfs3state->nfsx), vlm))){\
-                        gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE, \
-                                "Volume is disabled: %s",               \
-                                vlm->name);                             \
-                      rtval = RPCSVC_ACTOR_IGNORE;                      \
-                      goto erlbl;                                       \
-              }                                                         \
-        } while (0)                                                     \
-
-#define nlm4_check_fh_resolve_status(cst, nfstat, erlabl)               \
-        do {                                                            \
-                xlator_t *xlatorp = NULL;                               \
-                char buf[256], gfid[GF_UUID_BUF_SIZE];                  \
-                rpc_transport_t *trans = NULL;                          \
-                if ((cst)->resolve_ret < 0) {                           \
-                        trans = rpcsvc_request_transport (cst->req);    \
-                        xlatorp = nfs3_fh_to_xlator (cst->nfs3state,    \
-                                                     &cst->resolvefh);  \
-                        gf_uuid_unparse (cst->resolvefh.gfid, gfid);    \
-                        snprintf (buf, sizeof (buf), "(%s) %s : %s",    \
-                                  trans->peerinfo.identifier,           \
-                                  xlatorp ? xlatorp->name : "ERR",      \
-                                  gfid);                                \
-                        gf_msg (GF_NLM, GF_LOG_ERROR, 0,                \
-                                NFS_MSG_RESOLVE_FH_FAIL, "Unable to resolve FH"\
-                                ": %s", buf);                           \
-                        nfstat = nlm4_errno_to_nlm4stat (cst->resolve_errno);\
-                        goto erlabl;                                    \
-                }                                                       \
-        } while (0)                                                     \
-
+nfs3_fh_to_xlator(struct nfs3_state *nfs3, struct nfs3_fh *fh);
+
+#define nlm4_map_fh_to_volume(nfs3state, handle, req, volume, status, label)   \
+    do {                                                                       \
+        char exportid[256], gfid[256];                                         \
+        rpc_transport_t *trans = NULL;                                         \
+        volume = nfs3_fh_to_xlator((nfs3state), &handle);                      \
+        if (!volume) {                                                         \
+            gf_uuid_unparse(handle.exportid, exportid);                        \
+            gf_uuid_unparse(handle.gfid, gfid);                                \
+            trans = rpcsvc_request_transport(req);                             \
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FH_TO_VOL_FAIL,        \
+                   "Failed to map "                                            \
+                   "FH to vol: client=%s, exportid=%s, gfid=%s",               \
+                   trans->peerinfo.identifier, exportid, gfid);                \
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_VOLUME_ERROR,          \
+                   "Stale nfs client %s must be trying to "                    \
+                   "connect to a deleted volume, please "                      \
+                   "unmount it.",                                              \
+                   trans->peerinfo.identifier);                                \
+            status = nlm4_stale_fh;                                            \
+            goto label;                                                        \
+        } else {                                                               \
+            gf_msg_trace(GF_NLM, 0, "FH to Volume: %s", volume->name);         \
+            rpcsvc_request_set_private(req, volume);                           \
+        }                                                                      \
+    } while (0);
+
+#define nlm4_volume_started_check(nfs3state, vlm, rtval, erlbl)                \
+    do {                                                                       \
+        if ((!nfs_subvolume_started(nfs_state(nfs3state->nfsx), vlm))) {       \
+            gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_VOL_DISABLE,               \
+                   "Volume is disabled: %s", vlm->name);                       \
+            rtval = RPCSVC_ACTOR_IGNORE;                                       \
+            goto erlbl;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define nlm4_check_fh_resolve_status(cst, nfstat, erlabl)                      \
+    do {                                                                       \
+        xlator_t *xlatorp = NULL;                                              \
+        char buf[256], gfid[GF_UUID_BUF_SIZE];                                 \
+        rpc_transport_t *trans = NULL;                                         \
+        if ((cst)->resolve_ret < 0) {                                          \
+            trans = rpcsvc_request_transport(cst->req);                        \
+            xlatorp = nfs3_fh_to_xlator(cst->nfs3state, &cst->resolvefh);      \
+            gf_uuid_unparse(cst->resolvefh.gfid, gfid);                        \
+            snprintf(buf, sizeof(buf), "(%s) %s : %s",                         \
+                     trans->peerinfo.identifier,                               \
+                     xlatorp ? xlatorp->name : "ERR", gfid);                   \
+            gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_FH_FAIL,           \
+                   "Unable to resolve FH"                                      \
+                   ": %s",                                                     \
+                   buf);                                                       \
+            nfstat = nlm4_errno_to_nlm4stat(cst->resolve_errno);               \
+            goto erlabl;                                                       \
+        }                                                                      \
+    } while (0)
 
 void
-nlm4_prep_nlm4_testargs (nlm4_testargs *args, struct nfs3_fh *fh,
-                         nlm4_lkowner_t *oh, char *cookiebytes)
+nlm4_prep_nlm4_testargs(nlm4_testargs *args, struct nfs3_fh *fh,
+                        nlm4_lkowner_t *oh, char *cookiebytes)
 {
-        memset (args, 0, sizeof (*args));
-        args->alock.fh.nlm4_netobj_val = (void *)fh;
-        args->alock.oh.nlm4_netobj_val = (void *)oh;
-        args->cookie.nlm4_netobj_val = (void *)cookiebytes;
+    memset(args, 0, sizeof(*args));
+    args->alock.fh.nlm4_netobj_val = (void *)fh;
+    args->alock.oh.nlm4_netobj_val = (void *)oh;
+    args->cookie.nlm4_netobj_val = (void *)cookiebytes;
 }
 
 void
-nlm4_prep_nlm4_lockargs (nlm4_lockargs *args, struct nfs3_fh *fh,
-                         nlm4_lkowner_t *oh, char *cookiebytes)
+nlm4_prep_nlm4_lockargs(nlm4_lockargs *args, struct nfs3_fh *fh,
+                        nlm4_lkowner_t *oh, char *cookiebytes)
 {
-        memset (args, 0, sizeof (*args));
-        args->alock.fh.nlm4_netobj_val = (void *)fh;
-        args->alock.oh.nlm4_netobj_val = (void *)oh;
-        args->cookie.nlm4_netobj_val = (void *)cookiebytes;
+    memset(args, 0, sizeof(*args));
+    args->alock.fh.nlm4_netobj_val = (void *)fh;
+    args->alock.oh.nlm4_netobj_val = (void *)oh;
+    args->cookie.nlm4_netobj_val = (void *)cookiebytes;
 }
 
 void
-nlm4_prep_nlm4_cancargs (nlm4_cancargs *args, struct nfs3_fh *fh,
-                           nlm4_lkowner_t *oh, char *cookiebytes)
+nlm4_prep_nlm4_cancargs(nlm4_cancargs *args, struct nfs3_fh *fh,
+                        nlm4_lkowner_t *oh, char *cookiebytes)
 {
-        memset (args, 0, sizeof (*args));
-        args->alock.fh.nlm4_netobj_val = (void *)fh;
-        args->alock.oh.nlm4_netobj_val = (void *)oh;
-        args->cookie.nlm4_netobj_val = (void *)cookiebytes;
+    memset(args, 0, sizeof(*args));
+    args->alock.fh.nlm4_netobj_val = (void *)fh;
+    args->alock.oh.nlm4_netobj_val = (void *)oh;
+    args->cookie.nlm4_netobj_val = (void *)cookiebytes;
 }
 
 void
-nlm4_prep_nlm4_unlockargs (nlm4_unlockargs *args, struct nfs3_fh *fh,
-                           nlm4_lkowner_t *oh, char *cookiebytes)
+nlm4_prep_nlm4_unlockargs(nlm4_unlockargs *args, struct nfs3_fh *fh,
+                          nlm4_lkowner_t *oh, char *cookiebytes)
 {
-        memset (args, 0, sizeof (*args));
-        args->alock.fh.nlm4_netobj_val = (void *)fh;
-        args->alock.oh.nlm4_netobj_val = (void *)oh;
-        args->cookie.nlm4_netobj_val = (void *)cookiebytes;
+    memset(args, 0, sizeof(*args));
+    args->alock.fh.nlm4_netobj_val = (void *)fh;
+    args->alock.oh.nlm4_netobj_val = (void *)oh;
+    args->cookie.nlm4_netobj_val = (void *)cookiebytes;
 }
 
 void
-nlm4_prep_shareargs (nlm4_shareargs *args, struct nfs3_fh *fh,
-                     nlm4_lkowner_t *oh, char *cookiebytes)
+nlm4_prep_shareargs(nlm4_shareargs *args, struct nfs3_fh *fh,
+                    nlm4_lkowner_t *oh, char *cookiebytes)
 {
-        memset (args, 0, sizeof (*args));
-        args->share.fh.nlm4_netobj_val = (void *)fh;
-        args->share.oh.nlm4_netobj_val = (void *)oh;
-        args->cookie.nlm4_netobj_val = (void *)cookiebytes;
+    memset(args, 0, sizeof(*args));
+    args->share.fh.nlm4_netobj_val = (void *)fh;
+    args->share.oh.nlm4_netobj_val = (void *)oh;
+    args->cookie.nlm4_netobj_val = (void *)cookiebytes;
 }
 
 void
-nlm4_prep_freeallargs (nlm4_freeallargs *args, nlm4_lkowner_t *oh)
+nlm4_prep_freeallargs(nlm4_freeallargs *args, nlm4_lkowner_t *oh)
 {
-        memset (args, 0, sizeof (*args));
-        args->name = (void *)oh;
+    memset(args, 0, sizeof(*args));
+    args->name = (void *)oh;
 }
 
 void
-nlm_copy_lkowner (gf_lkowner_t *dst, nlm4_netobj *src)
+nlm_copy_lkowner(gf_lkowner_t *dst, nlm4_netobj *src)
 {
-        dst->len = src->nlm4_netobj_len;
-        memcpy (dst->data, src->nlm4_netobj_val, dst->len);
+    dst->len = src->nlm4_netobj_len;
+    memcpy(dst->data, src->nlm4_netobj_val, dst->len);
 }
 
 int
-nlm_is_oh_same_lkowner (gf_lkowner_t *a, nlm4_netobj *b)
+nlm_is_oh_same_lkowner(gf_lkowner_t *a, nlm4_netobj *b)
 {
-        if (!a || !b) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "invalid args");
-                return -1;
-        }
+    if (!a || !b) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "invalid args");
+        return -1;
+    }
 
-        return (a->len == b->nlm4_netobj_len &&
-                !memcmp (a->data, b->nlm4_netobj_val, a->len));
+    return (a->len == b->nlm4_netobj_len &&
+            !memcmp(a->data, b->nlm4_netobj_val, a->len));
 }
 
 nlm4_stats
-nlm4_errno_to_nlm4stat (int errnum)
+nlm4_errno_to_nlm4stat(int errnum)
 {
-        nlm4_stats        stat = nlm4_denied;
+    nlm4_stats stat = nlm4_denied;
 
-        switch (errnum) {
+    switch (errnum) {
         case 0:
-                stat = nlm4_granted;
-                break;
+            stat = nlm4_granted;
+            break;
         case EROFS:
-                stat = nlm4_rofs;
-                break;
+            stat = nlm4_rofs;
+            break;
         case ESTALE:
-                stat = nlm4_stale_fh;
-                break;
+            stat = nlm4_stale_fh;
+            break;
         case ENOLCK:
-                stat = nlm4_failed;
-                break;
+            stat = nlm4_failed;
+            break;
         default:
-                stat = nlm4_denied;
-                break;
-        }
+            stat = nlm4_denied;
+            break;
+    }
 
-        return stat;
+    return stat;
 }
 
 nfs3_call_state_t *
-nlm4_call_state_init (struct nfs3_state *s, rpcsvc_request_t *req)
+nlm4_call_state_init(struct nfs3_state *s, rpcsvc_request_t *req)
 {
-        nfs3_call_state_t       *cs = NULL;
+    nfs3_call_state_t *cs = NULL;
 
-        if ((!s) || (!req))
-                return NULL;
+    if ((!s) || (!req))
+        return NULL;
 
-        cs = nfs3_call_state_init (s, req, NULL);
-        if (!cs)
-                return NULL;
+    cs = nfs3_call_state_init(s, req, NULL);
+    if (!cs)
+        return NULL;
 
-        cs->monitor = 1;
+    cs->monitor = 1;
 
-        return cs;
+    return cs;
 }
 
 int
-nlm_monitor (char *caller_name)
-{
-        nlm_client_t *nlmclnt = NULL;
-        int monitor = -1;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        monitor = nlmclnt->nsm_monitor;
-                        nlmclnt->nsm_monitor = 1;
-                        break;
-                }
+nlm_monitor(char *caller_name)
+{
+    nlm_client_t *nlmclnt = NULL;
+    int monitor = -1;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            monitor = nlmclnt->nsm_monitor;
+            nlmclnt->nsm_monitor = 1;
+            break;
         }
-        UNLOCK (&nlm_client_list_lk);
+    }
+    UNLOCK(&nlm_client_list_lk);
 
-        if (monitor == -1)
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CALLER_NOT_FOUND,
-                        "%s was not found in the nlmclnt list", caller_name);
+    if (monitor == -1)
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CALLER_NOT_FOUND,
+               "%s was not found in the nlmclnt list", caller_name);
 
-        return monitor;
+    return monitor;
 }
 
 rpc_clnt_t *
-nlm_get_rpc_clnt (char *caller_name)
-{
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        rpc_clnt_t *rpc_clnt = NULL;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
-        }
-        if (!nlmclnt_found)
-                goto ret;
-        if (nlmclnt->rpc_clnt)
-                rpc_clnt = rpc_clnt_ref (nlmclnt->rpc_clnt);
+nlm_get_rpc_clnt(char *caller_name)
+{
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    rpc_clnt_t *rpc_clnt = NULL;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
+        }
+    }
+    if (!nlmclnt_found)
+        goto ret;
+    if (nlmclnt->rpc_clnt)
+        rpc_clnt = rpc_clnt_ref(nlmclnt->rpc_clnt);
 ret:
-        UNLOCK (&nlm_client_list_lk);
-        return rpc_clnt;
+    UNLOCK(&nlm_client_list_lk);
+    return rpc_clnt;
 }
 
 static void
-nlm_client_free (nlm_client_t *nlmclnt)
+nlm_client_free(nlm_client_t *nlmclnt)
 {
-        nlm_fde_t *fde = NULL, *tmp = NULL;
+    nlm_fde_t *fde = NULL, *tmp = NULL;
 
-        gf_msg_trace (GF_NLM, 0, "removing nlm-client %s from the list",
-                      nlmclnt->caller_name);
+    gf_msg_trace(GF_NLM, 0, "removing nlm-client %s from the list",
+                 nlmclnt->caller_name);
 
-        list_for_each_entry_safe (fde, tmp, &nlmclnt->fdes, fde_list) {
-                fd_unref (fde->fd);
-                list_del (&fde->fde_list);
-                GF_FREE (fde);
-        }
+    list_for_each_entry_safe(fde, tmp, &nlmclnt->fdes, fde_list)
+    {
+        fd_unref(fde->fd);
+        list_del(&fde->fde_list);
+        GF_FREE(fde);
+    }
 
-        list_del (&nlmclnt->fdes);
-        list_del (&nlmclnt->nlm_clients);
-        list_del (&nlmclnt->shares);
+    list_del(&nlmclnt->fdes);
+    list_del(&nlmclnt->nlm_clients);
+    list_del(&nlmclnt->shares);
 
-        GF_FREE (nlmclnt->caller_name);
+    GF_FREE(nlmclnt->caller_name);
 
-        if (nlmclnt->rpc_clnt) {
-                /* cleanup the saved-frames before last unref */
-                rpc_clnt_connection_cleanup (&nlmclnt->rpc_clnt->conn);
-                /* rpc_clnt_connection_cleanup() calls rpc_clnt_unref() */
-        }
+    if (nlmclnt->rpc_clnt) {
+        /* cleanup the saved-frames before last unref */
+        rpc_clnt_connection_cleanup(&nlmclnt->rpc_clnt->conn);
+        /* rpc_clnt_connection_cleanup() calls rpc_clnt_unref() */
+    }
 
-        GF_FREE (nlmclnt);
+    GF_FREE(nlmclnt);
 }
 
 int
-nlm_set_rpc_clnt (rpc_clnt_t *rpc_clnt, char *caller_name)
-{
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        int ret = -1;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
-        }
-
-        if (!nlmclnt_found) {
-                nlmclnt = GF_CALLOC (1, sizeof(*nlmclnt),
-                                     gf_nfs_mt_nlm4_nlmclnt);
-                if (nlmclnt == NULL)
-                        goto ret;
-
-                INIT_LIST_HEAD(&nlmclnt->fdes);
-                INIT_LIST_HEAD(&nlmclnt->nlm_clients);
-                INIT_LIST_HEAD(&nlmclnt->shares);
-
-                list_add (&nlmclnt->nlm_clients, &nlm_client_list);
-                nlmclnt->caller_name = gf_strdup (caller_name);
-        }
-
-        if (nlmclnt->rpc_clnt == NULL) {
-                nlmclnt->rpc_clnt = rpc_clnt_ref (rpc_clnt);
-        }
-        ret = 0;
+nlm_set_rpc_clnt(rpc_clnt_t *rpc_clnt, char *caller_name)
+{
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    int ret = -1;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
+        }
+    }
+
+    if (!nlmclnt_found) {
+        nlmclnt = GF_CALLOC(1, sizeof(*nlmclnt), gf_nfs_mt_nlm4_nlmclnt);
+        if (nlmclnt == NULL)
+            goto ret;
+
+        INIT_LIST_HEAD(&nlmclnt->fdes);
+        INIT_LIST_HEAD(&nlmclnt->nlm_clients);
+        INIT_LIST_HEAD(&nlmclnt->shares);
+
+        list_add(&nlmclnt->nlm_clients, &nlm_client_list);
+        nlmclnt->caller_name = gf_strdup(caller_name);
+    }
+
+    if (nlmclnt->rpc_clnt == NULL) {
+        nlmclnt->rpc_clnt = rpc_clnt_ref(rpc_clnt);
+    }
+    ret = 0;
 ret:
-        UNLOCK (&nlm_client_list_lk);
-        return ret;
+    UNLOCK(&nlm_client_list_lk);
+    return ret;
 }
 
 int
-nlm_unset_rpc_clnt (rpc_clnt_t *rpc)
+nlm_unset_rpc_clnt(rpc_clnt_t *rpc)
 {
-        nlm_client_t *nlmclnt = NULL;
+    nlm_client_t *nlmclnt = NULL;
 
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (rpc == nlmclnt->rpc_clnt) {
-                        nlm_client_free (nlmclnt);
-                        break;
-                }
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (rpc == nlmclnt->rpc_clnt) {
+            nlm_client_free(nlmclnt);
+            break;
         }
-        UNLOCK (&nlm_client_list_lk);
+    }
+    UNLOCK(&nlm_client_list_lk);
 
-        return 0;
+    return 0;
 }
 
 int
-nlm_add_nlmclnt (char *caller_name)
-{
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        int ret = -1;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
-        }
-        if (!nlmclnt_found) {
-                nlmclnt = GF_CALLOC (1, sizeof(*nlmclnt),
-                                     gf_nfs_mt_nlm4_nlmclnt);
-                if (nlmclnt == NULL) {
-                        gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY, "malloc error");
-                        goto ret;
-                }
-
-                INIT_LIST_HEAD(&nlmclnt->fdes);
-                INIT_LIST_HEAD(&nlmclnt->nlm_clients);
-                INIT_LIST_HEAD(&nlmclnt->shares);
-
-                list_add (&nlmclnt->nlm_clients, &nlm_client_list);
-                nlmclnt->caller_name = gf_strdup (caller_name);
+nlm_add_nlmclnt(char *caller_name)
+{
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    int ret = -1;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
+        }
+    }
+    if (!nlmclnt_found) {
+        nlmclnt = GF_CALLOC(1, sizeof(*nlmclnt), gf_nfs_mt_nlm4_nlmclnt);
+        if (nlmclnt == NULL) {
+            gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "malloc error");
+            goto ret;
         }
-        ret = 0;
+
+        INIT_LIST_HEAD(&nlmclnt->fdes);
+        INIT_LIST_HEAD(&nlmclnt->nlm_clients);
+        INIT_LIST_HEAD(&nlmclnt->shares);
+
+        list_add(&nlmclnt->nlm_clients, &nlm_client_list);
+        nlmclnt->caller_name = gf_strdup(caller_name);
+    }
+    ret = 0;
 ret:
-        UNLOCK (&nlm_client_list_lk);
-        return ret;
+    UNLOCK(&nlm_client_list_lk);
+    return ret;
 }
 
 int
-nlm4svc_submit_reply (rpcsvc_request_t *req, void *arg, nlm4_serializer sfunc)
-{
-        struct iovec            outmsg  = {0, };
-        struct iobuf            *iob    = NULL;
-        struct nfs3_state       *nfs3   = NULL;
-        int                     ret     = -1;
-        ssize_t                 msglen  = 0;
-        struct iobref           *iobref = NULL;
-
-        if (!req)
-                return -1;
-
-        nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req);
-        if (!nfs3) {
-                gf_msg (GF_NLM, 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.
-         */
-        iob = iobuf_get (nfs3->iobpool);
-        if (!iob) {
-                gf_msg (GF_NLM, 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_NLM, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL,
-                        "Failed to encode message");
-                goto ret;
-        }
-        outmsg.iov_len = msglen;
-
-        iobref = iobref_new ();
-        if (iobref == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobref");
-                goto ret;
-        }
-
-        ret = iobref_add (iobref, iob);
-        if (ret) {
-                gf_msg (GF_NLM, 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_NLM, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
-                        "Reply submission failed");
-                goto ret;
-        }
-
-        ret = 0;
+nlm4svc_submit_reply(rpcsvc_request_t *req, void *arg, nlm4_serializer sfunc)
+{
+    struct iovec outmsg = {
+        0,
+    };
+    struct iobuf *iob = NULL;
+    struct nfs3_state *nfs3 = NULL;
+    int ret = -1;
+    ssize_t msglen = 0;
+    struct iobref *iobref = NULL;
+
+    if (!req)
+        return -1;
+
+    nfs3 = (struct nfs3_state *)rpcsvc_request_program_private(req);
+    if (!nfs3) {
+        gf_msg(GF_NLM, 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.
+     */
+    iob = iobuf_get(nfs3->iobpool);
+    if (!iob) {
+        gf_msg(GF_NLM, 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_NLM, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL,
+               "Failed to encode message");
+        goto ret;
+    }
+    outmsg.iov_len = msglen;
+
+    iobref = iobref_new();
+    if (iobref == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobref");
+        goto ret;
+    }
+
+    ret = iobref_add(iobref, iob);
+    if (ret) {
+        gf_msg(GF_NLM, 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_NLM, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
+               "Reply submission failed");
+        goto ret;
+    }
+
+    ret = 0;
 ret:
-        if (iob)
-                iobuf_unref (iob);
-        if (iobref)
-                iobref_unref (iobref);
+    if (iob)
+        iobuf_unref(iob);
+    if (iobref)
+        iobref_unref(iobref);
 
-        return ret;
+    return ret;
 }
 
-typedef int (*nlm4_resume_fn_t) (void *cs);
+typedef int (*nlm4_resume_fn_t)(void *cs);
 
 int32_t
-nlm4_file_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+nlm4_file_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        nfs3_call_state_t *cs = frame->local;
+    nfs3_call_state_t *cs = frame->local;
 
-        if (op_ret == 0)
-                fd_bind (cs->fd);
-        cs->resolve_ret = op_ret;
-        cs->resume_fn (cs);
+    if (op_ret == 0)
+        fd_bind(cs->fd);
+    cs->resolve_ret = op_ret;
+    cs->resume_fn(cs);
 
-        frame->local = NULL;
-        STACK_DESTROY (frame->root);
-        GF_REF_PUT (cs);
+    frame->local = NULL;
+    STACK_DESTROY(frame->root);
+    GF_REF_PUT(cs);
 
-        return 0;
+    return 0;
 }
 
 void *
 nsm_monitor(void *arg)
 {
-        CLIENT *clnt = NULL;
-        enum clnt_stat ret;
-        struct mon nsm_mon;
-        struct sm_stat_res res;
-        struct timeval tout = { 5, 0 };
-        char *host = NULL;
-
-        host = arg;
-        nsm_mon.mon_id.mon_name = gf_strdup(host);
-        nsm_mon.mon_id.my_id.my_name = gf_strdup("localhost");
-        nsm_mon.mon_id.my_id.my_prog = NLMCBK_PROGRAM;
-        nsm_mon.mon_id.my_id.my_vers = NLMCBK_V1;
-        nsm_mon.mon_id.my_id.my_proc = NLMCBK_SM_NOTIFY;
-        /* nothing to put in the private data */
+    CLIENT *clnt = NULL;
+    enum clnt_stat ret;
+    struct mon nsm_mon;
+    struct sm_stat_res res;
+    struct timeval tout = {5, 0};
+    char *host = NULL;
+
+    host = arg;
+    nsm_mon.mon_id.mon_name = gf_strdup(host);
+    nsm_mon.mon_id.my_id.my_name = gf_strdup("localhost");
+    nsm_mon.mon_id.my_id.my_prog = NLMCBK_PROGRAM;
+    nsm_mon.mon_id.my_id.my_vers = NLMCBK_V1;
+    nsm_mon.mon_id.my_id.my_proc = NLMCBK_SM_NOTIFY;
+    /* nothing to put in the private data */
 #define SM_PROG 100024
 #define SM_VERS 1
 #define SM_MON 2
 
-        /* create a connection to nsm on the localhost */
-        clnt = clnt_create("localhost", SM_PROG, SM_VERS, "tcp");
-        if(!clnt)
-        {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CREATE_ERROR,
-                        "%s", clnt_spcreateerror ("Clnt_create()"));
-                goto out;
-        }
-
-        ret = clnt_call(clnt, SM_MON,
-                        (xdrproc_t) xdr_mon, (caddr_t) & nsm_mon,
-                        (xdrproc_t) xdr_sm_stat_res, (caddr_t) & res, tout);
-        if(ret != RPC_SUCCESS)
-        {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR,
-                        "clnt_call(): %s", clnt_sperrno(ret));
-                goto out;
-        }
-        if(res.res_stat != STAT_SUCC)
-        {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR,
-                        "clnt_call(): %s", clnt_sperrno(ret));
-                goto out;
-        }
+    /* create a connection to nsm on the localhost */
+    clnt = clnt_create("localhost", SM_PROG, SM_VERS, "tcp");
+    if (!clnt) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CREATE_ERROR, "%s",
+               clnt_spcreateerror("Clnt_create()"));
+        goto out;
+    }
+
+    ret = clnt_call(clnt, SM_MON, (xdrproc_t)xdr_mon, (caddr_t)&nsm_mon,
+                    (xdrproc_t)xdr_sm_stat_res, (caddr_t)&res, tout);
+    if (ret != RPC_SUCCESS) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR,
+               "clnt_call(): %s", clnt_sperrno(ret));
+        goto out;
+    }
+    if (res.res_stat != STAT_SUCC) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLNT_CALL_ERROR,
+               "clnt_call(): %s", clnt_sperrno(ret));
+        goto out;
+    }
 
 out:
-        GF_FREE(nsm_mon.mon_id.mon_name);
-        GF_FREE(nsm_mon.mon_id.my_id.my_name);
-        if (clnt != NULL)
-                clnt_destroy(clnt);
-        return NULL;
+    GF_FREE(nsm_mon.mon_id.mon_name);
+    GF_FREE(nsm_mon.mon_id.my_id.my_name);
+    if (clnt != NULL)
+        clnt_destroy(clnt);
+    return NULL;
 }
 
 nlm_client_t *
-__nlm_get_uniq (char *caller_name)
+__nlm_get_uniq(char *caller_name)
 {
-        nlm_client_t *nlmclnt = NULL;
+    nlm_client_t *nlmclnt = NULL;
 
-        if (!caller_name)
-                return NULL;
+    if (!caller_name)
+        return NULL;
 
-        list_for_each_entry (nlmclnt, &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name))
-                        return nlmclnt;
-        }
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name))
+            return nlmclnt;
+    }
 
-        return NULL;
+    return NULL;
 }
 
 nlm_client_t *
-nlm_get_uniq (char *caller_name)
+nlm_get_uniq(char *caller_name)
 {
-        nlm_client_t *nlmclnt = NULL;
+    nlm_client_t *nlmclnt = NULL;
 
-        LOCK (&nlm_client_list_lk);
-        nlmclnt = __nlm_get_uniq (caller_name);
-        UNLOCK (&nlm_client_list_lk);
+    LOCK(&nlm_client_list_lk);
+    nlmclnt = __nlm_get_uniq(caller_name);
+    UNLOCK(&nlm_client_list_lk);
 
-        return nlmclnt;
+    return nlmclnt;
 }
 
-
 int
 nlm4_file_open_and_resume(nfs3_call_state_t *cs, nlm4_resume_fn_t resume)
 {
-        fd_t *fd = NULL;
-        int ret = -1;
-        int flags = 0;
-        nlm_client_t *nlmclnt = NULL;
-        call_frame_t *frame = NULL;
-
-        if (cs->args.nlm4_lockargs.exclusive == _gf_false)
-                flags = O_RDONLY;
-        else
-                flags = O_WRONLY;
-
-        nlmclnt = nlm_get_uniq (cs->args.nlm4_lockargs.alock.caller_name);
-        if (nlmclnt == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK,
-                        NFS_MSG_NO_MEMORY, "nlm_get_uniq() "
-                        "returned NULL");
-                ret = -ENOLCK;
-                goto err;
-        }
-        cs->resume_fn = resume;
-        fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt);
-        if (fd) {
-                cs->fd = fd;
-                cs->resolve_ret = 0;
-                cs->resume_fn(cs);
-                ret = 0;
-                goto err;
-        }
-
-        fd = fd_create_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt);
-        if (fd == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY,
-                        "fd_create_uint64() returned NULL");
-                ret = -ENOLCK;
-                goto err;
-        }
-
+    fd_t *fd = NULL;
+    int ret = -1;
+    int flags = 0;
+    nlm_client_t *nlmclnt = NULL;
+    call_frame_t *frame = NULL;
+
+    if (cs->args.nlm4_lockargs.exclusive == _gf_false)
+        flags = O_RDONLY;
+    else
+        flags = O_WRONLY;
+
+    nlmclnt = nlm_get_uniq(cs->args.nlm4_lockargs.alock.caller_name);
+    if (nlmclnt == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY,
+               "nlm_get_uniq() "
+               "returned NULL");
+        ret = -ENOLCK;
+        goto err;
+    }
+    cs->resume_fn = resume;
+    fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt);
+    if (fd) {
         cs->fd = fd;
-
-        frame = create_frame (cs->nfsx, cs->nfsx->ctx->pool);
-        if (!frame) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "unable to create frame");
-                ret = -ENOMEM;
-                goto err;
-        }
-
-        frame->root->pid = NFS_PID;
-        frame->root->uid = rpcsvc_request_uid (cs->req);
-        frame->root->gid = rpcsvc_request_gid (cs->req);
-        frame->local = GF_REF_GET (cs);
-        nfs_fix_groups (cs->nfsx, frame->root);
-
-        STACK_WIND_COOKIE (frame, nlm4_file_open_cbk, cs->vol, cs->vol,
-                          cs->vol->fops->open, &cs->resolvedloc, flags,
-                          cs->fd, NULL);
+        cs->resolve_ret = 0;
+        cs->resume_fn(cs);
         ret = 0;
+        goto err;
+    }
+
+    fd = fd_create_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt);
+    if (fd == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY,
+               "fd_create_uint64() returned NULL");
+        ret = -ENOLCK;
+        goto err;
+    }
+
+    cs->fd = fd;
+
+    frame = create_frame(cs->nfsx, cs->nfsx->ctx->pool);
+    if (!frame) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "unable to create frame");
+        ret = -ENOMEM;
+        goto err;
+    }
+
+    frame->root->pid = NFS_PID;
+    frame->root->uid = rpcsvc_request_uid(cs->req);
+    frame->root->gid = rpcsvc_request_gid(cs->req);
+    frame->local = GF_REF_GET(cs);
+    nfs_fix_groups(cs->nfsx, frame->root);
+
+    STACK_WIND_COOKIE(frame, nlm4_file_open_cbk, cs->vol, cs->vol,
+                      cs->vol->fops->open, &cs->resolvedloc, flags, cs->fd,
+                      NULL);
+    ret = 0;
 err:
-        return ret;
+    return ret;
 }
 
 int
-nlm4_generic_reply (rpcsvc_request_t *req, nlm4_netobj cookie, nlm4_stats stat)
+nlm4_generic_reply(rpcsvc_request_t *req, nlm4_netobj cookie, nlm4_stats stat)
 {
-        nlm4_res res;
+    nlm4_res res;
 
-        memset (&res, 0, sizeof (res));
-        res.cookie = cookie;
-        res.stat.stat = stat;
+    memset(&res, 0, sizeof(res));
+    res.cookie = cookie;
+    res.stat.stat = stat;
 
-        nlm4svc_submit_reply (req, (void *)&res,
-                              (nlm4_serializer)xdr_serialize_nlm4_res);
-        return 0;
+    nlm4svc_submit_reply(req, (void *)&res,
+                         (nlm4_serializer)xdr_serialize_nlm4_res);
+    return 0;
 }
 
 int
-nlm4svc_null (rpcsvc_request_t *req)
+nlm4svc_null(rpcsvc_request_t *req)
 {
-        struct iovec    dummyvec = {0, };
+    struct iovec dummyvec = {
+        0,
+    };
 
-        if (!req) {
-                gf_msg (GF_NLM, 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_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "Got NULL request!");
         return 0;
+    }
+    rpcsvc_submit_generic(req, &dummyvec, 1, NULL, 0, NULL);
+    return 0;
 }
 
 int
-nlm4_gf_flock_to_holder (nlm4_holder *holder, struct gf_flock *flock)
+nlm4_gf_flock_to_holder(nlm4_holder *holder, struct gf_flock *flock)
 {
-        switch (flock->l_type) {
+    switch (flock->l_type) {
         case GF_LK_F_WRLCK:
-                holder->exclusive = 1;
-                break;
-        }
+            holder->exclusive = 1;
+            break;
+    }
 
-        holder->svid = flock->l_pid;
-        holder->l_offset = flock->l_start;
-        holder->l_len = flock->l_len;
-        return 0;
+    holder->svid = flock->l_pid;
+    holder->l_offset = flock->l_start;
+    holder->l_len = flock->l_len;
+    return 0;
 }
 
 int
-nlm4_lock_to_gf_flock (struct gf_flock *flock, nlm4_lock *lock, int excl)
-{
-        flock->l_pid = lock->svid;
-        flock->l_start = lock->l_offset;
-        flock->l_len = lock->l_len;
-        if (excl)
-                flock->l_type = F_WRLCK;
-        else
-                flock->l_type = F_RDLCK;
-        flock->l_whence = SEEK_SET;
-        nlm_copy_lkowner (&flock->l_owner, &lock->oh);
-        return 0;
+nlm4_lock_to_gf_flock(struct gf_flock *flock, nlm4_lock *lock, int excl)
+{
+    flock->l_pid = lock->svid;
+    flock->l_start = lock->l_offset;
+    flock->l_len = lock->l_len;
+    if (excl)
+        flock->l_type = F_WRLCK;
+    else
+        flock->l_type = F_RDLCK;
+    flock->l_whence = SEEK_SET;
+    nlm_copy_lkowner(&flock->l_owner, &lock->oh);
+    return 0;
 }
 
 rpc_clnt_procedure_t nlm4_clnt_actors[NLM4_PROC_COUNT] = {
-        [NLM4_NULL] = {"NULL", NULL},
-        [NLM4_GRANTED] = {"GRANTED", NULL},
+    [NLM4_NULL] = {"NULL", NULL},
+    [NLM4_GRANTED] = {"GRANTED", NULL},
 };
 
 char *nlm4_clnt_names[NLM4_PROC_COUNT] = {
-        [NLM4_NULL] = "NULL",
-        [NLM4_GRANTED] = "GRANTED",
+    [NLM4_NULL] = "NULL",
+    [NLM4_GRANTED] = "GRANTED",
 };
 
 rpc_clnt_prog_t nlm4clntprog = {
-        .progname = "NLMv4",
-        .prognum = NLM_PROGRAM,
-        .progver = NLM_V4,
-        .numproc = NLM4_PROC_COUNT,
-        .proctable = nlm4_clnt_actors,
-        .procnames = nlm4_clnt_names,
+    .progname = "NLMv4",
+    .prognum = NLM_PROGRAM,
+    .progver = NLM_V4,
+    .numproc = NLM4_PROC_COUNT,
+    .proctable = nlm4_clnt_actors,
+    .procnames = nlm4_clnt_names,
 };
 
 int
-nlm4_test_reply (nfs3_call_state_t *cs, nlm4_stats stat, struct gf_flock *flock)
+nlm4_test_reply(nfs3_call_state_t *cs, nlm4_stats stat, struct gf_flock *flock)
 {
-        nlm4_testres res;
+    nlm4_testres res;
 
-        memset (&res, 0, sizeof (res));
-        res.cookie = cs->args.nlm4_testargs.cookie;
-        res.stat.stat = stat;
-        if (stat == nlm4_denied)
-                nlm4_gf_flock_to_holder (&res.stat.nlm4_testrply_u.holder,
-                                         flock);
+    memset(&res, 0, sizeof(res));
+    res.cookie = cs->args.nlm4_testargs.cookie;
+    res.stat.stat = stat;
+    if (stat == nlm4_denied)
+        nlm4_gf_flock_to_holder(&res.stat.nlm4_testrply_u.holder, flock);
 
-        nlm4svc_submit_reply (cs->req, (void *)&res,
-                              (nlm4_serializer)xdr_serialize_nlm4_testres);
-        return 0;
+    nlm4svc_submit_reply(cs->req, (void *)&res,
+                         (nlm4_serializer)xdr_serialize_nlm4_testres);
+    return 0;
 }
 
 int
-nlm4svc_test_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                  dict_t *xdata)
+nlm4svc_test_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+                 dict_t *xdata)
 {
-        nlm4_stats                      stat = nlm4_denied;
-        nfs3_call_state_t              *cs = NULL;
+    nlm4_stats stat = nlm4_denied;
+    nfs3_call_state_t *cs = NULL;
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nlm4_errno_to_nlm4stat (op_errno);
-                goto err;
-        } else if (flock->l_type == F_UNLCK)
-                stat = nlm4_granted;
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nlm4_errno_to_nlm4stat(op_errno);
+        goto err;
+    } else if (flock->l_type == F_UNLCK)
+        stat = nlm4_granted;
 
 err:
-        nlm4_test_reply (cs, stat, flock);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nlm4_test_reply(cs, stat, flock);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
 int
-nlm4_test_fd_resume (void *carg)
-{
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        struct gf_flock                 flock = {0, };
-
-        if (!carg)
-                return ret;
+nlm4_test_fd_resume(void *carg)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+
+    if (!carg)
+        return ret;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nfs_request_user_init (&nfu, cs->req);
-        nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_testargs.alock,
-                               cs->args.nlm4_testargs.exclusive);
-        nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_testargs.alock.oh);
-        ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_GETLK, &flock,
-                      nlm4svc_test_cbk, cs);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nfs_request_user_init(&nfu, cs->req);
+    nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_testargs.alock,
+                          cs->args.nlm4_testargs.exclusive);
+    nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_testargs.alock.oh);
+    ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_GETLK, &flock,
+                 nlm4svc_test_cbk, cs);
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nlm4_test_resume (void *carg)
+nlm4_test_resume(void *carg)
 {
-        nlm4_stats                      stat = nlm4_failed;
-        int                             ret = -1;
-        nfs3_call_state_t               *cs = NULL;
-        fd_t                            *fd = NULL;
+    nlm4_stats stat = nlm4_failed;
+    int ret = -1;
+    nfs3_call_state_t *cs = NULL;
+    fd_t *fd = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nlm4_check_fh_resolve_status (cs, stat, nlm4err);
-        fd = fd_anonymous (cs->resolvedloc.inode);
-        if (!fd)
-                goto nlm4err;
-        cs->fd = fd;
-        ret = nlm4_test_fd_resume (cs);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nlm4_check_fh_resolve_status(cs, stat, nlm4err);
+    fd = fd_anonymous(cs->resolvedloc.inode);
+    if (!fd)
+        goto nlm4err;
+    cs->fd = fd;
+    ret = nlm4_test_fd_resume(cs);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL,
-                        "unable to open_and_resume");
-                stat = nlm4_errno_to_nlm4stat (-ret);
-                nlm4_test_reply (cs, stat, NULL);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL,
+               "unable to open_and_resume");
+        stat = nlm4_errno_to_nlm4stat(-ret);
+        nlm4_test_reply(cs, stat, NULL);
+        nfs3_call_state_wipe(cs);
+    }
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4svc_test (rpcsvc_request_t *req)
-{
-        xlator_t                        *vol = NULL;
-        nlm4_stats                      stat = nlm4_failed;
-        struct nfs_state               *nfs = NULL;
-        nfs3_state_t                   *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-        int                             ret = RPCSVC_ACTOR_ERROR;
-        struct nfs3_fh                  fh = {{0}, };
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_nlm4_testargs (&cs->args.nlm4_testargs, &fh, &cs->lkowner,
-                                 cs->cookiebytes);
-        if (xdr_to_nlm4_testargs(req->msg[0], &cs->args.nlm4_testargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err);
+nlm4svc_test(rpcsvc_request_t *req)
+{
+    xlator_t *vol = NULL;
+    nlm4_stats stat = nlm4_failed;
+    struct nfs_state *nfs = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    int ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+
+    if (!req)
+        return ret;
 
-        if (nlm_grace_period) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
-                        "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_test_reply (cs, stat, NULL);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_nlm4_testargs(&cs->args.nlm4_testargs, &fh, &cs->lkowner,
+                            cs->cookiebytes);
+    if (xdr_to_nlm4_testargs(req->msg[0], &cs->args.nlm4_testargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
+               "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_test_reply(cs, stat, NULL);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh,
-                                          NULL, nlm4_test_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_test_resume);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                nlm4_test_reply (cs, stat, NULL);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        nlm4_test_reply(cs, stat, NULL);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
 rpcerr:
-        if (ret < 0)
-                nfs3_call_state_wipe (cs);
+    if (ret < 0)
+        nfs3_call_state_wipe(cs);
 
-        return ret;
+    return ret;
 }
 
 struct nlm4_notify_args {
-        GF_REF_DECL;            /* refcounting */
+    GF_REF_DECL; /* refcounting */
 
-        nfs3_call_state_t *cs;  /* call state, w/ lock request details */
-        call_frame_t *frame;    /* frame to us for the reply */
+    nfs3_call_state_t *cs; /* call state, w/ lock request details */
+    call_frame_t *frame;   /* frame to us for the reply */
 };
 
 static int
-nlm4svc_send_granted_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                          void *myframe)
+nlm4svc_send_granted_cbk(struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
 {
-        call_frame_t            *frame = myframe;
-        struct nlm4_notify_args *args  = frame->local;
+    call_frame_t *frame = myframe;
+    struct nlm4_notify_args *args = frame->local;
 
-        GF_REF_PUT (args);
-        return 0;
+    GF_REF_PUT(args);
+    return 0;
 }
 
 static void
-nlm4_notify_free (struct nlm4_notify_args *ncf)
+nlm4_notify_free(struct nlm4_notify_args *ncf)
 {
-        GF_REF_PUT (ncf->cs);
-        STACK_DESTROY (ncf->frame->root);
-        GF_FREE (ncf);
+    GF_REF_PUT(ncf->cs);
+    STACK_DESTROY(ncf->frame->root);
+    GF_FREE(ncf);
 }
 
-static struct nlm4_notify_args*
-nlm4_notify_init (nfs3_call_state_t *cs)
+static struct nlm4_notify_args *
+nlm4_notify_init(nfs3_call_state_t *cs)
 {
-        struct nlm4_notify_args *ncf = NULL;
+    struct nlm4_notify_args *ncf = NULL;
 
-        ncf = GF_CALLOC (1, sizeof (struct nlm4_notify_args),
-                         gf_nfs_mt_nlm4_notify);
-        if (!ncf)
-                /* GF_CALLOW will log the ENOMEM error */
-                goto out;
+    ncf = GF_CALLOC(1, sizeof(struct nlm4_notify_args), gf_nfs_mt_nlm4_notify);
+    if (!ncf)
+        /* GF_CALLOW will log the ENOMEM error */
+        goto out;
 
-        GF_REF_INIT (ncf, nlm4_notify_free);
-        ncf->cs = GF_REF_GET (cs);
+    GF_REF_INIT(ncf, nlm4_notify_free);
+    ncf->cs = GF_REF_GET(cs);
 
 out:
-        return ncf;
+    return ncf;
 }
 
 static int
-nlm_handle_connect (struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf);
+nlm_handle_connect(struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf);
 
 int
-nlm_rpcclnt_notify (struct rpc_clnt *rpc_clnt, void *mydata,
-                    rpc_clnt_event_t fn, void *data)
+nlm_rpcclnt_notify(struct rpc_clnt *rpc_clnt, void *mydata, rpc_clnt_event_t fn,
+                   void *data)
 {
-        struct nlm4_notify_args   *ncf     = mydata;
+    struct nlm4_notify_args *ncf = mydata;
 
-        GF_VALIDATE_OR_GOTO ("NLM4-notify", ncf, out);
+    GF_VALIDATE_OR_GOTO("NLM4-notify", ncf, out);
 
-        switch (fn) {
+    switch (fn) {
         case RPC_CLNT_CONNECT:
-                nlm_handle_connect (rpc_clnt, ncf);
-                break;
+            nlm_handle_connect(rpc_clnt, ncf);
+            break;
 
         case RPC_CLNT_MSG:
-                break;
+            break;
 
         case RPC_CLNT_DISCONNECT:
-                nlm_unset_rpc_clnt (rpc_clnt);
-                break;
+            nlm_unset_rpc_clnt(rpc_clnt);
+            break;
 
         case RPC_CLNT_DESTROY:
-                GF_REF_PUT (ncf);
-                break;
+            GF_REF_PUT(ncf);
+            break;
 
         default:
-                break;
-        }
+            break;
+    }
 out:
-        return 0;
+    return 0;
 }
 
 void *
-nlm4_establish_callback (nfs3_call_state_t *cs, call_frame_t *cbk_frame)
+nlm4_establish_callback(nfs3_call_state_t *cs, call_frame_t *cbk_frame)
 {
-        int                           ret                        = -1;
-        union gf_sock_union           sock_union;
-        dict_t                       *options                    = NULL;
-        char                          peerip[INET6_ADDRSTRLEN+1] = {0};
-        char                         *portstr                    = NULL;
-        char                          myip[INET6_ADDRSTRLEN+1]   = {0};
-        rpc_clnt_t                   *rpc_clnt                   = NULL;
-        int                           port                       = -1;
-        struct nlm4_notify_args      *ncf                        = NULL;
+    int ret = -1;
+    union gf_sock_union sock_union;
+    dict_t *options = NULL;
+    char peerip[INET6_ADDRSTRLEN + 1] = {0};
+    char *portstr = NULL;
+    char myip[INET6_ADDRSTRLEN + 1] = {0};
+    rpc_clnt_t *rpc_clnt = NULL;
+    int port = -1;
+    struct nlm4_notify_args *ncf = NULL;
 
-        glusterfs_this_set (cs->nfsx);
+    glusterfs_this_set(cs->nfsx);
 
-        rpc_transport_get_peeraddr (cs->trans, NULL, 0, &sock_union.storage,
-                                    sizeof (sock_union.storage));
+    rpc_transport_get_peeraddr(cs->trans, NULL, 0, &sock_union.storage,
+                               sizeof(sock_union.storage));
 
-        switch (sock_union.sa.sa_family) {
+    switch (sock_union.sa.sa_family) {
         case AF_INET6:
-        /* can not come here as NLM listens on IPv4 */
-                gf_msg (GF_NLM, GF_LOG_ERROR, EAFNOSUPPORT,
-                        NFS_MSG_UNSUPPORTED_VERSION,
-                        "NLM is not supported on IPv6 in this release");
-                goto err;
-/*
-                inet_ntop (AF_INET6,
-                           &((struct sockaddr_in6 *)sockaddr)->sin6_addr,
-                           peerip, INET6_ADDRSTRLEN+1);
-                break;
-*/
+            /* can not come here as NLM listens on IPv4 */
+            gf_msg(GF_NLM, GF_LOG_ERROR, EAFNOSUPPORT,
+                   NFS_MSG_UNSUPPORTED_VERSION,
+                   "NLM is not supported on IPv6 in this release");
+            goto err;
+            /*
+                            inet_ntop (AF_INET6,
+                                       &((struct sockaddr_in6
+               *)sockaddr)->sin6_addr, peerip, INET6_ADDRSTRLEN+1); break;
+            */
         case AF_INET:
-                inet_ntop (AF_INET, &sock_union.sin.sin_addr, peerip,
-                           INET6_ADDRSTRLEN+1);
-                inet_ntop (AF_INET, &(((struct sockaddr_in *)&cs->trans->myinfo.sockaddr)->sin_addr),
-                           myip, INET6_ADDRSTRLEN + 1);
-
-                break;
+            inet_ntop(AF_INET, &sock_union.sin.sin_addr, peerip,
+                      INET6_ADDRSTRLEN + 1);
+            inet_ntop(AF_INET,
+                      &(((struct sockaddr_in *)&cs->trans->myinfo.sockaddr)
+                            ->sin_addr),
+                      myip, INET6_ADDRSTRLEN + 1);
+
+            break;
         default:
-                break;
-                /* FIXME: handle the error */
-        }
-
-        /* looks like libc rpc supports only ipv4 */
-        port = pmap_getport (&sock_union.sin, NLM_PROGRAM,
-                             NLM_V4, IPPROTO_TCP);
-
-        if (port == 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_GET_PORT_ERROR,
-                        "Unable to get NLM port of the client."
-                        " Is the firewall running on client?"
-                        " OR Are RPC services running (rpcinfo -p)?");
-                goto err;
-        }
-
-        options = dict_new();
-        ret = dict_set_str (options, "transport-type", "socket");
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
-        }
-
-        ret = dict_set_dynstr (options, "remote-host", gf_strdup (peerip));
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
-        }
-
-        ret = gf_asprintf (&portstr, "%d", port);
-        if (ret == -1)
-                goto err;
-
-        ret = dict_set_dynstr (options, "remote-port",
-                               portstr);
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_dynstr error");
-                goto err;
-        }
-
-        /* needed in case virtual IP is used */
-        ret = dict_set_dynstr (options, "transport.socket.source-addr",
-                               gf_strdup (myip));
-        if (ret == -1)
-                goto err;
-
-        ret = dict_set_str (options, "auth-null", "on");
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_dynstr error");
-                goto err;
-        }
-
-        ncf = nlm4_notify_init (cs);
-        if (!ncf) {
-                ret = -1;
-                goto err;
-        }
-
-        ncf->frame = cbk_frame;
-        ncf->frame->local = ncf;
-
-        /* TODO: is 32 frames in transit enough ? */
-        rpc_clnt = rpc_clnt_new (options, cs->nfsx, "NLM-client", 32);
-        if (rpc_clnt == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
-                        "rpc_clnt NULL");
-                goto err;
-        }
-
-        ret = rpc_clnt_register_notify (rpc_clnt, nlm_rpcclnt_notify, ncf);
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_RPC_CLNT_ERROR,
-                        "rpc_clnt_register_connect error");
-                goto err;
-        }
-
-        /* After this connect succeeds, granted msg is sent in notify */
-        ret = rpc_transport_connect (rpc_clnt->conn.trans, port);
-
-        if (ret == -1 && EINPROGRESS == errno)
-                ret = 0;
+            break;
+            /* FIXME: handle the error */
+    }
+
+    /* looks like libc rpc supports only ipv4 */
+    port = pmap_getport(&sock_union.sin, NLM_PROGRAM, NLM_V4, IPPROTO_TCP);
+
+    if (port == 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_GET_PORT_ERROR,
+               "Unable to get NLM port of the client."
+               " Is the firewall running on client?"
+               " OR Are RPC services running (rpcinfo -p)?");
+        goto err;
+    }
+
+    options = dict_new();
+    ret = dict_set_str(options, "transport-type", "socket");
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    ret = dict_set_dynstr(options, "remote-host", gf_strdup(peerip));
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    ret = gf_asprintf(&portstr, "%d", port);
+    if (ret == -1)
+        goto err;
+
+    ret = dict_set_dynstr(options, "remote-port", portstr);
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_dynstr error");
+        goto err;
+    }
+
+    /* needed in case virtual IP is used */
+    ret = dict_set_dynstr(options, "transport.socket.source-addr",
+                          gf_strdup(myip));
+    if (ret == -1)
+        goto err;
+
+    ret = dict_set_str(options, "auth-null", "on");
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_dynstr error");
+        goto err;
+    }
+
+    ncf = nlm4_notify_init(cs);
+    if (!ncf) {
+        ret = -1;
+        goto err;
+    }
+
+    ncf->frame = cbk_frame;
+    ncf->frame->local = ncf;
+
+    /* TODO: is 32 frames in transit enough ? */
+    rpc_clnt = rpc_clnt_new(options, cs->nfsx, "NLM-client", 32);
+    if (rpc_clnt == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY,
+               "rpc_clnt NULL");
+        goto err;
+    }
+
+    ret = rpc_clnt_register_notify(rpc_clnt, nlm_rpcclnt_notify, ncf);
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_RPC_CLNT_ERROR,
+               "rpc_clnt_register_connect error");
+        goto err;
+    }
+
+    /* After this connect succeeds, granted msg is sent in notify */
+    ret = rpc_transport_connect(rpc_clnt->conn.trans, port);
+
+    if (ret == -1 && EINPROGRESS == errno)
+        ret = 0;
 
 err:
-        if (ret == -1) {
-                if (rpc_clnt)
-                        rpc_clnt_unref (rpc_clnt);
-                if (ncf)
-                        GF_REF_PUT (ncf);
-        }
+    if (ret == -1) {
+        if (rpc_clnt)
+            rpc_clnt_unref(rpc_clnt);
+        if (ncf)
+            GF_REF_PUT(ncf);
+    }
 
-        return rpc_clnt;
+    return rpc_clnt;
 }
 
 static void
-nlm4svc_send_granted (struct nlm4_notify_args *ncf)
-{
-        int ret = -1;
-        nfs3_call_state_t *cs = ncf->cs;
-        rpc_clnt_t *rpc_clnt = NULL;
-        struct iovec            outmsg = {0, };
-        nlm4_testargs testargs;
-        struct iobuf *iobuf = NULL;
-        struct iobref *iobref = NULL;
-        char peerip[INET6_ADDRSTRLEN+1];
-        union gf_sock_union sock_union;
-
-        rpc_clnt = nlm_get_rpc_clnt (cs->args.nlm4_lockargs.alock.caller_name);
-        if (rpc_clnt == NULL) {
-                nlm4_establish_callback (cs, ncf->frame);
-                return;
-        }
+nlm4svc_send_granted(struct nlm4_notify_args *ncf)
+{
+    int ret = -1;
+    nfs3_call_state_t *cs = ncf->cs;
+    rpc_clnt_t *rpc_clnt = NULL;
+    struct iovec outmsg = {
+        0,
+    };
+    nlm4_testargs testargs;
+    struct iobuf *iobuf = NULL;
+    struct iobref *iobref = NULL;
+    char peerip[INET6_ADDRSTRLEN + 1];
+    union gf_sock_union sock_union;
+
+    rpc_clnt = nlm_get_rpc_clnt(cs->args.nlm4_lockargs.alock.caller_name);
+    if (rpc_clnt == NULL) {
+        nlm4_establish_callback(cs, ncf->frame);
+        return;
+    }
 
-        rpc_transport_get_peeraddr (cs->trans, NULL, 0, &sock_union.storage,
-                                    sizeof (sock_union.storage));
+    rpc_transport_get_peeraddr(cs->trans, NULL, 0, &sock_union.storage,
+                               sizeof(sock_union.storage));
 
-        switch (sock_union.sa.sa_family) {
+    switch (sock_union.sa.sa_family) {
         case AF_INET6:
-                inet_ntop (AF_INET6, &sock_union.sin6.sin6_addr, peerip,
-                           INET6_ADDRSTRLEN+1);
-                break;
+            inet_ntop(AF_INET6, &sock_union.sin6.sin6_addr, peerip,
+                      INET6_ADDRSTRLEN + 1);
+            break;
         case AF_INET:
-                inet_ntop (AF_INET, &sock_union.sin.sin_addr, peerip,
-                           INET6_ADDRSTRLEN+1);
-                break;
+            inet_ntop(AF_INET, &sock_union.sin.sin_addr, peerip,
+                      INET6_ADDRSTRLEN + 1);
+            break;
         default:
-                break;
-        }
-
-        testargs.cookie = cs->args.nlm4_lockargs.cookie;
-        testargs.exclusive = cs->args.nlm4_lockargs.exclusive;
-        testargs.alock = cs->args.nlm4_lockargs.alock;
-
-        iobuf = iobuf_get (cs->nfs3state->iobpool);
-        if (!iobuf) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobuf");
-                goto ret;
-        }
-
-        iobuf_to_iovec (iobuf, &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.
-         */
-        outmsg.iov_len = xdr_serialize_nlm4_testargs (outmsg, &testargs);
-
-        iobref = iobref_new ();
-        if (iobref == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to get iobref");
-                goto ret;
-        }
-
-        ret = iobref_add (iobref, iobuf);
-        if (ret) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
-                        "Failed to add iob to iobref");
-                goto ret;
-        }
-
-        GF_REF_GET (ncf);
-        ret = rpc_clnt_submit (rpc_clnt, &nlm4clntprog, NLM4_GRANTED,
-                               nlm4svc_send_granted_cbk, &outmsg, 1,
-                               NULL, 0, iobref, ncf->frame, NULL, 0,
-                               NULL, 0, NULL);
-
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RPC_CLNT_ERROR,
-                        "rpc_clnt_submit error");
-                goto ret;
-        }
+            break;
+    }
+
+    testargs.cookie = cs->args.nlm4_lockargs.cookie;
+    testargs.exclusive = cs->args.nlm4_lockargs.exclusive;
+    testargs.alock = cs->args.nlm4_lockargs.alock;
+
+    iobuf = iobuf_get(cs->nfs3state->iobpool);
+    if (!iobuf) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobuf");
+        goto ret;
+    }
+
+    iobuf_to_iovec(iobuf, &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.
+     */
+    outmsg.iov_len = xdr_serialize_nlm4_testargs(outmsg, &testargs);
+
+    iobref = iobref_new();
+    if (iobref == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to get iobref");
+        goto ret;
+    }
+
+    ret = iobref_add(iobref, iobuf);
+    if (ret) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+               "Failed to add iob to iobref");
+        goto ret;
+    }
+
+    GF_REF_GET(ncf);
+    ret = rpc_clnt_submit(rpc_clnt, &nlm4clntprog, NLM4_GRANTED,
+                          nlm4svc_send_granted_cbk, &outmsg, 1, NULL, 0, iobref,
+                          ncf->frame, NULL, 0, NULL, 0, NULL);
+
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RPC_CLNT_ERROR,
+               "rpc_clnt_submit error");
+        goto ret;
+    }
 ret:
-        if (iobref)
-                iobref_unref (iobref);
-        if (iobuf)
-                iobuf_unref (iobuf);
+    if (iobref)
+        iobref_unref(iobref);
+    if (iobuf)
+        iobuf_unref(iobuf);
 
-        rpc_clnt_unref (rpc_clnt);
-        return;
+    rpc_clnt_unref(rpc_clnt);
+    return;
 }
 
 int
-nlm_cleanup_fds (char *caller_name)
-{
-        int nlmclnt_found = 0;
-        nlm_client_t *nlmclnt = NULL;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt,
-                             &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
+nlm_cleanup_fds(char *caller_name)
+{
+    int nlmclnt_found = 0;
+    nlm_client_t *nlmclnt = NULL;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
         }
+    }
 
-        if (!nlmclnt_found)
-                goto ret;
+    if (!nlmclnt_found)
+        goto ret;
 
-        nlm_client_free (nlmclnt);
+    nlm_client_free(nlmclnt);
 ret:
-        UNLOCK (&nlm_client_list_lk);
-        return 0;
+    UNLOCK(&nlm_client_list_lk);
+    return 0;
 }
 
 void
-nlm_search_and_delete (fd_t *fd, nlm4_lock *lk)
-{
-        nlm_fde_t *fde = NULL;
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        int fde_found = 0;
-        int transit_cnt = 0;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt,
-                             &nlm_client_list, nlm_clients) {
-                if (!strcmp (lk->caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
+nlm_search_and_delete(fd_t *fd, nlm4_lock *lk)
+{
+    nlm_fde_t *fde = NULL;
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    int fde_found = 0;
+    int transit_cnt = 0;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(lk->caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
         }
+    }
 
-        if (!nlmclnt_found)
-                goto ret;
+    if (!nlmclnt_found)
+        goto ret;
 
-        list_for_each_entry (fde, &nlmclnt->fdes, fde_list) {
-                if (fde->fd == fd) {
-                        fde_found = 1;
-                        break;
-                }
+    list_for_each_entry(fde, &nlmclnt->fdes, fde_list)
+    {
+        if (fde->fd == fd) {
+            fde_found = 1;
+            break;
         }
+    }
 
-        if (!fde_found)
-                goto ret;
-        transit_cnt = fde->transit_cnt;
-        if (transit_cnt)
-                goto ret;
-        list_del (&fde->fde_list);
+    if (!fde_found)
+        goto ret;
+    transit_cnt = fde->transit_cnt;
+    if (transit_cnt)
+        goto ret;
+    list_del(&fde->fde_list);
 
 ret:
-        UNLOCK (&nlm_client_list_lk);
+    UNLOCK(&nlm_client_list_lk);
 
-        if (fde_found && !transit_cnt) {
-                fd_unref (fde->fd);
-                GF_FREE (fde);
-        }
-        return;
+    if (fde_found && !transit_cnt) {
+        fd_unref(fde->fd);
+        GF_FREE(fde);
+    }
+    return;
 }
 
 int
-nlm_dec_transit_count (fd_t *fd, char *caller_name)
-{
-        nlm_fde_t *fde = NULL;
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        int fde_found = 0;
-        int transit_cnt = -1;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt,
-                             &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
-        }
-
-        if (!nlmclnt_found) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND,
-                        "nlmclnt not found");
-                nlmclnt = NULL;
-                goto ret;
-        }
-
-        list_for_each_entry (fde, &nlmclnt->fdes, fde_list) {
-                if (fde->fd == fd) {
-                        fde_found = 1;
-                        break;
-                }
-        }
-
-        if (fde_found) {
-                transit_cnt = --fde->transit_cnt;
-                goto ret;
-        }
+nlm_dec_transit_count(fd_t *fd, char *caller_name)
+{
+    nlm_fde_t *fde = NULL;
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    int fde_found = 0;
+    int transit_cnt = -1;
+
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
+        }
+    }
+
+    if (!nlmclnt_found) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND,
+               "nlmclnt not found");
+        nlmclnt = NULL;
+        goto ret;
+    }
+
+    list_for_each_entry(fde, &nlmclnt->fdes, fde_list)
+    {
+        if (fde->fd == fd) {
+            fde_found = 1;
+            break;
+        }
+    }
+
+    if (fde_found) {
+        transit_cnt = --fde->transit_cnt;
+        goto ret;
+    }
 ret:
 
-        UNLOCK (&nlm_client_list_lk);
-        return transit_cnt;
+    UNLOCK(&nlm_client_list_lk);
+    return transit_cnt;
 }
 
-
 nlm_client_t *
-nlm_search_and_add (fd_t *fd, char *caller_name)
-{
-        nlm_fde_t *fde = NULL;
-        nlm_client_t *nlmclnt = NULL;
-        int nlmclnt_found = 0;
-        int fde_found = 0;
-
-        LOCK (&nlm_client_list_lk);
-        list_for_each_entry (nlmclnt,
-                             &nlm_client_list, nlm_clients) {
-                if (!strcmp(caller_name, nlmclnt->caller_name)) {
-                        nlmclnt_found = 1;
-                        break;
-                }
-        }
+nlm_search_and_add(fd_t *fd, char *caller_name)
+{
+    nlm_fde_t *fde = NULL;
+    nlm_client_t *nlmclnt = NULL;
+    int nlmclnt_found = 0;
+    int fde_found = 0;
 
-        if (!nlmclnt_found) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND,
-                        "nlmclnt not found");
-                nlmclnt = NULL;
-                goto ret;
+    LOCK(&nlm_client_list_lk);
+    list_for_each_entry(nlmclnt, &nlm_client_list, nlm_clients)
+    {
+        if (!strcmp(caller_name, nlmclnt->caller_name)) {
+            nlmclnt_found = 1;
+            break;
         }
+    }
 
-        list_for_each_entry (fde, &nlmclnt->fdes, fde_list) {
-                if (fde->fd == fd) {
-                        fde_found = 1;
-                        break;
-                }
+    if (!nlmclnt_found) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_NLMCLNT_NOT_FOUND,
+               "nlmclnt not found");
+        nlmclnt = NULL;
+        goto ret;
+    }
+
+    list_for_each_entry(fde, &nlmclnt->fdes, fde_list)
+    {
+        if (fde->fd == fd) {
+            fde_found = 1;
+            break;
         }
+    }
 
-        if (fde_found)
-                goto ret;
+    if (fde_found)
+        goto ret;
 
-        fde = GF_CALLOC (1, sizeof (*fde), gf_nfs_mt_nlm4_fde);
+    fde = GF_CALLOC(1, sizeof(*fde), gf_nfs_mt_nlm4_fde);
 
-        fde->fd = fd_ref (fd);
-        list_add (&fde->fde_list, &nlmclnt->fdes);
+    fde->fd = fd_ref(fd);
+    list_add(&fde->fde_list, &nlmclnt->fdes);
 ret:
-        if (nlmclnt_found && fde)
-                fde->transit_cnt++;
-        UNLOCK (&nlm_client_list_lk);
-        return nlmclnt;
+    if (nlmclnt_found && fde)
+        fde->transit_cnt++;
+    UNLOCK(&nlm_client_list_lk);
+    return nlmclnt;
 }
 
 int
-nlm4svc_lock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                  dict_t *xdata)
-{
-        nlm4_stats                       stat        = nlm4_denied;
-        int                              transit_cnt = -1;
-        char                            *caller_name = NULL;
-        nfs3_call_state_t               *cs          = NULL;
-        pthread_t                        thr;
-        struct nlm4_notify_args         *ncf         = NULL;
-
-        cs = frame->local;
-        caller_name = cs->args.nlm4_lockargs.alock.caller_name;
-        transit_cnt = nlm_dec_transit_count (cs->fd, caller_name);
-
-        if (op_ret == -1) {
-                if (transit_cnt == 0)
-                        nlm_search_and_delete (cs->fd,
-                                               &cs->args.nlm4_lockargs.alock);
-                stat = nlm4_errno_to_nlm4stat (op_errno);
-                goto err;
-        } else {
-                stat = nlm4_granted;
-                if (cs->monitor && !nlm_monitor (caller_name)) {
-                        /* FIXME: handle nsm_monitor failure */
-                        gf_thread_create (&thr, NULL, nsm_monitor,
-                                          (void *)caller_name, "nlmmon");
-                }
-        }
+nlm4svc_lock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+                 dict_t *xdata)
+{
+    nlm4_stats stat = nlm4_denied;
+    int transit_cnt = -1;
+    char *caller_name = NULL;
+    nfs3_call_state_t *cs = NULL;
+    pthread_t thr;
+    struct nlm4_notify_args *ncf = NULL;
+
+    cs = frame->local;
+    caller_name = cs->args.nlm4_lockargs.alock.caller_name;
+    transit_cnt = nlm_dec_transit_count(cs->fd, caller_name);
+
+    if (op_ret == -1) {
+        if (transit_cnt == 0)
+            nlm_search_and_delete(cs->fd, &cs->args.nlm4_lockargs.alock);
+        stat = nlm4_errno_to_nlm4stat(op_errno);
+        goto err;
+    } else {
+        stat = nlm4_granted;
+        if (cs->monitor && !nlm_monitor(caller_name)) {
+            /* FIXME: handle nsm_monitor failure */
+            gf_thread_create(&thr, NULL, nsm_monitor, (void *)caller_name,
+                             "nlmmon");
+        }
+    }
 
 err:
-        if (cs->args.nlm4_lockargs.block) {
-                ncf = nlm4_notify_init (cs);
-                if (ncf) {
-                        ncf->frame = copy_frame (frame);
-                        ncf->frame->local = ncf;
-                        nlm4svc_send_granted (ncf);
-                }
-        } else {
-                nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie,
-                                    stat);
-                nfs3_call_state_wipe (cs);
+    if (cs->args.nlm4_lockargs.block) {
+        ncf = nlm4_notify_init(cs);
+        if (ncf) {
+            ncf->frame = copy_frame(frame);
+            ncf->frame->local = ncf;
+            nlm4svc_send_granted(ncf);
         }
+    } else {
+        nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+    }
 
-        return 0;
+    return 0;
 }
 
 int
-nlm4_lock_fd_resume (void *carg)
-{
-        nlm4_stats                      stat = nlm4_denied;
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        struct gf_flock                 flock = {0, };
-
-        if (!carg)
-                return ret;
-
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nlm4_check_fh_resolve_status (cs, stat, nlm4err);
-        (void) nlm_search_and_add (cs->fd,
-                                   cs->args.nlm4_lockargs.alock.caller_name);
-        nfs_request_user_init (&nfu, cs->req);
-        nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_lockargs.alock,
-                               cs->args.nlm4_lockargs.exclusive);
-        nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_lockargs.alock.oh);
-        if (cs->args.nlm4_lockargs.block) {
-                nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie,
-                                    nlm4_blocked);
-                ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLKW,
-                              &flock, nlm4svc_lock_cbk, cs);
-                /* FIXME: handle error from nfs_lk() specially  by just
-                 * cleaning up cs and unblock the client lock request.
-                 */
-                ret = 0;
-        } else
-                ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK,
-                              &flock, nlm4svc_lock_cbk, cs);
+nlm4_lock_fd_resume(void *carg)
+{
+    nlm4_stats stat = nlm4_denied;
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+
+    if (!carg)
+        return ret;
+
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nlm4_check_fh_resolve_status(cs, stat, nlm4err);
+    (void)nlm_search_and_add(cs->fd, cs->args.nlm4_lockargs.alock.caller_name);
+    nfs_request_user_init(&nfu, cs->req);
+    nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_lockargs.alock,
+                          cs->args.nlm4_lockargs.exclusive);
+    nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_lockargs.alock.oh);
+    if (cs->args.nlm4_lockargs.block) {
+        nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie,
+                           nlm4_blocked);
+        ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLKW, &flock,
+                     nlm4svc_lock_cbk, cs);
+        /* FIXME: handle error from nfs_lk() specially  by just
+         * cleaning up cs and unblock the client lock request.
+         */
+        ret = 0;
+    } else
+        ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock,
+                     nlm4svc_lock_cbk, cs);
 
 nlm4err:
-        if (ret < 0) {
-                stat = nlm4_errno_to_nlm4stat (-ret);
-                gf_msg (GF_NLM, GF_LOG_ERROR, stat, NFS_MSG_LOCK_FAIL,
-                        "unable to call lk()");
-                nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie,
-                                    stat);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        stat = nlm4_errno_to_nlm4stat(-ret);
+        gf_msg(GF_NLM, GF_LOG_ERROR, stat, NFS_MSG_LOCK_FAIL,
+               "unable to call lk()");
+        nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+    }
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
-
 int
-nlm4_lock_resume (void *carg)
+nlm4_lock_resume(void *carg)
 {
-        nlm4_stats                      stat = nlm4_failed;
-        int                             ret  = -1;
-        nfs3_call_state_t              *cs   = NULL;
+    nlm4_stats stat = nlm4_failed;
+    int ret = -1;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nlm4_check_fh_resolve_status (cs, stat, nlm4err);
-        ret = nlm4_file_open_and_resume (cs, nlm4_lock_fd_resume);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nlm4_check_fh_resolve_status(cs, stat, nlm4err);
+    ret = nlm4_file_open_and_resume(cs, nlm4_lock_fd_resume);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL,
-                        "unable to open and resume");
-                stat = nlm4_errno_to_nlm4stat (-ret);
-                nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie,
-                                    stat);
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_OPEN_FAIL,
+               "unable to open and resume");
+        stat = nlm4_errno_to_nlm4stat(-ret);
+        nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+    }
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4svc_lock_common (rpcsvc_request_t *req, int mon)
-{
-        int                              ret      = RPCSVC_ACTOR_ERROR;
-        nlm4_stats                       stat     = nlm4_failed;
-        struct nfs3_fh                   fh       = {{0}, };
-        xlator_t                        *vol      = NULL;
-        nfs3_state_t                    *nfs3     = NULL;
-        nfs3_call_state_t               *cs       = NULL;
-        struct nfs_state                *nfs      = NULL;
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_nlm4_lockargs (&cs->args.nlm4_lockargs, &cs->lockfh,
-                                 &cs->lkowner, cs->cookiebytes);
-        if (xdr_to_nlm4_lockargs(req->msg[0], &cs->args.nlm4_lockargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nlm4svc_lock_common(rpcsvc_request_t *req, int mon)
+{
+    int ret = RPCSVC_ACTOR_ERROR;
+    nlm4_stats stat = nlm4_failed;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    xlator_t *vol = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs_state *nfs = NULL;
+
+    if (!req)
+        return ret;
 
-        fh = cs->lockfh;
-        cs->monitor = mon;
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err);
-
-        if (nlm_grace_period && !cs->args.nlm4_lockargs.reclaim) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
-                        "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_nlm4_lockargs(&cs->args.nlm4_lockargs, &cs->lockfh, &cs->lkowner,
+                            cs->cookiebytes);
+    if (xdr_to_nlm4_lockargs(req->msg[0], &cs->args.nlm4_lockargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    fh = cs->lockfh;
+    cs->monitor = mon;
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period && !cs->args.nlm4_lockargs.reclaim) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
+               "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        cs->trans = rpcsvc_request_transport_ref(req);
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    cs->trans = rpcsvc_request_transport_ref(req);
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nlm_add_nlmclnt (cs->args.nlm4_lockargs.alock.caller_name);
+    ret = nlm_add_nlmclnt(cs->args.nlm4_lockargs.alock.caller_name);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh,
-                                          NULL, nlm4_lock_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_lock_resume);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                nlm4_generic_reply (cs->req, cs->args.nlm4_lockargs.cookie,
-                                    stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        nlm4_generic_reply(cs->req, cs->args.nlm4_lockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
 rpcerr:
-        if (ret < 0) {
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        nfs3_call_state_wipe(cs);
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4svc_lock (rpcsvc_request_t *req)
+nlm4svc_lock(rpcsvc_request_t *req)
 {
-        return nlm4svc_lock_common (req, 1);
+    return nlm4svc_lock_common(req, 1);
 }
 
 int
-nlm4svc_nm_lock (rpcsvc_request_t *req)
+nlm4svc_nm_lock(rpcsvc_request_t *req)
 {
-        return nlm4svc_lock_common (req, 0);
+    return nlm4svc_lock_common(req, 0);
 }
 
 int
-nlm4svc_cancel_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                    dict_t *xdata)
-{
-        nlm4_stats                      stat = nlm4_denied;
-        nfs3_call_state_t              *cs = NULL;
-
-        cs = frame->local;
-        if (op_ret == -1) {
-                stat = nlm4_errno_to_nlm4stat (op_errno);
-                goto err;
-        } else {
-                stat = nlm4_granted;
-                nlm_search_and_delete (cs->fd, &cs->args.nlm4_lockargs.alock);
-        }
+nlm4svc_cancel_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+                   dict_t *xdata)
+{
+    nlm4_stats stat = nlm4_denied;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = frame->local;
+    if (op_ret == -1) {
+        stat = nlm4_errno_to_nlm4stat(op_errno);
+        goto err;
+    } else {
+        stat = nlm4_granted;
+        nlm_search_and_delete(cs->fd, &cs->args.nlm4_lockargs.alock);
+    }
 
 err:
-        nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie,
-                            stat);
-        nfs3_call_state_wipe (cs);
-        return 0;
+    nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
 int
-nlm4_cancel_fd_resume (void *carg)
-{
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        struct gf_flock                 flock = {0, };
-
-        if (!carg)
-                return ret;
+nlm4_cancel_fd_resume(void *carg)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+
+    if (!carg)
+        return ret;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nfs_request_user_init (&nfu, cs->req);
-        nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_cancargs.alock,
-                                cs->args.nlm4_cancargs.exclusive);
-        nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_cancargs.alock.oh);
-        flock.l_type = F_UNLCK;
-        ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK,
-                      &flock, nlm4svc_cancel_cbk, cs);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nfs_request_user_init(&nfu, cs->req);
+    nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_cancargs.alock,
+                          cs->args.nlm4_cancargs.exclusive);
+    nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_cancargs.alock.oh);
+    flock.l_type = F_UNLCK;
+    ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock,
+                 nlm4svc_cancel_cbk, cs);
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4_cancel_resume (void *carg)
+nlm4_cancel_resume(void *carg)
 {
-        nlm4_stats                      stat = nlm4_failed;
-        int                             ret = -EFAULT;
-        nfs3_call_state_t               *cs = NULL;
-        nlm_client_t                    *nlmclnt = NULL;
+    nlm4_stats stat = nlm4_failed;
+    int ret = -EFAULT;
+    nfs3_call_state_t *cs = NULL;
+    nlm_client_t *nlmclnt = NULL;
 
-        if (!carg)
-                return ret;
+    if (!carg)
+        return ret;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nlm4_check_fh_resolve_status (cs, stat, nlm4err);
-
-        nlmclnt = nlm_get_uniq (cs->args.nlm4_cancargs.alock.caller_name);
-        if (nlmclnt == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY,
-                        "nlm_get_uniq() returned NULL");
-                goto nlm4err;
-        }
-        cs->fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt);
-        if (cs->fd == NULL) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FD_LOOKUP_NULL,
-                        "fd_lookup_uint64 retrned NULL");
-                goto nlm4err;
-        }
-        ret = nlm4_cancel_fd_resume (cs);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nlm4_check_fh_resolve_status(cs, stat, nlm4err);
+
+    nlmclnt = nlm_get_uniq(cs->args.nlm4_cancargs.alock.caller_name);
+    if (nlmclnt == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, ENOLCK, NFS_MSG_NO_MEMORY,
+               "nlm_get_uniq() returned NULL");
+        goto nlm4err;
+    }
+    cs->fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt);
+    if (cs->fd == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_FD_LOOKUP_NULL,
+               "fd_lookup_uint64 retrned NULL");
+        goto nlm4err;
+    }
+    ret = nlm4_cancel_fd_resume(cs);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL,
-                        "unable to unlock_fd_resume()");
-                stat = nlm4_errno_to_nlm4stat (-ret);
-                nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie,
-                                    stat);
-
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL,
+               "unable to unlock_fd_resume()");
+        stat = nlm4_errno_to_nlm4stat(-ret);
+        nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat);
 
-        GF_REF_PUT (cs);
+        nfs3_call_state_wipe(cs);
+    }
 
-        /* clean up is taken care of */
-        return 0;
+    GF_REF_PUT(cs);
+
+    /* clean up is taken care of */
+    return 0;
 }
 
 int
-nlm4svc_cancel (rpcsvc_request_t *req)
-{
-        xlator_t                        *vol = NULL;
-        nlm4_stats                      stat = nlm4_failed;
-        struct nfs_state               *nfs = NULL;
-        nfs3_state_t                   *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-        int                             ret = RPCSVC_ACTOR_ERROR;
-        struct nfs3_fh                  fh = {{0}, };
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_nlm4_cancargs (&cs->args.nlm4_cancargs, &fh, &cs->lkowner,
-                                 cs->cookiebytes);
-        if (xdr_to_nlm4_cancelargs(req->msg[0], &cs->args.nlm4_cancargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err);
+nlm4svc_cancel(rpcsvc_request_t *req)
+{
+    xlator_t *vol = NULL;
+    nlm4_stats stat = nlm4_failed;
+    struct nfs_state *nfs = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    int ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+
+    if (!req)
+        return ret;
 
-        if (nlm_grace_period) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
-                        "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_nlm4_cancargs(&cs->args.nlm4_cancargs, &fh, &cs->lkowner,
+                            cs->cookiebytes);
+    if (xdr_to_nlm4_cancelargs(req->msg[0], &cs->args.nlm4_cancargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
+               "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh,
-                                          NULL, nlm4_cancel_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_cancel_resume);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                nlm4_generic_reply (cs->req, cs->args.nlm4_cancargs.cookie,
-                                    stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        nlm4_generic_reply(cs->req, cs->args.nlm4_cancargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
 rpcerr:
-        if (ret < 0) {
-                nfs3_call_state_wipe (cs);
-        }
-        return ret;
+    if (ret < 0) {
+        nfs3_call_state_wipe(cs);
+    }
+    return ret;
 }
 
 int
-nlm4svc_unlock_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                    dict_t *xdata)
-{
-        nlm4_stats                      stat = nlm4_denied;
-        nfs3_call_state_t              *cs = NULL;
-
-        cs = GF_REF_GET ((nfs3_call_state_t*) frame->local);
-        if (op_ret == -1) {
-                stat = nlm4_errno_to_nlm4stat (op_errno);
-                goto err;
-        } else {
-                stat = nlm4_granted;
-                if (flock->l_type == F_UNLCK)
-                        nlm_search_and_delete (cs->fd,
-                                               &cs->args.nlm4_unlockargs.alock);
-        }
+nlm4svc_unlock_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
+                   dict_t *xdata)
+{
+    nlm4_stats stat = nlm4_denied;
+    nfs3_call_state_t *cs = NULL;
+
+    cs = GF_REF_GET((nfs3_call_state_t *)frame->local);
+    if (op_ret == -1) {
+        stat = nlm4_errno_to_nlm4stat(op_errno);
+        goto err;
+    } else {
+        stat = nlm4_granted;
+        if (flock->l_type == F_UNLCK)
+            nlm_search_and_delete(cs->fd, &cs->args.nlm4_unlockargs.alock);
+    }
 
 err:
-        nlm4_generic_reply (cs->req, cs->args.nlm4_unlockargs.cookie, stat);
-        GF_REF_PUT (cs);
-        return 0;
+    nlm4_generic_reply(cs->req, cs->args.nlm4_unlockargs.cookie, stat);
+    GF_REF_PUT(cs);
+    return 0;
 }
 
 int
-nlm4_unlock_fd_resume (void *carg)
-{
-        int                             ret = -EFAULT;
-        nfs_user_t                      nfu = {0, };
-        nfs3_call_state_t               *cs = NULL;
-        struct gf_flock                 flock = {0, };
-
-        if (!carg)
-                return ret;
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nfs_request_user_init (&nfu, cs->req);
-        nlm4_lock_to_gf_flock (&flock, &cs->args.nlm4_unlockargs.alock, 0);
-        nlm_copy_lkowner (&nfu.lk_owner, &cs->args.nlm4_unlockargs.alock.oh);
-        flock.l_type = F_UNLCK;
-        ret = nfs_lk (cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK,
-                      &flock, nlm4svc_unlock_cbk, cs);
+nlm4_unlock_fd_resume(void *carg)
+{
+    int ret = -EFAULT;
+    nfs_user_t nfu = {
+        0,
+    };
+    nfs3_call_state_t *cs = NULL;
+    struct gf_flock flock = {
+        0,
+    };
+
+    if (!carg)
+        return ret;
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nfs_request_user_init(&nfu, cs->req);
+    nlm4_lock_to_gf_flock(&flock, &cs->args.nlm4_unlockargs.alock, 0);
+    nlm_copy_lkowner(&nfu.lk_owner, &cs->args.nlm4_unlockargs.alock.oh);
+    flock.l_type = F_UNLCK;
+    ret = nfs_lk(cs->nfsx, cs->vol, &nfu, cs->fd, F_SETLK, &flock,
+                 nlm4svc_unlock_cbk, cs);
 
-        GF_REF_PUT (cs);
+    GF_REF_PUT(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4_unlock_resume (void *carg)
+nlm4_unlock_resume(void *carg)
 {
-        nlm4_stats                      stat = nlm4_failed;
-        int                             ret = -1;
-        nfs3_call_state_t               *cs = NULL;
-        nlm_client_t                    *nlmclnt = NULL;
-        char                            *caller_name = NULL;
-
-        if (!carg)
-                return ret;
+    nlm4_stats stat = nlm4_failed;
+    int ret = -1;
+    nfs3_call_state_t *cs = NULL;
+    nlm_client_t *nlmclnt = NULL;
+    char *caller_name = NULL;
 
-        cs = GF_REF_GET ((nfs3_call_state_t *)carg);
-        nlm4_check_fh_resolve_status (cs, stat, nlm4err);
-        caller_name = cs->args.nlm4_unlockargs.alock.caller_name;
+    if (!carg)
+        return ret;
 
-        nlmclnt = nlm_get_uniq (caller_name);
-        if (nlmclnt == NULL) {
-                stat = nlm4_granted;
-                gf_msg (GF_NLM, GF_LOG_WARNING, ENOLCK, NFS_MSG_NO_MEMORY,
-                        "nlm_get_uniq() returned NULL for %s", caller_name);
-                goto nlm4err;
-        }
-        cs->fd = fd_lookup_uint64 (cs->resolvedloc.inode, (uint64_t)nlmclnt);
-        if (cs->fd == NULL) {
-                stat = nlm4_granted;
-                gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_FD_LOOKUP_NULL,
-                        "fd_lookup_uint64() returned NULL");
-                goto nlm4err;
-        }
-        ret = nlm4_unlock_fd_resume (cs);
+    cs = GF_REF_GET((nfs3_call_state_t *)carg);
+    nlm4_check_fh_resolve_status(cs, stat, nlm4err);
+    caller_name = cs->args.nlm4_unlockargs.alock.caller_name;
+
+    nlmclnt = nlm_get_uniq(caller_name);
+    if (nlmclnt == NULL) {
+        stat = nlm4_granted;
+        gf_msg(GF_NLM, GF_LOG_WARNING, ENOLCK, NFS_MSG_NO_MEMORY,
+               "nlm_get_uniq() returned NULL for %s", caller_name);
+        goto nlm4err;
+    }
+    cs->fd = fd_lookup_uint64(cs->resolvedloc.inode, (uint64_t)nlmclnt);
+    if (cs->fd == NULL) {
+        stat = nlm4_granted;
+        gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_FD_LOOKUP_NULL,
+               "fd_lookup_uint64() returned NULL");
+        goto nlm4err;
+    }
+    ret = nlm4_unlock_fd_resume(cs);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL,
-                        "unable to unlock_fd_resume");
-                stat = nlm4_errno_to_nlm4stat (-ret);
-                nlm4_generic_reply (cs->req, cs->args.nlm4_unlockargs.cookie,
-                                    stat);
-
-                nfs3_call_state_wipe (cs);
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, -ret, NFS_MSG_LOCK_FAIL,
+               "unable to unlock_fd_resume");
+        stat = nlm4_errno_to_nlm4stat(-ret);
+        nlm4_generic_reply(cs->req, cs->args.nlm4_unlockargs.cookie, stat);
 
-        GF_REF_PUT (cs);
+        nfs3_call_state_wipe(cs);
+    }
 
-        /* we have already taken care of cleanup */
-        return 0;
+    GF_REF_PUT(cs);
+
+    /* we have already taken care of cleanup */
+    return 0;
 }
 
 int
-nlm4svc_unlock (rpcsvc_request_t *req)
-{
-        xlator_t                        *vol = NULL;
-        nlm4_stats                      stat = nlm4_failed;
-        struct nfs_state               *nfs = NULL;
-        nfs3_state_t                   *nfs3 = NULL;
-        nfs3_call_state_t               *cs = NULL;
-        int                             ret = RPCSVC_ACTOR_ERROR;
-        struct nfs3_fh                  fh = {{0}, };
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_nlm4_unlockargs (&cs->args.nlm4_unlockargs, &fh, &cs->lkowner,
-                                   cs->cookiebytes);
-        if (xdr_to_nlm4_unlockargs(req->msg[0], &cs->args.nlm4_unlockargs) <= 0)
-        {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
-
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req, vol, stat, nlm4err);
+nlm4svc_unlock(rpcsvc_request_t *req)
+{
+    xlator_t *vol = NULL;
+    nlm4_stats stat = nlm4_failed;
+    struct nfs_state *nfs = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    int ret = RPCSVC_ACTOR_ERROR;
+    struct nfs3_fh fh = {
+        {0},
+    };
+
+    if (!req)
+        return ret;
 
-        if (nlm_grace_period) {
-                gf_msg (GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
-                        "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_nlm4_unlockargs(&cs->args.nlm4_unlockargs, &fh, &cs->lkowner,
+                              cs->cookiebytes);
+    if (xdr_to_nlm4_unlockargs(req->msg[0], &cs->args.nlm4_unlockargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period) {
+        gf_msg(GF_NLM, GF_LOG_WARNING, 0, NFS_MSG_NLM_GRACE_PERIOD,
+               "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        /* FIXME: check if trans is being used at all for unlock */
-        cs->trans = rpcsvc_request_transport_ref(req);
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    /* FIXME: check if trans is being used at all for unlock */
+    cs->trans = rpcsvc_request_transport_ref(req);
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh,
-                                          NULL, nlm4_unlock_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_unlock_resume);
 
 nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
-                        "unable to resolve and resume");
-                nlm4_generic_reply (req, cs->args.nlm4_unlockargs.cookie, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_RESOLVE_ERROR,
+               "unable to resolve and resume");
+        nlm4_generic_reply(req, cs->args.nlm4_unlockargs.cookie, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
 rpcerr:
-        if (ret < 0) {
-                nfs3_call_state_wipe (cs);
-        }
-        return ret;
+    if (ret < 0) {
+        nfs3_call_state_wipe(cs);
+    }
+    return ret;
 }
 
 int
-nlm4_share_reply (nfs3_call_state_t *cs, nlm4_stats stat)
+nlm4_share_reply(nfs3_call_state_t *cs, nlm4_stats stat)
 {
-        nlm4_shareres  res = {{0}, 0, 0};
+    nlm4_shareres res = {{0}, 0, 0};
 
-        if (!cs)
-                return -1;
+    if (!cs)
+        return -1;
 
-        res.cookie = cs->args.nlm4_shareargs.cookie;
-        res.stat = stat;
-        res.sequence = 0;
+    res.cookie = cs->args.nlm4_shareargs.cookie;
+    res.stat = stat;
+    res.sequence = 0;
 
-        nlm4svc_submit_reply (cs->req, (void *)&res,
-                              (nlm4_serializer)xdr_serialize_nlm4_shareres);
-        return 0;
+    nlm4svc_submit_reply(cs->req, (void *)&res,
+                         (nlm4_serializer)xdr_serialize_nlm4_shareres);
+    return 0;
 }
 
 nlm_share_t *
-nlm4_share_new ()
-{
-        nlm_share_t      *share     = NULL;
-
-        share = GF_CALLOC (1, sizeof (nlm_share_t),
-                           gf_nfs_mt_nlm4_share);
-        if (!share)
-                goto out;
-
-        INIT_LIST_HEAD (&share->client_list);
-        INIT_LIST_HEAD (&share->inode_list);
- out:
-        return share;
-}
-
-int
-nlm4_add_share_to_inode (nlm_share_t *share)
+nlm4_share_new()
 {
-        int                    ret     = -1;
-        uint64_t               ctx     = 0;
-        struct list_head      *head    = NULL;
-        xlator_t              *this    = NULL;
-        inode_t               *inode   = NULL;
-        struct nfs_inode_ctx  *ictx    = NULL;
-        struct nfs_state      *priv    = NULL;
-
-        this = THIS;
-        priv = this->private;
-        inode = share->inode;
-        ret = inode_ctx_get (inode, this, &ctx);
-
-        if (ret == -1) {
-                ictx = GF_CALLOC (1, sizeof (struct nfs_inode_ctx),
-                                  gf_nfs_mt_inode_ctx);
-                if (!ictx ) {
-                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
-                                NFS_MSG_NO_MEMORY,
-                                "could not allocate nfs inode ctx");
-                        ret = -1;
-                        goto out;
-                }
-                ictx->generation = priv->generation;
-
-                head = &ictx->shares;
-                INIT_LIST_HEAD (head);
-
-                ret = inode_ctx_put (inode, this, (uint64_t)ictx);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                NFS_MSG_SHARE_LIST_STORE_FAIL,
-                                "could not store share list");
-                        goto out;
-                }
-        }
-        else {
-                ictx = (struct nfs_inode_ctx *)ctx;
-                head = &ictx->shares;
-        }
+    nlm_share_t *share = NULL;
 
-        list_add (&share->inode_list, head);
+    share = GF_CALLOC(1, sizeof(nlm_share_t), gf_nfs_mt_nlm4_share);
+    if (!share)
+        goto out;
 
- out:
-        if (ret && head)
-                GF_FREE (head);
-
-        return ret;
+    INIT_LIST_HEAD(&share->client_list);
+    INIT_LIST_HEAD(&share->inode_list);
+out:
+    return share;
 }
 
 int
-nlm4_approve_share_reservation (nfs3_call_state_t *cs)
-{
-        int                       ret               = -1;
-        uint64_t                  ctx               = 0;
-        fsh_mode                  req_mode          = 0;
-        fsh_access                req_access        = 0;
-        inode_t                  *inode             = NULL;
-        nlm_share_t              *share             = NULL;
-        struct list_head         *head              = NULL;
-        struct nfs_inode_ctx     *ictx              = NULL;
-
-        if (!cs)
-                goto out;
+nlm4_add_share_to_inode(nlm_share_t *share)
+{
+    int ret = -1;
+    uint64_t ctx = 0;
+    struct list_head *head = NULL;
+    xlator_t *this = NULL;
+    inode_t *inode = NULL;
+    struct nfs_inode_ctx *ictx = NULL;
+    struct nfs_state *priv = NULL;
+
+    this = THIS;
+    priv = this->private;
+    inode = share->inode;
+    ret = inode_ctx_get(inode, this, &ctx);
+
+    if (ret == -1) {
+        ictx = GF_CALLOC(1, sizeof(struct nfs_inode_ctx), gf_nfs_mt_inode_ctx);
+        if (!ictx) {
+            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
+                   "could not allocate nfs inode ctx");
+            ret = -1;
+            goto out;
+        }
+        ictx->generation = priv->generation;
 
-        inode = cs->resolvedloc.inode;
+        head = &ictx->shares;
+        INIT_LIST_HEAD(head);
 
-        ret = inode_ctx_get (inode, THIS, &ctx);
+        ret = inode_ctx_put(inode, this, (uint64_t)ictx);
         if (ret) {
-                ret = 0;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0, NFS_MSG_SHARE_LIST_STORE_FAIL,
+                   "could not store share list");
+            goto out;
         }
+    } else {
         ictx = (struct nfs_inode_ctx *)ctx;
-
         head = &ictx->shares;
-        if (!head || list_empty (head))
-                goto out;
+    }
 
-        req_mode = cs->args.nlm4_shareargs.share.mode;
-        req_access = cs->args.nlm4_shareargs.share.access;
+    list_add(&share->inode_list, head);
 
-        list_for_each_entry (share, head, inode_list) {
-                ret = (((req_mode & share->access) == 0) &&
-                       ((req_access & share->mode) == 0));
-                if (!ret) {
-                        ret = -1;
-                        goto out;
-                }
-        }
-        ret = 0;
+out:
+    if (ret && head)
+        GF_FREE(head);
 
- out:
-         return ret;
+    return ret;
 }
 
 int
-nlm4_create_share_reservation (nfs3_call_state_t *cs)
+nlm4_approve_share_reservation(nfs3_call_state_t *cs)
 {
-        int                       ret        = -1;
-        nlm_share_t              *share      = NULL;
-        nlm_client_t             *client     = NULL;
-        inode_t                  *inode      = NULL;
+    int ret = -1;
+    uint64_t ctx = 0;
+    fsh_mode req_mode = 0;
+    fsh_access req_access = 0;
+    inode_t *inode = NULL;
+    nlm_share_t *share = NULL;
+    struct list_head *head = NULL;
+    struct nfs_inode_ctx *ictx = NULL;
 
-        LOCK (&nlm_client_list_lk);
+    if (!cs)
+        goto out;
 
-        inode = inode_ref (cs->resolvedloc.inode);
-        if (!inode) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND,
-                        "inode not found");
-                goto out;
-        }
+    inode = cs->resolvedloc.inode;
 
-        client = __nlm_get_uniq (cs->args.nlm4_shareargs.share.caller_name);
-        if (!client) {
-                /* DO NOT add client. the client is supposed
-                   to be here, since nlm4svc_share adds it */
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND,
-                        "client not found");
-                goto out;
-        }
+    ret = inode_ctx_get(inode, THIS, &ctx);
+    if (ret) {
+        ret = 0;
+        goto out;
+    }
+    ictx = (struct nfs_inode_ctx *)ctx;
 
-        ret = nlm4_approve_share_reservation (cs);
-        if (ret)
-                goto out;
+    head = &ictx->shares;
+    if (!head || list_empty(head))
+        goto out;
 
-        share = nlm4_share_new ();
-        if (!share) {
-                ret = -1;
-                goto out;
-        }
+    req_mode = cs->args.nlm4_shareargs.share.mode;
+    req_access = cs->args.nlm4_shareargs.share.access;
 
-        share->inode  = inode;
-        share->mode   = cs->args.nlm4_shareargs.share.mode;
-        share->access = cs->args.nlm4_shareargs.share.access;
-        nlm_copy_lkowner (&share->lkowner,
-                          &cs->args.nlm4_shareargs.share.oh);
+    list_for_each_entry(share, head, inode_list)
+    {
+        ret = (((req_mode & share->access) == 0) &&
+               ((req_access & share->mode) == 0));
+        if (!ret) {
+            ret = -1;
+            goto out;
+        }
+    }
+    ret = 0;
 
-        ret = nlm4_add_share_to_inode (share);
-        if (ret)
-                goto out;
+out:
+    return ret;
+}
 
-        list_add (&share->client_list, &client->shares);
+int
+nlm4_create_share_reservation(nfs3_call_state_t *cs)
+{
+    int ret = -1;
+    nlm_share_t *share = NULL;
+    nlm_client_t *client = NULL;
+    inode_t *inode = NULL;
+
+    LOCK(&nlm_client_list_lk);
+
+    inode = inode_ref(cs->resolvedloc.inode);
+    if (!inode) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND,
+               "inode not found");
+        goto out;
+    }
+
+    client = __nlm_get_uniq(cs->args.nlm4_shareargs.share.caller_name);
+    if (!client) {
+        /* DO NOT add client. the client is supposed
+           to be here, since nlm4svc_share adds it */
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND,
+               "client not found");
+        goto out;
+    }
+
+    ret = nlm4_approve_share_reservation(cs);
+    if (ret)
+        goto out;
+
+    share = nlm4_share_new();
+    if (!share) {
+        ret = -1;
+        goto out;
+    }
+
+    share->inode = inode;
+    share->mode = cs->args.nlm4_shareargs.share.mode;
+    share->access = cs->args.nlm4_shareargs.share.access;
+    nlm_copy_lkowner(&share->lkowner, &cs->args.nlm4_shareargs.share.oh);
+
+    ret = nlm4_add_share_to_inode(share);
+    if (ret)
+        goto out;
+
+    list_add(&share->client_list, &client->shares);
 
- out:
-        if (ret && inode) {
-                inode_unref (inode);
-                GF_FREE (share);
-        }
+out:
+    if (ret && inode) {
+        inode_unref(inode);
+        GF_FREE(share);
+    }
 
-        UNLOCK (&nlm_client_list_lk);
-        return ret;
+    UNLOCK(&nlm_client_list_lk);
+    return ret;
 }
 
 /*
@@ -2096,676 +2093,672 @@ nlm4_create_share_reservation (nfs3_call_state_t *cs)
   at *nfs xlator level only*, in memory
 */
 int
-nlm4_share_resume (void *call_state)
+nlm4_share_resume(void *call_state)
 {
-        int                             ret             = -1;
-        nlm4_stats                      stat            = nlm4_failed;
-        nfs3_call_state_t              *cs              = NULL;
+    int ret = -1;
+    nlm4_stats stat = nlm4_failed;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!call_state)
-                return ret;
+    if (!call_state)
+        return ret;
 
-        cs = (nfs3_call_state_t *)call_state;
-        nlm4_check_fh_resolve_status (cs, stat, out);
+    cs = (nfs3_call_state_t *)call_state;
+    nlm4_check_fh_resolve_status(cs, stat, out);
 
-        ret = nlm4_create_share_reservation (cs);
-        if (!ret)
-                stat = nlm4_granted;
+    ret = nlm4_create_share_reservation(cs);
+    if (!ret)
+        stat = nlm4_granted;
 
- out:
-        nlm4_share_reply (cs, stat);
-        nfs3_call_state_wipe (cs);
-        return 0;
+out:
+    nlm4_share_reply(cs, stat);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
 int
-nlm4svc_share (rpcsvc_request_t *req)
-{
-        nlm4_stats                    stat      = nlm4_failed;
-        xlator_t                     *vol       = NULL;
-        nfs3_state_t                 *nfs3      = NULL;
-        nfs3_call_state_t            *cs        = NULL;
-        struct nfs_state             *nfs       = NULL;
-        struct nfs3_fh                fh        = {{0}, };
-        int                           ret       = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_shareargs (&cs->args.nlm4_shareargs, &cs->lockfh,
-                             &cs->lkowner, cs->cookiebytes);
-
-        if (xdr_to_nlm4_shareargs (req->msg[0],
-                                   &cs->args.nlm4_shareargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding SHARE args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nlm4svc_share(rpcsvc_request_t *req)
+{
+    nlm4_stats stat = nlm4_failed;
+    xlator_t *vol = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs_state *nfs = NULL;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    if (!req)
+        return ret;
 
-        fh = cs->lockfh;
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req,
-                               vol, stat, nlm4err);
-
-        if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) {
-                gf_msg_debug (GF_NLM, 0, "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_share_reply (cs, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_shareargs(&cs->args.nlm4_shareargs, &cs->lockfh, &cs->lkowner,
+                        cs->cookiebytes);
+
+    if (xdr_to_nlm4_shareargs(req->msg[0], &cs->args.nlm4_shareargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding SHARE args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    fh = cs->lockfh;
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) {
+        gf_msg_debug(GF_NLM, 0, "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_share_reply(cs, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        cs->trans = rpcsvc_request_transport_ref(req);
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    cs->trans = rpcsvc_request_transport_ref(req);
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nlm_add_nlmclnt (cs->args.nlm4_shareargs.share.caller_name);
+    ret = nlm_add_nlmclnt(cs->args.nlm4_shareargs.share.caller_name);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh, NULL, nlm4_share_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_share_resume);
 
- nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_SHARE_CALL_FAIL,
-                        "SHARE call failed");
-                nlm4_share_reply (cs, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+nlm4err:
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_SHARE_CALL_FAIL,
+               "SHARE call failed");
+        nlm4_share_reply(cs, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
- rpcerr:
-        if (ret < 0)
-                nfs3_call_state_wipe (cs);
+rpcerr:
+    if (ret < 0)
+        nfs3_call_state_wipe(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4_remove_share_reservation (nfs3_call_state_t *cs)
-{
-        int                      ret        = -1;
-        uint64_t                 ctx        = 0;
-        fsh_mode                 req_mode   = 0;
-        fsh_access               req_access = 0;
-        nlm_share_t             *share      = NULL;
-        nlm_share_t             *tmp        = NULL;
-        nlm_client_t            *client     = NULL;
-        char                    *caller     = NULL;
-        inode_t                 *inode      = NULL;
-        xlator_t                *this       = NULL;
-        struct list_head        *head       = NULL;
-        nlm4_shareargs          *args       = NULL;
-        struct nfs_inode_ctx    *ictx       = NULL;
-
-        LOCK (&nlm_client_list_lk);
-
-        args = &cs->args.nlm4_shareargs;
-        caller = args->share.caller_name;
-
-        client = __nlm_get_uniq (caller);
-        if (!client) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND,
-                        "client not found: %s", caller);
-                goto out;
-        }
-
-        inode = cs->resolvedloc.inode;
-        if (!inode) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND,
-                        "inode not found: client: %s", caller);
-                goto out;
-        }
-
-        this = THIS;
-        ret = inode_ctx_get (inode, this, &ctx);
+nlm4_remove_share_reservation(nfs3_call_state_t *cs)
+{
+    int ret = -1;
+    uint64_t ctx = 0;
+    fsh_mode req_mode = 0;
+    fsh_access req_access = 0;
+    nlm_share_t *share = NULL;
+    nlm_share_t *tmp = NULL;
+    nlm_client_t *client = NULL;
+    char *caller = NULL;
+    inode_t *inode = NULL;
+    xlator_t *this = NULL;
+    struct list_head *head = NULL;
+    nlm4_shareargs *args = NULL;
+    struct nfs_inode_ctx *ictx = NULL;
+
+    LOCK(&nlm_client_list_lk);
+
+    args = &cs->args.nlm4_shareargs;
+    caller = args->share.caller_name;
+
+    client = __nlm_get_uniq(caller);
+    if (!client) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_CLIENT_NOT_FOUND,
+               "client not found: %s", caller);
+        goto out;
+    }
+
+    inode = cs->resolvedloc.inode;
+    if (!inode) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_NOT_FOUND,
+               "inode not found: client: %s", caller);
+        goto out;
+    }
+
+    this = THIS;
+    ret = inode_ctx_get(inode, this, &ctx);
+    if (ret) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_INODE_SHARES_NOT_FOUND,
+               "no shares found for inode:"
+               "gfid: %s; client: %s",
+               inode->gfid, caller);
+        goto out;
+    }
+    ictx = (struct nfs_inode_ctx *)ctx;
+
+    head = &ictx->shares;
+    if (list_empty(head)) {
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
+    req_mode = args->share.mode;
+    req_access = args->share.access;
+
+    list_for_each_entry_safe(share, tmp, head, inode_list)
+    {
+        ret = ((req_mode == share->mode) && (req_access == share->access) &&
+               nlm_is_oh_same_lkowner(&share->lkowner, &args->share.oh));
         if (ret) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0,
-                        NFS_MSG_INODE_SHARES_NOT_FOUND,
-                        "no shares found for inode:"
-                        "gfid: %s; client: %s",
-                        inode->gfid, caller);
-                goto out;
+            list_del(&share->client_list);
+            list_del(&share->inode_list);
+            inode_unref(share->inode);
+            GF_FREE(share);
+            break;
         }
-        ictx = (struct nfs_inode_ctx *)ctx;
-
-        head = &ictx->shares;
-        if (list_empty (head)) {
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
-        req_mode = args->share.mode;
-        req_access = args->share.access;
-
-        list_for_each_entry_safe (share, tmp, head, inode_list) {
-                ret = ((req_mode == share->mode) &&
-                       (req_access == share->access) &&
-                       nlm_is_oh_same_lkowner (&share->lkowner, &args->share.oh));
-                if (ret) {
-                        list_del (&share->client_list);
-                        list_del (&share->inode_list);
-                        inode_unref (share->inode);
-                        GF_FREE (share);
-                        break;
-                }
-        }
-
-        ret = 0;
- out:
-        UNLOCK (&nlm_client_list_lk);
-        return ret;
+    }
 
+    ret = 0;
+out:
+    UNLOCK(&nlm_client_list_lk);
+    return ret;
 }
 
 int
-nlm4_unshare_resume (void *call_state)
+nlm4_unshare_resume(void *call_state)
 {
-        int                ret        = -1;
-        nlm4_stats         stat       = nlm4_failed;
-        nfs3_call_state_t *cs         = NULL;
+    int ret = -1;
+    nlm4_stats stat = nlm4_failed;
+    nfs3_call_state_t *cs = NULL;
 
-        if (!call_state)
-                return ret;
+    if (!call_state)
+        return ret;
 
-        cs = (nfs3_call_state_t *)call_state;
+    cs = (nfs3_call_state_t *)call_state;
 
-        nlm4_check_fh_resolve_status (cs, stat, out);
-        ret = nlm4_remove_share_reservation (cs);
-        if (!ret)
-                stat = nlm4_granted;
+    nlm4_check_fh_resolve_status(cs, stat, out);
+    ret = nlm4_remove_share_reservation(cs);
+    if (!ret)
+        stat = nlm4_granted;
 
- out:
-        nlm4_share_reply (cs, stat);
-        nfs3_call_state_wipe (cs);
-        return 0;
+out:
+    nlm4_share_reply(cs, stat);
+    nfs3_call_state_wipe(cs);
+    return 0;
 }
 
 int
-nlm4svc_unshare (rpcsvc_request_t *req)
-{
-        nlm4_stats                    stat      = nlm4_failed;
-        xlator_t                     *vol       = NULL;
-        nfs3_state_t                 *nfs3      = NULL;
-        nfs3_call_state_t            *cs        = NULL;
-        struct nfs_state             *nfs       = NULL;
-        struct nfs3_fh                fh        = {{0}, };
-        int                           ret       = RPCSVC_ACTOR_ERROR;
-
-        if (!req)
-                return ret;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, rpcerr, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs, req,
-                                     stat, rpcerr);
-
-        nlm4_prep_shareargs (&cs->args.nlm4_shareargs, &cs->lockfh,
-                             &cs->lkowner, cs->cookiebytes);
-
-        if (xdr_to_nlm4_shareargs (req->msg[0],
-                                   &cs->args.nlm4_shareargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding UNSHARE args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto rpcerr;
-        }
+nlm4svc_unshare(rpcsvc_request_t *req)
+{
+    nlm4_stats stat = nlm4_failed;
+    xlator_t *vol = NULL;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs_state *nfs = NULL;
+    struct nfs3_fh fh = {
+        {0},
+    };
+    int ret = RPCSVC_ACTOR_ERROR;
+
+    if (!req)
+        return ret;
 
-        fh = cs->lockfh;
-        nlm4_validate_gluster_fh (&fh, stat, nlm4err);
-        nlm4_map_fh_to_volume (cs->nfs3state, fh, req,
-                               vol, stat, nlm4err);
-
-        if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) {
-                gf_msg_debug (GF_NLM, 0, "NLM in grace period");
-                stat = nlm4_denied_grace_period;
-                nlm4_share_reply (cs, stat);
-                nfs3_call_state_wipe (cs);
-                return 0;
-        }
+    nlm4_validate_nfs3_state(req, nfs3, stat, rpcerr, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, rpcerr);
+
+    nlm4_prep_shareargs(&cs->args.nlm4_shareargs, &cs->lockfh, &cs->lkowner,
+                        cs->cookiebytes);
+
+    if (xdr_to_nlm4_shareargs(req->msg[0], &cs->args.nlm4_shareargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding UNSHARE args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto rpcerr;
+    }
+
+    fh = cs->lockfh;
+    nlm4_validate_gluster_fh(&fh, stat, nlm4err);
+    nlm4_map_fh_to_volume(cs->nfs3state, fh, req, vol, stat, nlm4err);
+
+    if (nlm_grace_period && !cs->args.nlm4_shareargs.reclaim) {
+        gf_msg_debug(GF_NLM, 0, "NLM in grace period");
+        stat = nlm4_denied_grace_period;
+        nlm4_share_reply(cs, stat);
+        nfs3_call_state_wipe(cs);
+        return 0;
+    }
 
-        cs->vol = vol;
-        cs->trans = rpcsvc_request_transport_ref(req);
-        nlm4_volume_started_check (nfs3, vol, ret, rpcerr);
+    cs->vol = vol;
+    cs->trans = rpcsvc_request_transport_ref(req);
+    nlm4_volume_started_check(nfs3, vol, ret, rpcerr);
 
-        ret = nfs3_fh_resolve_and_resume (cs, &fh, NULL,
-                                          nlm4_unshare_resume);
+    ret = nfs3_fh_resolve_and_resume(cs, &fh, NULL, nlm4_unshare_resume);
 
- nlm4err:
-        if (ret < 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_UNSHARE_CALL_FAIL,
-                        "UNSHARE call failed");
-                nlm4_share_reply (cs, stat);
-                ret = 0;
-                return 0;
-        }
+nlm4err:
+    if (ret < 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, -ret, NFS_MSG_UNSHARE_CALL_FAIL,
+               "UNSHARE call failed");
+        nlm4_share_reply(cs, stat);
+        ret = 0;
+        return 0;
+    }
 
- rpcerr:
-        if (ret < 0)
-                nfs3_call_state_wipe (cs);
+rpcerr:
+    if (ret < 0)
+        nfs3_call_state_wipe(cs);
 
-        return ret;
+    return ret;
 }
 
 int
-nlm4_free_all_shares (char *caller_name)
-{
-        nlm_share_t             *share      = NULL;
-        nlm_share_t             *tmp        = NULL;
-        nlm_client_t            *client     = NULL;
-
-        LOCK (&nlm_client_list_lk);
-
-        client = __nlm_get_uniq (caller_name);
-        if (!client) {
-                gf_msg_debug (GF_NLM, 0, "client not found: %s", caller_name);
-                goto out;
-        }
-
-        list_for_each_entry_safe (share, tmp, &client->shares, client_list) {
-                list_del (&share->inode_list);
-                list_del (&share->client_list);
-                inode_unref (share->inode);
-                GF_FREE (share);
-        }
- out:
-        UNLOCK (&nlm_client_list_lk);
-        return 0;
+nlm4_free_all_shares(char *caller_name)
+{
+    nlm_share_t *share = NULL;
+    nlm_share_t *tmp = NULL;
+    nlm_client_t *client = NULL;
+
+    LOCK(&nlm_client_list_lk);
+
+    client = __nlm_get_uniq(caller_name);
+    if (!client) {
+        gf_msg_debug(GF_NLM, 0, "client not found: %s", caller_name);
+        goto out;
+    }
+
+    list_for_each_entry_safe(share, tmp, &client->shares, client_list)
+    {
+        list_del(&share->inode_list);
+        list_del(&share->client_list);
+        inode_unref(share->inode);
+        GF_FREE(share);
+    }
+out:
+    UNLOCK(&nlm_client_list_lk);
+    return 0;
 }
 
 int
-nlm4svc_free_all (rpcsvc_request_t *req)
-{
-        int                           ret       = RPCSVC_ACTOR_ERROR;
-        nlm4_stats                    stat      = nlm4_failed;
-        nfs3_state_t                 *nfs3      = NULL;
-        nfs3_call_state_t            *cs        = NULL;
-        struct nfs_state             *nfs       = NULL;
-
-        nlm4_validate_nfs3_state (req, nfs3, stat, err, ret);
-        nfs = nfs_state (nfs3->nfsx);
-        nlm4_handle_call_state_init (nfs->nfs3state, cs,
-                                     req, stat, err);
-
-        nlm4_prep_freeallargs (&cs->args.nlm4_freeallargs,
-                               &cs->lkowner);
-
-        if (xdr_to_nlm4_freeallargs (req->msg[0],
-                                     &cs->args.nlm4_freeallargs) <= 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
-                        "Error decoding FREE_ALL args");
-                rpcsvc_request_seterr (req, GARBAGE_ARGS);
-                goto err;
-        }
+nlm4svc_free_all(rpcsvc_request_t *req)
+{
+    int ret = RPCSVC_ACTOR_ERROR;
+    nlm4_stats stat = nlm4_failed;
+    nfs3_state_t *nfs3 = NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nfs_state *nfs = NULL;
 
-        ret = nlm4_free_all_shares (cs->args.nlm4_freeallargs.name);
-        if (ret)
-                goto err;
+    nlm4_validate_nfs3_state(req, nfs3, stat, err, ret);
+    nfs = nfs_state(nfs3->nfsx);
+    nlm4_handle_call_state_init(nfs->nfs3state, cs, req, stat, err);
 
-        ret = nlm_cleanup_fds (cs->args.nlm4_freeallargs.name);
-        if (ret)
-                goto err;
+    nlm4_prep_freeallargs(&cs->args.nlm4_freeallargs, &cs->lkowner);
 
- err:
-        nfs3_call_state_wipe (cs);
-        if (ret)
-                gf_msg_debug (GF_NLM, 0, "error in free all; stat: %d", stat);
-        return ret;
+    if (xdr_to_nlm4_freeallargs(req->msg[0], &cs->args.nlm4_freeallargs) <= 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_ARGS_DECODE_ERROR,
+               "Error decoding FREE_ALL args");
+        rpcsvc_request_seterr(req, GARBAGE_ARGS);
+        goto err;
+    }
+
+    ret = nlm4_free_all_shares(cs->args.nlm4_freeallargs.name);
+    if (ret)
+        goto err;
+
+    ret = nlm_cleanup_fds(cs->args.nlm4_freeallargs.name);
+    if (ret)
+        goto err;
 
+err:
+    nfs3_call_state_wipe(cs);
+    if (ret)
+        gf_msg_debug(GF_NLM, 0, "error in free all; stat: %d", stat);
+    return ret;
 }
 
 void
-nlm4svc_sm_notify (struct nlm_sm_status *status)
+nlm4svc_sm_notify(struct nlm_sm_status *status)
 {
-        gf_msg (GF_NLM, GF_LOG_INFO, 0, NFS_MSG_SM_NOTIFY, "sm_notify: "
-                "%s, state: %d", status->mon_name, status->state);
-        nlm_cleanup_fds (status->mon_name);
+    gf_msg(GF_NLM, GF_LOG_INFO, 0, NFS_MSG_SM_NOTIFY,
+           "sm_notify: "
+           "%s, state: %d",
+           status->mon_name, status->state);
+    nlm_cleanup_fds(status->mon_name);
 }
 
-
 /* RPC_CLNT_CONNECT gets called on (re)connects and should be able to handle
  * different NLM requests. */
 static int
-nlm_handle_connect (struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf)
-{
-        int                 ret         = -1;
-        int                 nlm_proc    = NLM4_NULL;
-        nfs3_call_state_t  *cs          = NULL;
-        struct nlm4_lock   *alock       = NULL;
-        char               *caller_name = NULL;
-
-        cs = GF_REF_GET (ncf->cs);
-        if (!cs || !cs->req) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_RPC_CLNT_ERROR,
-                        "Spurious notify?!");
-                goto out;
-        }
-
-        /* NLM4_* actions from nlm4.h */
-        if (cs->req->prognum == NLM_PROGRAM) {
-                nlm_proc = cs->req->procnum;
-        } else {
-                /* hmm, cs->req has not been filled completely */
-                if (cs->resume_fn == nlm4_lock_fd_resume)
-                        nlm_proc = NLM4_LOCK;
-                else if (cs->resume_fn == nlm4_cancel_fd_resume)
-                        nlm_proc = NLM4_CANCEL;
-                else if (cs->resume_fn == nlm4_unlock_fd_resume)
-                        nlm_proc = NLM4_UNLOCK;
-                else {
-                        gf_msg (GF_NLM, GF_LOG_ERROR, 0,
-                                NFS_MSG_RPC_CLNT_ERROR, "(re)connect with an "
-                                "unexpected NLM4 procedure (%d)", nlm_proc);
-                        goto out;
-                }
+nlm_handle_connect(struct rpc_clnt *rpc_clnt, struct nlm4_notify_args *ncf)
+{
+    int ret = -1;
+    int nlm_proc = NLM4_NULL;
+    nfs3_call_state_t *cs = NULL;
+    struct nlm4_lock *alock = NULL;
+    char *caller_name = NULL;
+
+    cs = GF_REF_GET(ncf->cs);
+    if (!cs || !cs->req) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_RPC_CLNT_ERROR,
+               "Spurious notify?!");
+        goto out;
+    }
+
+    /* NLM4_* actions from nlm4.h */
+    if (cs->req->prognum == NLM_PROGRAM) {
+        nlm_proc = cs->req->procnum;
+    } else {
+        /* hmm, cs->req has not been filled completely */
+        if (cs->resume_fn == nlm4_lock_fd_resume)
+            nlm_proc = NLM4_LOCK;
+        else if (cs->resume_fn == nlm4_cancel_fd_resume)
+            nlm_proc = NLM4_CANCEL;
+        else if (cs->resume_fn == nlm4_unlock_fd_resume)
+            nlm_proc = NLM4_UNLOCK;
+        else {
+            gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR,
+                   "(re)connect with an "
+                   "unexpected NLM4 procedure (%d)",
+                   nlm_proc);
+            goto out;
         }
+    }
 
-        switch (nlm_proc) {
+    switch (nlm_proc) {
         case NLM4_LOCK:
-                alock = &cs->args.nlm4_lockargs.alock;
-                caller_name = alock->caller_name;
-
-                ret = nlm_set_rpc_clnt (rpc_clnt, caller_name);
-                if (ret == -1) {
-                        gf_msg (GF_NLM, GF_LOG_ERROR, 0,
-                                NFS_MSG_RPC_CLNT_ERROR, "Failed to set "
-                                "rpc clnt");
-                        goto out;
-                }
+            alock = &cs->args.nlm4_lockargs.alock;
+            caller_name = alock->caller_name;
+
+            ret = nlm_set_rpc_clnt(rpc_clnt, caller_name);
+            if (ret == -1) {
+                gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR,
+                       "Failed to set "
+                       "rpc clnt");
+                goto out;
+            }
 
-                /* extra ref taken with nlm_set_rpc_clnt() */
-                rpc_clnt_unref (rpc_clnt);
+            /* extra ref taken with nlm_set_rpc_clnt() */
+            rpc_clnt_unref(rpc_clnt);
 
-                nlm4svc_send_granted (ncf);
-                break;
+            nlm4svc_send_granted(ncf);
+            break;
 
         case NLM4_CANCEL:
-                /* alock = &cs->args.nlm4_cancargs.alock; */
-                ret = nlm4svc_cancel (cs->req);
-                break;
+            /* alock = &cs->args.nlm4_cancargs.alock; */
+            ret = nlm4svc_cancel(cs->req);
+            break;
 
         case NLM4_UNLOCK:
-                /* alock = &cs->args.nlm4_unlockargs.alock; */
-                ret = nlm4svc_unlock (cs->req);
-                break;
+            /* alock = &cs->args.nlm4_unlockargs.alock; */
+            ret = nlm4svc_unlock(cs->req);
+            break;
 
         default:
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR,
-                        "(re)connect with an unexpected NLM4 procedure "
-                        "(%d)", nlm_proc);
-        }
+            gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_RPC_CLNT_ERROR,
+                   "(re)connect with an unexpected NLM4 procedure "
+                   "(%d)",
+                   nlm_proc);
+    }
 
 out:
-        if (cs)
-                GF_REF_PUT (cs);
-
-        return ret;
-}
-
-
-rpcsvc_actor_t  nlm4svc_actors[NLM4_PROC_COUNT] = {
-        /* 0 */
-        {"NULL",       NLM4_NULL,         nlm4svc_null,      NULL, 0, DRC_IDEMPOTENT},
-        {"TEST",       NLM4_TEST,         nlm4svc_test,      NULL, 0, DRC_IDEMPOTENT},
-        {"LOCK",       NLM4_LOCK,         nlm4svc_lock,      NULL, 0, DRC_NON_IDEMPOTENT},
-        {"CANCEL",     NLM4_CANCEL,       nlm4svc_cancel,    NULL, 0, DRC_NON_IDEMPOTENT},
-        {"UNLOCK",     NLM4_UNLOCK,       nlm4svc_unlock,    NULL, 0, DRC_NON_IDEMPOTENT},
-        /* 5 */
-        {"GRANTED",    NLM4_GRANTED,      NULL,              NULL, 0, DRC_NA},
-        {"TEST",       NLM4_TEST_MSG,     NULL,              NULL, 0, DRC_NA},
-        {"LOCK",       NLM4_LOCK_MSG,     NULL,              NULL, 0, DRC_NA},
-        {"CANCEL",     NLM4_CANCEL_MSG,   NULL,              NULL, 0, DRC_NA},
-        {"UNLOCK",     NLM4_UNLOCK_MSG,   NULL,              NULL, 0, DRC_NA},
-        /* 10 */
-        {"GRANTED",    NLM4_GRANTED_MSG,  NULL,              NULL, 0, DRC_NA},
-        {"TEST",       NLM4_TEST_RES,     NULL,              NULL, 0, DRC_NA},
-        {"LOCK",       NLM4_LOCK_RES,     NULL,              NULL, 0, DRC_NA},
-        {"CANCEL",     NLM4_CANCEL_RES,   NULL,              NULL, 0, DRC_NA},
-        {"UNLOCK",     NLM4_UNLOCK_RES,   NULL,              NULL, 0, DRC_NA},
-        /* 15 ; procedures 17,18,19 are not defined by nlm */
-        {"GRANTED",    NLM4_GRANTED_RES,  NULL,              NULL, 0, DRC_NA},
-        {"SM_NOTIFY",  NLM4_SM_NOTIFY,    NULL,              NULL, 0, DRC_NA},
-        {"SEVENTEEN",  NLM4_SEVENTEEN,    NULL,              NULL, 0, DRC_NA},
-        {"EIGHTEEN",   NLM4_EIGHTEEN,     NULL,              NULL, 0, DRC_NA},
-        {"NINETEEN",   NLM4_NINETEEN,     NULL,              NULL, 0, DRC_NA},
-        /* 20 */
-        {"SHARE",      NLM4_SHARE,        nlm4svc_share,     NULL, 0, DRC_NON_IDEMPOTENT},
-        {"UNSHARE",    NLM4_UNSHARE,      nlm4svc_unshare,   NULL, 0, DRC_NON_IDEMPOTENT},
-        {"NM_LOCK",    NLM4_NM_LOCK,      nlm4svc_nm_lock,   NULL, 0, DRC_NON_IDEMPOTENT},
-        {"FREE_ALL",   NLM4_FREE_ALL,     nlm4svc_free_all,  NULL, 0, DRC_IDEMPOTENT},
+    if (cs)
+        GF_REF_PUT(cs);
+
+    return ret;
+}
+
+rpcsvc_actor_t nlm4svc_actors[NLM4_PROC_COUNT] = {
+    /* 0 */
+    {"NULL", NLM4_NULL, nlm4svc_null, NULL, 0, DRC_IDEMPOTENT},
+    {"TEST", NLM4_TEST, nlm4svc_test, NULL, 0, DRC_IDEMPOTENT},
+    {"LOCK", NLM4_LOCK, nlm4svc_lock, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"CANCEL", NLM4_CANCEL, nlm4svc_cancel, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"UNLOCK", NLM4_UNLOCK, nlm4svc_unlock, NULL, 0, DRC_NON_IDEMPOTENT},
+    /* 5 */
+    {"GRANTED", NLM4_GRANTED, NULL, NULL, 0, DRC_NA},
+    {"TEST", NLM4_TEST_MSG, NULL, NULL, 0, DRC_NA},
+    {"LOCK", NLM4_LOCK_MSG, NULL, NULL, 0, DRC_NA},
+    {"CANCEL", NLM4_CANCEL_MSG, NULL, NULL, 0, DRC_NA},
+    {"UNLOCK", NLM4_UNLOCK_MSG, NULL, NULL, 0, DRC_NA},
+    /* 10 */
+    {"GRANTED", NLM4_GRANTED_MSG, NULL, NULL, 0, DRC_NA},
+    {"TEST", NLM4_TEST_RES, NULL, NULL, 0, DRC_NA},
+    {"LOCK", NLM4_LOCK_RES, NULL, NULL, 0, DRC_NA},
+    {"CANCEL", NLM4_CANCEL_RES, NULL, NULL, 0, DRC_NA},
+    {"UNLOCK", NLM4_UNLOCK_RES, NULL, NULL, 0, DRC_NA},
+    /* 15 ; procedures 17,18,19 are not defined by nlm */
+    {"GRANTED", NLM4_GRANTED_RES, NULL, NULL, 0, DRC_NA},
+    {"SM_NOTIFY", NLM4_SM_NOTIFY, NULL, NULL, 0, DRC_NA},
+    {"SEVENTEEN", NLM4_SEVENTEEN, NULL, NULL, 0, DRC_NA},
+    {"EIGHTEEN", NLM4_EIGHTEEN, NULL, NULL, 0, DRC_NA},
+    {"NINETEEN", NLM4_NINETEEN, NULL, NULL, 0, DRC_NA},
+    /* 20 */
+    {"SHARE", NLM4_SHARE, nlm4svc_share, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"UNSHARE", NLM4_UNSHARE, nlm4svc_unshare, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"NM_LOCK", NLM4_NM_LOCK, nlm4svc_nm_lock, NULL, 0, DRC_NON_IDEMPOTENT},
+    {"FREE_ALL", NLM4_FREE_ALL, nlm4svc_free_all, NULL, 0, DRC_IDEMPOTENT},
 };
 
-rpcsvc_program_t        nlm4prog = {
-        .progname       = "NLM4",
-        .prognum        = NLM_PROGRAM,
-        .progver        = NLM_V4,
-        .progport       = GF_NLM4_PORT,
-        .actors         = nlm4svc_actors,
-        .numactors      = NLM4_PROC_COUNT,
-        .min_auth       = AUTH_NULL,
+rpcsvc_program_t nlm4prog = {
+    .progname = "NLM4",
+    .prognum = NLM_PROGRAM,
+    .progver = NLM_V4,
+    .progport = GF_NLM4_PORT,
+    .actors = nlm4svc_actors,
+    .numactors = NLM4_PROC_COUNT,
+    .min_auth = AUTH_NULL,
 };
 
-
 int
-nlm4_init_state (xlator_t *nfsx)
+nlm4_init_state(xlator_t *nfsx)
 {
-        return 0;
+    return 0;
 }
 
-extern void *nsm_thread (void *argv);
+extern void *
+nsm_thread(void *argv);
 
-void nlm_grace_period_over(void *arg)
+void
+nlm_grace_period_over(void *arg)
 {
-        nlm_grace_period = 0;
+    nlm_grace_period = 0;
 }
 
 rpcsvc_program_t *
 nlm4svc_init(xlator_t *nfsx)
 {
-        struct nfs3_state *ns = NULL;
-        struct nfs_state *nfs = NULL;
-        dict_t *options = NULL;
-        int ret = -1;
-        char *portstr = NULL;
-        pthread_t thr;
-        struct timespec timeout = {0,};
-        FILE   *pidfile = NULL;
-        pid_t   pid     = -1;
-        static gf_boolean_t nlm4_inited = _gf_false;
-
-        /* Already inited */
-        if (nlm4_inited)
-                return &nlm4prog;
-
-        nfs = (struct nfs_state*)nfsx->private;
-
-        ns = nfs->nfs3state;
-        if (!ns) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_NLM_INIT_FAIL,
-                        "NLM4 init failed");
-                goto err;
-        }
-        nlm4prog.private = ns;
-
-        options = dict_new ();
-
-        ret = gf_asprintf (&portstr, "%d", GF_NLM4_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_NLM, 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_NLM, 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_NLM, GF_LOG_ERROR, errno,
-                                NFS_MSG_DICT_SET_FAILED, "dict_set_str error");
-                        goto err;
-                }
-        }
+    struct nfs3_state *ns = NULL;
+    struct nfs_state *nfs = NULL;
+    dict_t *options = NULL;
+    int ret = -1;
+    char *portstr = NULL;
+    pthread_t thr;
+    struct timespec timeout = {
+        0,
+    };
+    FILE *pidfile = NULL;
+    pid_t pid = -1;
+    static gf_boolean_t nlm4_inited = _gf_false;
+
+    /* Already inited */
+    if (nlm4_inited)
+        return &nlm4prog;
 
-        ret = dict_set_str (options, "transport.address-family", "inet");
+    nfs = (struct nfs_state *)nfsx->private;
+
+    ns = nfs->nfs3state;
+    if (!ns) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, EINVAL, NFS_MSG_NLM_INIT_FAIL,
+               "NLM4 init failed");
+        goto err;
+    }
+    nlm4prog.private = ns;
+
+    options = dict_new();
+
+    ret = gf_asprintf(&portstr, "%d", GF_NLM4_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_NLM, 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_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
-                        "dict_set_str error");
-                goto err;
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
         }
-
-        ret = rpcsvc_create_listeners (nfs->rpcsvc, options, "NLM");
+        ret = dict_set_str(options, "rpc-auth.ports.insecure", "on");
         if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno,
-                        NFS_MSG_LISTENERS_CREATE_FAIL,
-                        "Unable to create listeners");
-                dict_unref (options);
-                goto err;
-        }
-        INIT_LIST_HEAD(&nlm_client_list);
-        LOCK_INIT (&nlm_client_list_lk);
-
-        /* unlink sm-notify.pid so that when we restart rpc.statd/sm-notify
-         * it thinks that the machine has restarted and sends NOTIFY to clients.
-         */
-
-        /* TODO:
-           notify/rpc.statd is done differently on OSX
-
-           On OSX rpc.statd is controlled by rpc.lockd and are part for launchd
-           (unified service management framework)
-
-           A runcmd() should be invoking "launchctl start com.apple.lockd"
-           instead. This is still a theory but we need to thoroughly test it
-           out. Until then NLM support is non-existent on OSX.
-        */
-        ret = sys_unlink (GF_SM_NOTIFY_PIDFILE);
-        if (ret == -1 && errno != ENOENT) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR,
-                        "unable to unlink %s: %d",
-                        GF_SM_NOTIFY_PIDFILE, errno);
-                goto err;
-        }
-        /* temporary work around to restart statd, not distro/OS independent.
-         * Need to figure out a more graceful way
-         * killall will cause problems on solaris.
+            gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+                   "dict_set_str error");
+            goto err;
+        }
+    }
+
+    ret = dict_set_str(options, "transport.address-family", "inet");
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED,
+               "dict_set_str error");
+        goto err;
+    }
+
+    ret = rpcsvc_create_listeners(nfs->rpcsvc, options, "NLM");
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_LISTENERS_CREATE_FAIL,
+               "Unable to create listeners");
+        dict_unref(options);
+        goto err;
+    }
+    INIT_LIST_HEAD(&nlm_client_list);
+    LOCK_INIT(&nlm_client_list_lk);
+
+    /* unlink sm-notify.pid so that when we restart rpc.statd/sm-notify
+     * it thinks that the machine has restarted and sends NOTIFY to clients.
+     */
+
+    /* TODO:
+       notify/rpc.statd is done differently on OSX
+
+       On OSX rpc.statd is controlled by rpc.lockd and are part for launchd
+       (unified service management framework)
+
+       A runcmd() should be invoking "launchctl start com.apple.lockd"
+       instead. This is still a theory but we need to thoroughly test it
+       out. Until then NLM support is non-existent on OSX.
+    */
+    ret = sys_unlink(GF_SM_NOTIFY_PIDFILE);
+    if (ret == -1 && errno != ENOENT) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR,
+               "unable to unlink %s: %d", GF_SM_NOTIFY_PIDFILE, errno);
+        goto err;
+    }
+    /* temporary work around to restart statd, not distro/OS independent.
+     * Need to figure out a more graceful way
+     * killall will cause problems on solaris.
+     */
+
+    char *pid_file = GF_RPC_STATD_PIDFILE;
+    if (nfs->rpc_statd_pid_file)
+        pid_file = nfs->rpc_statd_pid_file;
+    pidfile = fopen(pid_file, "r");
+    if (pidfile) {
+        ret = fscanf(pidfile, "%d", &pid);
+        if (ret <= 0) {
+            gf_msg(GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_GET_PID_FAIL,
+                   "unable to get pid of "
+                   "rpc.statd from %s ",
+                   GF_RPC_STATD_PIDFILE);
+            ret = runcmd(KILLALL_CMD, "-9", "rpc.statd", NULL);
+        } else
+            kill(pid, SIGKILL);
+
+        fclose(pidfile);
+    } else {
+        gf_msg(GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_OPEN_FAIL,
+               "opening %s of rpc.statd failed (%s)", pid_file,
+               strerror(errno));
+        /* if ret == -1, do nothing - case either statd was not
+         * running or was running in valgrind mode
          */
-
-        char *pid_file = GF_RPC_STATD_PIDFILE;
-        if (nfs->rpc_statd_pid_file)
-                pid_file = nfs->rpc_statd_pid_file;
-        pidfile = fopen (pid_file, "r");
-        if (pidfile) {
-                ret = fscanf (pidfile, "%d", &pid);
-                if (ret <= 0) {
-                        gf_msg (GF_NLM, GF_LOG_WARNING, errno,
-                                NFS_MSG_GET_PID_FAIL, "unable to get pid of "
-                                "rpc.statd from %s ", GF_RPC_STATD_PIDFILE);
-                        ret = runcmd (KILLALL_CMD, "-9", "rpc.statd", NULL);
-                } else
-                        kill (pid, SIGKILL);
-
-                fclose (pidfile);
-        } else {
-                gf_msg (GF_NLM, GF_LOG_WARNING, errno, NFS_MSG_OPEN_FAIL,
-                        "opening %s of rpc.statd failed (%s)",
-                        pid_file, strerror (errno));
-                /* if ret == -1, do nothing - case either statd was not
-                 * running or was running in valgrind mode
-                 */
-                ret = runcmd (KILLALL_CMD, "-9", "rpc.statd", NULL);
-        }
-
-        ret = sys_unlink (GF_RPC_STATD_PIDFILE);
-        if (ret == -1 && errno != ENOENT) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR,
-                        "unable to unlink %s", pid_file);
-                goto err;
-        }
-
-        ret = runcmd (nfs->rpc_statd, NULL);
-        if (ret == -1) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_START_ERROR,
-                        "unable to start %s", nfs->rpc_statd);
-                goto err;
-        }
-
-
-        gf_thread_create (&thr, NULL, nsm_thread, (void *)NULL, "nfsnsm");
-
-        timeout.tv_sec = nlm_grace_period;
-        timeout.tv_nsec = 0;
-
-        gf_timer_call_after (nfsx->ctx, timeout, nlm_grace_period_over, NULL);
-        nlm4_inited = _gf_true;
-        return &nlm4prog;
+        ret = runcmd(KILLALL_CMD, "-9", "rpc.statd", NULL);
+    }
+
+    ret = sys_unlink(GF_RPC_STATD_PIDFILE);
+    if (ret == -1 && errno != ENOENT) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UNLINK_ERROR,
+               "unable to unlink %s", pid_file);
+        goto err;
+    }
+
+    ret = runcmd(nfs->rpc_statd, NULL);
+    if (ret == -1) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_START_ERROR,
+               "unable to start %s", nfs->rpc_statd);
+        goto err;
+    }
+
+    gf_thread_create(&thr, NULL, nsm_thread, (void *)NULL, "nfsnsm");
+
+    timeout.tv_sec = nlm_grace_period;
+    timeout.tv_nsec = 0;
+
+    gf_timer_call_after(nfsx->ctx, timeout, nlm_grace_period_over, NULL);
+    nlm4_inited = _gf_true;
+    return &nlm4prog;
 err:
-        return NULL;
+    return NULL;
 }
 
 int32_t
-nlm_priv (xlator_t *this)
+nlm_priv(xlator_t *this)
 {
-        int32_t                  ret                       = -1;
-        uint32_t                 client_count              = 0;
-        uint64_t                 file_count                = 0;
-        nlm_client_t            *client                    = NULL;
-        nlm_fde_t               *fde                       = NULL;
-        char                     key[GF_DUMP_MAX_BUF_LEN]  = {0};
-        char                     gfid_str[64]              = {0};
-
-        gf_proc_dump_add_section("nfs.nlm");
-
-        if (TRY_LOCK (&nlm_client_list_lk))
-                goto out;
+    int32_t ret = -1;
+    uint32_t client_count = 0;
+    uint64_t file_count = 0;
+    nlm_client_t *client = NULL;
+    nlm_fde_t *fde = NULL;
+    char key[GF_DUMP_MAX_BUF_LEN] = {0};
+    char gfid_str[64] = {0};
 
-        list_for_each_entry (client, &nlm_client_list, nlm_clients) {
+    gf_proc_dump_add_section("nfs.nlm");
 
-                gf_proc_dump_build_key (key, "client", "%d.hostname", client_count);
-                gf_proc_dump_write (key, "%s\n", client->caller_name);
+    if (TRY_LOCK(&nlm_client_list_lk))
+        goto out;
 
-                file_count = 0;
-                list_for_each_entry (fde, &client->fdes, fde_list) {
-                        gf_proc_dump_build_key (key, "file", "%ld.gfid", file_count);
-                        memset (gfid_str, 0, 64);
-                        uuid_utoa_r (fde->fd->inode->gfid, gfid_str);
-                        gf_proc_dump_write (key, "%s", gfid_str);
-                        file_count++;
-                }
+    list_for_each_entry(client, &nlm_client_list, nlm_clients)
+    {
+        gf_proc_dump_build_key(key, "client", "%d.hostname", client_count);
+        gf_proc_dump_write(key, "%s\n", client->caller_name);
 
-                gf_proc_dump_build_key (key, "client", "files-locked");
-                gf_proc_dump_write (key, "%ld\n", file_count);
-                client_count++;
+        file_count = 0;
+        list_for_each_entry(fde, &client->fdes, fde_list)
+        {
+            gf_proc_dump_build_key(key, "file", "%ld.gfid", file_count);
+            memset(gfid_str, 0, 64);
+            uuid_utoa_r(fde->fd->inode->gfid, gfid_str);
+            gf_proc_dump_write(key, "%s", gfid_str);
+            file_count++;
         }
 
-        gf_proc_dump_build_key (key, "nlm", "client-count");
-        gf_proc_dump_write (key, "%d", client_count);
-        ret = 0;
-        UNLOCK (&nlm_client_list_lk);
+        gf_proc_dump_build_key(key, "client", "files-locked");
+        gf_proc_dump_write(key, "%ld\n", file_count);
+        client_count++;
+    }
 
- out:
-        if (ret) {
-                gf_proc_dump_build_key (key, "nlm", "statedump_error");
-                gf_proc_dump_write (key, "Unable to dump nlm state because "
-                                    "nlm_client_list_lk lock couldn't be acquired");
-        }
+    gf_proc_dump_build_key(key, "nlm", "client-count");
+    gf_proc_dump_write(key, "%d", client_count);
+    ret = 0;
+    UNLOCK(&nlm_client_list_lk);
 
-        return ret;
+out:
+    if (ret) {
+        gf_proc_dump_build_key(key, "nlm", "statedump_error");
+        gf_proc_dump_write(key,
+                           "Unable to dump nlm state because "
+                           "nlm_client_list_lk lock couldn't be acquired");
+    }
+
+    return ret;
 }
diff --git a/xlators/nfs/server/src/nlmcbk_svc.c b/xlators/nfs/server/src/nlmcbk_svc.c
index badbd088f3d..1d57f415e2c 100644
--- a/xlators/nfs/server/src/nlmcbk_svc.c
+++ b/xlators/nfs/server/src/nlmcbk_svc.c
@@ -25,102 +25,105 @@
 #include <netinet/in.h>
 
 #ifndef SIG_PF
-#define SIG_PF void(*)(int)
+#define SIG_PF void (*)(int)
 #endif
 
 void
-nlm4svc_sm_notify (struct nlm_sm_status *status);
+nlm4svc_sm_notify(struct nlm_sm_status *status);
 
-void *nlmcbk_sm_notify_0_svc(struct nlm_sm_status *status, struct svc_req *req)
+void *
+nlmcbk_sm_notify_0_svc(struct nlm_sm_status *status, struct svc_req *req)
 {
-        nlm4svc_sm_notify (status);
-        return NULL;
+    nlm4svc_sm_notify(status);
+    return NULL;
 }
 
 static void
 nlmcbk_program_0(struct svc_req *rqstp, register SVCXPRT *transp)
 {
-	union {
-		struct nlm_sm_status nlmcbk_sm_notify_0_arg;
-	} argument;
-	char *result;
-	xdrproc_t _xdr_argument, _xdr_result;
-	char *(*local)(char *, struct svc_req *);
+    union {
+        struct nlm_sm_status nlmcbk_sm_notify_0_arg;
+    } argument;
+    char *result;
+    xdrproc_t _xdr_argument, _xdr_result;
+    char *(*local)(char *, struct svc_req *);
 
-	switch (rqstp->rq_proc) {
-	case NULLPROC:
-		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
-		return;
+    switch (rqstp->rq_proc) {
+        case NULLPROC:
+            (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
+            return;
 
-	case NLMCBK_SM_NOTIFY:
-		_xdr_argument = (xdrproc_t) xdr_nlm_sm_status;
-		_xdr_result = (xdrproc_t) xdr_void;
-		local = (char *(*)(char *, struct svc_req *)) nlmcbk_sm_notify_0_svc;
-		break;
+        case NLMCBK_SM_NOTIFY:
+            _xdr_argument = (xdrproc_t)xdr_nlm_sm_status;
+            _xdr_result = (xdrproc_t)xdr_void;
+            local = (char *(*)(char *, struct svc_req *))nlmcbk_sm_notify_0_svc;
+            break;
 
-	default:
-		svcerr_noproc (transp);
-		return;
-	}
-	memset ((char *)&argument, 0, sizeof (argument));
-	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
-		svcerr_decode (transp);
-		return;
-	}
-	result = (*local)((char *)&argument, rqstp);
-	if (!svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {
-		svcerr_systemerr (transp);
-	}
+        default:
+            svcerr_noproc(transp);
+            return;
+    }
+    memset((char *)&argument, 0, sizeof(argument));
+    if (!svc_getargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) {
+        svcerr_decode(transp);
+        return;
+    }
+    result = (*local)((char *)&argument, rqstp);
+    if (!svc_sendreply(transp, (xdrproc_t)_xdr_result, result)) {
+        svcerr_systemerr(transp);
+    }
 
-	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
-		gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL,
-                        "unable to free arguments");
-                return;
-	}
-	return;
+    if (!svc_freeargs(transp, (xdrproc_t)_xdr_argument, (caddr_t)&argument)) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL,
+               "unable to free arguments");
+        return;
+    }
+    return;
 }
 
 void *
-nsm_thread (void *argv)
+nsm_thread(void *argv)
 {
-	register SVCXPRT *transp;
-        int ret = 0;
+    register SVCXPRT *transp;
+    int ret = 0;
 
-        ret = pmap_unset (NLMCBK_PROGRAM, NLMCBK_V1);
-        if (ret == 0) {
-                gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_PMAP_UNSET_FAIL,
-                        "pmap_unset failed");
-                return NULL;
-        }
-        transp = svcudp_create(RPC_ANYSOCK);
-	if (transp == NULL) {
-		gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UDP_SERV_FAIL,
-                        "cannot create udp service.");
-                return NULL;
-	}
-	if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, IPPROTO_UDP)) {
-		gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL,
-                        "unable to register (NLMCBK_PROGRAM, "
-                        "NLMCBK_V0, udp).");
-                return NULL;
-	}
-
-	transp = svctcp_create(RPC_ANYSOCK, 0, 0);
-	if (transp == NULL) {
-		gf_msg (GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_TCP_SERV_FAIL,
-                        "cannot create tcp service.");
-                return NULL;
-	}
-	if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0, IPPROTO_TCP)) {
-		gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL,
-                        "unable to register (NLMCBK_PROGRAM, "
-                        "NLMCBK_V0, tcp).");
-                return NULL;
-	}
+    ret = pmap_unset(NLMCBK_PROGRAM, NLMCBK_V1);
+    if (ret == 0) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_PMAP_UNSET_FAIL,
+               "pmap_unset failed");
+        return NULL;
+    }
+    transp = svcudp_create(RPC_ANYSOCK);
+    if (transp == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_UDP_SERV_FAIL,
+               "cannot create udp service.");
+        return NULL;
+    }
+    if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0,
+                      IPPROTO_UDP)) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL,
+               "unable to register (NLMCBK_PROGRAM, "
+               "NLMCBK_V0, udp).");
+        return NULL;
+    }
 
-	svc_run ();
-	gf_msg (GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED,
-                "svc_run returned");
+    transp = svctcp_create(RPC_ANYSOCK, 0, 0);
+    if (transp == NULL) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, errno, NFS_MSG_TCP_SERV_FAIL,
+               "cannot create tcp service.");
         return NULL;
-	/* NOTREACHED */
+    }
+    if (!svc_register(transp, NLMCBK_PROGRAM, NLMCBK_V1, nlmcbk_program_0,
+                      IPPROTO_TCP)) {
+        gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_REG_NLMCBK_FAIL,
+               "unable to register (NLMCBK_PROGRAM, "
+               "NLMCBK_V0, tcp).");
+        return NULL;
+    }
+
+    svc_run();
+    gf_msg(GF_NLM, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED,
+           "svc_run returned");
+    return NULL;
+    /* NOTREACHED */
 }