summaryrefslogtreecommitdiffstats
path: root/glusterfs-guts/src/guts-replay.c
diff options
context:
space:
mode:
Diffstat (limited to 'glusterfs-guts/src/guts-replay.c')
-rw-r--r--glusterfs-guts/src/guts-replay.c834
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;
-}