From 2dd394a27166f4e08ad9521ad47b6c0d3fa83432 Mon Sep 17 00:00:00 2001

From: Amar Tumballi <amarts@redhat.com>

Date: Fri, 17 Nov 2017 10:35:26 +0530

Subject: [PATCH 224/236] protocol/server: Backport patch to reduce duplicate

 code in server-rpc-fops.c

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

> (cherry picked from commit a81c0c2b9abdcb8ad73d0a226b53120d84082a09)

> (upstream patch review link https://review.gluster.org/#/c/19638/)

> BUG: 1549505

BUG: 1535281

Change-Id: I33475c44665665cf08ecda798d6fd07455396584

Signed-off-by: Mohit Agrawal <moagrawa@redhat.com>

Reviewed-on: https://code.engineering.redhat.com/gerrit/136210

Tested-by: RHGS Build Bot <nigelb@redhat.com>

Reviewed-by: Atin Mukherjee <amukherj@redhat.com>

---

 xlators/protocol/server/src/server-rpc-fops.c | 1199 +++++--------------------

 1 file changed, 208 insertions(+), 991 deletions(-)

diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c

index c947f06..21f78a3 100644

--- a/xlators/protocol/server/src/server-rpc-fops.c

+++ b/xlators/protocol/server/src/server-rpc-fops.c

@@ -32,6 +32,7 @@

                 ret = RPCSVC_ACTOR_ERROR;                       \

         } while (0)

+

 void

 forget_inode_if_no_dentry (inode_t *inode)

 {

@@ -3450,7 +3451,48 @@ err:

         return ret;

 }

+

+

 /* Fop section */

+static inline int

+rpc_receive_common (rpcsvc_request_t *req, call_frame_t **fr,

+                    server_state_t **st, ssize_t *xdrlen, void *args,

+                    void *xdrfn, glusterfs_fop_t fop)

+{

+        int ret = -1;

+        ssize_t len = 0;

+

+        len = xdr_to_generic (req->msg[0], args, (xdrproc_t)xdrfn);

+        if (len < 0) {

+                /* failed to decode msg; */

+                SERVER_REQ_SET_ERROR (req, ret);

+                goto out;

+        }

+

+        /* Few fops use the xdr size to get the vector sizes */

+        if (xdrlen)

+                *xdrlen = len;

+

+        *fr = get_frame_from_request (req);

+        if (!(*fr)) {

+                /* something wrong, mostly no memory */

+                SERVER_REQ_SET_ERROR (req, ret);

+                goto out;

+        }

+        (*fr)->root->op = fop;

+

+        *st = CALL_STATE ((*fr));

+        if (!(*fr)->root->client->bound_xl) {

+                /* auth failure, mostly setvolume is not successful */

+                SERVER_REQ_SET_ERROR (req, ret);

+                goto out;

+        }

+        ret = 0;

+

+out:

+        return ret;

+}

+

 int

 server3_3_stat (rpcsvc_request_t *req)

@@ -3465,25 +3507,9 @@ server3_3_stat (rpcsvc_request_t *req)

                 return 0;

         /* Initialize args first, then decode */

-

-        ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_stat_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_STAT;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_stat_req, GF_FOP_STAT);

+        if (ret != 0) {

                 goto out;

         }

@@ -3522,26 +3548,9 @@ server3_3_setattr (rpcsvc_request_t *req)

         if (!req)

                 return 0;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_setattr_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_SETATTR;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_setattr_req, GF_FOP_SETATTR);

+        if (ret != 0) {

                 goto out;

         }

@@ -3582,25 +3591,9 @@ server3_3_fsetattr (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_fsetattr_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FSETATTR;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_fsetattr_req, GF_FOP_FSETATTR);

+        if (ret != 0) {

                 goto out;

         }

@@ -3640,26 +3633,9 @@ server3_3_fallocate(rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_fallocate_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FALLOCATE;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_fallocate_req, GF_FOP_FALLOCATE);

+        if (ret != 0) {

                 goto out;

         }

@@ -3702,26 +3678,9 @@ server3_3_discard(rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_discard_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_DISCARD;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_discard_req, GF_FOP_DISCARD);

+        if (ret != 0) {

                 goto out;

         }

@@ -3763,26 +3722,9 @@ server3_3_zerofill(rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_zerofill_req);

-        if (ret < 0) {

-                /*failed to decode msg*/;

-                req->rpc_err = GARBAGE_ARGS;

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                /* something wrong, mostly insufficient memory*/

-                req->rpc_err = GARBAGE_ARGS; /* TODO */

-                goto out;

-        }

-        frame->root->op = GF_FOP_ZEROFILL;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                req->rpc_err = GARBAGE_ARGS;

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_zerofill_req, GF_FOP_ZEROFILL);

+        if (ret != 0) {

                 goto out;

         }

@@ -3813,50 +3755,31 @@ out:

 int

 server3_3_ipc (rpcsvc_request_t *req)

 {

+        server_state_t  *state          = NULL;

         call_frame_t    *frame          = NULL;

         gfs3_ipc_req     args           = {0,};

         int              ret            = -1;

         int              op_errno       = 0;

-        dict_t          *xdata          = NULL;

         xlator_t        *bound_xl       = NULL;

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_ipc_req);

-        if (ret < 0) {

-                /*failed to decode msg*/;

-                req->rpc_err = GARBAGE_ARGS;

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                /* something wrong, mostly insufficient memory*/

-                req->rpc_err = GARBAGE_ARGS; /* TODO */

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_ipc_req, GF_FOP_IPC);

+        if (ret != 0) {

                 goto out;

         }

-        frame->root->op = GF_FOP_IPC;

         bound_xl = frame->root->client->bound_xl;

-        if (!bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                req->rpc_err = GARBAGE_ARGS;

-                goto out;

-        }

