From ecc54b50659398a76a14aa33d866f1eb5dcc1019 Mon Sep 17 00:00:00 2001

From: Anuradha Talur <atalur@redhat.com>

Date: Mon, 29 Aug 2016 16:41:09 +0530

Subject: [PATCH 78/86] compound fops: Some fixes to compound fops framework

	Backport of: http://review.gluster.org/15010

Change-Id: Ia0a87d71a9761d9caf6ad466bbb750925f88bb95

BUG: 1360978

Signed-off-by: Anuradha Talur <atalur@redhat.com>

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

Reviewed-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

Tested-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

---

 libglusterfs/src/Makefile.am                       |    2 +-

 libglusterfs/src/compound-fop-utils.c              |  104 ++++-

 libglusterfs/src/compound-fop-utils.h              |   35 ++

 libglusterfs/src/default-args.c                    |   12 +-

 libglusterfs/src/default-args.h                    |    2 +

 .../performance/decompounder/src/decompounder.c    |  179 ++++----

 .../performance/decompounder/src/decompounder.h    |    1 +

 xlators/protocol/client/src/client-common.c        |    1 +

 xlators/protocol/client/src/client-helpers.c       |  298 +++++++++--

 xlators/protocol/client/src/client-rpc-fops.c      |   56 +--

 xlators/protocol/client/src/client.h               |   25 +-

 xlators/protocol/server/src/server-helpers.c       |  528 +++++++++++++++++++-

 xlators/protocol/server/src/server-helpers.h       |    5 +

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

 xlators/protocol/server/src/server.h               |   28 +

 15 files changed, 1093 insertions(+), 247 deletions(-)

 create mode 100644 libglusterfs/src/compound-fop-utils.h

diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am

index 93403db..849cb97 100644

--- a/libglusterfs/src/Makefile.am

+++ b/libglusterfs/src/Makefile.am

@@ -52,7 +52,7 @@ libglusterfs_la_HEADERS = common-utils.h defaults.h default-args.h \

 	glfs-message-id.h template-component-messages.h strfd.h \

 	syncop-utils.h parse-utils.h libglusterfs-messages.h tw.h \

 	lvm-defaults.h quota-common-utils.h rot-buffs.h \

-	compat-uuid.h upcall-utils.h events.h

+	compat-uuid.h upcall-utils.h events.h compound-fop-utils.h

 libglusterfs_ladir = $(includedir)/glusterfs

diff --git a/libglusterfs/src/compound-fop-utils.c b/libglusterfs/src/compound-fop-utils.c

index 16cd5c6..03d7b5b 100644

--- a/libglusterfs/src/compound-fop-utils.c

+++ b/libglusterfs/src/compound-fop-utils.c

@@ -13,12 +13,94 @@

 #include "mem-types.h"

 #include "dict.h"

+void

+compound_args_cleanup (compound_args_t *args)

+{

+        int i;

+

+        if (!args)

+                return;

+

+        if (args->xdata)

+                dict_unref (args->xdata);

+

+        if (args->req_list) {

+                for (i = 0; i < args->fop_length; i++) {

+                        args_wipe (&args->req_list[i]);

+                }

+        }

+

+        GF_FREE (args->enum_list);

+        GF_FREE (args->req_list);

+        GF_FREE (args);

+}

+

+void

+compound_args_cbk_cleanup (compound_args_cbk_t *args_cbk)

+{

+        int i;

+

+        if (!args_cbk)

+                return;

+

+        if (args_cbk->xdata)

+                dict_unref (args_cbk->xdata);

+

+        if (args_cbk->rsp_list) {

+                for (i = 0; i < args_cbk->fop_length; i++) {

+                        args_cbk_wipe (&args_cbk->rsp_list[i]);

+                }

+        }

+

+        GF_FREE (args_cbk->rsp_list);

+        GF_FREE (args_cbk->enum_list);

+        GF_FREE (args_cbk);

+}

+

+compound_args_cbk_t*

+compound_args_cbk_alloc (int length, dict_t *xdata)

