Land part 2 of clang-format changes

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

1 files changed, 875 insertions, 909 deletions

diff --git a/xlators/features/namespace/src/namespace.c b/xlators/features/namespace/src/namespace.c
index b1c61c912fc..581b470381d 100644
--- a/xlators/features/namespace/src/namespace.c
+++ b/xlators/features/namespace/src/namespace.c
@@ -23,9 +23,9 @@
 
 /* Return codes for common path parsing functions. */
 enum _path_parse_result {
-        PATH_PARSE_RESULT_NO_PATH = 0,
-        PATH_PARSE_RESULT_FOUND   = 1,
-        PATH_PARSE_RESULT_IS_GFID = 2,
+    PATH_PARSE_RESULT_NO_PATH = 0,
+    PATH_PARSE_RESULT_FOUND = 1,
+    PATH_PARSE_RESULT_IS_GFID = 2,
 };
 
 typedef enum _path_parse_result path_parse_result_t;
@@ -33,48 +33,50 @@ typedef enum _path_parse_result path_parse_result_t;
 /* Clean up an ns_local struct. Wipe a loc (its inode is ref'd, so we're good.)
  */
 static inline void
-ns_local_cleanup (ns_local_t *local)
+ns_local_cleanup(ns_local_t *local)
 {
-        if (!local) {
-                return;
-        }
+    if (!local) {
+        return;
+    }
 
-        loc_wipe (&local->loc);
-        GF_FREE (local);
+    loc_wipe(&local->loc);
+    GF_FREE(local);
 }
 
 /* Create a new ns_local. We ref the inode, fake a new loc struct, and stash
  * the stub given to us. */
 static inline ns_local_t *
-ns_local_new (call_stub_t *stub, inode_t *inode)
+ns_local_new(call_stub_t *stub, inode_t *inode)
 {
-        ns_local_t *local = NULL;
-        loc_t       loc   = {0, };
+    ns_local_t *local = NULL;
+    loc_t loc = {
+        0,
+    };
 
-        if (!stub || !inode) {
-                goto out;
-        }
+    if (!stub || !inode) {
+        goto out;
+    }
 
-        local = GF_CALLOC (1, sizeof (ns_local_t), 0);
-        if (local == NULL) {
-                goto out;
-        }
+    local = GF_CALLOC(1, sizeof(ns_local_t), 0);
+    if (local == NULL) {
+        goto out;
+    }
 
-        /* Set up a fake loc_t struct to give to the getxattr call. */
-        gf_uuid_copy (loc.gfid, inode->gfid);
-        loc.inode = inode_ref (inode);
+    /* Set up a fake loc_t struct to give to the getxattr call. */
+    gf_uuid_copy(loc.gfid, inode->gfid);
+    loc.inode = inode_ref(inode);
 
-        /* If for some reason inode_ref() fails, then just give up. */
-        if (!loc.inode) {
-                GF_FREE (local);
-                goto out;
-        }
+    /* If for some reason inode_ref() fails, then just give up. */
+    if (!loc.inode) {
+        GF_FREE(local);
+        goto out;
+    }
 
-        local->stub = stub;
-        local->loc = loc;
+    local->stub = stub;
+    local->loc = loc;
 
 out:
-        return local;
+    return local;
 }
 
 /* Try parsing a path string. If the path string is a GFID, then return
@@ -82,110 +84,109 @@ out:
  * return PATH_PARSE_RESULT_NO_PATH and set the hash to 1. Otherwise, hash the
  * namespace and store it in the info struct. */
 static path_parse_result_t
-parse_path (ns_info_t *info, const char *path)
+parse_path(ns_info_t *info, const char *path)
 {
-        int         len      = 0;
-        const char *ns_begin = path;
-        const char *ns_end   = NULL;
-
-        if (!path || strlen (path) == 0) {
-                return PATH_PARSE_RESULT_NO_PATH;
-        }
-
-        if (path[0] == '<') {
-                return PATH_PARSE_RESULT_IS_GFID;
-        }
-
-        /* Right now we only want the top-level directory, so
-         * skip the initial '/' and read until the next '/'. */
-        while (*ns_begin == '/') {
-                ns_begin++;
-        }
-
-        /* ns_end will point to the next '/' or NULL if there is no delimiting
-         * '/' (i.e. "/directory" or the top level "/") */
-        ns_end = strchr (ns_begin, '/');
-        len = ns_end ? (ns_end - ns_begin) : strlen (ns_begin);
-
-        if (len != 0) {
-                info->hash = SuperFastHash (ns_begin, len);
-        } else {
-                /* If our substring is empty, then we can hash '/' instead.
-                 * '/' is used in the namespace config for the top-level
-                 * namespace. */
-                info->hash = SuperFastHash ("/", 1);
-        }
-
-        info->found = _gf_true;
-        return PATH_PARSE_RESULT_FOUND;
+    int len = 0;
+    const char *ns_begin = path;
+    const char *ns_end = NULL;
+
+    if (!path || strlen(path) == 0) {
+        return PATH_PARSE_RESULT_NO_PATH;
+    }
+
+    if (path[0] == '<') {
+        return PATH_PARSE_RESULT_IS_GFID;
+    }
+
+    /* Right now we only want the top-level directory, so
+     * skip the initial '/' and read until the next '/'. */
+    while (*ns_begin == '/') {
+        ns_begin++;
+    }
+
+    /* ns_end will point to the next '/' or NULL if there is no delimiting
+     * '/' (i.e. "/directory" or the top level "/") */
+    ns_end = strchr(ns_begin, '/');
+    len = ns_end ? (ns_end - ns_begin) : strlen(ns_begin);
+
+    if (len != 0) {
+        info->hash = SuperFastHash(ns_begin, len);
+    } else {
+        /* If our substring is empty, then we can hash '/' instead.
+         * '/' is used in the namespace config for the top-level
+         * namespace. */
+        info->hash = SuperFastHash("/", 1);
+    }
+
+    info->found = _gf_true;
+    return PATH_PARSE_RESULT_FOUND;
 }
 
 /* Cache namespace info stored in the stack (info) into the inode. */
 static int
-ns_inode_ctx_put (inode_t *inode, xlator_t *this, ns_info_t *info)
+ns_inode_ctx_put(inode_t *inode, xlator_t *this, ns_info_t *info)
 {
-        ns_info_t *cached_ns_info = NULL;
-        uint64_t   ns_as_64       = 0;
-        int        ret            = -1;
-
-        if (!inode || !this) {
-                gf_log (this ? this->name : "namespace", GF_LOG_WARNING,
-                        "Need a valid inode and xlator to cache ns_info.");
-                ret = -1;
-                goto out;
-        }
+    ns_info_t *cached_ns_info = NULL;
+    uint64_t ns_as_64 = 0;
+    int ret = -1;
 
-        cached_ns_info = GF_CALLOC (1, sizeof (ns_info_t), 0);
+    if (!inode || !this) {
+        gf_log(this ? this->name : "namespace", GF_LOG_WARNING,
+               "Need a valid inode and xlator to cache ns_info.");
+        ret = -1;
+        goto out;
+    }
 
-        /* If we've run out of memory, then return ENOMEM. */
-        if (cached_ns_info == NULL) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "No memory to cache ns_info.");
-                ret = -(ENOMEM);
-                goto out;
-        }
+    cached_ns_info = GF_CALLOC(1, sizeof(ns_info_t), 0);
 
