core: change lk-owner as a 1k buffer

so, NLM can send the lk-owner field directly to the locks translators,
while doing the same effort, also enabled sending maximum of 500 aux gid
over protocol.

Change-Id: I87c2514392748416f7ffe21d5154faad2e413969
Signed-off-by: Amar Tumballi <amar@gluster.com>
BUG: 767229
Reviewed-on: http://review.gluster.com/779
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@gluster.com>

22 files changed, 603 insertions, 423 deletions

diff --git a/rpc/rpc-lib/src/Makefile.am b/rpc/rpc-lib/src/Makefile.am
index fcf091e9b..8b087301c 100644
--- a/rpc/rpc-lib/src/Makefile.am
+++ b/rpc/rpc-lib/src/Makefile.am
@@ -1,8 +1,8 @@
 lib_LTLIBRARIES = libgfrpc.la
 
 libgfrpc_la_SOURCES = auth-unix.c rpcsvc-auth.c rpcsvc.c auth-null.c \
-	rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c \
-	rpc-common.c
+	rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c
+
 libgfrpc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
 
 noinst_HEADERS = rpcsvc.h rpc-transport.h xdr-common.h xdr-rpc.h xdr-rpcclnt.h \
diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c
index 4faaddb9e..9996bfad4 100644
--- a/rpc/rpc-lib/src/auth-glusterfs.c
+++ b/rpc/rpc-lib/src/auth-glusterfs.c
@@ -29,94 +29,9 @@
 #include "dict.h"
 #include "xdr-rpc.h"
 #include "xdr-common.h"
+#include "rpc-common-xdr.h"
 
-bool_t
-xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp)
-{
-	register int32_t *buf;
-
-	int i;
-
-	if (xdrs->x_op == XDR_ENCODE) {
-		 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, (4 +  16 )* BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_u_int (xdrs, &objp->pid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->uid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->gid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->ngrps))
-				 return FALSE;
-			 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
-				sizeof (u_int), (xdrproc_t) xdr_u_int))
-				 return FALSE;
-		} else {
-			IXDR_PUT_U_LONG(buf, objp->pid);
-			IXDR_PUT_U_LONG(buf, objp->uid);
-			IXDR_PUT_U_LONG(buf, objp->gid);
-			IXDR_PUT_U_LONG(buf, objp->ngrps);
-			{
-				register u_int *genp;
-
-				for (i = 0, genp = objp->groups;
-					i < 16; ++i) {
-					IXDR_PUT_U_LONG(buf, *genp++);
-				}
-			}
-		}
-		return TRUE;
-	} else if (xdrs->x_op == XDR_DECODE) {
-		 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
-			 return FALSE;
-		buf = XDR_INLINE (xdrs, (4 +  16 )* BYTES_PER_XDR_UNIT);
-		if (buf == NULL) {
-			 if (!xdr_u_int (xdrs, &objp->pid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->uid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->gid))
-				 return FALSE;
-			 if (!xdr_u_int (xdrs, &objp->ngrps))
-				 return FALSE;
-			 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
-				sizeof (u_int), (xdrproc_t) xdr_u_int))
-				 return FALSE;
-		} else {
-			objp->pid = IXDR_GET_U_LONG(buf);
-			objp->uid = IXDR_GET_U_LONG(buf);
-			objp->gid = IXDR_GET_U_LONG(buf);
-			objp->ngrps = IXDR_GET_U_LONG(buf);
-			{
-				register u_int *genp;
-
-				for (i = 0, genp = objp->groups;
-					i < 16; ++i) {
-					*genp++ = IXDR_GET_U_LONG(buf);
-				}
-			}
-		}
-	 return TRUE;
-	}
-
-	 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
-		 return FALSE;
-	 if (!xdr_u_int (xdrs, &objp->pid))
-		 return FALSE;
-	 if (!xdr_u_int (xdrs, &objp->uid))
-		 return FALSE;
-	 if (!xdr_u_int (xdrs, &objp->gid))
-		 return FALSE;
-	 if (!xdr_u_int (xdrs, &objp->ngrps))
-		 return FALSE;
-	 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
-		sizeof (u_int), (xdrproc_t) xdr_u_int))
-		 return FALSE;
-	return TRUE;
-}
-
+/* V1 */
 
 ssize_t
 xdr_to_glusterfs_auth (char *buf, struct auth_glusterfs_parms *req)
@@ -146,7 +61,7 @@ auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv)
 {
         if (!req)
                 return -1;
-        memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES);
+        memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES);
         req->verf.datalen = 0;
         req->verf.flavour = AUTH_NULL;
 
@@ -155,9 +70,12 @@ auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv)
 
 int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv)
 {
-        int                          ret = RPCSVC_AUTH_REJECT;
         struct auth_glusterfs_parms  au = {0,};
-        int                          gidcount = 0;
+
+        int ret      = RPCSVC_AUTH_REJECT;
+        int gidcount = 0;
+        int j        = 0;
+        int i        = 0;
 
         if (!req)
                 return ret;
@@ -173,7 +91,11 @@ int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv)
         req->pid = au.pid;
         req->uid = au.uid;
         req->gid = au.gid;
-        req->lk_owner = au.lk_owner;
+        req->lk_owner.len = 8;
+        {
+                for (i = 0; i < req->lk_owner.len; i++, j += 8)
+                        req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff);
+        }
         req->auxgidcount = au.ngrps;
 
         if (req->auxgidcount > 16) {
@@ -187,8 +109,8 @@ int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv)
                 req->auxgids[gidcount] = au.groups[gidcount];
 
         gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %"PRId64,
-                req->pid, req->uid, req->gid, req->lk_owner);
+                ", gid: %d, owner: %s",
+                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
         ret = RPCSVC_AUTH_ACCEPT;
 err:
         return ret;