+{

+        int                 i             = 0;

+        compound_args_cbk_t *args_cbk     = NULL;

+

+        args_cbk = GF_CALLOC (1, sizeof (*args_cbk), gf_mt_compound_rsp_t);

+        if (!args_cbk)

+                return NULL;

+

+        args_cbk->fop_length = length;

+

+        args_cbk->rsp_list = GF_CALLOC (length, sizeof (*args_cbk->rsp_list),

+                                        gf_mt_default_args_cbk_t);

+        if (!args_cbk->rsp_list)

+                goto out;

+

+        for (i = 0; i < length; i++) {

+                args_cbk_init (&args_cbk->rsp_list[i]);

+        }

+

+        args_cbk->enum_list = GF_CALLOC (length, sizeof (*args_cbk->enum_list),

+                                        gf_common_mt_int);

+        if (!args_cbk->enum_list)

+                goto out;

+

+        if (xdata) {

+                args_cbk->xdata = dict_copy_with_ref (xdata, NULL);

+                if (!args_cbk->xdata)

+                        goto out;

+        }

+

+        return args_cbk;

+out:

+        compound_args_cbk_cleanup (args_cbk);

+        return NULL;

+}

+

 compound_args_t*

 compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata)

 {

         compound_args_t *args     = NULL;

-        args = GF_CALLOC (1, sizeof (args), gf_mt_compound_req_t);

+        args = GF_CALLOC (1, sizeof (*args), gf_mt_compound_req_t);

         if (!args)

                 return NULL;

@@ -29,7 +111,7 @@ compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata)

          * fop list packed.

          */

         args->fop_enum = fop;

-        args->fop_length   = length;

+        args->fop_length = length;

         args->enum_list = GF_CALLOC (length, sizeof (*args->enum_list),

                                      gf_common_mt_int);

@@ -51,22 +133,6 @@ compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata)

         return args;

 out:

-        if (args->xdata)

-                dict_unref (args->xdata);

-

-        if (args->req_list)

-                GF_FREE (args->req_list);

-

-        if (args->enum_list)

-                GF_FREE (args->enum_list);

-

-        if (args)

-                GF_FREE (args);

-

+        compound_args_cleanup (args);

         return NULL;

 }

-

-#define COMPOUND_PACK_ARGS(fop, fop_enum, args, counter, params ...) do {    \

-        args->enum_list[counter] = fop_enum;                                 \

-        args_##fop##_store (&args->req_list[counter], params);               \

-} while (0)

diff --git a/libglusterfs/src/compound-fop-utils.h b/libglusterfs/src/compound-fop-utils.h

new file mode 100644

index 0000000..bfd0649

--- /dev/null

+++ b/libglusterfs/src/compound-fop-utils.h

@@ -0,0 +1,35 @@

+/*

+  Copyright (c) 2016 Red Hat, Inc. <http://www.redhat.com>

+  This file is part of GlusterFS.

+

+  This file is licensed to you under your choice of the GNU Lesser

+  General Public License, version 3 or any later version (LGPLv3 or

+  later), or the GNU General Public License, version 2 (GPLv2), in all

+  cases as published by the Free Software Foundation.

+*/

+

+#ifndef __COMPOUND_FOP_UTILS_H__

+#define __COMPOUND_FOP_UTILS_H__

+

+#include "defaults.h"

+#include "default-args.h"

+#include "mem-types.h"

+#include "dict.h"

+

+#define COMPOUND_PACK_ARGS(fop, fop_enum, args, counter, params ...) do {    \

+        args->enum_list[counter] = fop_enum;                                 \

+        args_##fop##_store (&args->req_list[counter], params);               \

+} while (0)

+

+compound_args_t*

+compound_fop_alloc (int length, glusterfs_compound_fop_t fop, dict_t *xdata);

+

+void

+compound_args_cleanup (compound_args_t *args);

+

+void

+compound_args_cbk_cleanup (compound_args_cbk_t *args_cbk);

+

+compound_args_cbk_t*

+compound_args_cbk_alloc (int length, dict_t *xdata);

+#endif /* __COMPOUND_FOP_UTILS_H__ */

diff --git a/libglusterfs/src/default-args.c b/libglusterfs/src/default-args.c

index 2e51bf2..f40de2d 100644

--- a/libglusterfs/src/default-args.c

+++ b/libglusterfs/src/default-args.c

@@ -1576,11 +1576,9 @@ args_wipe (default_args_t *args)

         if (!args)

                 return;

-        if (&args->loc)

-                loc_wipe (&args->loc);

+        loc_wipe (&args->loc);

-        if (&args->loc2)

-                loc_wipe (&args->loc2);

+        loc_wipe (&args->loc2);

         if (args->fd)

                 fd_unref (args->fd);