-        *cached_ns_info = *info;
-        ns_as_64 = (uint64_t)cached_ns_info;
+    /* If we've run out of memory, then return ENOMEM. */
+    if (cached_ns_info == NULL) {
+        gf_log(this->name, GF_LOG_WARNING, "No memory to cache ns_info.");
+        ret = -(ENOMEM);
+        goto out;
+    }
 
-        ret = inode_ctx_put (inode, this, ns_as_64);
+    *cached_ns_info = *info;
+    ns_as_64 = (uint64_t)cached_ns_info;
 
-        if (ret) {
-                goto out;
-        }
+    ret = inode_ctx_put(inode, this, ns_as_64);
+
+    if (ret) {
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        if (ret && cached_ns_info) {
-                GF_FREE (cached_ns_info);
-        }
+    if (ret && cached_ns_info) {
+        GF_FREE(cached_ns_info);
+    }
 
-        return ret;
+    return ret;
 }
 
 /* Retrieve namespace info cached in the inode into the stack for use in later
  * translators. */
 static int
-ns_inode_ctx_get (inode_t *inode, xlator_t *this, ns_info_t *info)
+ns_inode_ctx_get(inode_t *inode, xlator_t *this, ns_info_t *info)
 {
-        ns_info_t *cached_ns_info = NULL;
-        uint64_t   ns_as_64       = 0;
-        int        ret            = -1;
+    ns_info_t *cached_ns_info = NULL;
+    uint64_t ns_as_64 = 0;
+    int ret = -1;
 
-        if (!inode) {
-                ret = -ENOENT;
-                goto out;
-        }
+    if (!inode) {
+        ret = -ENOENT;
+        goto out;
+    }
 
-        ret = inode_ctx_get (inode, this, &ns_as_64);
+    ret = inode_ctx_get(inode, this, &ns_as_64);
 
-        if (!ret) {
-                cached_ns_info = (ns_info_t *)ns_as_64;
-                *info = *cached_ns_info;
-        }
+    if (!ret) {
+        cached_ns_info = (ns_info_t *)ns_as_64;
+        *info = *cached_ns_info;
+    }
 
 out:
-        return ret;
+    return ret;
 }
 
 /* This callback is the top of the unwind path of our attempt to get the path
@@ -194,76 +195,75 @@ out:
  * default stub that we provide in the local, since there's nothing else to do
  * once we've gotten the namespace hash. */
 int32_t
-get_path_resume_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict,
-                     dict_t *xdata)
+get_path_resume_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata)
 {
-        path_parse_result_t  ret          = PATH_PARSE_RESULT_NO_PATH;
-        call_frame_t        *resume_frame = NULL;
-        ns_local_t          *local        = NULL;
-        call_stub_t         *stub         = NULL;
-        ns_info_t           *info         = NULL;
-        char                *path         = NULL;
-
-        GF_VALIDATE_OR_GOTO (this->name, frame, out);
-        local = frame->local;
-
-        GF_VALIDATE_OR_GOTO (this->name, local, out);
-        stub = local->stub;
-
-        GF_VALIDATE_OR_GOTO (this->name, stub, out);
-        /* Get the ns_info from the frame that we will eventually resume,
-         * not the frame that we're going to destroy (frame). */
-        resume_frame = stub->frame;
-
-        GF_VALIDATE_OR_GOTO (this->name, resume_frame, out);
-        GF_VALIDATE_OR_GOTO (this->name, resume_frame->root, out);
-        info = &resume_frame->root->ns_info;
-
-        GF_VALIDATE_OR_GOTO (this->name, dict, out);
-
-        /* If we get a value back for the GET_ANCESTRY_PATH_KEY, then we
-         * try to access it and parse it like a path. */
-        if (!op_ret && !dict_get_str (dict, GET_ANCESTRY_PATH_KEY, &path)) {
-                gf_log (this->name, GF_LOG_DEBUG, "G>P %s retrieved path %s",
-                        uuid_utoa (local->loc.gfid), path);
-                /* Now let's parse a path, finally. */
-                ret = parse_path (info, path);
-        }
-
-        if (ret == PATH_PARSE_RESULT_FOUND) {
-                /* If we finally found namespace, then stash it. */
-                ns_inode_ctx_put (local->loc.inode, this, info);
-
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "G>P %s %10u namespace found %s",
-                        uuid_utoa (local->loc.inode->gfid), info->hash, path);
-        } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
-                gf_log (this->name, GF_LOG_WARNING, "G>P %s has no path",
-                        uuid_utoa (local->loc.inode->gfid));
-        } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "G>P %s winding failed, still have gfid",
-                        uuid_utoa (local->loc.inode->gfid));
-        }
+    path_parse_result_t ret = PATH_PARSE_RESULT_NO_PATH;
+    call_frame_t *resume_frame = NULL;
+    ns_local_t *local = NULL;
+    call_stub_t *stub = NULL;
+    ns_info_t *info = NULL;
+    char *path = NULL;
+
+    GF_VALIDATE_OR_GOTO(this->name, frame, out);
+    local = frame->local;
+
+    GF_VALIDATE_OR_GOTO(this->name, local, out);
+    stub = local->stub;
+
+    GF_VALIDATE_OR_GOTO(this->name, stub, out);
+    /* Get the ns_info from the frame that we will eventually resume,
+     * not the frame that we're going to destroy (frame). */
+    resume_frame = stub->frame;
+
+    GF_VALIDATE_OR_GOTO(this->name, resume_frame, out);
+    GF_VALIDATE_OR_GOTO(this->name, resume_frame->root, out);
+    info = &resume_frame->root->ns_info;
+
+    GF_VALIDATE_OR_GOTO(this->name, dict, out);
+
+    /* If we get a value back for the GET_ANCESTRY_PATH_KEY, then we
+     * try to access it and parse it like a path. */
+    if (!op_ret && !dict_get_str(dict, GET_ANCESTRY_PATH_KEY, &path)) {
+        gf_log(this->name, GF_LOG_DEBUG, "G>P %s retrieved path %s",
+               uuid_utoa(local->loc.gfid), path);
+        /* Now let's parse a path, finally. */
+        ret = parse_path(info, path);
+    }
+
+    if (ret == PATH_PARSE_RESULT_FOUND) {
+        /* If we finally found namespace, then stash it. */
+        ns_inode_ctx_put(local->loc.inode, this, info);
+
+        gf_log(this->name, GF_LOG_DEBUG, "G>P %s %10u namespace found %s",
+               uuid_utoa(local->loc.inode->gfid), info->hash, path);
+    } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
+        gf_log(this->name, GF_LOG_WARNING, "G>P %s has no path",
+               uuid_utoa(local->loc.inode->gfid));
+    } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "G>P %s winding failed, still have gfid",
+               uuid_utoa(local->loc.inode->gfid));
+    }
 
 out:
