summaryrefslogtreecommitdiffstats
path: root/xlators/features/namespace
diff options
context:
space:
mode:
authorGluster Ant <bugzilla-bot@gluster.org>2018-09-12 17:52:45 +0530
committerNigel Babu <nigelb@redhat.com>2018-09-12 17:52:45 +0530
commite16868dede6455cab644805af6fe1ac312775e13 (patch)
tree15aebdb4fff2d87cf8a72f836816b3aa634da58d /xlators/features/namespace
parent45a71c0548b6fd2c757aa2e7b7671a1411948894 (diff)
Land part 2 of clang-format changes
Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4 Signed-off-by: Nigel Babu <nigelb@redhat.com>
Diffstat (limited to 'xlators/features/namespace')
-rw-r--r--xlators/features/namespace/src/namespace.c1784
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}},
};