@@ -1603,3 +1601,9 @@ args_wipe (default_args_t *args)

 	GF_FREE ((char *)args->volume);

 }

+

+void

+args_cbk_init (default_args_cbk_t *args_cbk)

+{

+        INIT_LIST_HEAD (&args_cbk->entries);

+}

diff --git a/libglusterfs/src/default-args.h b/libglusterfs/src/default-args.h

index 93426ca..a2201dd 100644

--- a/libglusterfs/src/default-args.h

+++ b/libglusterfs/src/default-args.h

@@ -479,4 +479,6 @@ args_getactivelk_cbk_store (default_args_cbk_t *args,

 int

 args_setactivelk_store (default_args_t *args, loc_t *loc,

                           lock_migration_info_t *locklist, dict_t *xdata);

+void

+args_cbk_init (default_args_cbk_t *args_cbk);

 #endif /* _DEFAULT_ARGS_H */

diff --git a/xlators/performance/decompounder/src/decompounder.c b/xlators/performance/decompounder/src/decompounder.c

index 3009fcd..cd353b7 100644

--- a/xlators/performance/decompounder/src/decompounder.c

+++ b/xlators/performance/decompounder/src/decompounder.c

@@ -10,17 +10,14 @@

 #include "decompounder.h"

 #include "mem-types.h"

+#include "compound-fop-utils.h"

 void

 dc_local_cleanup (dc_local_t *local)

 {

         int i = 0;

-        for (i = 0; i < local->length; i++)

-                args_cbk_wipe (&local->compound_rsp->rsp_list[i]);

-

-        GF_FREE (local->compound_rsp->rsp_list);

-        GF_FREE (local->compound_rsp);

+        compound_args_cbk_cleanup (local->compound_rsp);

         return;

 }

@@ -551,290 +548,292 @@ dc_compound_fop_wind (call_frame_t *frame, xlator_t *this)

         compound_args_t         *c_req          = local->compound_req;

         compound_args_cbk_t     *c_rsp          = local->compound_rsp;

         int                     counter         = local->counter;

-        default_args_t          curr_fop        = c_req->req_list[counter];

+        default_args_t          *curr_fop       = &c_req->req_list[counter];

         int                     op_ret          = 0;

         int                     op_errno        = ENOMEM;

         if (local->counter == local->length)

                 goto done;

+        c_rsp->enum_list[counter] = c_req->enum_list[counter];

+

         switch (c_req->enum_list[counter]) {

         case GF_FOP_STAT:

                 STACK_WIND (frame, dc_stat_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat,

-                            &curr_fop.loc, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->xdata);

                 break;

         case GF_FOP_READLINK:

                 STACK_WIND (frame, dc_readlink_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->readlink,

-                            &curr_fop.loc, curr_fop.size,

-                            curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->size,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_MKNOD:

                 STACK_WIND (frame, dc_mknod_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,

-                            &curr_fop.loc, curr_fop.mode, curr_fop.rdev,

-                            curr_fop.umask, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->mode, curr_fop->rdev,

+                            curr_fop->umask, curr_fop->xdata);

                 break;

         case GF_FOP_MKDIR:

                 STACK_WIND (frame, dc_mkdir_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir,

-                            &curr_fop.loc, curr_fop.mode,

-                            curr_fop.umask, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->mode,

+                            curr_fop->umask, curr_fop->xdata);

                 break;

         case GF_FOP_UNLINK:

                 STACK_WIND (frame, dc_unlink_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink,

-                            &curr_fop.loc, curr_fop.xflag, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->xflag, curr_fop->xdata);

                 break;

         case GF_FOP_RMDIR:

                 STACK_WIND (frame, dc_rmdir_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir,

-                            &curr_fop.loc, curr_fop.flags, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->flags, curr_fop->xdata);

                 break;

         case GF_FOP_SYMLINK:

                 STACK_WIND (frame, dc_symlink_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink,

-                            curr_fop.linkname, &curr_fop.loc,

-                            curr_fop.umask, curr_fop.xdata);

+                            curr_fop->linkname, &curr_fop->loc,

+                            curr_fop->umask, curr_fop->xdata);

                 break;

         case GF_FOP_RENAME:

                 STACK_WIND (frame, dc_rename_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename,

-                            &curr_fop.loc, &curr_fop.loc2, curr_fop.xdata);

+                            &curr_fop->loc, &curr_fop->loc2, curr_fop->xdata);

                 break;

         case GF_FOP_LINK:

                 STACK_WIND (frame, dc_link_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,

-                            &curr_fop.loc, &curr_fop.loc2, curr_fop.xdata);

+                            &curr_fop->loc, &curr_fop->loc2, curr_fop->xdata);

                 break;

         case GF_FOP_TRUNCATE:

                 STACK_WIND (frame, dc_truncate_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->truncate,

-                            &curr_fop.loc, curr_fop.offset, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->offset, curr_fop->xdata);

                 break;

         case GF_FOP_OPEN:

                 STACK_WIND (frame, dc_open_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,

-                            &curr_fop.loc, curr_fop.flags, curr_fop.fd,

-                            curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->flags, curr_fop->fd,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_READ:

                 STACK_WIND (frame, dc_readv_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv,

-                            curr_fop.fd, curr_fop.size, curr_fop.offset,

-                            curr_fop.flags, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->size, curr_fop->offset,

+                            curr_fop->flags, curr_fop->xdata);

                 break;

         case GF_FOP_WRITE:

                 STACK_WIND (frame, dc_writev_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,

-                            curr_fop.fd, curr_fop.vector, curr_fop.count,

-                            curr_fop.offset, curr_fop.flags, curr_fop.iobref,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->vector, curr_fop->count,

+                            curr_fop->offset, curr_fop->flags, curr_fop->iobref,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_STATFS:

                 STACK_WIND (frame, dc_statfs_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs,

-                            &curr_fop.loc, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->xdata);

                 break;

         case GF_FOP_FLUSH:

                 STACK_WIND (frame, dc_flush_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush,

-                            curr_fop.fd, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->xdata);

                 break;

         case GF_FOP_FSYNC:

                 STACK_WIND (frame, dc_fsync_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync,

-                            curr_fop.fd, curr_fop.datasync, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->datasync, curr_fop->xdata);

                 break;

         case GF_FOP_SETXATTR:

                 STACK_WIND (frame, dc_setxattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->setxattr,

-                            &curr_fop.loc, curr_fop.xattr, curr_fop.flags,

-                            curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->xattr, curr_fop->flags,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_GETXATTR:

                 STACK_WIND (frame, dc_getxattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->getxattr,

-                            &curr_fop.loc, curr_fop.name, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->name, curr_fop->xdata);

                 break;

         case GF_FOP_REMOVEXATTR:

                 STACK_WIND (frame, dc_removexattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->removexattr,

-                            &curr_fop.loc, curr_fop.name, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->name, curr_fop->xdata);

                 break;

         case GF_FOP_OPENDIR:

                 STACK_WIND (frame, dc_opendir_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->opendir,

-                            &curr_fop.loc, curr_fop.fd, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->fd, curr_fop->xdata);

                 break;

         case GF_FOP_FSYNCDIR:

                 STACK_WIND (frame, dc_fsyncdir_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fsyncdir,

-                            curr_fop.fd, curr_fop.datasync, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->datasync, curr_fop->xdata);

                 break;

         case GF_FOP_ACCESS:

                 STACK_WIND (frame, dc_access_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->access,

-                            &curr_fop.loc, curr_fop.mask, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->mask, curr_fop->xdata);

                 break;

         case GF_FOP_CREATE:

                 STACK_WIND (frame, dc_create_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->create,

-                            &curr_fop.loc, curr_fop.flags, curr_fop.mode,

-                            curr_fop.umask, curr_fop.fd, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->flags, curr_fop->mode,

+                            curr_fop->umask, curr_fop->fd, curr_fop->xdata);

                 break;

         case GF_FOP_FTRUNCATE:

                 STACK_WIND (frame, dc_ftruncate_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->ftruncate,

-                            curr_fop.fd, curr_fop.offset, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->offset, curr_fop->xdata);

                 break;

         case GF_FOP_FSTAT:

                 STACK_WIND (frame, dc_fstat_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat,

-                            curr_fop.fd, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->xdata);

                 break;

         case GF_FOP_LK:

                 STACK_WIND (frame, dc_lk_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk,

-                            curr_fop.fd,

-                            curr_fop.cmd, &curr_fop.lock, curr_fop.xdata);

+                            curr_fop->fd,

+                            curr_fop->cmd, &curr_fop->lock, curr_fop->xdata);

                 break;

         case GF_FOP_LOOKUP:

                 STACK_WIND (frame, dc_lookup_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup,

-                            &curr_fop.loc, curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->xdata);

                 break;

         case GF_FOP_READDIR:

                 STACK_WIND (frame, dc_readdir_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,

-                            curr_fop.fd, curr_fop.size, curr_fop.offset,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->size, curr_fop->offset,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_INODELK:

                 STACK_WIND (frame, dc_inodelk_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk,

-                            curr_fop.volume, &curr_fop.loc,

-                            curr_fop.cmd, &curr_fop.lock, curr_fop.xdata);

+                            curr_fop->volume, &curr_fop->loc,

+                            curr_fop->cmd, &curr_fop->lock, curr_fop->xdata);

                 break;

         case GF_FOP_FINODELK:

                 STACK_WIND (frame, dc_finodelk_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->finodelk,

-                            curr_fop.volume, curr_fop.fd,

-                            curr_fop.cmd, &curr_fop.lock, curr_fop.xdata);

+                            curr_fop->volume, curr_fop->fd,

+                            curr_fop->cmd, &curr_fop->lock, curr_fop->xdata);

                 break;

         case GF_FOP_ENTRYLK:

                 STACK_WIND (frame, dc_entrylk_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk,

-                            curr_fop.volume, &curr_fop.loc,

-                            curr_fop.name, curr_fop.entrylkcmd,

-                            curr_fop.entrylktype, curr_fop.xdata);

+                            curr_fop->volume, &curr_fop->loc,

+                            curr_fop->name, curr_fop->entrylkcmd,

+                            curr_fop->entrylktype, curr_fop->xdata);

                 break;

         case GF_FOP_FENTRYLK:

                 STACK_WIND (frame, dc_fentrylk_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fentrylk,

-                            curr_fop.volume, curr_fop.fd,

-                            curr_fop.name, curr_fop.entrylkcmd,

-                            curr_fop.entrylktype, curr_fop.xdata);