-        /* Make sure to clean up local finally. */
+    /* Make sure to clean up local finally. */
 
-        if (frame) {
-                frame->local = NULL;
-                STACK_DESTROY (frame->root);
-        }
+    if (frame) {
+        frame->local = NULL;
+        STACK_DESTROY(frame->root);
+    }
 
-        if (local) {
-                ns_local_cleanup (local);
-        }
+    if (local) {
+        ns_local_cleanup(local);
+    }
 
-        if (stub) {
-                call_resume (stub);
-        }
+    if (stub) {
+        call_resume(stub);
+    }
 
-        return 0;
+    return 0;
 }
 
 /* This function tries first to set a namespace based on the information that
@@ -271,133 +271,129 @@ out:
  * namespace in the inode, then trying to parse the path string in the `loc_t`
  * struct. If this fails, then it will try to call inode_path. */
 static path_parse_result_t
-set_ns_from_loc (const char *fn, call_frame_t *frame, xlator_t *this,
-                 loc_t *loc)
+set_ns_from_loc(const char *fn, call_frame_t *frame, xlator_t *this, loc_t *loc)
 {
-        path_parse_result_t ret = PATH_PARSE_RESULT_NO_PATH;
-        ns_private_t *priv      = (ns_private_t *)this->private;
-        ns_info_t *info         = &frame->root->ns_info;
-        char *path              = NULL;
+    path_parse_result_t ret = PATH_PARSE_RESULT_NO_PATH;
+    ns_private_t *priv = (ns_private_t *)this->private;
+    ns_info_t *info = &frame->root->ns_info;
+    char *path = NULL;
+
+    info->hash = 0;
+    info->found = _gf_false;
 
-        info->hash = 0;
-        info->found = _gf_false;
+    if (!priv->tag_namespaces) {
+        return ret;
+    }
+
+    /* This is our first pass at trying to get a path. Try getting
+     * from the inode context, then from the loc's path itself. */
+    if (!loc || !loc->path || !loc->inode) {
+        ret = PATH_PARSE_RESULT_NO_PATH;
+    } else if (!ns_inode_ctx_get(loc->inode, this, info)) {
+        ret = PATH_PARSE_RESULT_FOUND;
+    } else {
+        ret = parse_path(info, loc->path);
+        gf_log(this->name, GF_LOG_DEBUG, "%s: LOC retrieved path %s", fn,
+               loc->path);
 
-        if (!priv->tag_namespaces) {
-                return ret;
+        if (ret == PATH_PARSE_RESULT_FOUND) {
+            ns_inode_ctx_put(loc->inode, this, info);
         }
+    }
 
-        /* This is our first pass at trying to get a path. Try getting
-         * from the inode context, then from the loc's path itself. */
-        if (!loc || !loc->path || !loc->inode) {
-                ret = PATH_PARSE_RESULT_NO_PATH;
-        } else if (!ns_inode_ctx_get (loc->inode, this, info)) {
-                ret = PATH_PARSE_RESULT_FOUND;
-        } else {
-                ret = parse_path (info, loc->path);
-                gf_log (this->name, GF_LOG_DEBUG, "%s: LOC retrieved path %s",
-                        fn, loc->path);
-
-                if (ret == PATH_PARSE_RESULT_FOUND) {
-                        ns_inode_ctx_put (loc->inode, this, info);
-                }
+    /* Keep trying by calling inode_path next, making sure to copy
+    the loc's gfid into its inode if necessary. */
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        if (gf_uuid_is_null(loc->inode->gfid)) {
+            gf_uuid_copy(loc->inode->gfid, loc->gfid);
         }
 
-        /* Keep trying by calling inode_path next, making sure to copy
-        the loc's gfid into its inode if necessary. */
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                if (gf_uuid_is_null (loc->inode->gfid)) {
-                        gf_uuid_copy (loc->inode->gfid, loc->gfid);
-                }
-
-                if (inode_path (loc->inode, NULL, &path) >= 0 && path) {
-                        ret = parse_path (info, loc->path);
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "%s: LOC retrieved path %s", fn, path);
-
-                        if (ret == PATH_PARSE_RESULT_FOUND) {
-                                ns_inode_ctx_put (loc->inode, this, info);
-                        }
-                }
-
-                if (path) {
-                        GF_FREE (path);
-                }
+        if (inode_path(loc->inode, NULL, &path) >= 0 && path) {
+            ret = parse_path(info, loc->path);
+            gf_log(this->name, GF_LOG_DEBUG, "%s: LOC retrieved path %s", fn,
+                   path);
+
+            if (ret == PATH_PARSE_RESULT_FOUND) {
+                ns_inode_ctx_put(loc->inode, this, info);
+            }
         }
 
-        /* Report our status, and if we have a GFID, we'll eventually try a
-         * GET_ANCESTRY_PATH_KEY wind when we return from this function. */
-        if (ret == PATH_PARSE_RESULT_FOUND) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "%s: LOC %s %10u namespace found for %s", fn,
-                        uuid_utoa (loc->inode->gfid), info->hash, loc->path);
-        } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
-                gf_log (this->name, GF_LOG_WARNING, "%s: LOC has no path", fn);
-        } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                /* Make sure to copy the inode's gfid for the eventual wind. */
-                if (gf_uuid_is_null (loc->inode->gfid)) {
-                        gf_uuid_copy (loc->inode->gfid, loc->gfid);
-                }
-
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "%s: LOC %s winding, looking for path", fn,
-                        uuid_utoa (loc->inode->gfid));
+        if (path) {
+            GF_FREE(path);
         }
+    }
 
