protocol: make on-wire-change of protocol using new XDR definition.

With this patchset, some major things are changed in XDR, mainly:

* Naming: Instead of gfs3/gfs4 settle for gfx_ for xdr structures
* add iattx as a separate structure, and add conversion methods
* the *_rsp structure is now changed, and is also reduced in number
  (ie, no need for different strucutes if it is similar to other response).
* use proper XDR methods for sending dict on wire.

Also, with the change of xdr structure, there are changes needed
outside of xlator protocol layer to handle these properly. Mainly
because the abstraction was broken to support 0-copy RDMA with payload
for write and read FOP. This made transport layer know about the xdr
payload, hence with the change of xdr payload structure, transport layer
needed to know about the change.

Updates #384

Change-Id: I1448fbe9deab0a1b06cb8351f2f37488cefe461f
Signed-off-by: Amar Tumballi <amarts@redhat.com>

1 files changed, 0 insertions, 209 deletions

diff --git a/libglusterfs/src/dict.c b/libglusterfs/src/dict.c
index 8a6fbb21d4b..d1a64c4a3a2 100644
--- a/libglusterfs/src/dict.c
+++ b/libglusterfs/src/dict.c
@@ -29,8 +29,6 @@
 #include "libglusterfs-messages.h"
 
 #include "glusterfs-fops.h"
-#include "rpc-common-xdr.h"
-#include "glusterfs3.h"
 
 struct dict_cmp {
         dict_t *dict;
@@ -3251,210 +3249,3 @@ unlock:
         UNLOCK (&dict->lock);
         return 0;
 }