@@ -213,3 +135,111 @@ rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options)
 {
         return &rpcsvc_auth_glusterfs;
 }
+
+/* V2 */
+
+ssize_t
+xdr_to_glusterfs_auth_v2 (char *buf, struct auth_glusterfs_parms_v2 *req)
+{
+        XDR     xdr;
+        ssize_t ret = -1;
+
+        if ((!buf) || (!req))
+                return -1;
+
+        xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE);
+        if (!xdr_auth_glusterfs_parms_v2 (&xdr, req)) {
+                gf_log ("", GF_LOG_WARNING,
+                        "failed to decode glusterfs v2 parameters");
+                ret  = -1;
+                goto ret;
+        }
+
+        ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base));
+ret:
+        return ret;
+
+}
+int
+auth_glusterfs_v2_request_init (rpcsvc_request_t *req, void *priv)
+{
+        if (!req)
+                return -1;
+        memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES);
+        req->verf.datalen = 0;
+        req->verf.flavour = AUTH_NULL;
+
+        return 0;
+}
+
+int auth_glusterfs_v2_authenticate (rpcsvc_request_t *req, void *priv)
+{
+        struct auth_glusterfs_parms_v2  au = {0,};
+        int ret = RPCSVC_AUTH_REJECT;
+        int i   = 0;
+
+        if (!req)
+                return ret;
+
+        ret = xdr_to_glusterfs_auth_v2 (req->cred.authdata, &au);
+        if (ret == -1) {
+                gf_log ("", GF_LOG_WARNING,
+                        "failed to decode glusterfs credentials");
+                ret = RPCSVC_AUTH_REJECT;
+                goto err;
+        }
+
+        req->pid = au.pid;
+        req->uid = au.uid;
+        req->gid = au.gid;
+        req->lk_owner.len = au.lk_owner.lk_owner_len;
+        req->auxgidcount = au.groups.groups_len;
+
+        if (req->auxgidcount > GF_MAX_AUX_GROUPS) {
+                gf_log ("", GF_LOG_WARNING,
+                        "more than max aux gids found (%d) , truncating it "
+                        "to %d and continuing", au.groups.groups_len,
+                        GF_MAX_AUX_GROUPS);
+                req->auxgidcount = GF_MAX_AUX_GROUPS;
+        }
+
+        if (req->lk_owner.len > GF_MAX_LOCK_OWNER_LEN) {
+                gf_log ("", GF_LOG_WARNING,
+                        "lkowner field > 1k, failing authentication");
+                ret = RPCSVC_AUTH_REJECT;
+                goto err;
+        }
+
+        for (i = 0; i < req->auxgidcount; ++i)
+                req->auxgids[i] = au.groups.groups_val[i];
+
+        for (i = 0; i < au.lk_owner.lk_owner_len; ++i)
+                req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i];
+
+        gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
+                ", gid: %d, owner: %s",
+                req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner));
+        ret = RPCSVC_AUTH_ACCEPT;
+err:
+        return ret;
+}
+
+rpcsvc_auth_ops_t auth_glusterfs_ops_v2 = {
+        .transport_init         = NULL,
+        .request_init           = auth_glusterfs_v2_request_init,
+        .authenticate           = auth_glusterfs_v2_authenticate
+};
+
+rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {
+        .authname       = "AUTH_GLUSTERFS-v2",
+        .authnum        = AUTH_GLUSTERFS_v2,
+        .authops        = &auth_glusterfs_ops_v2,
+        .authprivate    = NULL
+};
+
+
+rpcsvc_auth_t *
+rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options)
+{
+        return &rpcsvc_auth_glusterfs_v2;
+}
diff --git a/rpc/rpc-lib/src/auth-null.c b/rpc/rpc-lib/src/auth-null.c
index ee50ab669..aa6b4c1bd 100644
--- a/rpc/rpc-lib/src/auth-null.c
+++ b/rpc/rpc-lib/src/auth-null.c
@@ -34,10 +34,10 @@ auth_null_request_init (rpcsvc_request_t *req, void *priv)
         if (!req)
                 return -1;
 
-        memset (req->cred.authdata, 0, RPCSVC_MAX_AUTH_BYTES);
+        memset (req->cred.authdata, 0, GF_MAX_AUTH_BYTES);
         req->cred.datalen = 0;
 
-        memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES);
+        memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES);
         req->verf.datalen = 0;
 
         return 0;
diff --git a/rpc/rpc-lib/src/auth-unix.c b/rpc/rpc-lib/src/auth-unix.c
index c48743db9..c3b58945a 100644
--- a/rpc/rpc-lib/src/auth-unix.c
+++ b/rpc/rpc-lib/src/auth-unix.c
@@ -35,7 +35,7 @@ auth_unix_request_init (rpcsvc_request_t *req, void *priv)
 {
         if (!req)
                 return -1;
-        memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES);
+        memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES);
         req->verf.datalen = 0;
         req->verf.flavour = AUTH_NULL;
 
diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c
index 43791dc57..e21aac755 100644
--- a/rpc/rpc-lib/src/rpc-clnt.c
+++ b/rpc/rpc-lib/src/rpc-clnt.c
@@ -32,6 +32,7 @@
 #include "protocol-common.h"
 #include "mem-pool.h"
 #include "xdr-rpc.h"
+#include "rpc-common-xdr.h"
 
 void
 rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool);
@@ -1091,7 +1092,7 @@ rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn,
 }
 
 ssize_t
-xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms *au)
+xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms_v2 *au)
 {
         ssize_t ret = -1;
         XDR     xdr;
@@ -1099,10 +1100,9 @@ xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms *au)
         if ((!dest) || (!au))
                 return -1;
 