+                            curr_fop->volume, curr_fop->fd,

+                            curr_fop->name, curr_fop->entrylkcmd,

+                            curr_fop->entrylktype, curr_fop->xdata);

                 break;

         case GF_FOP_XATTROP:

                 STACK_WIND (frame, dc_xattrop_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->xattrop,

-                            &curr_fop.loc, curr_fop.optype, curr_fop.xattr,

-                            curr_fop.xdata);

+                            &curr_fop->loc, curr_fop->optype, curr_fop->xattr,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_FXATTROP:

                 STACK_WIND (frame, dc_fxattrop_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fxattrop,

-                            curr_fop.fd, curr_fop.optype, curr_fop.xattr,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->optype, curr_fop->xattr,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_FGETXATTR:

                 STACK_WIND (frame, dc_fgetxattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fgetxattr,

-                            curr_fop.fd, curr_fop.name, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->name, curr_fop->xdata);

                 break;

         case GF_FOP_FSETXATTR:

                 STACK_WIND (frame, dc_fsetxattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fsetxattr,

-                            curr_fop.fd, curr_fop.xattr, curr_fop.flags,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->xattr, curr_fop->flags,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_RCHECKSUM:

                 STACK_WIND (frame, dc_rchecksum_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->rchecksum,

-                            curr_fop.fd, curr_fop.offset, curr_fop.size,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->offset, curr_fop->size,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_SETATTR:

                 STACK_WIND (frame, dc_setattr_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr,

-                            &curr_fop.loc, &curr_fop.stat, curr_fop.valid,

-                            curr_fop.xdata);

+                            &curr_fop->loc, &curr_fop->stat, curr_fop->valid,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_FSETATTR:

                 STACK_WIND (frame, dc_fsetattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fsetattr,

-                            curr_fop.fd, &curr_fop.stat, curr_fop.valid,

-                            curr_fop.xdata);

+                            curr_fop->fd, &curr_fop->stat, curr_fop->valid,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_READDIRP:

                 STACK_WIND (frame, dc_readdirp_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->readdirp,

-                            curr_fop.fd, curr_fop.size, curr_fop.offset,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->size, curr_fop->offset,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_FREMOVEXATTR:

                 STACK_WIND (frame, dc_fremovexattr_cbk,

                             FIRST_CHILD(this),

                             FIRST_CHILD(this)->fops->fremovexattr,

-                            curr_fop.fd, curr_fop.name, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->name, curr_fop->xdata);

                 break;

         case GF_FOP_FALLOCATE:

                 STACK_WIND (frame, dc_fallocate_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->fallocate,

-                            curr_fop.fd, curr_fop.flags, curr_fop.offset,

-                            curr_fop.size, curr_fop.xdata);

+                            curr_fop->fd, curr_fop->flags, curr_fop->offset,

+                            curr_fop->size, curr_fop->xdata);

                 break;

         case GF_FOP_DISCARD:

                 STACK_WIND (frame, dc_discard_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->discard,

-                            curr_fop.fd, curr_fop.offset, curr_fop.size,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->offset, curr_fop->size,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_ZEROFILL:

                 STACK_WIND (frame, dc_zerofill_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->zerofill,

-                            curr_fop.fd, curr_fop.offset, curr_fop.size,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->offset, curr_fop->size,

+                            curr_fop->xdata);

                 break;

         case GF_FOP_IPC:

                 STACK_WIND (frame, dc_ipc_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->ipc,

-                            curr_fop.cmd, curr_fop.xdata);

+                            curr_fop->cmd, curr_fop->xdata);

                 break;

         case GF_FOP_SEEK:

                 STACK_WIND (frame, dc_seek_cbk,

                             FIRST_CHILD(this), FIRST_CHILD(this)->fops->seek,

-                            curr_fop.fd, curr_fop.offset, curr_fop.what,

-                            curr_fop.xdata);

+                            curr_fop->fd, curr_fop->offset, curr_fop->what,

+                            curr_fop->xdata);

                 break;

         default:

                 return -ENOTSUP;

@@ -865,20 +864,13 @@ dc_compound (call_frame_t *frame, xlator_t *this, void *data, dict_t *xdata)

         frame->local = local;

-        local->compound_rsp = GF_CALLOC (1, sizeof (local->compound_rsp),

-                                         gf_dc_mt_rsp_t);

+        local->compound_rsp = compound_args_cbk_alloc (compound_req->fop_length,

+                                                       NULL);

         if (!local->compound_rsp)

                 goto out;

         compound_rsp = local->compound_rsp;

-        compound_rsp->fop_length = compound_req->fop_length;

-        compound_rsp->rsp_list = GF_CALLOC (compound_rsp->fop_length,

-                                            sizeof (default_args_cbk_t),

-                                            gf_mt_default_args_cbk_t);

-        if (!compound_rsp->rsp_list)

-                goto out;

-

         local->length =  compound_req->fop_length;

         local->counter = 0;

         local->compound_req = compound_req;

@@ -941,6 +933,13 @@ init (xlator_t *this)

                 ret = -1;

                 goto out;

         }

+

+        this->local_pool = mem_pool_new (dc_local_t, 128);

+        if (!this->local_pool) {

+                ret = -1;

+                goto out;

+        }

+

 out:

         return ret;

 }

