diff options
Diffstat (limited to 'glusterfs-guts/src/guts-replay.c')
| -rw-r--r-- | glusterfs-guts/src/guts-replay.c | 834 |
1 files changed, 0 insertions, 834 deletions
diff --git a/glusterfs-guts/src/guts-replay.c b/glusterfs-guts/src/guts-replay.c deleted file mode 100644 index 777480a96b9..00000000000 --- a/glusterfs-guts/src/guts-replay.c +++ /dev/null @@ -1,834 +0,0 @@ -/* - Copyright (c) 2008-2009 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/>. -*/ - -#include "glusterfs-guts.h" -#include "guts-parse.h" -#include <signal.h> -#include "guts-tables.h" -#include "guts-replay.h" -#include "guts-trace.h" - -static void -convert_attr (const struct fuse_setattr_in *attr, - struct stat *stbuf) -{ - stbuf->st_mode = attr->mode; - stbuf->st_uid = attr->uid; - stbuf->st_gid = attr->gid; - stbuf->st_size = attr->size; - stbuf->st_atime = attr->atime; - /* - ST_ATIM_NSEC_SET (stbuf, attr->atimensec); - ST_MTIM_NSEC_SET (stbuf, attr->mtimensec);*/ -} - -static void -guts_replay_lookup (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - char *name = (char *) inargs; - - if (req->f->op.lookup) - req->f->op.lookup(req, ino, name); - else - guts_reply_err (req, ENOSYS); - -} - -static void -guts_replay_forget (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_forget_in *arg = (struct fuse_forget_in *) inargs; - - if (req->f->op.forget) - req->f->op.forget (req, ino, arg->nlookup); - -} - -static void -guts_replay_getattr (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - (void) inargs; - - if (req->f->op.getattr) - req->f->op.getattr (req, ino, NULL); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_setattr (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_setattr_in *arg = (struct fuse_setattr_in *)inargs; - - if (req->f->op.setattr) { - struct fuse_file_info *fi = NULL; - struct fuse_file_info fi_store; - struct stat stbuf; - memset (&stbuf, 0, sizeof (stbuf)); - convert_attr (arg, &stbuf); - if (arg->valid & FATTR_FH) { - arg->valid &= ~FATTR_FH; - memset (&fi_store, 0, sizeof (fi_store)); - fi = &fi_store; - fi->fh = arg->fh; - fi->fh_old = fi->fh; - } - req->f->op.setattr (req, ino, &stbuf, arg->valid, fi); - } else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_access (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_access_in *arg = (struct fuse_access_in *)inargs; - - if (req->f->op.access) - req->f->op.access (req, ino, arg->mask); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_readlink (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - (void) inargs; - - if (req->f->op.readlink) - req->f->op.readlink (req, ino); - else - guts_reply_err (req, ENOSYS); -} - - -static void -guts_replay_mknod (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_mknod_in *arg = (struct fuse_mknod_in *) inargs; - - if (req->f->op.mknod) - req->f->op.mknod (req, ino, PARAM(arg), arg->mode, arg->rdev); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_mkdir (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inargs; - - if (req->f->op.mkdir) - req->f->op.mkdir (req, ino, PARAM(arg), arg->mode); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_unlink (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - char *name = (char *)inargs; - - if (req->f->op.unlink) { - - req->f->op.unlink (req, ino, name); - } else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_rmdir (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - char *name = (char *)inargs; - - if (req->f->op.rmdir) { - req->f->op.rmdir (req, ino, name); - } else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_symlink (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - char *name = (char *) inargs; - char *linkname = ((char *) inargs) + strlen ((char *) inargs) + 1; - - if (req->f->op.symlink) { - req->f->op.symlink (req, linkname, ino, name); - } else - guts_reply_err (req, ENOSYS); -} - - - -static void -guts_replay_rename (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_rename_in *arg = (struct fuse_rename_in *) inargs; - char *oldname = PARAM(arg); - char *newname = oldname + strlen (oldname) + 1; - - if (req->f->op.rename) { - req->f->op.rename (req, ino, oldname, arg->newdir, newname); - } else - guts_reply_err (req, ENOSYS); - -} - -static void -guts_replay_link (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_link_in *arg = (struct fuse_link_in *) inargs; - - if (req->f->op.link) { - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - fuse_ino_t old_ino = guts_inode_search (ctx, arg->oldnodeid); - - req->f->op.link (req, old_ino, ino, PARAM(arg)); - } else - guts_reply_err (req, ENOSYS); -} - - -static void -guts_replay_create (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct guts_create_in *arg = (struct guts_create_in *) inargs; - - if (req->f->op.create) { - struct fuse_file_info fi; - memset (&fi, 0, sizeof (fi)); - fi.flags = arg->open_in.flags; - - req->f->op.create (req, ino, arg->name, arg->open_in.mode, &fi); - } else - guts_reply_err (req, ENOSYS); - -} - -static void -guts_replay_open (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_open_in *arg = (struct fuse_open_in *) inargs; - struct fuse_file_info fi; - - memset (&fi, 0, sizeof (fi)); - fi.flags = arg->flags; - - if (req->f->op.open) { - /* TODO: how efficient is using dict_get here?? */ - req->f->op.open (req, ino, &fi); - } else - guts_reply_open (req, &fi); -} - - -static void -guts_replay_read(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_read_in *arg = (struct fuse_read_in *) inarg; - - if (req->f->op.read){ - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - /* TODO: how efficient is using dict_get here?? */ - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - if (!fi.fh) { - /* TODO: make it more meaningful and organized */ - printf ("readv called without opening the file\n"); - guts_reply_err (req, EBADFD); - } else { - fi.fh_old = fi.fh; - req->f->op.read (req, ino, arg->size, arg->offset, &fi); - } - } else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_write(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_write_in *arg = (struct fuse_write_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - - if (!fi.fh) { - /* TODO: make it more meaningful and organized */ - printf ("writev called without opening the file\n"); - guts_reply_err (req, EBADFD); - } else { - fi.fh_old = fi.fh; - fi.writepage = arg->write_flags & 1; - if (req->f->op.write) - req->f->op.write (req, ino, PARAM(arg), arg->size, arg->offset, &fi); - else - guts_reply_err (req, ENOSYS); - } -} - -static void -guts_replay_flush(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_flush_in *arg = (struct fuse_flush_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - if (!fi.fh) { - printf ("flush called without calling open\n"); - guts_reply_err (req, EBADFD); - } else { - fi.fh_old = fi.fh; - fi.flush = 1; - - if (req->f->conn.proto_minor >= 7) - fi.lock_owner = arg->lock_owner; - - if (req->f->op.flush) - req->f->op.flush (req, ino, &fi); - else - guts_reply_err (req, ENOSYS); - } -} - -static void -guts_replay_release(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_release_in *arg = (struct fuse_release_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.flags = arg->flags; - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - - if (!fi.fh) { - printf ("release called without calling open\n"); - guts_reply_err (req, EBADFD); - } else { - fi.fh_old = fi.fh; - if (req->f->conn.proto_minor >= 8) { - fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0; - fi.lock_owner = arg->lock_owner; - } - if (req->f->op.release) - req->f->op.release (req, ino, &fi); - else - guts_reply_err (req, ENOSYS); - } -} - -static void -guts_replay_fsync(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - fi.fh_old = fi.fh; - - if (req->f->op.fsync) - req->f->op.fsync (req, ino, arg->fsync_flags & 1, &fi); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_opendir (fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_open_in *arg = (struct fuse_open_in *) inarg; - struct fuse_file_info fi; - - memset (&fi, 0, sizeof (fi)); - fi.flags = arg->flags; - - if (req->f->op.opendir) { - req->f->op.opendir (req, ino, &fi); - } else - guts_reply_open (req, &fi); -} - -static void -guts_replay_readdir(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_read_in *arg = (struct fuse_read_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - - if (!fi.fh) { - /* TODO: make it more meaningful and organized */ - printf ("readdir called without opening the file\n"); - guts_reply_err (req, EBADFD); - } else { - fi.fh_old = fi.fh; - - if (req->f->op.readdir) - req->f->op.readdir (req, ino, arg->size, arg->offset, &fi); - else - guts_reply_err (req, ENOSYS); - } - -} - -static void -guts_replay_releasedir(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_release_in *arg = (struct fuse_release_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.flags = arg->flags; - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - if (!fi.fh) { - printf ("releasedir called without calling opendir\n"); - guts_reply_err (req, EBADFD); - } else { - - fi.fh_old = fi.fh; - if (req->f->op.releasedir) - req->f->op.releasedir (req, ino, &fi); - else - guts_reply_err (req, ENOSYS); - } -} - -static void -guts_replay_fsyncdir(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg; - struct fuse_file_info fi; - guts_replay_ctx_t *ctx = (guts_replay_ctx_t *) req->u.ni.data; - - memset (&fi, 0, sizeof (fi)); - fi.fh = (unsigned long) guts_fd_search (ctx, arg->fh); - fi.fh_old = fi.fh; - - if (req->f->op.fsyncdir) - req->f->op.fsyncdir (req, ino, arg->fsync_flags & 1, &fi); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_statfs (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - (void) ino; - (void) inargs; - - if (req->f->op.statfs) { - req->f->op.statfs (req, ino); - } else { - struct statvfs buf = { - .f_namemax = 255, - .f_bsize = 512, - }; - guts_reply_statfs (req, &buf); - } -} - -static void -guts_replay_setxattr(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg; - char *name = PARAM(arg); - char *value = name + strlen(name) + 1; - - if (req->f->op.setxattr) - req->f->op.setxattr (req, ino, name, value, arg->size, arg->flags); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_getxattr(fuse_req_t req, - fuse_ino_t ino, - const void *inarg) -{ - struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg; - - if (req->f->op.getxattr) - req->f->op.getxattr (req, ino, PARAM(arg), arg->size); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_listxattr (fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inargs; - - if (req->f->op.listxattr) - req->f->op.listxattr (req, ino, arg->size); - else - guts_reply_err (req, ENOSYS); -} - -static void -guts_replay_removexattr(fuse_req_t req, - fuse_ino_t ino, - const void *inargs) -{ - char *name = (char *)inargs; - - if (req->f->op.removexattr) - req->f->op.removexattr (req, ino, name); - else - guts_reply_err (req, ENOSYS); -} - -guts_replay_t guts_replay_fop[] = { - [FUSE_LOOKUP] = { guts_replay_lookup, "lookup" }, - [FUSE_FORGET] = { guts_replay_forget, "forget" }, - [FUSE_GETATTR] = { guts_replay_getattr, "getattr" }, - [FUSE_SETATTR] = { guts_replay_setattr, "setattr" }, - [FUSE_ACCESS] = { guts_replay_access, "access" }, - [FUSE_READLINK] = { guts_replay_readlink, "readlink" }, - [FUSE_MKNOD] = { guts_replay_mknod, "mknod" }, - [FUSE_MKDIR] = { guts_replay_mkdir, "mkdir" }, - [FUSE_UNLINK] = { guts_replay_unlink, "unlink" }, - [FUSE_RMDIR] = { guts_replay_rmdir, "rmdir" }, - [FUSE_SYMLINK] = { guts_replay_symlink, "symlink" }, - [FUSE_RENAME] = { guts_replay_rename, "rename" }, - [FUSE_LINK] = { guts_replay_link, "link" }, - [FUSE_CREATE] = { guts_replay_create, "create" }, - [FUSE_OPEN] = { guts_replay_open, "open" }, - [FUSE_READ] = { guts_replay_read, "read" }, - [FUSE_WRITE] = { guts_replay_write, "write" }, - [FUSE_FLUSH] = { guts_replay_flush, "flush" }, - [FUSE_RELEASE] = { guts_replay_release, "release" }, - [FUSE_FSYNC] = { guts_replay_fsync, "fsync" }, - [FUSE_OPENDIR] = { guts_replay_opendir, "opendir" }, - [FUSE_READDIR] = { guts_replay_readdir, "readdir" }, - [FUSE_RELEASEDIR] = { guts_replay_releasedir, "releasedir" }, - [FUSE_FSYNCDIR] = { guts_replay_fsyncdir, "fsyncdir" }, - [FUSE_STATFS] = { guts_replay_statfs, "statfs" }, - [FUSE_SETXATTR] = { guts_replay_setxattr, "setxattr" }, - [FUSE_GETXATTR] = { guts_replay_getxattr, "getxattr" }, - [FUSE_LISTXATTR] = { guts_replay_listxattr, "listxattr" }, - [FUSE_REMOVEXATTR] = { guts_replay_removexattr, "removexattr" }, -}; - -static inline void -list_init_req (struct fuse_req *req) -{ - req->next = req; - req->prev = req; -} - - -static int32_t -guts_transport_notify (xlator_t *xl, - int32_t event, - void *data, - ...) -{ - /* dummy, nobody has got anything to notify me.. ;) */ - return 0; -} - -static int32_t -guts_transport_init (transport_t *this, - dict_t *options, - event_notify_fn_t notify) -{ - struct fuse_private *priv = CALLOC (1, sizeof (*priv)); - ERR_ABORT (priv); - - this->notify = NULL; - this->private = (void *)priv; - - /* fuse channel */ - priv->ch = NULL; - - /* fuse session */ - priv->se = NULL; - - /* fuse channel fd */ - priv->fd = -1; - - this->buf = data_ref (data_from_dynptr (NULL, 0)); - this->buf->is_locked = 1; - - priv->mountpoint = NULL; - - transport_ref (this); - - return 0; -} - -static void -guts_transport_fini (transport_t *this) -{ - -} - -static int32_t -guts_transport_disconnect (transport_t *this) -{ - struct fuse_private *priv = this->private; - - gf_log ("glusterfs-guts", - GF_LOG_DEBUG, - "cleaning up fuse transport in disconnect handler"); - - FREE (priv); - priv = NULL; - this->private = NULL; - - /* TODO: need graceful exit. every xlator should be ->fini()'ed - and come out of main poll loop cleanly - */ - return -1; -} - -static struct transport_ops guts_transport_ops = { - .disconnect = guts_transport_disconnect, -}; - -static transport_t guts_transport = { - .ops = &guts_transport_ops, - .private = NULL, - .xl = NULL, - .init = guts_transport_init, - .fini = guts_transport_fini, - .notify = guts_transport_notify -}; - -static inline xlator_t * -fuse_graph (xlator_t *graph) -{ - xlator_t *top = NULL; - xlator_list_t *xlchild; - - top = CALLOC (1, sizeof (*top)); - ERR_ABORT (top); - - xlchild = CALLOC (1, sizeof(*xlchild)); - ERR_ABORT (xlchild); - xlchild->xlator = graph; - top->children = xlchild; - top->ctx = graph->ctx; - top->next = graph; - graph->parent = top; - - return top; -} - -static guts_replay_ctx_t * -guts_replay_init (guts_thread_ctx_t *thread) -{ - guts_replay_ctx_t *ctx = NULL; - int32_t fd = open (thread->file, O_RDONLY); - - if (fd < 0) { - gf_log ("glusterfs-guts", GF_LOG_DEBUG, - "failed to open tio_file %s", thread->file); - return ctx; - } else { - struct fuse_ll *guts_ll = CALLOC (1, sizeof (*guts_ll)); - ERR_ABORT (guts_ll); - - ctx = CALLOC (1, sizeof (*ctx)); - ERR_ABORT (ctx); - - if (ctx) { - /* equivalent to fuse_new_session () */ - guts_ll->conn.async_read = 1; - guts_ll->conn.max_write = UINT_MAX; - guts_ll->conn.max_readahead = UINT_MAX; - memcpy (&guts_ll->op, &fuse_ops, sizeof (struct fuse_lowlevel_ops)); - list_init_req (&guts_ll->list); - list_init_req (&guts_ll->interrupts); - guts_ll->owner = getuid (); - guts_ll->userdata = thread; - - /* TODO: need to create transport_t object which whole of the glusterfs - * so desperately depends on */ - transport_t *guts_trans = CALLOC (1, sizeof (*guts_trans)); - - if (guts_trans) { - memcpy (guts_trans, &guts_transport, sizeof (*guts_trans)); - guts_trans->ops = &guts_transport_ops; - } else { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to allocate memory for guts transport object"); - return NULL; - } - - glusterfs_ctx_t *glfs_ctx = CALLOC (1, sizeof (*glfs_ctx));; - if (glfs_ctx) { - guts_trans->xl_private = glfs_ctx; - guts_trans->xl = fuse_graph (thread->ctx->graph); - }else { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to allocate memory for glusterfs_ctx_t object"); - return NULL; - } - - call_pool_t *pool = CALLOC (1, sizeof (call_pool_t)); - if (pool) { - glfs_ctx->pool = pool; - LOCK_INIT (&pool->lock); - INIT_LIST_HEAD (&pool->all_frames); - } else { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to allocate memory for guts call pool"); - return NULL; - } - - guts_trans->xl->ctx = glfs_ctx; - guts_trans->init (guts_trans, NULL, guts_transport_notify); - guts_ll->userdata = guts_trans; - - /* call fuse_init */ - guts_ll->op.init (guts_trans, NULL); - - { - ctx->guts_ll = guts_ll; - ctx->tio_fd = fd; - ctx->inodes = get_new_dict (); - ctx->fds = get_new_dict (); - ctx->replies = get_new_dict (); - INIT_LIST_HEAD(&ctx->requests); - ctx->requests_dict = get_new_dict (); - } - } else { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to allocate memory for guts_ctx_t object"); - return NULL; - } - } - - return ctx; -} - -int32_t -guts_replay (guts_thread_ctx_t *thread) -{ - guts_req_t *entry = NULL; - guts_replay_ctx_t *ctx = guts_replay_init (thread); - - if (!ctx) { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to initialize guts_replay"); - return -1; - } else { - while ((entry = guts_read_entry (ctx))) { - /* here we go ... execute the request */ - fuse_req_t req = CALLOC (1, sizeof (struct fuse_req)); - ino_t ino = entry->header.nodeid; - void *arg = entry->arg; - - if (req) { - req->f = ctx->guts_ll; - req->unique = entry->header.unique; - req->ctx.uid = entry->header.uid; - req->ctx.pid = entry->header.pid; - - /* req->u.ni.data is unused void *, while running in replay mode. Making use of available real-estate - * to store useful information of thread specific guts_replay_ctx */ - req->u.ni.data = (void *) ctx; - /* req->ch is of type 'struct fuse_chan', which fuse uses only at the - * time of the response it gets and is useful in sending the reply data to correct channel - * in /dev/fuse. This is not useful for us, so we ignore it by keeping it NULL */ - list_init_req (req); - - fuse_ino_t new_ino = guts_inode_search (ctx, ino); - - if (guts_replay_fop[entry->header.opcode].func) { - printf ("operation: %s && inode: %ld\n", guts_replay_fop[entry->header.opcode].name, new_ino); - guts_replay_fop[entry->header.opcode].func (req, new_ino, arg); - } - - if (entry->arg) - free (entry->arg); - free (entry); - } else { - gf_log ("glusterfs-guts", GF_LOG_ERROR, - "failed to allocate memory for fuse_req_t object"); - return -1; - } - } - } - return 0; -} |