-        xdrmem_create (&xdr, dest, 1024,
-                       XDR_ENCODE);
+        xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE);
 
-        if (!xdr_auth_glusterfs_parms (&xdr, au)) {
+        if (!xdr_auth_glusterfs_parms_v2 (&xdr, au)) {
                 gf_log (THIS->name, GF_LOG_WARNING,
                         "failed to encode auth glusterfs elements");
                 ret = -1;
@@ -1118,7 +1118,7 @@ ret:
 
 int
 rpc_clnt_fill_request (int prognum, int progver, int procnum, int payload,
-                       uint64_t xid, struct auth_glusterfs_parms *au,
+                       uint64_t xid, struct auth_glusterfs_parms_v2 *au,
                        struct rpc_msg *request, char *auth_data)
 {
         int   ret          = -1;
@@ -1146,7 +1146,7 @@ rpc_clnt_fill_request (int prognum, int progver, int procnum, int payload,
                 goto out;
         }
 
-        request->rm_call.cb_cred.oa_flavor = AUTH_GLUSTERFS;
+        request->rm_call.cb_cred.oa_flavor = AUTH_GLUSTERFS_v2;
         request->rm_call.cb_cred.oa_base   = auth_data;
         request->rm_call.cb_cred.oa_length = ret;
 
@@ -1198,16 +1198,16 @@ out:
 struct iobuf *
 rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver,
                               int procnum, size_t payload, uint64_t xid,
-                              struct auth_glusterfs_parms *au,
+                              struct auth_glusterfs_parms_v2 *au,
                               struct iovec *recbuf)
 {
-        struct rpc_msg           request                            = {0, };
-        struct iobuf            *request_iob                        = NULL;
-        char                    *record                             = NULL;
-        struct iovec             recordhdr                          = {0, };
-        size_t                   pagesize                           = 0;
-        int                      ret                                = -1;
-        char                     auth_data[RPC_CLNT_MAX_AUTH_BYTES] = {0, };
+        struct rpc_msg  request                      = {0, };
+        struct iobuf   *request_iob                  = NULL;
+        char           *record                       = NULL;
+        struct iovec    recordhdr                    = {0, };
+        size_t          pagesize                     = 0;
+        int             ret                          = -1;
+        char            auth_data[GF_MAX_AUTH_BYTES] = {0, };
 
         if ((!clnt) || (!recbuf) || (!au)) {
                 goto out;
@@ -1237,8 +1237,6 @@ rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver,
         recordhdr = rpc_clnt_record_build_header (record, pagesize, &request,
                                                   payload);
 
-        //GF_FREE (request.rm_call.cb_cred.oa_base);
-
         if (!recordhdr.iov_base) {
                 gf_log (clnt->conn.trans->name, GF_LOG_ERROR,
                         "Failed to build record header");
@@ -1261,29 +1259,38 @@ rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame,
                  rpc_clnt_prog_t *prog,int procnum, size_t payload_len,
                  struct iovec *rpchdr, uint64_t callid)
 {
-        struct auth_glusterfs_parms  au                    = {0, };
-        struct iobuf                *request_iob           = NULL;
+        struct auth_glusterfs_parms_v2  au          = {0, };
+        struct iobuf                   *request_iob = NULL;
+        char                            owner[4] = {0,};
 
         if (!prog || !rpchdr || !call_frame) {
                 goto out;
         }
 
-        au.pid      = call_frame->root->pid;
-        au.uid      = call_frame->root->uid;
-        au.gid      = call_frame->root->gid;
-        au.ngrps    = call_frame->root->ngrps;
-        au.lk_owner = call_frame->root->lk_owner;
-        if (!au.lk_owner)
-                au.lk_owner = au.pid;
+        au.pid                   = call_frame->root->pid;
+        au.uid                   = call_frame->root->uid;
+        au.gid                   = call_frame->root->gid;
+        au.groups.groups_len     = call_frame->root->ngrps;
+        au.lk_owner.lk_owner_len = call_frame->root->lk_owner.len;
 
-        gf_log (clnt->conn.trans->name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
-                ", gid: %d, owner: %"PRId64,
-                au.pid, au.uid, au.gid, au.lk_owner);
+        if (au.groups.groups_len)
+                au.groups.groups_val = call_frame->root->groups;
 
-        memcpy (au.groups, call_frame->root->groups, sizeof (au.groups));
+        if (call_frame->root->lk_owner.len)
+                au.lk_owner.lk_owner_val = call_frame->root->lk_owner.data;
+        else {
+                owner[0] = (char)(au.pid & 0xff);
+                owner[1] = (char)((au.pid >> 8) & 0xff);
+                owner[2] = (char)((au.pid >> 16) & 0xff);
+                owner[3] = (char)((au.pid >> 24) & 0xff);
 
-        //rpc_transport_get_myname (clnt->conn.trans, myname, UNIX_PATH_MAX);
-        //au.aup_machname = myname;
+                au.lk_owner.lk_owner_val = owner;
+                au.lk_owner.lk_owner_len = 4;
+        }
+
+        gf_log (clnt->conn.trans->name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"
+                ", gid: %d, owner: %s", au.pid, au.uid, au.gid,
+                lkowner_utoa (&call_frame->root->lk_owner));
 
         /* Assuming the client program would like to speak to the same version of
          * program on server.
diff --git a/rpc/rpc-lib/src/rpc-clnt.h b/rpc/rpc-lib/src/rpc-clnt.h
index e3b2ec3f1..7034da705 100644
--- a/rpc/rpc-lib/src/rpc-clnt.h
+++ b/rpc/rpc-lib/src/rpc-clnt.h
@@ -31,8 +31,6 @@ typedef enum {
         RPC_CLNT_MSG
 } rpc_clnt_event_t;
 
-#define AUTH_GLUSTERFS  5
-#define RPC_CLNT_MAX_AUTH_BYTES 1024
 
 #define SFRAME_GET_PROGNUM(sframe) (sframe->rpcreq->prog->prognum)
 #define SFRAME_GET_PROGVER(sframe) (sframe->rpcreq->prog->progver)
@@ -121,11 +119,10 @@ typedef struct rpcclnt_cb_program {
 
 
 
-#define RPC_MAX_AUTH_BYTES   400
 typedef struct rpc_auth_data {
-        int             flavour;
-        int             datalen;
-        char            authdata[RPC_MAX_AUTH_BYTES];
+        int  flavour;
+        int  datalen;
+        char authdata[GF_MAX_AUTH_BYTES];
 } rpc_auth_data_t;
 
 
diff --git a/rpc/rpc-lib/src/rpc-common.c b/rpc/rpc-lib/src/rpc-common.c
deleted file mode 100644
index ff8785c67..000000000
--- a/rpc/rpc-lib/src/rpc-common.c
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-  Copyright (c) 2010-2011 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 "logging.h"
-#include "xdr-common.h"
-
-ssize_t
-xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc)
-{
-        ssize_t ret = -1;
-        XDR     xdr;
-
-        if ((!outmsg.iov_base) || (!res) || (!proc))
-                return -1;
-
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
-
-        if (!proc (&xdr, res)) {
-                gf_log_callingfn ("xdr", GF_LOG_WARNING,
-                                  "XDR encoding failed");
-                ret = -1;
-                goto ret;
-        }
-
-        ret = xdr_encoded_length (xdr);
-
-ret:
-        return ret;
-}
-
-
-ssize_t
-xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc)
-{
-        XDR     xdr;
-        ssize_t ret = -1;
-
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
-
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
-
-        if (!proc (&xdr, args)) {
-                gf_log_callingfn ("xdr", GF_LOG_WARNING,
-                                  "XDR decoding failed");
-                ret  = -1;
-                goto ret;
-        }
-
-        ret = xdr_decoded_length (xdr);
-ret:
-        return ret;
-}
-
-
-bool_t
-xdr_gf_dump_req (XDR *xdrs, gf_dump_req *objp)
-{
-	 if (!xdr_u_quad_t (xdrs, &objp->gfs_id))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_gf_prog_detail (XDR *xdrs, gf_prog_detail *objp)
-{
-	 if (!xdr_string (xdrs, &objp->progname, ~0))
-		 return FALSE;
-	 if (!xdr_u_quad_t (xdrs, &objp->prognum))
-		 return FALSE;
-	 if (!xdr_u_quad_t (xdrs, &objp->progver))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (gf_prog_detail),
-                           (xdrproc_t) xdr_gf_prog_detail))
-		 return FALSE;
-	return TRUE;
-}
-
-bool_t
-xdr_gf_dump_rsp (XDR *xdrs, gf_dump_rsp *objp)
-{
-	 if (!xdr_u_quad_t (xdrs, &objp->gfs_id))
-		 return FALSE;
-	 if (!xdr_int (xdrs, &objp->op_ret))
-		 return FALSE;
-	 if (!xdr_int (xdrs, &objp->op_errno))
-		 return FALSE;
-	 if (!xdr_pointer (xdrs, (char **)&objp->prog, sizeof (gf_prog_detail),
-                           (xdrproc_t) xdr_gf_prog_detail))
-		 return FALSE;
-	return TRUE;
-}
-
-
-ssize_t
-xdr_serialize_dump_rsp (struct iovec outmsg, void *rsp)
-{
-        return xdr_serialize_generic (outmsg, (void *)rsp,
-                                      (xdrproc_t)xdr_gf_dump_rsp);
-}
-
-ssize_t
-xdr_to_dump_req (struct iovec inmsg, void *args)
-{
-        return xdr_to_generic (inmsg, (void *)args,
-                               (xdrproc_t)xdr_gf_dump_req);
-}
-
-
-ssize_t
-xdr_from_dump_req (struct iovec outmsg, void *rsp)
-{
-        return xdr_serialize_generic (outmsg, (void *)rsp,
-                                      (xdrproc_t)xdr_gf_dump_req);
-}
-
-ssize_t
-xdr_to_dump_rsp (struct iovec inmsg, void *args)
-{
-        return xdr_to_generic (inmsg, (void *)args,
-                               (xdrproc_t)xdr_gf_dump_rsp);
-}
diff --git a/rpc/rpc-lib/src/rpcsvc-auth.c b/rpc/rpc-lib/src/rpcsvc-auth.c
index d62bd100b..930eabdda 100644
--- a/rpc/rpc-lib/src/rpcsvc-auth.c
+++ b/rpc/rpc-lib/src/rpcsvc-auth.c
@@ -29,6 +29,8 @@ rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options);
 
 extern rpcsvc_auth_t *
 rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options);
+extern rpcsvc_auth_t *
+rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options);
 
 int
 rpcsvc_auth_add_initer (struct list_head *list, char *idfier,
@@ -66,6 +68,16 @@ rpcsvc_auth_add_initers (rpcsvc_t *svc)
                 goto err;
         }
 
+
+        ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v2",
+                                      (rpcsvc_auth_initer_t)
+                                      rpcsvc_auth_glusterfs_v2_init);
+        if (ret == -1) {
+                gf_log (GF_RPCSVC, GF_LOG_ERROR,
+                        "Failed to add AUTH_GLUSTERFS-v2");
+                goto err;
+        }
+
         ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-unix",
                                       (rpcsvc_auth_initer_t)
                                       rpcsvc_auth_unix_init);
@@ -434,8 +446,12 @@ rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen)
                 return NULL;
 
         /* In case of AUTH_NULL auxgids are not used */
-        if ((req->cred.flavour != AUTH_UNIX) &&
-            (req->cred.flavour != AUTH_GLUSTERFS)) {
+        switch (req->cred.flavour) {
+        case AUTH_UNIX:
+        case AUTH_GLUSTERFS:
+        case AUTH_GLUSTERFS_v2:
+                break;
+        default:
                 gf_log ("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs");
                 return NULL;
         }
diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c
index 5805f8a5c..e0fc29184 100644
--- a/rpc/rpc-lib/src/rpcsvc.c
+++ b/rpc/rpc-lib/src/rpcsvc.c
@@ -34,6 +34,8 @@
 #include "iobuf.h"
 #include "globals.h"
 #include "xdr-common.h"
+#include "xdr-generic.h"
+#include "rpc-common-xdr.h"
 
 #include <errno.h>
 #include <pthread.h>
@@ -1687,7 +1689,7 @@ fail:
         iov.iov_base = rsp_buf;
         iov.iov_len  = dump_rsp_len;
 
-        ret = xdr_serialize_dump_rsp (iov, &rsp);
+        ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp);
         if (ret < 0) {
                 if (req)
                         req->rpc_err = GARBAGE_ARGS;
diff --git a/rpc/rpc-lib/src/rpcsvc.h b/rpc/rpc-lib/src/rpcsvc.h
index 83aa33f80..b15476704 100644
--- a/rpc/rpc-lib/src/rpcsvc.h
+++ b/rpc/rpc-lib/src/rpcsvc.h
@@ -43,10 +43,6 @@
 #include <rpc/rpc_msg.h>
 #include "compat.h"
 
-#ifndef NGRPS
-#define NGRPS 16
-#endif /* !NGRPS */
-
 #ifndef MAX_IOVEC
 #define MAX_IOVEC 16
 #endif
@@ -115,8 +111,6 @@
 #define AUTH_KERB       4               /* kerberos style */
 #endif /* */
 
-#define AUTH_GLUSTERFS  5
-
 typedef struct rpcsvc_program rpcsvc_program_t;
 
 struct rpcsvc_notify_wrapper {
@@ -143,11 +137,10 @@ struct rpcsvc_config {
         int    max_block_size;
 };
 
-#define RPCSVC_MAX_AUTH_BYTES   400
 typedef struct rpcsvc_auth_data {
         int             flavour;
         int             datalen;
-        char            authdata[RPCSVC_MAX_AUTH_BYTES];
+        char            authdata[GF_MAX_AUTH_BYTES];
 } rpcsvc_auth_data_t;
 
 #define rpcsvc_auth_flavour(au)    ((au).flavour)
@@ -184,13 +177,13 @@ struct rpcsvc_request {
         gid_t                   gid;
         pid_t                   pid;
 
-        uint64_t                lk_owner;
+        gf_lkowner_t            lk_owner;
         uint64_t                gfs_id;
 
         /* Might want to move this to AUTH_UNIX specific state since this array
          * is not available for every authentication scheme.
          */
-        gid_t                   auxgids[NGRPS];
+        gid_t                   auxgids[GF_MAX_AUX_GROUPS];
         int                     auxgidcount;
 
 
diff --git a/rpc/rpc-lib/src/xdr-common.h b/rpc/rpc-lib/src/xdr-common.h
index 8402a6222..d5198d20f 100644
--- a/rpc/rpc-lib/src/xdr-common.h
+++ b/rpc/rpc-lib/src/xdr-common.h
@@ -34,7 +34,6 @@
 #include <dirent.h>
 #endif /* __NetBSD__ */
 
-
 enum gf_dump_procnum {
         GF_DUMP_NULL,
         GF_DUMP_DUMP,
@@ -44,6 +43,7 @@ enum gf_dump_procnum {
 #define GLUSTER_DUMP_PROGRAM 123451501 /* Completely random */
 #define GLUSTER_DUMP_VERSION 1
 
+#define GF_MAX_AUTH_BYTES   2048
 
 #if GF_DARWIN_HOST_OS
 #define xdr_u_quad_t xdr_u_int64_t
@@ -67,52 +67,6 @@ enum gf_dump_procnum {
 #define xdr_uint32_t xdr_uint32_t
 #endif
 
-struct auth_glusterfs_parms {
-	uint64_t lk_owner;
-	u_int pid;
-	u_int uid;
-	u_int gid;
-	u_int ngrps;
-	u_int groups[16];
-} __attribute__((packed));
-typedef struct auth_glusterfs_parms auth_glusterfs_parms;
-
-struct gf_dump_req {
-	uint64_t gfs_id;
-} __attribute__((packed));
-typedef struct gf_dump_req gf_dump_req;
-
-struct gf_prog_detail {
-	char    *progname;
-	uint64_t prognum;
-	uint64_t progver;
-	struct gf_prog_detail *next;
-} __attribute__((packed));
-typedef struct gf_prog_detail gf_prog_detail;
-
-struct gf_dump_rsp {
-	uint64_t gfs_id;
-	int op_ret;
-	int op_errno;
-	struct gf_prog_detail *prog;
-}__attribute__((packed));
-typedef struct gf_dump_rsp gf_dump_rsp;
-
-extern bool_t
-xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp);
-extern bool_t xdr_gf_dump_req (XDR *, gf_dump_req*);
-extern bool_t xdr_gf_prog_detail (XDR *, gf_prog_detail*);
-extern bool_t xdr_gf_dump_rsp (XDR *, gf_dump_rsp*);
-
-ssize_t
-xdr_serialize_dump_rsp (struct iovec outmsg, void *rsp);
-ssize_t
-xdr_to_dump_req (struct iovec inmsg, void *args);
-ssize_t
-xdr_from_dump_req (struct iovec outmsg, void *rsp);
-ssize_t
-xdr_to_dump_rsp (struct iovec inmsg, void *args);
-
 /* Returns the address of the byte that follows the
  * last byte used for decoding the previous xdr component.
  * E.g. once the RPC call for NFS has been decoded, the macro will return
diff --git a/rpc/rpc-lib/src/xdr-rpc.h b/rpc/rpc-lib/src/xdr-rpc.h
index 99ad88836..226f8e8b3 100644
--- a/rpc/rpc-lib/src/xdr-rpc.h
+++ b/rpc/rpc-lib/src/xdr-rpc.h
@@ -17,7 +17,7 @@
   <http://www.gnu.org/licenses/>.
 */
 
-#ifndef _XDR_RPC_H
+#ifndef _XDR_RPC_H_
 #define _XDR_RPC_H_
 
 #ifndef _CONFIG_H
@@ -39,6 +39,13 @@
 #include <rpc/xdr.h>
 #include <sys/uio.h>
 
+#include "xdr-common.h"
+
+typedef enum {
+        AUTH_GLUSTERFS = 5,
+        AUTH_GLUSTERFS_v2 = 6,
+} gf_rpc_authtype_t;
+
 /* Converts a given network buffer from its XDR format to a structure
  * that contains everything an RPC call needs to work.
  */
diff --git a/rpc/rpc-transport/rdma/src/Makefile.am b/rpc/rpc-transport/rdma/src/Makefile.am
index bc888b175..b4b940bca 100644
--- a/rpc/rpc-transport/rdma/src/Makefile.am
+++ b/rpc/rpc-transport/rdma/src/Makefile.am
@@ -15,6 +15,6 @@ noinst_HEADERS = rdma.h name.h
 
 AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS)  \
 	-I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src/ \
-	-I$(top_srcdir)/xlators/protocol/lib/src -shared -nostartfiles $(GF_CFLAGS)
+	-I$(top_srcdir)/rpc/xdr/src -shared -nostartfiles $(GF_CFLAGS)
 
 CLEANFILES = *~
diff --git a/rpc/xdr/src/Makefile.am b/rpc/xdr/src/Makefile.am
index cabab3db6..57c193387 100644
--- a/rpc/xdr/src/Makefile.am
+++ b/rpc/xdr/src/Makefile.am
@@ -9,14 +9,14 @@ libgfxdr_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 \
 libgfxdr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 		$(top_builddir)/rpc/rpc-lib/src/libgfrpc.la
 
-libgfxdr_la_SOURCES =  xdr-generic.c \
+libgfxdr_la_SOURCES =  xdr-generic.c rpc-common-xdr.c \
 			glusterfs3-xdr.c \
 			cli1-xdr.c \
 			glusterd1-xdr.c \
 			portmap-xdr.c \
 			xdr-nfs3.c msg-nfs3.c
 
-noinst_HEADERS = xdr-generic.h \
+noinst_HEADERS = xdr-generic.h rpc-common-xdr.h \
 		glusterfs3-xdr.h glusterfs3.h \
 		cli1-xdr.h \
 		glusterd1-xdr.h \
diff --git a/rpc/xdr/src/glusterfs3-xdr.c b/rpc/xdr/src/glusterfs3-xdr.c
index 64e504f46..62cff241d 100644
--- a/rpc/xdr/src/glusterfs3-xdr.c
+++ b/rpc/xdr/src/glusterfs3-xdr.c
@@ -80,7 +80,7 @@ xdr_gf_proto_flock (XDR *xdrs, gf_proto_flock *objp)
 		 return FALSE;
 	 if (!xdr_u_int (xdrs, &objp->pid))
 		 return FALSE;
-	 if (!xdr_u_quad_t (xdrs, &objp->owner))
+	 if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
 		 return FALSE;
 	return TRUE;
 }
diff --git a/rpc/xdr/src/glusterfs3-xdr.h b/rpc/xdr/src/glusterfs3-xdr.h
index 0c8af17d2..d9cf7926f 100644
--- a/rpc/xdr/src/glusterfs3-xdr.h
+++ b/rpc/xdr/src/glusterfs3-xdr.h
@@ -63,7 +63,10 @@ struct gf_proto_flock {
 	u_quad_t start;
 	u_quad_t len;
 	u_int pid;
-	u_quad_t owner;
+	struct {
+		u_int lk_owner_len;
+		char *lk_owner_val;
+	} lk_owner;
 };
 typedef struct gf_proto_flock gf_proto_flock;
 
diff --git a/rpc/xdr/src/glusterfs3-xdr.x b/rpc/xdr/src/glusterfs3-xdr.x
index 592f7ed70..131feff1b 100644
--- a/rpc/xdr/src/glusterfs3-xdr.x
+++ b/rpc/xdr/src/glusterfs3-xdr.x
@@ -19,7 +19,7 @@ struct gf_proto_flock {
 	unsigned hyper start;
 	unsigned hyper len;
         unsigned int   pid;
-        unsigned hyper owner;
+        opaque         lk_owner<>;
 } ;
 
 
diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h
index ba64a0b45..82a9e2001 100644
--- a/rpc/xdr/src/glusterfs3.h
+++ b/rpc/xdr/src/glusterfs3.h
@@ -197,7 +197,11 @@ gf_proto_flock_to_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock
 	gf_flock->l_start    = gf_proto_flock->start;
 	gf_flock->l_len      = gf_proto_flock->len;
 	gf_flock->l_pid      = gf_proto_flock->pid;
-	gf_flock->l_owner    = gf_proto_flock->owner;
+        gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len;
+        if (gf_flock->l_owner.len &&
+            (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN))
+                memcpy (gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val,
+                        gf_flock->l_owner.len);
 }
 
 
@@ -212,7 +216,9 @@ gf_proto_flock_from_flock (struct gf_proto_flock *gf_proto_flock, struct gf_floc
 	gf_proto_flock->start    =  (gf_flock->l_start);
 	gf_proto_flock->len      =  (gf_flock->l_len);
 	gf_proto_flock->pid      =  (gf_flock->l_pid);
-	gf_proto_flock->owner    =  (gf_flock->l_owner);
+	gf_proto_flock->lk_owner.lk_owner_len =  gf_flock->l_owner.len;
+        if (gf_flock->l_owner.len)
+                gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data;
 }
 
 static inline void
diff --git a/rpc/xdr/src/msg-nfs3.c b/rpc/xdr/src/msg-nfs3.c
index d760d43b5..5fc92123c 100644
--- a/rpc/xdr/src/msg-nfs3.c
+++ b/rpc/xdr/src/msg-nfs3.c
@@ -63,84 +63,6 @@ ret:
         return ret;
 }
 
-/*
-ssize_t
-xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc)
-{
-        ssize_t ret = -1;
-        XDR     xdr;
-
-        if ((!outmsg.iov_base) || (!res) || (!proc))
-                return -1;
-
-        xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len,
-                       XDR_ENCODE);
-
-        if (!proc (&xdr, res)) {
-                ret = -1;
-                goto ret;
-        }
-
-        ret = xdr_encoded_length (xdr);
-
-ret:
-        return ret;
-}
-
-
-ssize_t
-xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc)
-{
-        XDR     xdr;
-        ssize_t ret = -1;
-
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
-
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
-
-        if (!proc (&xdr, args)) {
-                ret  = -1;
-                goto ret;
-        }
-
-        ret = xdr_decoded_length (xdr);
-ret:
-        return ret;
-}
-
-
-ssize_t
-xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc,
-                            struct iovec *pendingpayload)
-{
-        XDR     xdr;
-        ssize_t ret = -1;
-
-        if ((!inmsg.iov_base) || (!args) || (!proc))
-                return -1;
-
-        xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len,
-                       XDR_DECODE);
-
-        if (!proc (&xdr, args)) {
-                ret  = -1;
-                goto ret;
-        }
-
-        ret = xdr_decoded_length (xdr);
-
-        if (pendingpayload) {
-                pendingpayload->iov_base = xdr_decoded_remaining_addr (xdr);
-                pendingpayload->iov_len = xdr_decoded_remaining_len (xdr);
-        }
-
-ret:
-        return ret;
-}
-*/
-
 /* Translate the mountres3 structure in res into XDR format into memory
  * referenced by outmsg.iov_base.
  * Returns the number of bytes used in encoding into XDR format.
diff --git a/rpc/xdr/src/rpc-common-xdr.c b/rpc/xdr/src/rpc-common-xdr.c
new file mode 100644
index 000000000..14ddea715
--- /dev/null
+++ b/rpc/xdr/src/rpc-common-xdr.c
@@ -0,0 +1,232 @@
+/*
+  Copyright (c) 2007-2011 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 "xdr-common.h"
+#include "compat.h"
+
+#if defined(__GNUC__)
+#if __GNUC__ >= 4
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#endif
+
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "rpc-common-xdr.h"
+
+bool_t
+xdr_auth_glusterfs_parms_v2 (XDR *xdrs, auth_glusterfs_parms_v2 *objp)
+{
+	register int32_t *buf;
+        buf = NULL;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->pid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->uid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->gid))
+				 return FALSE;
+
+		} else {
+		IXDR_PUT_LONG(buf, objp->pid);
+		IXDR_PUT_U_LONG(buf, objp->uid);
+		IXDR_PUT_U_LONG(buf, objp->gid);
+		}
+		 if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
+			sizeof (u_int), (xdrproc_t) xdr_u_int))
+			 return FALSE;
+		 if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
+			 return FALSE;
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->pid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->uid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->gid))
+				 return FALSE;
+
+		} else {
+		objp->pid = IXDR_GET_LONG(buf);
+		objp->uid = IXDR_GET_U_LONG(buf);
+		objp->gid = IXDR_GET_U_LONG(buf);
+		}
+		 if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
+			sizeof (u_int), (xdrproc_t) xdr_u_int))
+			 return FALSE;
+		 if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
+			 return FALSE;
+	 return TRUE;
+	}
+
+	 if (!xdr_int (xdrs, &objp->pid))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->uid))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->gid))
+		 return FALSE;
+	 if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
+		sizeof (u_int), (xdrproc_t) xdr_u_int))
+		 return FALSE;
+	 if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp)
+{
+	register int32_t *buf;
+        int i;
+        buf = NULL;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
+			 return FALSE;
+		buf = XDR_INLINE (xdrs, (4 +  16 )* BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_u_int (xdrs, &objp->pid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->uid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->gid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->ngrps))
+				 return FALSE;
+			 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
+				sizeof (u_int), (xdrproc_t) xdr_u_int))
+				 return FALSE;
+		} else {
+			IXDR_PUT_U_LONG(buf, objp->pid);
+			IXDR_PUT_U_LONG(buf, objp->uid);
+			IXDR_PUT_U_LONG(buf, objp->gid);
+			IXDR_PUT_U_LONG(buf, objp->ngrps);
+			{
+				register u_int *genp;
+
+				for (i = 0, genp = objp->groups;
+					i < 16; ++i) {
+					IXDR_PUT_U_LONG(buf, *genp++);
+				}
+			}
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
+			 return FALSE;
+		buf = XDR_INLINE (xdrs, (4 +  16 )* BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_u_int (xdrs, &objp->pid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->uid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->gid))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->ngrps))
+				 return FALSE;
+			 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
+				sizeof (u_int), (xdrproc_t) xdr_u_int))
+				 return FALSE;
+		} else {
+			objp->pid = IXDR_GET_U_LONG(buf);
+			objp->uid = IXDR_GET_U_LONG(buf);
+			objp->gid = IXDR_GET_U_LONG(buf);
+			objp->ngrps = IXDR_GET_U_LONG(buf);
+			{
+				register u_int *genp;
+
+				for (i = 0, genp = objp->groups;
+					i < 16; ++i) {
+					*genp++ = IXDR_GET_U_LONG(buf);
+				}
+			}
+		}
+	 return TRUE;
+	}
+
+	 if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->pid))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->uid))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->gid))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->ngrps))
+		 return FALSE;
+	 if (!xdr_vector (xdrs, (char *)objp->groups, 16,
+		sizeof (u_int), (xdrproc_t) xdr_u_int))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_gf_dump_req (XDR *xdrs, gf_dump_req *objp)
+{
+	register int32_t *buf;
+        buf = NULL;
+
+	 if (!xdr_u_quad_t (xdrs, &objp->gfs_id))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_gf_prog_detail (XDR *xdrs, gf_prog_detail *objp)
+{
+	register int32_t *buf;
+        buf = NULL;
+
+	 if (!xdr_string (xdrs, &objp->progname, ~0))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->prognum))
+		 return FALSE;
+	 if (!xdr_u_quad_t (xdrs, &objp->progver))
+		 return FALSE;
+	 if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_gf_dump_rsp (XDR *xdrs, gf_dump_rsp *objp)
+{
+	register int32_t *buf;
+        buf = NULL;
+
+	 if (!xdr_u_quad_t (xdrs, &objp->gfs_id))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->op_ret))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->op_errno))
+		 return FALSE;
+	 if (!xdr_pointer (xdrs, (char **)&objp->prog, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail))
+		 return FALSE;
+	return TRUE;
+}
diff --git a/rpc/xdr/src/rpc-common-xdr.h b/rpc/xdr/src/rpc-common-xdr.h
new file mode 100644
index 000000000..66d9c3772
--- /dev/null
+++ b/rpc/xdr/src/rpc-common-xdr.h
@@ -0,0 +1,113 @@
+/*
+  Copyright (c) 2007-2011 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 "xdr-common.h"
+#include "compat.h"
+
+#if defined(__GNUC__)
+#if __GNUC__ >= 4
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#endif
+
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _RPC_COMMON_XDR_H_RPCGEN
+#define _RPC_COMMON_XDR_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct auth_glusterfs_parms_v2 {
+	int pid;
+	u_int uid;
+	u_int gid;
+	struct {
+		u_int groups_len;
+		u_int *groups_val;
+	} groups;
+	struct {
+		u_int lk_owner_len;
+		char *lk_owner_val;
+	} lk_owner;
+};
+typedef struct auth_glusterfs_parms_v2 auth_glusterfs_parms_v2;
+
+struct auth_glusterfs_parms {
+	u_quad_t lk_owner;
+	u_int pid;
+	u_int uid;
+	u_int gid;
+	u_int ngrps;
+	u_int groups[16];
+};
+typedef struct auth_glusterfs_parms auth_glusterfs_parms;
+
+struct gf_dump_req {
+	u_quad_t gfs_id;
+};
+typedef struct gf_dump_req gf_dump_req;
+
+struct gf_prog_detail {
+	char *progname;
+	u_quad_t prognum;
+	u_quad_t progver;
+	struct gf_prog_detail *next;
+};
+typedef struct gf_prog_detail gf_prog_detail;
+
+struct gf_dump_rsp {
+	u_quad_t gfs_id;
+	int op_ret;
+	int op_errno;
+	struct gf_prog_detail *prog;
+};
+typedef struct gf_dump_rsp gf_dump_rsp;
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern  bool_t xdr_auth_glusterfs_parms_v2 (XDR *, auth_glusterfs_parms_v2*);
+extern  bool_t xdr_auth_glusterfs_parms (XDR *, auth_glusterfs_parms*);
+extern  bool_t xdr_gf_dump_req (XDR *, gf_dump_req*);
+extern  bool_t xdr_gf_prog_detail (XDR *, gf_prog_detail*);
+extern  bool_t xdr_gf_dump_rsp (XDR *, gf_dump_rsp*);
+
+#else /* K&R C */
+extern bool_t xdr_auth_glusterfs_parms_v2 ();
+extern bool_t xdr_auth_glusterfs_parms ();
+extern bool_t xdr_gf_dump_req ();
+extern bool_t xdr_gf_prog_detail ();
+extern bool_t xdr_gf_dump_rsp ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_RPC_COMMON_XDR_H_RPCGEN */
diff --git a/rpc/xdr/src/rpc-common-xdr.x b/rpc/xdr/src/rpc-common-xdr.x
new file mode 100644
index 000000000..ca28f38b5
--- /dev/null
+++ b/rpc/xdr/src/rpc-common-xdr.x
@@ -0,0 +1,39 @@
+/* This file has definition of few XDR structures which are
+ * not captured in any section specific file */
+
+struct auth_glusterfs_parms_v2 {
+        int pid;
+        unsigned int uid;
+        unsigned int gid;
+        unsigned int groups<>;
+        opaque lk_owner<>;
+};
+
+struct auth_glusterfs_parms {
+        unsigned hyper lk_owner;
+        unsigned int pid;
+        unsigned int uid;
+	unsigned int gid;
+	unsigned int ngrps;
+	unsigned groups[16];
+};
+
+struct gf_dump_req {
+	unsigned hyper gfs_id;
+};
+
+
+struct gf_prog_detail {
+	string progname<>;
+	unsigned hyper prognum;
+	unsigned hyper progver;
+	struct gf_prog_detail *next;
+};
+
+
+struct gf_dump_rsp {
+        unsigned hyper gfs_id;
+        int op_ret;
+	int op_errno;
+	struct gf_prog_detail *prog;
+};