-        return ret;
+    /* Report our status, and if we have a GFID, we'll eventually try a
+     * GET_ANCESTRY_PATH_KEY wind when we return from this function. */
+    if (ret == PATH_PARSE_RESULT_FOUND) {
+        gf_log(this->name, GF_LOG_DEBUG,
+               "%s: LOC %s %10u namespace found for %s", fn,
+               uuid_utoa(loc->inode->gfid), info->hash, loc->path);
+    } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
+        gf_log(this->name, GF_LOG_WARNING, "%s: LOC has no path", fn);
+    } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        /* Make sure to copy the inode's gfid for the eventual wind. */
+        if (gf_uuid_is_null(loc->inode->gfid)) {
+            gf_uuid_copy(loc->inode->gfid, loc->gfid);
+        }
+
+        gf_log(this->name, GF_LOG_DEBUG, "%s: LOC %s winding, looking for path",
+               fn, uuid_utoa(loc->inode->gfid));
+    }
+
+    return ret;
 }
 
 /* This function tries first to set a namespace based on the information that
  * it can retrieve from an `fd_t`. This includes first looking for a cached
  * namespace in the inode, then trying to call inode_path manually. */
 static path_parse_result_t
-set_ns_from_fd (const char *fn, call_frame_t *frame, xlator_t *this, fd_t *fd)
+set_ns_from_fd(const char *fn, call_frame_t *frame, xlator_t *this, fd_t *fd)
 {
-        path_parse_result_t  ret  = PATH_PARSE_RESULT_NO_PATH;
-        ns_private_t        *priv = (ns_private_t *)this->private;
-        ns_info_t           *info = &frame->root->ns_info;
-        char                *path = NULL;
-
-        info->hash = 0;
-        info->found = _gf_false;
-
-        if (!priv->tag_namespaces) {
-                return ret;
-        }
+    path_parse_result_t ret = PATH_PARSE_RESULT_NO_PATH;
+    ns_private_t *priv = (ns_private_t *)this->private;
+    ns_info_t *info = &frame->root->ns_info;
+    char *path = NULL;
 
-        /* This is our first pass at trying to get a path. Try getting
-         * from the inode context, then inode_path. */
-        if (!fd || !fd->inode) {
-                ret = PATH_PARSE_RESULT_NO_PATH;
-        } else if (!ns_inode_ctx_get (fd->inode, this, info)) {
-                ret = PATH_PARSE_RESULT_FOUND;
-        } else if (inode_path (fd->inode, NULL, &path) >= 0 && path) {
-                ret = parse_path (info, path);
-                gf_log (this->name, GF_LOG_DEBUG, "%s: FD  retrieved path %s",
-                        fn, path);
-
-                if (ret == PATH_PARSE_RESULT_FOUND) {
-                        ns_inode_ctx_put (fd->inode, this, info);
-                }
-        }
+    info->hash = 0;
+    info->found = _gf_false;
 
-        if (path) {
-                GF_FREE (path);
-        }
+    if (!priv->tag_namespaces) {
+        return ret;
+    }
+
+    /* This is our first pass at trying to get a path. Try getting
+     * from the inode context, then inode_path. */
+    if (!fd || !fd->inode) {
+        ret = PATH_PARSE_RESULT_NO_PATH;
+    } else if (!ns_inode_ctx_get(fd->inode, this, info)) {
+        ret = PATH_PARSE_RESULT_FOUND;
+    } else if (inode_path(fd->inode, NULL, &path) >= 0 && path) {
+        ret = parse_path(info, path);
+        gf_log(this->name, GF_LOG_DEBUG, "%s: FD  retrieved path %s", fn, path);
 
-        /* Report our status, and if we have a GFID, we'll eventually try a
-         * GET_ANCESTRY_PATH_KEY wind when we return from this function. */
         if (ret == PATH_PARSE_RESULT_FOUND) {
-                gf_log (this->name, GF_LOG_DEBUG, "%s: FD  %s %10u namespace found",
-                        fn, uuid_utoa (fd->inode->gfid), info->hash);
-        } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
-                gf_log (this->name, GF_LOG_WARNING, "%s: FD  has no path", fn);
-        } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                gf_log (this->name, GF_LOG_DEBUG,
-                        "%s: FD  %s winding, looking for path",
-                        fn, uuid_utoa (fd->inode->gfid));
-        }
-
-        return ret;
+            ns_inode_ctx_put(fd->inode, this, info);
+        }
+    }
+
+    if (path) {
+        GF_FREE(path);
+    }
+
+    /* Report our status, and if we have a GFID, we'll eventually try a
+     * GET_ANCESTRY_PATH_KEY wind when we return from this function. */
+    if (ret == PATH_PARSE_RESULT_FOUND) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s: FD  %s %10u namespace found", fn,
+               uuid_utoa(fd->inode->gfid), info->hash);
+    } else if (ret == PATH_PARSE_RESULT_NO_PATH) {
+        gf_log(this->name, GF_LOG_WARNING, "%s: FD  has no path", fn);
+    } else if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        gf_log(this->name, GF_LOG_DEBUG, "%s: FD  %s winding, looking for path",
+               fn, uuid_utoa(fd->inode->gfid));
+    }
+
+    return ret;
 }
 
 /* This macro does the work of winding down a call of `getxattr` in the case
@@ -405,963 +401,933 @@ set_ns_from_fd (const char *fn, call_frame_t *frame, xlator_t *this, fd_t *fd)
  * called `wind` and the existence of several basic variables (frame, this),
  * but otherwise is general enough for any fop (fd- or loc-based.) */
 #define GET_ANCESTRY_PATH_WIND(fop, inode, args...)                            \