diff --git a/xlators/performance/decompounder/src/decompounder.h b/xlators/performance/decompounder/src/decompounder.h

index 1b8c1d6..59fb908 100644

--- a/xlators/performance/decompounder/src/decompounder.h

+++ b/xlators/performance/decompounder/src/decompounder.h

@@ -26,6 +26,7 @@ typedef struct {

 #define DC_STACK_UNWIND(frame, op_ret, op_errno, rsp, xdata) do {\

                 dc_local_t      *__local = NULL;                      \

+                                                                      \

                 if (frame) {                                          \

                         __local = frame->local;                       \

                         frame->local = NULL;                          \

diff --git a/xlators/protocol/client/src/client-common.c b/xlators/protocol/client/src/client-common.c

index 05939b8..4fff7e6 100644

--- a/xlators/protocol/client/src/client-common.c

+++ b/xlators/protocol/client/src/client-common.c

@@ -1402,6 +1402,7 @@ client_post_readlink (xlator_t *this, gfs3_readlink_rsp *rsp,

                                       rsp->op_errno, out);

 out:

+

         return ret;

 }

diff --git a/xlators/protocol/client/src/client-helpers.c b/xlators/protocol/client/src/client-helpers.c

index 4bdb364..a7e46b5 100644

--- a/xlators/protocol/client/src/client-helpers.c

+++ b/xlators/protocol/client/src/client-helpers.c

@@ -135,10 +135,6 @@ client_local_wipe (clnt_local_t *local)