summaryrefslogtreecommitdiffstats
path: root/xlators/mount/fuse/src/fuse-resolve.c
diff options
context:
space:
mode:
Diffstat (limited to 'xlators/mount/fuse/src/fuse-resolve.c')
-rw-r--r--xlators/mount/fuse/src/fuse-resolve.c1009
1 files changed, 477 insertions, 532 deletions
diff --git a/xlators/mount/fuse/src/fuse-resolve.c b/xlators/mount/fuse/src/fuse-resolve.c
index dd248f3d9..8565ce0e4 100644
--- a/xlators/mount/fuse/src/fuse-resolve.c
+++ b/xlators/mount/fuse/src/fuse-resolve.c
@@ -1,22 +1,12 @@
/*
- Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
- This file is part of GlusterFS.
-
- GlusterFS is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3 of the License,
- or (at your option) any later version.
-
- GlusterFS is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see
- <http://www.gnu.org/licenses/>.
-*/
+ Copyright (c) 2010-2012 Red Hat, Inc. <http://www.redhat.com>
+ This file is part of GlusterFS.
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
@@ -25,618 +15,638 @@
#include "fuse-bridge.h"
static int
-gf_resolve_all (fuse_state_t *state);
-static int
-resolve_entry_simple (fuse_state_t *state);
-static int
-resolve_inode_simple (fuse_state_t *state);
-static int
-resolve_path_simple (fuse_state_t *state);
-
-static int
-component_count (const char *path)
-{
- int count = 0;
- const char *trav = NULL;
-
- for (trav = path; *trav; trav++) {
- if (*trav == '/')
- count++;
- }
+fuse_resolve_all (fuse_state_t *state);
- return count + 2;
-}
+int fuse_resolve_continue (fuse_state_t *state);
+int fuse_resolve_entry_simple (fuse_state_t *state);
+int fuse_resolve_inode_simple (fuse_state_t *state);
+int fuse_migrate_fd (xlator_t *this, fd_t *fd, xlator_t *old_subvol,
+ xlator_t *new_subvol);
+fuse_fd_ctx_t *
+fuse_fd_ctx_get (xlator_t *this, fd_t *fd);
-static int
-prepare_components (fuse_state_t *state)
-{
- xlator_t *active_xl = NULL;
- gf_resolve_t *resolve = NULL;
- char *resolved = NULL;
- struct gf_resolve_comp *components = NULL;
- char *trav = NULL;
- int count = 0;
- int i = 0;
-
- resolve = state->resolve_now;
-
- resolved = gf_strdup (resolve->path);
- resolve->resolved = resolved;
-
- count = component_count (resolve->path);
- components = GF_CALLOC (sizeof (*components), count, 0); //TODO
- if (!components)
- goto out;
- resolve->components = components;
-
- active_xl = fuse_active_subvol (state->this);
-
- components[0].basename = "";
- components[0].ino = 1;
- components[0].gen = 0;
- components[0].inode = inode_ref (active_xl->itable->root);
-
- i = 1;
- for (trav = resolved; *trav; trav++) {
- if (*trav == '/') {
- components[i].basename = trav + 1;
- *trav = 0;
- i++;
- }
- }
-out:
- return 0;
-}
-
+gf_boolean_t fuse_inode_needs_lookup (inode_t *inode, xlator_t *this);
static int
-resolve_loc_touchup (fuse_state_t *state)
+fuse_resolve_loc_touchup (fuse_state_t *state)
{
- gf_resolve_t *resolve = NULL;
- loc_t *loc = NULL;
- char *path = NULL;
- int ret = 0;
+ fuse_resolve_t *resolve = NULL;
+ loc_t *loc = NULL;
+ char *path = NULL;
+ int ret = 0;
resolve = state->resolve_now;
loc = state->loc_now;
if (!loc->path) {
- if (loc->parent) {
+ if (loc->parent && resolve->bname) {
ret = inode_path (loc->parent, resolve->bname, &path);
+ uuid_copy (loc->pargfid, loc->parent->gfid);
+ loc->name = resolve->bname;
} else if (loc->inode) {
ret = inode_path (loc->inode, NULL, &path);
+ uuid_copy (loc->gfid, loc->inode->gfid);
}
if (ret)
- gf_log ("", GF_LOG_TRACE,
+ gf_log (THIS->name, GF_LOG_TRACE,
"return value inode_path %d", ret);
-
- if (!path)
- path = gf_strdup (resolve->path);
-
loc->path = path;
}
- loc->name = strrchr (loc->path, '/');
- if (loc->name)
- loc->name++;
-
- if (!loc->parent && loc->inode) {
- loc->parent = inode_parent (loc->inode, 0, NULL);
- }
-
return 0;
}
-static int
-fuse_resolve_newfd_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, fd_t *fd)
+
+int
+fuse_resolve_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+ int op_ret, int op_errno, inode_t *inode,
+ struct iatt *buf, dict_t *xattr,
+ struct iatt *postparent)
{
- fuse_state_t *state = NULL;
- gf_resolve_t *resolve = NULL;
- fd_t *old_fd = NULL;
- fd_t *tmp_fd = NULL;
- uint64_t tmp_fd_ctx = 0;
- int ret = 0;
+ fuse_state_t *state = NULL;
+ fuse_resolve_t *resolve = NULL;
+ inode_t *link_inode = NULL;
+ loc_t *resolve_loc = NULL;
state = frame->root->state;
resolve = state->resolve_now;
+ resolve_loc = &resolve->resolve_loc;
STACK_DESTROY (frame->root);
if (op_ret == -1) {
- resolve->op_ret = -1;
+ gf_log (this->name, (op_errno == ENOENT)
+ ? GF_LOG_DEBUG : GF_LOG_WARNING,
+ "%s/%s: failed to resolve (%s)",
+ uuid_utoa (resolve_loc->pargfid), resolve_loc->name,
+ strerror (op_errno));
+ resolve->op_ret = -1;
resolve->op_errno = op_errno;
goto out;
}
- old_fd = resolve->fd;
-
- state->fd = fd_ref (fd);
+ link_inode = inode_link (inode, resolve_loc->parent,
+ resolve_loc->name, buf);
- fd_bind (fd);
+ state->loc_now->inode = link_inode;
- resolve->fd = NULL;
- ret = fd_ctx_del (old_fd, state->this, &tmp_fd_ctx);
- if (!ret) {
- tmp_fd = (fd_t *)(long)tmp_fd_ctx;
- fd_unref (tmp_fd);
- }
- ret = fd_ctx_set (old_fd, state->this, (uint64_t)(long)fd);
- if (ret)
- gf_log ("resolve", GF_LOG_WARNING,
- "failed to set the fd ctx with resolved fd");
out:
- gf_resolve_all (state);
+ loc_wipe (resolve_loc);
+
+ fuse_resolve_continue (state);
return 0;
}
-static void
-gf_resolve_new_fd (fuse_state_t *state)
+
+int
+fuse_resolve_entry (fuse_state_t *state)
{
- gf_resolve_t *resolve = NULL;
- fd_t *new_fd = NULL;
- fd_t *fd = NULL;
+ fuse_resolve_t *resolve = NULL;
+ loc_t *resolve_loc = NULL;
- resolve = state->resolve_now;
- fd = resolve->fd;
+ resolve = state->resolve_now;
+ resolve_loc = &resolve->resolve_loc;
+
+ resolve_loc->parent = inode_ref (state->loc_now->parent);
+ uuid_copy (resolve_loc->pargfid, state->loc_now->pargfid);
+ resolve_loc->name = resolve->bname;
+ resolve_loc->inode = inode_new (state->itable);
- new_fd = fd_create (state->loc.inode, state->finh->pid);
- new_fd->flags = (fd->flags & ~O_TRUNC);
+ inode_path (resolve_loc->parent, resolve_loc->name,
+ (char **) &resolve_loc->path);
- gf_log ("resolve", GF_LOG_DEBUG,
- "%"PRIu64": OPEN %s", state->finh->unique,
- state->loc.path);
+ FUSE_FOP (state, fuse_resolve_entry_cbk, GF_FOP_LOOKUP,
+ lookup, resolve_loc, NULL);
- FUSE_FOP (state, fuse_resolve_newfd_cbk, GF_FOP_OPEN,
- open, &state->loc, new_fd->flags, new_fd, 0);
+ return 0;
}
-static int
-resolve_deep_continue (fuse_state_t *state)
+
+int
+fuse_resolve_gfid_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+ int op_ret, int op_errno, inode_t *inode,
+ struct iatt *buf, dict_t *xattr, struct iatt *postparent)
{
- gf_resolve_t *resolve = NULL;
- int ret = 0;
+ fuse_state_t *state = NULL;
+ fuse_resolve_t *resolve = NULL;
+ inode_t *link_inode = NULL;
+ loc_t *loc_now = NULL;
+ state = frame->root->state;
resolve = state->resolve_now;
+ loc_now = state->loc_now;
+
+ STACK_DESTROY (frame->root);
+
+ if (op_ret == -1) {
+ gf_log (this->name, (op_errno == ENOENT)
+ ? GF_LOG_DEBUG : GF_LOG_WARNING,
+ "%s: failed to resolve (%s)",
+ uuid_utoa (resolve->resolve_loc.gfid),
+ strerror (op_errno));
+ loc_wipe (&resolve->resolve_loc);
+
+ /* resolve->op_ret can have 3 values: 0, -1, -2.
+ * 0 : resolution was successful.
+ * -1: parent inode could not be resolved.
+ * -2: entry (inode corresponding to path) could not be resolved
+ */
+
+ if (uuid_is_null (resolve->gfid)) {
+ resolve->op_ret = -1;
+ } else {
+ resolve->op_ret = -2;
+ }
+
+ resolve->op_errno = op_errno;
+ goto out;
+ }
- resolve->op_ret = 0;
- resolve->op_errno = 0;
+ loc_wipe (&resolve->resolve_loc);
- if (resolve->par)
- ret = resolve_entry_simple (state);
- else if (resolve->ino)
- ret = resolve_inode_simple (state);
- else if (resolve->path)
- ret = resolve_path_simple (state);
- if (ret)
- gf_log ("resolve", GF_LOG_TRACE,
- "return value of resolve_*_simple %d", ret);
+ link_inode = inode_link (inode, NULL, NULL, buf);
+
+ if (!link_inode)
+ goto out;
- resolve_loc_touchup (state);
+ if (!uuid_is_null (resolve->gfid)) {
+ loc_now->inode = link_inode;
+ goto out;
+ }
- /* This function is called by either fd resolve or inode resolve */
- if (!resolve->fd)
- gf_resolve_all (state);
- else
- gf_resolve_new_fd (state);
+ loc_now->parent = link_inode;
+ uuid_copy (loc_now->pargfid, link_inode->gfid);
+ fuse_resolve_entry (state);
+
+ return 0;
+out:
+ fuse_resolve_continue (state);
return 0;
}
-static int
-resolve_deep_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
- dict_t *xattr, struct iatt *postparent)
+int
+fuse_resolve_gfid (fuse_state_t *state)
{
- xlator_t *active_xl = NULL;
- fuse_state_t *state = NULL;
- gf_resolve_t *resolve = NULL;
- struct gf_resolve_comp *components = NULL;
- inode_t *link_inode = NULL;
- int i = 0;
+ fuse_resolve_t *resolve = NULL;
+ loc_t *resolve_loc = NULL;
+ int ret = 0;
- state = frame->root->state;
resolve = state->resolve_now;
- components = resolve->components;
-
- i = (long) cookie;
+ resolve_loc = &resolve->resolve_loc;
- STACK_DESTROY (frame->root);
-
- if (op_ret == -1) {
- goto get_out_of_here;
+ if (!uuid_is_null (resolve->pargfid)) {
+ uuid_copy (resolve_loc->gfid, resolve->pargfid);
+ } else if (!uuid_is_null (resolve->gfid)) {
+ uuid_copy (resolve_loc->gfid, resolve->gfid);
}
- if (i != 0) {
- inode_ref (inode);
- /* no linking for root inode */
- link_inode = inode_link (inode, resolve->deep_loc.parent,
- resolve->deep_loc.name, buf);
- components[i].inode = inode_ref (link_inode);
- link_inode = NULL;
+ /* inode may already exist in case we are looking up an inode which was
+ linked through readdirplus */
+ resolve_loc->inode = inode_find (state->itable, resolve_loc->gfid);
+ if (!resolve_loc->inode)
+ resolve_loc->inode = inode_new (state->itable);
+ ret = loc_path (resolve_loc, NULL);
+
+ if (ret <= 0) {
+ gf_log (THIS->name, GF_LOG_WARNING,
+ "failed to get the path for inode %s",
+ uuid_utoa (resolve->gfid));
}
- inode_ref (resolve->deep_loc.parent);
- inode_ref (inode);
- loc_wipe (&resolve->deep_loc);
- i++; /* next component */
-
- if (!components[i].basename) {
- /* all components of the path are resolved */
- goto get_out_of_here;
- }
-
- /* join the current component with the path resolved until now */
- *(components[i].basename - 1) = '/';
- active_xl = fuse_active_subvol (state->this);
+ FUSE_FOP (state, fuse_resolve_gfid_cbk, GF_FOP_LOOKUP,
+ lookup, resolve_loc, NULL);
- resolve->deep_loc.path = gf_strdup (resolve->resolved);
- resolve->deep_loc.parent = inode_ref (components[i-1].inode);
- resolve->deep_loc.inode = inode_new (active_xl->itable);
- resolve->deep_loc.name = components[i].basename;
-
- FUSE_FOP_COOKIE (state, active_xl, resolve_deep_cbk, (void *)(long)i,
- GF_FOP_LOOKUP, lookup, &resolve->deep_loc, NULL);
- return 0;
-
-get_out_of_here:
- resolve_deep_continue (state);
return 0;
}
-static int
-resolve_path_deep (fuse_state_t *state)
+/*
+ * Return value:
+ * 0 - resolved parent and entry (as necessary)
+ * -1 - resolved parent but not entry (though necessary)
+ * 1 - resolved neither parent nor entry
+ */
+
+int
+fuse_resolve_parent_simple (fuse_state_t *state)
{
- xlator_t *active_xl = NULL;
- gf_resolve_t *resolve = NULL;
- struct gf_resolve_comp *components = NULL;
- inode_t *inode = NULL;
- long i = 0;
+ fuse_resolve_t *resolve = NULL;
+ loc_t *loc = NULL;
+ inode_t *parent = NULL;
+ inode_t *inode = NULL;
resolve = state->resolve_now;
+ loc = state->loc_now;
+
+ loc->name = resolve->bname;
+
+ parent = resolve->parhint;
+ if (parent->table == state->itable) {
+ if (fuse_inode_needs_lookup (parent, THIS))
+ return 1;
+
+ /* no graph switches since */
+ loc->parent = inode_ref (parent);
+ uuid_copy (loc->pargfid, parent->gfid);
+ loc->inode = inode_grep (state->itable, parent, loc->name);
+
+ /* nodeid for root is 1 and we blindly take the latest graph's
+ * table->root as the parhint and because of this there is
+ * ambiguity whether the entry should have existed or not, and
+ * we took the conservative approach of assuming entry should
+ * have been there even though it need not have (bug #804592).
+ */
+ if ((loc->inode == NULL)
+ && __is_root_gfid (parent->gfid)) {
+ /* non decisive result - entry missing */
+ return -1;
+ }
- prepare_components (state);
+ /* decisive result - resolution success */
+ return 0;
+ }
+
+ parent = inode_find (state->itable, resolve->pargfid);
+ if (!parent) {
+ /* non decisive result - parent missing */
+ return 1;
+ }
+ if (fuse_inode_needs_lookup (parent, THIS)) {
+ inode_unref (parent);
+ return 1;
+ }
+
+ loc->parent = parent;
+ uuid_copy (loc->pargfid, resolve->pargfid);
+
+ inode = inode_grep (state->itable, parent, loc->name);
+ if (inode) {
+ loc->inode = inode;
+ /* decisive result - resolution success */
+ return 0;
+ }
+
+ /* non decisive result - entry missing */
+ return -1;
+}
- components = resolve->components;
- /* start from the root */
- active_xl = fuse_active_subvol (state->this);
- resolve->deep_loc.inode = inode_ref (active_xl->itable->root);
- resolve->deep_loc.path = gf_strdup ("/");
- resolve->deep_loc.name = "";
+int
+fuse_resolve_parent (fuse_state_t *state)
+{
+ int ret = 0;
- for (i = 1; components[i].basename; i++) {
- *(components[i].basename - 1) = '/';
- inode = inode_grep (active_xl->itable, components[i-1].inode,
- components[i].basename);
- if (!inode)
- break;
- components[i].inode = inode_ref (inode);
+ ret = fuse_resolve_parent_simple (state);
+ if (ret > 0) {
+ fuse_resolve_gfid (state);
+ return 0;
}
- if (!components[i].basename)
- goto resolved;
-
- resolve->deep_loc.path = gf_strdup (resolve->resolved);
- resolve->deep_loc.parent = inode_ref (components[i-1].inode);
- resolve->deep_loc.inode = inode_new (active_xl->itable);
- resolve->deep_loc.name = components[i].basename;
+ if (ret < 0) {
+ fuse_resolve_entry (state);
+ return 0;
+ }
- FUSE_FOP_COOKIE (state, active_xl, resolve_deep_cbk, (void *)(long)i,
- GF_FOP_LOOKUP, lookup, &resolve->deep_loc, NULL);
+ fuse_resolve_continue (state);
return 0;
-resolved:
- resolve_deep_continue (state);
- return 0;
}
-static int
-resolve_path_simple (fuse_state_t *state)
+int
+fuse_resolve_inode_simple (fuse_state_t *state)
{
- gf_resolve_t *resolve = NULL;
- struct gf_resolve_comp *components = NULL;
- int ret = -1;
- int par_idx = 0;
- int ino_idx = 0;
- int i = 0;
+ fuse_resolve_t *resolve = NULL;
+ loc_t *loc = NULL;
+ inode_t *inode = NULL;
resolve = state->resolve_now;
- components = resolve->components;
-
- if (!components) {
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- goto out;
- }
+ loc = state->loc_now;
+
+ inode = resolve->hint;
+ if (inode->table == state->itable)
+ inode_ref (inode);
+ else
+ inode = inode_find (state->itable, resolve->gfid);
+
+ if (inode) {
+ if (!fuse_inode_needs_lookup (inode, THIS))
+ goto found;
+ /* inode was linked through readdirplus */
+ inode_unref (inode);
+ }
+
+ return 1;
+found:
+ loc->inode = inode;
+ return 0;
+}
- for (i = 0; components[i].basename; i++) {
- par_idx = ino_idx;
- ino_idx = i;
- }
- if (!components[par_idx].inode) {
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- goto out;
- }
+int
+fuse_resolve_inode (fuse_state_t *state)
+{
+ int ret = 0;
- if (!components[ino_idx].inode &&
- (resolve->type == RESOLVE_MUST || resolve->type == RESOLVE_EXACT)) {
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- goto out;
- }
+ ret = fuse_resolve_inode_simple (state);
- if (components[ino_idx].inode && resolve->type == RESOLVE_NOT) {
- resolve->op_ret = -1;
- resolve->op_errno = EEXIST;
- goto out;
+ if (ret > 0) {
+ fuse_resolve_gfid (state);
+ return 0;
}
- if (components[ino_idx].inode)
- state->loc_now->inode = inode_ref (components[ino_idx].inode);
- state->loc_now->parent = inode_ref (components[par_idx].inode);
-
- ret = 0;
+ fuse_resolve_continue (state);
-out:
- return ret;
+ return 0;
}
-/*
- Check if the requirements are fulfilled by entries in the inode cache itself
- Return value:
- <= 0 - simple resolution was decisive and complete (either success or failure)
- > 0 - indecisive, need to perform deep resolution
-*/
-static int
-resolve_entry_simple (fuse_state_t *state)
+int
+fuse_migrate_fd_task (void *data)
{
- xlator_t *this = NULL;
- xlator_t *active_xl = NULL;
- gf_resolve_t *resolve = NULL;
- inode_t *parent = NULL;
- inode_t *inode = NULL;
- int ret = 0;
-
- this = state->this;
- resolve = state->resolve_now;
-
- active_xl = fuse_active_subvol (this);
-
- parent = inode_get (active_xl->itable, resolve->par, 0);
- if (!parent) {
- /* simple resolution is indecisive. need to perform
- deep resolution */
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- ret = 1;
-
- inode = inode_grep (active_xl->itable, parent, resolve->bname);
- if (inode != NULL) {
- gf_log (this->name, GF_LOG_DEBUG, "%"PRId64": inode "
- "(pointer:%p ino: %"PRIu64") present but parent"
- " is NULL for path (%s)", 0L,
- inode, inode->ino, resolve->path);
- inode_unref (inode);
- }
+ int ret = -1;
+ fuse_state_t *state = NULL;
+ fd_t *basefd = NULL, *oldfd = NULL;
+ fuse_fd_ctx_t *basefd_ctx = NULL;
+ xlator_t *old_subvol = NULL;
+
+ state = data;
+ if (state == NULL) {
goto out;
}
- /* expected @parent was found from the inode cache */
- state->loc_now->parent = inode_ref (parent);
-
- inode = inode_grep (active_xl->itable, parent, resolve->bname);
- if (!inode) {
- switch (resolve->type) {
- case RESOLVE_DONTCARE:
- case RESOLVE_NOT:
- ret = 0;
- break;
- case RESOLVE_MAY:
- ret = 1;
- break;
- default:
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- ret = 1;
- break;
- }
+ basefd = state->fd;
- goto out;
+ basefd_ctx = fuse_fd_ctx_get (state->this, basefd);
+
+ LOCK (&basefd->lock);
+ {
+ oldfd = basefd_ctx->activefd ? basefd_ctx->activefd : basefd;
+ fd_ref (oldfd);
}
+ UNLOCK (&basefd->lock);
- if (resolve->type == RESOLVE_NOT) {
- gf_log (this->name, GF_LOG_DEBUG, "inode (pointer: %p ino:%"
- PRIu64") found for path (%s) while type is RESOLVE_NOT",
- inode, inode->ino, resolve->path);
- resolve->op_ret = -1;
- resolve->op_errno = EEXIST;
- ret = -1;
- goto out;
+ old_subvol = oldfd->inode->table->xl;
+
+ ret = fuse_migrate_fd (state->this, basefd, old_subvol,
+ state->active_subvol);
+
+ LOCK (&basefd->lock);
+ {
+ if (ret < 0) {
+ basefd_ctx->migration_failed = 1;
+ } else {
+ basefd_ctx->migration_failed = 0;
+ }
}
+ UNLOCK (&basefd->lock);
ret = 0;
- state->loc_now->inode = inode_ref (inode);
-
out:
- if (parent)
- inode_unref (parent);
-
- if (inode)
- inode_unref (inode);
+ if (oldfd)
+ fd_unref (oldfd);
return ret;
}
-static int
-gf_resolve_entry (fuse_state_t *state)
+static inline int
+fuse_migrate_fd_error (xlator_t *this, fd_t *fd)
{
- int ret = 0;
- loc_t *loc = NULL;
-
- loc = state->loc_now;
+ fuse_fd_ctx_t *fdctx = NULL;
+ char error = 0;
- ret = resolve_entry_simple (state);
-
- if (ret > 0) {
- loc_wipe (loc);
- resolve_path_deep (state);
- return 0;
+ fdctx = fuse_fd_ctx_get (this, fd);
+ if (fdctx != NULL) {
+ if (fdctx->migration_failed) {
+ error = 1;
+ }
}
- if (ret == 0)
- resolve_loc_touchup (state);
-
- gf_resolve_all (state);
-
- return 0;
+ return error;
}
+#define FUSE_FD_GET_ACTIVE_FD(activefd, basefd) \
+ do { \
+ LOCK (&basefd->lock); \
+ { \
+ activefd = basefd_ctx->activefd ? \
+ basefd_ctx->activefd : basefd; \
+ if (activefd != basefd) { \
+ fd_ref (activefd); \
+ } \
+ } \
+ UNLOCK (&basefd->lock); \
+ \
+ if (activefd == basefd) { \
+ fd_ref (activefd); \
+ } \
+ } while (0);
+
static int
-resolve_inode_simple (fuse_state_t *state)
+fuse_resolve_fd (fuse_state_t *state)
{
- xlator_t *active_xl = NULL;
- gf_resolve_t *resolve = NULL;
- inode_t *inode = NULL;
- int ret = 0;
+ fuse_resolve_t *resolve = NULL;
+ fd_t *basefd = NULL, *activefd = NULL;
+ xlator_t *active_subvol = NULL, *this = NULL;
+ int ret = 0;
+ char fd_migration_error = 0;
+ fuse_fd_ctx_t *basefd_ctx = NULL;
resolve = state->resolve_now;
- active_xl = fuse_active_subvol (state->this);
+ this = state->this;
- if (resolve->type == RESOLVE_EXACT) {
- inode = inode_get (active_xl->itable, resolve->ino,
- resolve->gen);
- } else {
- inode = inode_get (active_xl->itable, resolve->ino, 0);
+ basefd = resolve->fd;
+ basefd_ctx = fuse_fd_ctx_get (this, basefd);
+ if (basefd_ctx == NULL) {
+ gf_log (state->this->name, GF_LOG_WARNING,
+ "fdctx is NULL for basefd (ptr:%p inode-gfid:%s), "
+ "resolver erroring out with errno EINVAL",
+ basefd, uuid_utoa (basefd->inode->gfid));
+ resolve->op_ret = -1;
+ resolve->op_errno = EINVAL;
+ goto resolve_continue;
}
- if (!inode) {
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- ret = 1;
- goto out;
+ FUSE_FD_GET_ACTIVE_FD (activefd, basefd);
+
+ active_subvol = activefd->inode->table->xl;
+
+ fd_migration_error = fuse_migrate_fd_error (state->this, basefd);
+ if (fd_migration_error) {
+ resolve->op_ret = -1;
+ resolve->op_errno = EBADF;
+ } else if (state->active_subvol != active_subvol) {
+ ret = synctask_new (state->this->ctx->env, fuse_migrate_fd_task,
+ NULL, NULL, state);
+
+ fd_migration_error = fuse_migrate_fd_error (state->this,
+ basefd);
+ fd_unref (activefd);
+
+ FUSE_FD_GET_ACTIVE_FD (activefd, basefd);
+ active_subvol = activefd->inode->table->xl;
+
+ if ((ret == -1) || fd_migration_error
+ || (state->active_subvol != active_subvol)) {
+ if (ret == -1) {
+ gf_log (state->this->name, GF_LOG_WARNING,
+ "starting sync-task to migrate "
+ "basefd (ptr:%p inode-gfid:%s) failed "
+ "(old-subvolume:%s-%d "
+ "new-subvolume:%s-%d)",
+ basefd,
+ uuid_utoa (basefd->inode->gfid),
+ active_subvol->name,
+ active_subvol->graph->id,
+ state->active_subvol->name,
+ state->active_subvol->graph->id);
+ } else {
+ gf_log (state->this->name, GF_LOG_WARNING,
+ "fd migration of basefd "
+ "(ptr:%p inode-gfid:%s) failed "
+ "(old-subvolume:%s-%d "
+ "new-subvolume:%s-%d)",
+ basefd,
+ uuid_utoa (basefd->inode->gfid),
+ active_subvol->name,
+ active_subvol->graph->id,
+ state->active_subvol->name,
+ state->active_subvol->graph->id);
+ }
+
+ resolve->op_ret = -1;
+ resolve->op_errno = EBADF;
+ } else {
+ gf_log (state->this->name, GF_LOG_DEBUG,
+ "basefd (ptr:%p inode-gfid:%s) migrated "
+ "successfully in resolver "
+ "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+ basefd, uuid_utoa (basefd->inode->gfid),
+ active_subvol->name, active_subvol->graph->id,
+ state->active_subvol->name,
+ state->active_subvol->graph->id);
+ }
}
- ret = 0;
+ if ((resolve->op_ret == -1) && (resolve->op_errno == EBADF)) {
+ gf_log ("fuse-resolve", GF_LOG_WARNING,
+ "migration of basefd (ptr:%p inode-gfid:%s) "
+ "did not complete, failing fop with EBADF "
+ "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
+ uuid_utoa (basefd->inode->gfid),
+ active_subvol->name, active_subvol->graph->id,
+ state->active_subvol->name,
+ state->active_subvol->graph->id);
+ }
- state->loc_now->inode = inode_ref (inode);
+ if (activefd != basefd) {
+ state->fd = fd_ref (activefd);
+ fd_unref (basefd);
+ }
-out:
- if (inode)
- inode_unref (inode);
+ /* state->active_subvol = active_subvol; */
- return ret;
+resolve_continue:
+ if (activefd != NULL) {
+ fd_unref (activefd);
+ }
+
+ fuse_resolve_continue (state);
+
+ return 0;
}
-static int
-gf_resolve_inode (fuse_state_t *state)
+int
+fuse_gfid_set (fuse_state_t *state)
{
- int ret = 0;
- loc_t *loc = NULL;
+ int ret = 0;
- loc = state->loc_now;
+ if (uuid_is_null (state->gfid))
+ goto out;
- ret = resolve_inode_simple (state);
+ if (!state->xdata)
+ state->xdata = dict_new ();
- if (ret > 0) {
- loc_wipe (loc);
- resolve_path_deep (state);
- return 0;
+ if (!state->xdata) {
+ ret = -1;
+ goto out;
}
- if (ret == 0)
- resolve_loc_touchup (state);
-
- gf_resolve_all (state);
-
- return 0;
+ ret = dict_set_static_bin (state->xdata, "gfid-req",
+ state->gfid, sizeof (state->gfid));
+out:
+ return ret;
}
-static int
-gf_resolve_fd (fuse_state_t *state)
+int
+fuse_resolve_entry_init (fuse_state_t *state, fuse_resolve_t *resolve,
+ ino_t par, char *name)
{
- gf_resolve_t *resolve = NULL;
- fd_t *fd = NULL;
- int ret = 0;
- uint64_t tmp_fd_ctx = 0;
- char *path = NULL;
- char *name = NULL;
+ inode_t *parent = NULL;
- resolve = state->resolve_now;
+ parent = fuse_ino_to_inode (par, state->this);
+ uuid_copy (resolve->pargfid, parent->gfid);
+ resolve->parhint = parent;
+ resolve->bname = gf_strdup (name);
- fd = resolve->fd;
+ return 0;
+}
- ret = fd_ctx_get (fd, state->this, &tmp_fd_ctx);
- if (!ret) {
- state->fd = (fd_t *)(long)tmp_fd_ctx;
- fd_ref (state->fd);
- gf_resolve_all (state);
- goto out;
- }
- ret = inode_path (fd->inode, 0, &path);
- if (!ret || !path)
- gf_log ("", GF_LOG_WARNING,
- "failed to do inode-path on fd %d %s", ret, path);
+int
+fuse_resolve_inode_init (fuse_state_t *state, fuse_resolve_t *resolve,
+ ino_t ino)
+{
+ inode_t *inode = NULL;
- name = strrchr (path, '/');
- if (name)
- name++;
+ inode = fuse_ino_to_inode (ino, state->this);
+ uuid_copy (resolve->gfid, inode->gfid);
+ resolve->hint = inode;
- resolve->path = path;
- resolve->bname = gf_strdup (name);
+ return 0;
+}
- state->loc_now = &state->loc;
- resolve_path_deep (state);
+int
+fuse_resolve_fd_init (fuse_state_t *state, fuse_resolve_t *resolve,
+ fd_t *fd)
+{
+ resolve->fd = fd_ref (fd);
-out:
- return 0;
+ return 0;
}
static int
-gf_resolve (fuse_state_t *state)
- {
- gf_resolve_t *resolve = NULL;
+fuse_resolve (fuse_state_t *state)
+{
+ fuse_resolve_t *resolve = NULL;
resolve = state->resolve_now;
if (resolve->fd) {
- gf_resolve_fd (state);
+ fuse_resolve_fd (state);
- } else if (resolve->par) {
+ } else if (!uuid_is_null (resolve->pargfid)) {
- gf_resolve_entry (state);
+ fuse_resolve_parent (state);
- } else if (resolve->ino) {
+ } else if (!uuid_is_null (resolve->gfid)) {
- gf_resolve_inode (state);
+ fuse_resolve_inode (state);
- } else if (resolve->path) {
-
- resolve_path_deep (state);
-
- } else {
-
- resolve->op_ret = 0;
- resolve->op_errno = EINVAL;
-
- gf_resolve_all (state);
+ } else {
+ fuse_resolve_all (state);
}
return 0;
@@ -644,21 +654,14 @@ gf_resolve (fuse_state_t *state)
static int
-gf_resolve_done (fuse_state_t *state)
+fuse_resolve_done (fuse_state_t *state)
{
fuse_resume_fn_t fn = NULL;
- if (state->resolve.op_ret || state->resolve2.op_ret) {
- send_fuse_err (state->this, state->finh,
- state->resolve.op_errno);
- free_fuse_state (state);
- goto out;
- }
fn = state->resume_fn;
- if (fn)
- fn (state);
-out:
+ fn (state);
+
return 0;
}
@@ -668,25 +671,25 @@ out:
* state->resolve_now is used to decide which location/fd is to be resolved now
*/
static int
-gf_resolve_all (fuse_state_t *state)
+fuse_resolve_all (fuse_state_t *state)
{
if (state->resolve_now == NULL) {
state->resolve_now = &state->resolve;
state->loc_now = &state->loc;
- gf_resolve (state);
+ fuse_resolve (state);
} else if (state->resolve_now == &state->resolve) {
state->resolve_now = &state->resolve2;
state->loc_now = &state->loc2;
- gf_resolve (state);
+ fuse_resolve (state);
} else if (state->resolve_now == &state->resolve2) {
- gf_resolve_done (state);
+ fuse_resolve_done (state);
} else {
gf_log ("fuse-resolve", GF_LOG_ERROR,
@@ -698,82 +701,24 @@ gf_resolve_all (fuse_state_t *state)
int
-fuse_gfid_set (fuse_state_t *state)
+fuse_resolve_continue (fuse_state_t *state)
{
- int ret = 0;
+ fuse_resolve_loc_touchup (state);
- if (uuid_is_null (state->gfid))
- goto out;
-
- if (!state->dict)
- state->dict = dict_new ();
-
- if (!state->dict) {
- ret = -1;
- goto out;
- }
+ fuse_resolve_all (state);
- ret = dict_set_static_bin (state->dict, "gfid-req",
- state->gfid, sizeof (state->gfid));
-out:
- return ret;
+ return 0;
}
int
fuse_resolve_and_resume (fuse_state_t *state, fuse_resume_fn_t fn)
{
- xlator_t *inode_xl = NULL;
- xlator_t *active_xl = NULL;
-
fuse_gfid_set (state);
state->resume_fn = fn;
- active_xl = fuse_active_subvol (state->this);
- inode_xl = fuse_state_subvol (state);
- if (!inode_xl && state->loc.parent)
- inode_xl = state->loc.parent->table->xl;
-
- /* If inode or fd is already in new graph, goto resume */
- if (inode_xl == active_xl)
- goto resume;
-
- /* If the resolve is for 'fd' and its open with 'write' flag
- set, don't switch to new graph yet */
- if (state->fd && ((state->fd->flags & O_RDWR) ||
- (state->fd->flags & O_WRONLY)))
- goto resume;
-
- if (state->loc.path) {
- state->resolve.path = gf_strdup (state->loc.path);
- state->resolve.bname = gf_strdup (state->loc.name);
- /* TODO: make sure there is no leaks in inode refs */
- //loc_wipe (&state->loc);
- state->loc.inode = NULL;
- state->loc.parent = NULL;
- }
-
- /* Needed for rename and link */
- if (state->loc2.path) {
- state->resolve2.path = gf_strdup (state->loc2.path);
- state->resolve2.bname = gf_strdup (state->loc2.name);
- //loc_wipe (&state->loc2);
- state->loc2.inode = NULL;
- state->loc2.parent = NULL;
- }
-
- if (state->fd) {
- state->resolve.fd = state->fd;
- /* TODO: check if its a leak, if yes, then do 'unref' */
- state->fd = NULL;
- }
-
- gf_resolve_all (state);
-
- return 0;
-resume:
- fn (state);
+ fuse_resolve_all (state);
return 0;
}
generated by cgit (git 2.34.1) at 2026-01-05 07:35:27 +0000