-        do {                                                                   \
-                ns_info_t *info         = &frame->root->ns_info;               \
-                call_frame_t *new_frame = NULL;                                \
-                ns_local_t *local       = NULL;                                \
-                call_stub_t *stub       = NULL;                                \
+    do {                                                                       \
+        ns_info_t *info = &frame->root->ns_info;                               \
+        call_frame_t *new_frame = NULL;                                        \
+        ns_local_t *local = NULL;                                              \
+        call_stub_t *stub = NULL;                                              \
                                                                                \
-                gf_log (this->name, GF_LOG_DEBUG,                              \
-                        "    %s winding, looking for path",                    \
-                        uuid_utoa (inode->gfid));                              \
+        gf_log(this->name, GF_LOG_DEBUG, "    %s winding, looking for path",   \
+               uuid_utoa(inode->gfid));                                        \
                                                                                \
-                new_frame = create_frame (this, this->ctx->pool);              \
-                if (!new_frame) {                                              \
-                        gf_log (this->name, GF_LOG_ERROR,                      \
-                                "Cannot allocate new call frame.");            \
-                        goto wind;                                             \
-                }                                                              \
+        new_frame = create_frame(this, this->ctx->pool);                       \
+        if (!new_frame) {                                                      \
+            gf_log(this->name, GF_LOG_ERROR,                                   \
+                   "Cannot allocate new call frame.");                         \
+            goto wind;                                                         \
+        }                                                                      \
                                                                                \
-                stub = fop_##fop##_stub (frame, default_##fop, args);          \
-                if (!stub) {                                                   \
-                        gf_log (this->name, GF_LOG_ERROR,                      \
-                                "Cannot allocate function stub.");             \
-                        goto wind;                                             \
-                }                                                              \
+        stub = fop_##fop##_stub(frame, default_##fop, args);                   \
+        if (!stub) {                                                           \
+            gf_log(this->name, GF_LOG_ERROR,                                   \
+                   "Cannot allocate function stub.");                          \
+            goto wind;                                                         \
+        }                                                                      \
                                                                                \
-                new_frame->root->uid = 0;                                      \
-                new_frame->root->gid = 0;                                      \
-                /* Put a phony "not found" NS info into this call. */          \
-                new_frame->root->ns_info = *info;                              \
+        new_frame->root->uid = 0;                                              \
+        new_frame->root->gid = 0;                                              \
+        /* Put a phony "not found" NS info into this call. */                  \
+        new_frame->root->ns_info = *info;                                      \
                                                                                \
-                local = ns_local_new (stub, inode);                            \
-                if (!local) {                                                  \
-                        gf_log (this->name, GF_LOG_ERROR,                      \
-                                "Cannot allocate function local.");            \
-                        goto wind;                                             \
-                }                                                              \
+        local = ns_local_new(stub, inode);                                     \
+        if (!local) {                                                          \
+            gf_log(this->name, GF_LOG_ERROR,                                   \
+                   "Cannot allocate function local.");                         \
+            goto wind;                                                         \
+        }                                                                      \
                                                                                \
-                new_frame->local = local;                                      \
-                /* After allocating a new frame, a call stub (to               \
-                 * resume our current fop), and a local variables              \
-                 * struct (for our loc to getxattr and our resume              \
-                 * stub), call getxattr and unwind to get_path_resume_cbk.     \
-                 */                                                            \
-                STACK_WIND (new_frame, get_path_resume_cbk,                    \
-                            FIRST_CHILD (this),                                \
-                            FIRST_CHILD (this)->fops->getxattr, &local->loc,   \
-                            GET_ANCESTRY_PATH_KEY, NULL);                      \
-        } while (0)
+        new_frame->local = local;                                              \
+        /* After allocating a new frame, a call stub (to                       \
+         * resume our current fop), and a local variables                      \
+         * struct (for our loc to getxattr and our resume                      \
+         * stub), call getxattr and unwind to get_path_resume_cbk.             \
+         */                                                                    \
+        STACK_WIND(new_frame, get_path_resume_cbk, FIRST_CHILD(this),          \
+                   FIRST_CHILD(this)->fops->getxattr, &local->loc,             \
+                   GET_ANCESTRY_PATH_KEY, NULL);                               \
+    } while (0)
 
 int32_t
-ns_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
-          dict_t *xdata)
+ns_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
+         dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (rmdir, loc->inode, loc, xflags, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_rmdir_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->rmdir, loc, xflags, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(rmdir, loc->inode, loc, xflags, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_rmdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->rmdir, loc, xflags, xdata);
+    return 0;
 }
 
 int32_t
-ns_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
-           dict_t *xdata)
+ns_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
+          dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (unlink, loc->inode, loc, xflags, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->unlink, loc, xflags, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(unlink, loc->inode, loc, xflags, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->unlink, loc, xflags, xdata);
+    return 0;
 }
 
 int32_t
-ns_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-           dict_t *xdata)
+ns_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+          dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, newloc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this,
+                                              newloc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (rename, newloc->inode, oldloc, newloc,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_rename_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->rename, oldloc, newloc, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(rename, newloc->inode, oldloc, newloc, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_rename_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
+    return 0;
 }
 
 int32_t
-ns_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-         dict_t *xdata)
+ns_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+        dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, newloc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this,
+                                              newloc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (link, newloc->inode, oldloc, newloc,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_link_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->link, oldloc, newloc, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(link, newloc->inode, oldloc, newloc, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_link_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
+    return 0;
 }
 
 int32_t
-ns_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          mode_t umask, dict_t *xdata)
+ns_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+         mode_t umask, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (mkdir, loc->inode, loc, mode, umask,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_mkdir_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->mkdir, loc, mode, umask, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(mkdir, loc->inode, loc, mode, umask, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_mkdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata);
+    return 0;
 }
 
 int32_t
-ns_symlink (call_frame_t *frame, xlator_t *this, const char *linkname,
-            loc_t *loc, mode_t umask, dict_t *xdata)
+ns_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
+           loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (symlink, loc->inode, linkname, loc,
-                                        umask, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_symlink_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->symlink, linkname, loc, umask,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(symlink, loc->inode, linkname, loc, umask,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_symlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata);
+    return 0;
 }
 
 int32_t
-ns_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dev_t dev, mode_t umask, dict_t *xdata)
+ns_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+         dev_t dev, mode_t umask, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (mknod, loc->inode, loc, mode, dev,
-                                        umask, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_mknod_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->mknod, loc, mode, dev, umask,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(mknod, loc->inode, loc, mode, dev, umask, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_mknod_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->mknod, loc, mode, dev, umask, xdata);
+    return 0;
 }
 
 int32_t
-ns_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+ns_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+          mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (create, loc->inode, loc, flags, mode,
-                                        umask, fd, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_create_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->create, loc, flags, mode, umask,
-                    fd, xdata);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(create, loc->inode, loc, flags, mode, umask, fd,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_create_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
+               xdata);
+    return 0;
 }
 
 int32_t
-ns_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
-             int32_t valid, dict_t *xdata)
+ns_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
+            int32_t valid, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fsetattr, fd->inode, fd, stbuf, valid,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fsetattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fsetattr, fd->inode, fd, stbuf, valid, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fsetattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
+    return 0;
 }
 
 int32_t
-ns_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
-            int32_t valid, dict_t *xdata)
+ns_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
+           int32_t valid, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (setattr, loc->inode, loc, stbuf, valid,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_setattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(setattr, loc->inode, loc, stbuf, valid, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
+    return 0;
 }
 
 int32_t
-ns_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name, dict_t *xdata)
+ns_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
+                dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fremovexattr, fd->inode, fd, name,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fremovexattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fremovexattr, fd, name, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fremovexattr, fd->inode, fd, name, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fremovexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
+    return 0;
 }
 
 int32_t
-ns_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name, dict_t *xdata)
+ns_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
+               const char *name, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (removexattr, loc->inode, loc, name,
-                                        xdata);
-                return 0;
-        }
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(removexattr, loc->inode, loc, name, xdata);
+        return 0;
+    }
 wind:
-        STACK_WIND (frame, default_removexattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->removexattr, loc, name, xdata);
+    STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
+    return 0;
+}
+
+int32_t
+ns_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+            int32_t flags, dict_t *xdata)
+{
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
+
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(setxattr, loc->inode, loc, dict, flags, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_setxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
+    return 0;
 }
 
 int32_t
-ns_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+ns_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
              int32_t flags, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (setxattr, loc->inode, loc, dict, flags,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_setxattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->setxattr, loc, dict, flags,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fsetxattr, fd->inode, fd, dict, flags, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fsetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
+    return 0;
 }
 
 int32_t
-ns_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int32_t flags, dict_t *xdata)
+ns_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+            dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fsetxattr, fd->inode, fd, dict, flags,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fsetxattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsetxattr, fd, dict, flags,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(truncate, loc->inode, loc, offset, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
+    return 0;
 }
 
 int32_t