-
-/* dict_to_xdr () */
-int
-dict_to_xdr (dict_t *this, gfx_dict *dict)
-{
-        int ret = -1;
-        int i = 0;
-        int index = 0;
-        data_pair_t *dpair = NULL;
-        gfx_dict_pair *xpair = NULL;
-
-        /* This is a failure as we expect destination to be valid */
-        if (!dict)
-                goto out;
-
-        /* This is OK as dictionary can be null, in which case, destination
-           will be set as 0 sized dictionary */
-        if (!this) {
-                ret = 0;
-                dict->count = 0;
-                dict->pairs.pairs_len = 0;
-                goto out;
-        }
-
-        dict->pairs.pairs_val = GF_CALLOC (1, (this->count *
-                                               sizeof (gfx_dict_pair)),
-                                           gf_common_mt_char);
-        if (!dict->pairs.pairs_val)
-                goto out;
-
-        dpair = this->members_list;
-        for (i = 0; i < this->count; i++) {
-                xpair = &dict->pairs.pairs_val[index];
-
-                xpair->value.type = dpair->value->data_type;
-                xpair->key.key_val = dpair->key;
-                xpair->key.key_len = strlen (dpair->key) + 1;
-
-                switch (dpair->value->data_type) {
-                        /* Add more type here */
-                case GF_DATA_TYPE_INT:
-                        index++;
-                        data_to_int64_ptr (dpair->value, &xpair->value.gfx_value_u.value_int);
-                        break;
-                case GF_DATA_TYPE_UINT:
-                        index++;
-                        data_to_uint64_ptr (dpair->value, &xpair->value.gfx_value_u.value_uint);
-                        break;
-                case GF_DATA_TYPE_DOUBLE:
-                        index++;
-                        data_to_double_ptr (dpair->value,
-                                            &xpair->value.gfx_value_u.value_dbl);
-                        break;
-                case GF_DATA_TYPE_STR:
-                        index++;
-                        xpair->value.gfx_value_u.val_string.val_string_val = dpair->value->data;
-                        xpair->value.gfx_value_u.val_string.val_string_len = dpair->value->len;
-                        break;
-                case GF_DATA_TYPE_IATT:
-                        index++;
-                        gf_stat_from_iatt (&xpair->value.gfx_value_u.iatt,
-                                           (struct iatt *)dpair->value->data);
-                        break;
-                case GF_DATA_TYPE_GFUUID:
-                        index++;
-                        memcpy (&xpair->value.gfx_value_u.uuid,
-                                dpair->value->data, sizeof (uuid_t));
-                        break;
-
-                case GF_DATA_TYPE_PTR:
-                        index++;
-                        /* Ideally, each type of data stored in dictionary
-                           should have type. A pointer type shouldn't be
-                           sent on wire */
-
-                        /* This is done for backward compatibility as dict is
-                           heavily used for transporting data over wire.
-                           Ideally, whereever there is an issue, fix and move on */
-                        xpair->value.gfx_value_u.other.other_val =
-                                dpair->value->data;
-                        xpair->value.gfx_value_u.other.other_len =
-                                dpair->value->len;
-
-                        /* Change this to INFO, after taking the above down */
-                        gf_msg ("dict", GF_LOG_INFO, EINVAL,
-                                LG_MSG_DICT_SERIAL_FAILED,
-                                "key '%s' is would not be sent on wire in future",
-                                dpair->key);
-                        break;
-                default:
-                        /* Unknown type and ptr type is not sent on wire */
-                        gf_msg ("dict", GF_LOG_WARNING, EINVAL, LG_MSG_DICT_SERIAL_FAILED,
-                                "key '%s' is not sent on wire", dpair->key);
-                        break;
-                }
-
-                dpair = dpair->next;
-        }
-
-        dict->pairs.pairs_len = index;
-        dict->count = index;
-        ret = 0;
-out:
-        return ret;
-}
-
-int
-xdr_to_dict (gfx_dict *dict, dict_t **to)
-{
-        int ret = -1;
-        int index = 0;
-        char *key = NULL;
-        char *value = NULL;
-        gfx_dict_pair *xpair = NULL;
-        dict_t *this = NULL;
-        unsigned char *uuid = NULL;
-        struct iatt *iatt = NULL;
-
-        if (!to || !dict)
-                goto out;
-
-        this = dict_new();
-        if (!this)
-                goto out;
-
-        for (index = 0; index < dict->pairs.pairs_len; index++) {
-                ret = -1;
-                xpair = &dict->pairs.pairs_val[index];
-
-                key = xpair->key.key_val;
-                switch (xpair->value.type) {
-                        /* Add more type here */
-                case GF_DATA_TYPE_INT:
-                        ret = dict_set_int64 (this, key,
-                                    xpair->value.gfx_value_u.value_int);
-                        break;
-                case GF_DATA_TYPE_UINT:
-                        ret = dict_set_uint64 (this, key,
-                                    xpair->value.gfx_value_u.value_uint);
-                        break;
-                case GF_DATA_TYPE_DOUBLE:
-                        ret = dict_set_double (this, key,
-                                    xpair->value.gfx_value_u.value_dbl);
-                        break;
-                case GF_DATA_TYPE_STR:
-                        value = gf_strdup (xpair->value.gfx_value_u.val_string.val_string_val);
-                        if (!value) {
-                                errno = ENOMEM;
-                                goto out;
-                        }
-                        free (xpair->value.gfx_value_u.val_string.val_string_val);
-                        ret = dict_set_dynstr (this, key, value);
-                        break;
-                case GF_DATA_TYPE_GFUUID:
-                        uuid = GF_CALLOC (1, 20, gf_common_mt_uuid_t);
-                        if (!uuid) {
-                                errno = ENOMEM;
-                                goto out;
-                        }
-                        memcpy (uuid, xpair->value.gfx_value_u.uuid, 16);
-                        ret = dict_set_gfuuid (this, key, uuid, false);
-                        break;
-                case GF_DATA_TYPE_IATT:
-                        iatt = GF_CALLOC (1, sizeof (struct iatt), gf_common_mt_char);
-                        if (!iatt) {
-                                errno = ENOMEM;
-                                goto out;
-                        }
-                        gf_stat_to_iatt (&xpair->value.gfx_value_u.iatt, iatt);
-                        ret = dict_set_iatt (this, key, iatt, false);
-                        break;
-                case GF_DATA_TYPE_PTR:
-                        value = gf_memdup (xpair->value.gfx_value_u.other.other_val,
-                                xpair->value.gfx_value_u.other.other_len);
-                        if (!value) {
-                                errno = ENOMEM;
-                                goto out;
-                        }
-                        free (xpair->value.gfx_value_u.other.other_val);
-                        ret = dict_set_dynptr (this, key, value,
-                                               xpair->value.gfx_value_u.other.other_len);
-                        break;
-                default:
-                        ret = 0;
-                        /* Unknown type and ptr type is not sent on wire */
-                        break;
-                }
-                if (ret) {
-                        gf_msg_debug ("dict", ENOMEM,
-                                      "failed to set the key (%s) into dict",
-                                      key);
-                }
-                free (xpair->key.key_val);
-        }
-
-        free (dict->pairs.pairs_val);
-        ret = 0;
-
-        /* If everything is fine, assign the dictionary to target */
-        *to = this;
-        this = NULL;
-out:
-        if (this)
-                dict_unref (this);
-
-        return ret;
-}