64 files changed, 32304 insertions, 43 deletions

diff --git a/configure.ac b/configure.ac
index 6ef8188a6..0347ca59a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -84,6 +84,16 @@ AC_CONFIG_FILES([Makefile
 		xlators/protocol/auth/addr/src/Makefile
 		xlators/protocol/auth/login/Makefile
 		xlators/protocol/auth/login/src/Makefile
+                xlators/protocol/rpc/Makefile
+                xlators/protocol/rpc/rpc-lib/Makefile
+                xlators/protocol/rpc/rpc-lib/src/Makefile
+                xlators/protocol/rpc/rpc-transport/Makefile
+                xlators/protocol/rpc/rpc-transport/socket/Makefile
+                xlators/protocol/rpc/rpc-transport/socket/src/Makefile
+		xlators/protocol/client/Makefile
+		xlators/protocol/client/src/Makefile
+		xlators/protocol/server/Makefile
+		xlators/protocol/server/src/Makefile
 		xlators/features/Makefile
 		xlators/features/locks/Makefile
 		xlators/features/locks/src/Makefile
diff --git a/doc/rpc-for-glusterfs.changes-done.txt b/doc/rpc-for-glusterfs.changes-done.txt
new file mode 100644
index 000000000..6bbbca788
--- /dev/null
+++ b/doc/rpc-for-glusterfs.changes-done.txt
@@ -0,0 +1,18 @@
+This document serves as a basic coding standard/practise for further
+developments after proper protocol layer is implemented.
+
+With this release we are bringing abstraction based on xlator driven
+operation and protocol driven operation. ie, all the client side (fuse)
+operations are xlator driven operations and will come with 'op' value
+taken from 'libglusterfs/'.
+
+All the server protocol driven operations are driven by which ever
+version of protocol is used.
+
+All the currently implemented fops will remain, and 'getspec' being generated
+by top level and passes through translator graph, is treated as an 'fop'.
+
+All new 'gluster' and 'glusterd' related calls will be _mgmt_ calls instead of
+fops. All release, releasedir and forget are treated as fops (but they won't
+come with requirement to use STACK_WIND and STACK_UNWIND).
+
diff --git a/libglusterfs/src/iatt.h b/libglusterfs/src/iatt.h
index 92d679f4c..ef64f9afc 100644
--- a/libglusterfs/src/iatt.h
+++ b/libglusterfs/src/iatt.h
@@ -30,6 +30,7 @@
 #include <sys/stat.h> /* for iatt <--> stat conversions */
 #include <unistd.h>
 
+#include "compat.h"
 
 typedef enum {
         IA_INVAL = 0,
diff --git a/xlators/protocol/Makefile.am b/xlators/protocol/Makefile.am
index 0e1eca0c8..b38506d47 100644
--- a/xlators/protocol/Makefile.am
+++ b/xlators/protocol/Makefile.am
@@ -1,3 +1 @@
-SUBDIRS = lib auth legacy
-
-CLEANFILES = 
+SUBDIRS = lib auth legacy rpc client server
diff --git a/xlators/protocol/auth/Makefile.am b/xlators/protocol/auth/Makefile.am
index 6bd54eee3..e9e0ba97e 100644
--- a/xlators/protocol/auth/Makefile.am
+++ b/xlators/protocol/auth/Makefile.am
@@ -1,3 +1 @@
 SUBDIRS = addr login
-
-CLEANFILES = 
diff --git a/xlators/protocol/auth/addr/Makefile.am b/xlators/protocol/auth/addr/Makefile.am
index d471a3f92..af437a64d 100644
--- a/xlators/protocol/auth/addr/Makefile.am
+++ b/xlators/protocol/auth/addr/Makefile.am
@@ -1,3 +1 @@
 SUBDIRS = src
-
-CLEANFILES = 
diff --git a/xlators/protocol/auth/addr/src/Makefile.am b/xlators/protocol/auth/addr/src/Makefile.am
index 2c94c94e4..ebf20b38a 100644
--- a/xlators/protocol/auth/addr/src/Makefile.am
+++ b/xlators/protocol/auth/addr/src/Makefile.am
@@ -10,5 +10,3 @@ addr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS)\
 	-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS) \
 	-I$(top_srcdir)/xlators/protocol/lib/src
-
-CLEANFILES = 
diff --git a/xlators/protocol/auth/login/Makefile.am b/xlators/protocol/auth/login/Makefile.am
index d471a3f92..af437a64d 100644
--- a/xlators/protocol/auth/login/Makefile.am
+++ b/xlators/protocol/auth/login/Makefile.am
@@ -1,3 +1 @@
 SUBDIRS = src
-
-CLEANFILES = 
diff --git a/xlators/protocol/auth/login/src/Makefile.am b/xlators/protocol/auth/login/src/Makefile.am
index ef99a965b..b3b625b6e 100644
--- a/xlators/protocol/auth/login/src/Makefile.am
+++ b/xlators/protocol/auth/login/src/Makefile.am
@@ -11,5 +11,3 @@ login_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS)\
 	-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS) \
 	-I$(top_srcdir)/xlators/protocol/lib/src