-ns_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+ns_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
              dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (truncate, loc->inode, loc, offset,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_truncate_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->truncate, loc, offset, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(ftruncate, fd->inode, fd, offset, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
+    return 0;
 }
 
 int32_t
-ns_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              dict_t *xdata)
+ns_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
+          int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
+          dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (ftruncate, fd->inode, fd, offset,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_ftruncate_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->ftruncate, fd, offset, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(writev, fd->inode, fd, vector, count, offset,
+                               flags, iobref, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
+               flags, iobref, xdata);
+    return 0;
 }
 
 int32_t
-ns_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-           int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
-           dict_t *xdata)
+ns_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (writev, fd->inode, fd, vector, count,
-                                        offset, flags, iobref, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_writev_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->writev, fd, vector, count, offset,
-                    flags, iobref, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(lookup, loc->inode, loc, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_lookup_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lookup, loc, xdata);
+    return 0;
 }
 
 int32_t
-ns_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+ns_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (lookup, loc->inode, loc, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_lookup_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->lookup, loc, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(stat, loc->inode, loc, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_stat_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->stat, loc, xdata);
+    return 0;
 }
 
 int32_t
-ns_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+ns_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (stat, loc->inode, loc, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_stat_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->stat, loc, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fstat, fd->inode, fd, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fstat_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fstat, fd, xdata);
+    return 0;
 }
 
 int32_t
-ns_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+ns_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+            dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fstat, fd->inode, fd, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fstat_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fstat, fd, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(readlink, loc->inode, loc, size, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_readlink_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readlink, loc, size, xdata);
+    return 0;
 }
 
 int32_t
-ns_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-             dict_t *xdata)
+ns_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
+          dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (readlink, loc->inode, loc, size, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_readlink_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->readlink, loc, size, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(access, loc->inode, loc, mask, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_access_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->access, loc, mask, xdata);
+    return 0;
 }
 
 int32_t
-ns_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-           dict_t *xdata)
+ns_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
+        fd_t *fd, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (access, loc->inode, loc, mask, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_access_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->access, loc, mask, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(open, fd->inode, loc, flags, fd, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_open_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
+    return 0;
 }
 
 int32_t
-ns_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, dict_t *xdata)
+ns_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+         off_t offset, uint32_t flags, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (open, fd->inode, loc, flags, fd, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_open_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->open, loc, flags, fd, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(readv, fd->inode, fd, size, offset, flags,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata);
+    return 0;
 }
 
 int32_t
-ns_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-          off_t offset, uint32_t flags, dict_t *xdata)
+ns_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (readv, fd->inode, fd, size, offset,
-                                        flags, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_readv_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->readv, fd, size, offset, flags,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(flush, fd->inode, fd, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_flush_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->flush, fd, xdata);
+    return 0;
 }
 
 int32_t
-ns_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
+ns_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
+         dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (flush, fd->inode, fd, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_flush_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->flush, fd, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fsync, fd->inode, fd, datasync, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata);
+    return 0;
 }
 
 int32_t
-ns_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-          dict_t *xdata)
+ns_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+           dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fsync, fd->inode, fd, datasync, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fsync_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsync, fd, datasync, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(opendir, loc->inode, loc, fd, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_opendir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->opendir, loc, fd, xdata);
+    return 0;
 }
 
 int32_t
-ns_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
+ns_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
             dict_t *xdata)
+
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (opendir, loc->inode, loc, fd, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_opendir_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->opendir, loc, fd, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fsyncdir, fd->inode, fd, datasync, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fsyncdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fsyncdir, fd, datasync, xdata);
+    return 0;
 }
 
 int32_t
-ns_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-             dict_t *xdata)
-
+ns_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+             int32_t len, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fsyncdir, fd->inode, fd, datasync,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fsyncdir_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsyncdir, fd, datasync, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(rchecksum, fd->inode, fd, offset, len, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_rchecksum_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata);
+    return 0;
 }
 
 int32_t
-ns_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              int32_t len, dict_t *xdata)
+ns_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (rchecksum, fd->inode, fd, offset, len,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_rchecksum_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->rchecksum, fd, offset, len,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(statfs, loc->inode, loc, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_statfs_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->statfs, loc, xdata);
+    return 0;
 }
 
 int32_t
-ns_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+ns_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+           int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (statfs, loc->inode, loc, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_statfs_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->statfs, loc, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(inodelk, loc->inode, volume, loc, cmd, flock,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_inodelk_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->inodelk, volume, loc, cmd, flock,
+               xdata);
+    return 0;
 }
 
 int32_t
-ns_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+ns_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
             int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (inodelk, loc->inode, volume, loc, cmd,
-                                        flock, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_inodelk_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->inodelk, volume, loc, cmd, flock,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(finodelk, fd->inode, volume, fd, cmd, flock,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_finodelk_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->finodelk, volume, fd, cmd, flock,
+               xdata);
+    return 0;
 }
 
 int32_t
-ns_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-             int32_t cmd, struct gf_flock *flock, dict_t *xdata)
+ns_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+           const char *basename, entrylk_cmd cmd, entrylk_type type,
+           dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (finodelk, fd->inode, volume, fd, cmd,
-                                        flock, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_finodelk_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->finodelk, volume, fd, cmd, flock,
-                    xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(entrylk, loc->inode, volume, loc, basename, cmd,
+                               type, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_entrylk_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->entrylk, volume, loc, basename, cmd,
+               type, xdata);
+    return 0;
 }
 
 int32_t
-ns_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc,
+ns_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
             const char *basename, entrylk_cmd cmd, entrylk_type type,
             dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (entrylk, loc->inode, volume, loc,
-                                        basename, cmd, type, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_entrylk_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->entrylk, volume, loc, basename,
-                    cmd, type, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fentrylk, fd->inode, volume, fd, basename, cmd,
+                               type, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fentrylk_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fentrylk, volume, fd, basename, cmd,
+               type, xdata);
+    return 0;
 }
 
 int32_t
-ns_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd,
-             const char *basename, entrylk_cmd cmd, entrylk_type type,
+ns_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
              dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fentrylk, fd->inode, volume, fd,
-                                        basename, cmd, type, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fentrylk_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fentrylk, volume, fd, basename,
-                    cmd, type, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fgetxattr, fd->inode, fd, name, xdata);
         return 0;