-

-        GF_PROTOCOL_DICT_UNSERIALIZE (bound_xl, xdata,

+        GF_PROTOCOL_DICT_UNSERIALIZE (bound_xl, state->xdata,

                                       args.xdata.xdata_val,

                                       args.xdata.xdata_len,

                                       ret, op_errno, out);

         ret = 0;

         STACK_WIND (frame, server_ipc_cbk, bound_xl, bound_xl->fops->ipc,

-                    args.op, xdata);

-        if (xdata) {

-                dict_unref(xdata);

-        }

+                    args.op, state->xdata);

 out:

         free (args.xdata.xdata_val);

@@ -3872,7 +3795,7 @@ server3_3_seek (rpcsvc_request_t *req)

 {

         server_state_t        *state          = NULL;

         call_frame_t          *frame          = NULL;

-        struct gfs3_seek_req   args           = {{0,},};

+        gfs3_seek_req          args           = {{0,},};

         int                    ret            = -1;

         int                    op_errno       = 0;

         dict_t                *xdata          = NULL;

@@ -3881,26 +3804,9 @@ server3_3_seek (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_seek_req);

-        if (ret < 0) {

-                /*failed to decode msg*/;

-                req->rpc_err = GARBAGE_ARGS;

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                /* something wrong, mostly insufficient memory*/

-                req->rpc_err = GARBAGE_ARGS; /* TODO */

-                goto out;

-        }

-        frame->root->op = GF_FOP_SEEK;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_seek_req, GF_FOP_SEEK);

+        if (ret != 0) {

                 goto out;

         }

@@ -3911,6 +3817,7 @@ server3_3_seek (rpcsvc_request_t *req)

         state->what = args.what;

         memcpy(state->resolve.gfid, args.gfid, 16);

+        bound_xl = frame->root->client->bound_xl;

         GF_PROTOCOL_DICT_UNSERIALIZE (bound_xl, xdata,

                                       args.xdata.xdata_val,

                                       args.xdata.xdata_len,

@@ -3940,26 +3847,9 @@ server3_3_readlink (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_readlink_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_READLINK;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_readlink_req, GF_FOP_READLINK);

+        if (ret != 0) {

                 goto out;

         }

@@ -4001,30 +3891,12 @@ server3_3_create (rpcsvc_request_t *req)

         args.bname = alloca (req->msg[0].iov_len);

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_create_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_CREATE;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_create_req, GF_FOP_CREATE);

+        if (ret != 0) {

                 goto out;

         }

-

         state->resolve.bname  = gf_strdup (args.bname);

         state->mode           = args.mode;

         state->umask          = args.umask;

@@ -4072,25 +3944,9 @@ server3_3_open (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_open_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_OPEN;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_open_req, GF_FOP_OPEN);

+        if (ret != 0) {

                 goto out;

         }

@@ -4129,25 +3985,9 @@ server3_3_readv (rpcsvc_request_t *req)

         if (!req)

                 goto out;

-        ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_read_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_READ;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_read_req, GF_FOP_READ);

+        if (ret != 0) {

                 goto out;

         }

@@ -4192,26 +4032,9 @@ server3_3_writev (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        len = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_write_req);

-        if (len < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_WRITE;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, &len, &args,

+                                  xdr_gfs3_write_req, GF_FOP_WRITE);

+        if (ret != 0) {

                 goto out;

         }

@@ -4418,26 +4241,9 @@ server3_3_fsync (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_fsync_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FSYNC;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_fsync_req, GF_FOP_FSYNC);

+        if (ret != 0) {

                 goto out;

         }

@@ -4477,26 +4283,9 @@ server3_3_flush (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_flush_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FLUSH;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_flush_req, GF_FOP_FLUSH);

+        if (ret != 0) {

                 goto out;

         }

@@ -4535,26 +4324,9 @@ server3_3_ftruncate (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_ftruncate_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FTRUNCATE;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_ftruncate_req, GF_FOP_FTRUNCATE);

+        if (ret != 0) {

                 goto out;

         }

@@ -4593,26 +4365,9 @@ server3_3_fstat (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_fstat_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_FSTAT;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_fstat_req, GF_FOP_FSTAT);

+        if (ret != 0) {

                 goto out;

         }

@@ -4650,26 +4405,9 @@ server3_3_truncate (rpcsvc_request_t *req)

         if (!req)

                 return ret;

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_truncate_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_TRUNCATE;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_truncate_req, GF_FOP_TRUNCATE);

+        if (ret != 0) {

                 goto out;

         }

@@ -4710,26 +4448,9 @@ server3_3_unlink (rpcsvc_request_t *req)

         args.bname = alloca (req->msg[0].iov_len);

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_unlink_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_UNLINK;

-

-        state = CALL_STATE (frame);

-        if (!frame->root->client->bound_xl) {

-                /* auth failure, request on subvolume without setvolume */

-                SERVER_REQ_SET_ERROR (req, ret);

+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,

+                                  xdr_gfs3_unlink_req, GF_FOP_UNLINK);

+        if (ret != 0) {

                 goto out;

         }

@@ -4774,26 +4495,9 @@ server3_3_setxattr (rpcsvc_request_t *req)

         args.dict.dict_val = alloca (req->msg[0].iov_len);

-        ret = xdr_to_generic (req->msg[0], &args,

-                              (xdrproc_t)xdr_gfs3_setxattr_req);

-        if (ret < 0) {

-                //failed to decode msg;

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-

-        frame = get_frame_from_request (req);

-        if (!frame) {

-                // something wrong, mostly insufficient memory

-                SERVER_REQ_SET_ERROR (req, ret);

-                goto out;

-        }

-        frame->root->op = GF_FOP_SETXATTR;

-

-        state = CALL_STATE (frame);