-
-CLEANFILES = 
diff --git a/xlators/protocol/client/Makefile.am b/xlators/protocol/client/Makefile.am
new file mode 100644
index 000000000..af437a64d
--- /dev/null
+++ b/xlators/protocol/client/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = src
diff --git a/xlators/protocol/client/src/Makefile.am b/xlators/protocol/client/src/Makefile.am
new file mode 100644
index 000000000..40281467e
--- /dev/null
+++ b/xlators/protocol/client/src/Makefile.am
@@ -0,0 +1,16 @@
+
+xlator_LTLIBRARIES = client.la
+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/alpha/protocol
+
+client_la_LDFLAGS = -module -avoidversion
+
+client_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
+	$(top_builddir)/xlators/protocol/rpc/rpc-lib/src/libgfrpc.la \
+	$(top_builddir)/xlators/protocol/lib/src/libgfproto1.la
+
+client_la_SOURCES = client.c client-helpers.c client3_1-fops.c client-handshake.c
+noinst_HEADERS = client.h client-mem-types.h
+
+AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS) \
+	-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS)  \
+	-I$(top_srcdir)/xlators/protocol/lib/src -I$(top_srcdir)/xlators/protocol/rpc/rpc-lib/src/
diff --git a/xlators/protocol/client/src/client-handshake.c b/xlators/protocol/client/src/client-handshake.c
new file mode 100644
index 000000000..79cabd106
--- /dev/null
+++ b/xlators/protocol/client/src/client-handshake.c
@@ -0,0 +1,738 @@
+/*
+  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/>.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "client.h"
+#include "xlator.h"
+#include "defaults.h"
+#include "glusterfs.h"
+#include "msg-xdr.h"
+#include "statedump.h"
+#include "compat-errno.h"
+
+extern rpc_clnt_prog_t clnt3_1_fop_prog;
+extern rpc_clnt_prog_t clnt3_1_mgmt_prog;
+
+/* Handshake */
+
+void
+rpc_client_ping_timer_expired (void *data)
+{
+        rpc_transport_t         *trans              = NULL;
+        rpc_clnt_connection_t   *conn               = NULL;
+        int                      disconnect         = 0;
+        int                      transport_activity = 0;
+        struct timeval           timeout            = {0, };
+        struct timeval           current            = {0, };
+        struct rpc_clnt         *clnt               = NULL;
+        xlator_t                *this               = NULL;
+        clnt_conf_t             *conf               = NULL;
+
+        if (!data) {
+                goto out;
+        }
+
+        this = data;
+        conf = this->private;
+
+        conn = &conf->rpc->conn;
+        trans = conn->trans;
+
+        if (!clnt || !trans) {
+                goto out;
+        }
+
+        pthread_mutex_lock (&conn->lock);
+        {
+                if (conn->ping_timer)
+                        gf_timer_call_cancel (this->ctx,
+                                              conn->ping_timer);
+                gettimeofday (&current, NULL);
+
+                if (((current.tv_sec - conn->last_received.tv_sec) <
+                     conf->opt.ping_timeout)
+                    || ((current.tv_sec - conn->last_sent.tv_sec) <
+                        conf->opt.ping_timeout)) {
+                        transport_activity = 1;
+                }
+
+                if (transport_activity) {
+                        gf_log (trans->name, GF_LOG_TRACE,
+                                "ping timer expired but transport activity "
+                                "detected - not bailing transport");
+                        timeout.tv_sec = conf->opt.ping_timeout;
+                        timeout.tv_usec = 0;
+
+                        conn->ping_timer =
+                                gf_timer_call_after (this->ctx, timeout,
+                                                     rpc_client_ping_timer_expired,
+                                                     (void *) this);
+                        if (conn->ping_timer == NULL)
+                                gf_log (trans->name, GF_LOG_DEBUG,
+                                        "unable to setup timer");
+
+                } else {
+                        conn->ping_started = 0;
+                        conn->ping_timer = NULL;
+                        disconnect = 1;
+                }
+        }
+        pthread_mutex_unlock (&conn->lock);
+
+        if (disconnect) {
+                gf_log (trans->name, GF_LOG_ERROR,
+                        "Server %s has not responded in the last %d "
+                        "seconds, disconnecting.",
+                        conn->trans->peerinfo.identifier,
+                        conf->opt.ping_timeout);
+
+                rpc_transport_disconnect (conn->trans);
+        }
+
+out:
+        return;
+}
+
+
+void
+client_start_ping (void *data)
+{
+        xlator_t                *this        = NULL;
+        clnt_conf_t             *conf        = NULL;
+        rpc_clnt_connection_t   *conn        = NULL;
+        int32_t                  ret         = -1;
+        struct timeval           timeout     = {0, };
+        call_frame_t            *frame       = NULL;
+        int                      frame_count = 0;
+        rpc_transport_t         *trans       = NULL;
+
+        this = data;
+        conf  = this->private;
+
+        conn = &conf->rpc->conn;
+        trans = conn->trans;
+
+        if (conf->opt.ping_timeout == 0)
+                return;
+
+        pthread_mutex_lock (&conn->lock);
+        {
+                if (conn->ping_timer)
+                        gf_timer_call_cancel (this->ctx, conn->ping_timer);
+
+                conn->ping_timer = NULL;
+                conn->ping_started = 0;
+
+                if (conn->saved_frames)
+                        /* treat the case where conn->saved_frames is NULL
+                           as no pending frames */
+                        frame_count = conn->saved_frames->count;
+
+                if ((frame_count == 0) || !conn->connected) {
+                        /* using goto looked ugly here,
+                         * hence getting out this way */
+                        /* unlock */
+                        pthread_mutex_unlock (&conn->lock);
+                        return;
+                }
+
+                if (frame_count < 0) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "saved_frames->count is %"PRId64,
+                                conn->saved_frames->count);
+                        conn->saved_frames->count = 0;
+                }
+
+                timeout.tv_sec = conf->opt.ping_timeout;
+                timeout.tv_usec = 0;
+
+                conn->ping_timer =
+                        gf_timer_call_after (this->ctx, timeout,
+                                             rpc_client_ping_timer_expired,
+                                             (void *) this);
+
+                if (conn->ping_timer == NULL) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "unable to setup timer");
+                } else {
+                        conn->ping_started = 1;
+                }
+        }
+        pthread_mutex_unlock (&conn->lock);
+
+        frame = create_frame (this, this->ctx->pool);
+        if (!frame)
+                goto fail;
+
+        ret = client_submit_request (this, NULL, frame, conf->handshake,
+                                     GF_HNDSK_PING, NULL, NULL);
+
+        return;
+fail:
+
+        if (frame) {
+                STACK_DESTROY (frame->root);
+        }
+
+        return;
+}
+
+
+int
+client_ping_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                 void *myframe)
+{
+        xlator_t              *this    = NULL;
+        rpc_clnt_connection_t *conn    = NULL;
+        struct timeval         timeout = {0, };
+        call_frame_t          *frame   = NULL;
+        clnt_conf_t           *conf    = NULL;
+
+        frame = myframe;
+
+        this = frame->this;
+        conf = this->private;
+        conn = &conf->rpc->conn;
+
+        if (req->rpc_status == -1) {
+                /* timer expired and transport bailed out */
+                gf_log (this->name, GF_LOG_DEBUG, "timer must have expired");
+                goto out;
+        }
+
+        pthread_mutex_lock (&conn->lock);
+        {
+                timeout.tv_sec  = conf->opt.ping_timeout;
+                timeout.tv_usec = 0;
+
+                gf_timer_call_cancel (this->ctx,
+                                      conn->ping_timer);
+
+                conn->ping_timer =
+                        gf_timer_call_after (this->ctx, timeout,
+                                             client_start_ping, (void *)this);
+
+                if (conn->ping_timer == NULL)
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "gf_timer_call_after() returned NULL");
+        }
+        pthread_mutex_unlock (&conn->lock);
+out:
+        STACK_DESTROY (frame->root);
+        return 0;
+}
+
+
+int
+client_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, void *myframe)
+{
+        gf_getspec_rsp           rsp   = {0,};
+        call_frame_t            *frame = NULL;
+        clnt_conf_t             *conf = NULL;
+        int                      ret   = 0;
+        char                     spec[(32*1024)] = {0,};
+
+        frame = myframe;
+        conf  = frame->this->private;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        rsp.spec = spec;
+        ret = xdr_to_dump_version_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 == rsp.op_ret) {
+                gf_log (frame->this->name, GF_LOG_ERROR,
+                        "failed to get the 'volume file' from server");
+                goto out;
+        }
+
+out:
+        /* no _STRICT for mops */
+        STACK_UNWIND_STRICT (getspec, frame, rsp.op_ret, rsp.op_errno, rsp.spec);
+        return 0;
+}
+
+
+int
+client_post_handshake (call_frame_t *frame, xlator_t *this)
+{
+        clnt_conf_t            *conf = NULL;
+        clnt_fd_ctx_t          *tmp = NULL;
+        clnt_fd_ctx_t          *fdctx = NULL;
+        xlator_list_t          *parent = NULL;
+        struct list_head        reopen_head;
+
+        if (!this || !this->private)
+                goto out;
+
+        conf = this->private;
+        INIT_LIST_HEAD (&reopen_head);
+
+        pthread_mutex_lock (&conf->lock);
+        {
+                list_for_each_entry_safe (fdctx, tmp, &conf->saved_fds,
+                                          sfd_pos) {
+                        if (fdctx->remote_fd != -1)
+                                continue;
+
+                        list_del_init (&fdctx->sfd_pos);
+                        list_add_tail (&fdctx->sfd_pos, &reopen_head);
+                }
+        }
+        pthread_mutex_unlock (&conf->lock);
+
+        list_for_each_entry_safe (fdctx, tmp, &reopen_head, sfd_pos) {
+                list_del_init (&fdctx->sfd_pos);
+
+                if (fdctx->is_dir)
+                        protocol_client_reopendir (this, fdctx);
+                else
+                        protocol_client_reopen (this, fdctx);
+        }
+
+        parent = this->parents;
+
+        while (parent) {
+                xlator_notify (parent->xlator, GF_EVENT_CHILD_UP,
+                               this);
+                parent = parent->next;
+        }
+
+out:
+        return 0;
+}
+
+int
+client_setvolume_cbk (struct rpc_req *req, struct iovec *iov, int count, void *myframe)
+{
+        call_frame_t         *frame         = NULL;
+        clnt_conf_t          *conf          = NULL;
+        xlator_t             *this          = NULL;
+        dict_t               *reply         = NULL;
+        xlator_list_t        *parent        = NULL;
+        char                 *process_uuid  = NULL;
+        char                 *remote_error  = NULL;
+        char                 *remote_subvol = NULL;
+        rpc_transport_t      *peer_trans    = NULL;
+        gf_setvolume_rsp      rsp           = {0,};
+        uint64_t              peertrans_int = 0;
+        int                   ret           = 0;
+        int                   op_ret        = 0;
+        int                   op_errno      = 0;
+
+        frame = myframe;
+        this  = frame->this;
+        conf  = this->private;
+
+        if (-1 == req->rpc_status) {
+                op_ret = -1;
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        ret = xdr_to_setvolume_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                op_errno = EINVAL;
+                op_ret = -1;
+                goto out;
+        }
+        op_ret   = rsp.op_ret;
+        op_errno = gf_error_to_errno (rsp.op_errno);
+        if (-1 == rsp.op_ret) {
+                gf_log (frame->this->name, GF_LOG_WARNING,
+                        "failed to set the volume");
+        }
+
+        reply = dict_new ();
+        if (!reply)
+                goto out;
+
+        if (rsp.dict.dict_len) {
+                ret = dict_unserialize (rsp.dict.dict_val,
+                                        rsp.dict.dict_len, &reply);
+                if (ret < 0) {
+                        gf_log (frame->this->name, GF_LOG_DEBUG,
+                                "failed to unserialize buffer to dict");
+                        goto out;
+                }
+        }
+
+        ret = dict_get_str (reply, "ERROR", &remote_error);
+        if (ret < 0) {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "failed to get ERROR string from reply dict");
+        }
+
+        ret = dict_get_str (reply, "process-uuid", &process_uuid);
+        if (ret < 0) {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "failed to get 'process-uuid' from reply dict");
+        }
+
+        if (op_ret < 0) {
+                gf_log (this->name, GF_LOG_ERROR,
+                        "SETVOLUME on remote-host failed: %s",
+                        remote_error ? remote_error : strerror (op_errno));
+                errno = op_errno;
+                if (op_errno == ESTALE) {
+                        parent = this->parents;
+                        while (parent) {
+                                xlator_notify (parent->xlator,
+                                               GF_EVENT_VOLFILE_MODIFIED,
+                                               this);
+                                parent = parent->next;
+                        }
+                }
+                goto out;
+        }
+        ret = dict_get_str (this->options, "remote-subvolume",
+                            &remote_subvol);
+        if (!remote_subvol)
+                goto out;
+
+        if (process_uuid &&
+            !strcmp (this->ctx->process_uuid, process_uuid)) {
+                ret = dict_get_uint64 (reply, "transport-ptr",
+                                       &peertrans_int);
+
+                peer_trans = (void *) (long) (peertrans_int);
+
+                gf_log (this->name, GF_LOG_WARNING,
+                        "attaching to the local volume '%s'",
+                        remote_subvol);
+
+                if (req->conn) {
+                        /* TODO: Some issues with this logic at present */
+                        //rpc_transport_setpeer (req->conn->trans, peer_trans);
+                }
+        }
+
+        gf_log (this->name, GF_LOG_NORMAL,
+                "Connected to %s, attached to remote volume '%s'.",
+                conf->rpc->conn.trans->peerinfo.ident