-}
-
-int32_t
-ns_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
-              dict_t *xdata)
-{
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
-
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fgetxattr, fd->inode, fd, name, xdata);
-                return 0;
-        }
+    }
 wind:
-        STACK_WIND (frame, default_fgetxattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fgetxattr, fd, name, xdata);
-        return 0;
+    STACK_WIND(frame, default_fgetxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
+    return 0;
 }
 
 int32_t
-ns_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
-             dict_t *xdata)
+ns_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
+            dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (getxattr, loc->inode, loc, name, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->getxattr, loc, name, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(getxattr, loc->inode, loc, name, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_getxattr_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
+    return 0;
 }
 
 int32_t
-ns_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-       struct gf_flock *flock, dict_t *xdata)
+ns_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
+      struct gf_flock *flock, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (lk, fd->inode, fd, cmd, flock, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_lk_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->lk, fd, cmd, flock, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(lk, fd->inode, fd, cmd, flock, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_lk_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->lk, fd, cmd, flock, xdata);
+    return 0;
 }
 
 int32_t
-ns_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-            off_t offset, dict_t *xdata)
+ns_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+           off_t offset, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (readdir, fd->inode, fd, size, offset,
-                                        xdata);
-                return 0;
-        }
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(readdir, fd->inode, fd, size, offset, xdata);
+        return 0;
+    }
 wind:
-        STACK_WIND (frame, default_readdir_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->readdir, fd, size, offset, xdata);
+    STACK_WIND(frame, default_readdir_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-ns_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, dict_t *dict)
+ns_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+            off_t offset, dict_t *dict)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (readdirp, fd->inode, fd, size, offset,
-                                        dict);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_readdirp_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->readdirp, fd, size, offset, dict);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(readdirp, fd->inode, fd, size, offset, dict);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_readdirp_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict);
+    return 0;
 }
 
 int32_t
-ns_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+ns_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc,
+           gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_loc (__FUNCTION__, frame, this, loc);
+    path_parse_result_t ret = set_ns_from_loc(__FUNCTION__, frame, this, loc);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (xattrop, loc->inode, loc, flags, dict,
-                                        xdata);
-                return 0;
-        }
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(xattrop, loc->inode, loc, flags, dict, xdata);
+        return 0;
+    }
 wind:
-        STACK_WIND (frame, default_xattrop_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->xattrop, loc, flags, dict, xdata);
+    STACK_WIND(frame, default_xattrop_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->xattrop, loc, flags, dict, xdata);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-ns_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-             gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
+ns_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd,
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fxattrop, fd->inode, fd, flags, dict,
-                                        xdata);
-                return 0;
-        }
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fxattrop, fd->inode, fd, flags, dict, xdata);
+        return 0;
+    }
 wind:
-        STACK_WIND (frame, default_fxattrop_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fxattrop, fd, flags, dict, xdata);
+    STACK_WIND(frame, default_fxattrop_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict, xdata);
 
-        return 0;
+    return 0;
 }
 
-
 int32_t
-ns_getspec (call_frame_t *frame, xlator_t *this, const char *key, int32_t flag)
+ns_getspec(call_frame_t *frame, xlator_t *this, const char *key, int32_t flag)
 {
-        STACK_WIND (frame, default_getspec_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->getspec, key, flag);
-        return 0;
+    STACK_WIND(frame, default_getspec_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->getspec, key, flag);
+    return 0;
 }
 
 int32_t
-ns_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size,
-              off_t offset, size_t len, dict_t *xdata)
+ns_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size,
+             off_t offset, size_t len, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (fallocate, fd->inode, fd, keep_size,
-                                        offset, len, xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_fallocate_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fallocate, fd, keep_size, offset,
-                    len, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(fallocate, fd->inode, fd, keep_size, offset, len,
+                               xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_fallocate_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->fallocate, fd, keep_size, offset, len,
+               xdata);
+    return 0;
 }
 
 int32_t
-ns_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            size_t len, dict_t *xdata)
+ns_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+           size_t len, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (discard, fd->inode, fd, offset, len,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_discard_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->discard, fd, offset, len, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(discard, fd->inode, fd, offset, len, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_discard_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata);
+    return 0;
 }
 
 int32_t
-ns_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             off_t len, dict_t *xdata)
+ns_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+            off_t len, dict_t *xdata)
 {
-        path_parse_result_t ret = set_ns_from_fd (__FUNCTION__, frame, this, fd);
+    path_parse_result_t ret = set_ns_from_fd(__FUNCTION__, frame, this, fd);
 
-        if (ret == PATH_PARSE_RESULT_IS_GFID) {
-                GET_ANCESTRY_PATH_WIND (zerofill, fd->inode, fd, offset, len,
-                                        xdata);
-                return 0;
-        }
-wind:
-        STACK_WIND (frame, default_zerofill_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->zerofill, fd, offset, len, xdata);
+    if (ret == PATH_PARSE_RESULT_IS_GFID) {
+        GET_ANCESTRY_PATH_WIND(zerofill, fd->inode, fd, offset, len, xdata);
         return 0;
+    }
+wind:
+    STACK_WIND(frame, default_zerofill_cbk, FIRST_CHILD(this),
+               FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata);
+    return 0;
 }
 
 int
-ns_forget (xlator_t *this, inode_t *inode)
+ns_forget(xlator_t *this, inode_t *inode)
 {
-        uint64_t ns_as_64 = 0;
-        ns_info_t *info   = NULL;
+    uint64_t ns_as_64 = 0;
+    ns_info_t *info = NULL;
 
-        inode_ctx_del (inode, this, &ns_as_64);
+    inode_ctx_del(inode, this, &ns_as_64);
 
-        if (!ns_as_64) {
-                return 0;
-        }
+    if (!ns_as_64) {
+        return 0;
+    }
 
-        info = (ns_info_t *)ns_as_64;
-        GF_FREE (info);
+    info = (ns_info_t *)ns_as_64;
+    GF_FREE(info);
 
-        return 0;
+    return 0;
 }
 
 int32_t
-init (xlator_t *this)
+init(xlator_t *this)
 {
-        int32_t ret        = -1;
-        ns_private_t *priv = NULL;
+    int32_t ret = -1;
+    ns_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO (GF_NAMESPACE, this, out);
+    GF_VALIDATE_OR_GOTO(GF_NAMESPACE, this, out);
 
-        if (!this->children || this->children->next) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "translator needs a single subvolume.");
-                goto out;
-        }
+    if (!this->children || this->children->next) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "translator needs a single subvolume.");
+        goto out;
+    }
 
-        if (!this->parents) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "dangling volume. please check volfile.");
-                goto out;
-        }
+    if (!this->parents) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "dangling volume. please check volfile.");
+        goto out;
+    }
 
-        priv = GF_CALLOC (1, sizeof (ns_private_t), 0);
+    priv = GF_CALLOC(1, sizeof(ns_private_t), 0);
 
-        if (!priv) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "Can't allocate ns_priv structure.");
-                goto out;
-        }
+    if (!priv) {
+        gf_log(this->name, GF_LOG_ERROR, "Can't allocate ns_priv structure.");
+        goto out;
+    }
 
-        GF_OPTION_INIT ("tag-namespaces", priv->tag_namespaces, bool, out);
+    GF_OPTION_INIT("tag-namespaces", priv->tag_namespaces, bool, out);
 
-        gf_log (this->name, GF_LOG_INFO, "Namespace xlator loaded");
-        this->private = priv;
-        ret           = 0;
+    gf_log(this->name, GF_LOG_INFO, "Namespace xlator loaded");
+    this->private = priv;
+    ret = 0;
 
 out:
-        if (ret) {
-                GF_FREE (priv);
-        }
+    if (ret) {
+        GF_FREE(priv);
+    }
 
-        return ret;
+    return ret;
 }
 
 void
-fini (xlator_t *this)
+fini(xlator_t *this)
 {
-        GF_FREE (this->private);
+    GF_FREE(this->private);
 }
 
 int
-reconfigure (xlator_t *this, dict_t *options)
+reconfigure(xlator_t *this, dict_t *options)
 {
-        int ret            = -1;
-        ns_private_t *priv = NULL;
+    int ret = -1;
+    ns_private_t *priv = NULL;
 
-        GF_VALIDATE_OR_GOTO (this->name, this, out);
-        GF_VALIDATE_OR_GOTO (this->name, this->private, out);
-        GF_VALIDATE_OR_GOTO (this->name, options, out);
+    GF_VALIDATE_OR_GOTO(this->name, this, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
+    GF_VALIDATE_OR_GOTO(this->name, options, out);
 
-        priv = (ns_private_t *)this->private;
+    priv = (ns_private_t *)this->private;
 
-        GF_OPTION_RECONF ("tag-namespaces", priv->tag_namespaces, options, bool,
-                          out);
+    GF_OPTION_RECONF("tag-namespaces", priv->tag_namespaces, options, bool,
+                     out);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 struct xlator_fops fops = {
-        .lookup       = ns_lookup,
-        .stat         = ns_stat,
-        .fstat        = ns_fstat,
-        .truncate     = ns_truncate,
-        .ftruncate    = ns_ftruncate,
-        .access       = ns_access,
-        .readlink     = ns_readlink,
-        .mknod        = ns_mknod,
-        .mkdir        = ns_mkdir,
-        .unlink       = ns_unlink,
-        .rmdir        = ns_rmdir,
-        .symlink      = ns_symlink,
-        .rename       = ns_rename,
-        .link         = ns_link,
-        .create       = ns_create,
-        .open         = ns_open,
-        .readv        = ns_readv,
-        .writev       = ns_writev,
-        .flush        = ns_flush,
-        .fsync        = ns_fsync,
-        .opendir      = ns_opendir,
-        .readdir      = ns_readdir,
-        .readdirp     = ns_readdirp,
-        .fsyncdir     = ns_fsyncdir,
-        .statfs       = ns_statfs,
-        .setxattr     = ns_setxattr,
-        .getxattr     = ns_getxattr,
-        .fsetxattr    = ns_fsetxattr,
-        .fgetxattr    = ns_fgetxattr,
-        .removexattr  = ns_removexattr,
-        .fremovexattr = ns_fremovexattr,
-        .lk           = ns_lk,
-        .inodelk      = ns_inodelk,
-        .finodelk     = ns_finodelk,
-        .entrylk      = ns_entrylk,
-        .fentrylk     = ns_fentrylk,
-        .rchecksum    = ns_rchecksum,
-        .xattrop      = ns_xattrop,
-        .fxattrop     = ns_fxattrop,
-        .setattr      = ns_setattr,
-        .fsetattr     = ns_fsetattr,
-        .getspec      = ns_getspec,
-        .fallocate    = ns_fallocate,
-        .discard      = ns_discard,
-        .zerofill     = ns_zerofill,
+    .lookup = ns_lookup,
+    .stat = ns_stat,
+    .fstat = ns_fstat,
+    .truncate = ns_truncate,
+    .ftruncate = ns_ftruncate,
+    .access = ns_access,
+    .readlink = ns_readlink,
+    .mknod = ns_mknod,
+    .mkdir = ns_mkdir,
+    .unlink = ns_unlink,
+    .rmdir = ns_rmdir,
+    .symlink = ns_symlink,
+    .rename = ns_rename,
+    .link = ns_link,
+    .create = ns_create,
+    .open = ns_open,
+    .readv = ns_readv,
+    .writev = ns_writev,
+    .flush = ns_flush,
+    .fsync = ns_fsync,
+    .opendir = ns_opendir,
+    .readdir = ns_readdir,
+    .readdirp = ns_readdirp,
+    .fsyncdir = ns_fsyncdir,
+    .statfs = ns_statfs,
+    .setxattr = ns_setxattr,
+    .getxattr = ns_getxattr,
+    .fsetxattr = ns_fsetxattr,
+    .fgetxattr = ns_fgetxattr,
+    .removexattr = ns_removexattr,
+    .fremovexattr = ns_fremovexattr,
+    .lk = ns_lk,
+    .inodelk = ns_inodelk,
+    .finodelk = ns_finodelk,
+    .entrylk = ns_entrylk,
+    .fentrylk = ns_fentrylk,
+    .rchecksum = ns_rchecksum,
+    .xattrop = ns_xattrop,
+    .fxattrop = ns_fxattrop,
+    .setattr = ns_setattr,
+    .fsetattr = ns_fsetattr,
+    .getspec = ns_getspec,
+    .fallocate = ns_fallocate,
+    .discard = ns_discard,
+    .zerofill = ns_zerofill,
 };
 
 struct xlator_cbks cbks = {
-        .forget = ns_forget,
+    .forget = ns_forget,
 };
 
 struct xlator_dumpops dumpops;
 
 struct volume_options options[] = {
-        {
-        .key           = { "tag-namespaces" },
-        .type          = GF_OPTION_TYPE_BOOL,
+    {
+        .key = {"tag-namespaces"},
+        .type = GF_OPTION_TYPE_BOOL,
         .default_value = "off",
-        .description   = "This option enables this translator's functionality "
+        .description = "This option enables this translator's functionality "
                        "that tags every fop with a namespace hash for later "
                        "throttling, stats collection, logging, etc.",
-        .op_version    = {GD_OP_VERSION_4_1_0},
-        .tags          = {"namespace"},
-        .flags         = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
-        },
-        {.key = { NULL } },
+        .op_version = {GD_OP_VERSION_4_1_0},
+        .tags = {"namespace"},
+        .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC,
+    },
+    {.key = {NULL}},
 };