all: remove code which is not being considered in build

These xlators are now removed from build as per discussion/announcement
done at https://lists.gluster.org/pipermail/gluster-users/2018-July/034400.html

* move rot-13 to playground, as it is used only as demo
  purpose, and is documented in many places.

* Removed code of below xlators:
  - cluster/stripe
  - cluster/tier
  - features/changetimerecorder
  - features/glupy
  - performance/symlink-cache
  - encryption/crypt
  - storage/bd
  - experimental/posix2
  - experimental/dht2
  - experimental/fdl
  - experimental/jbr

updates: bz#1635688
Change-Id: I1d2d63c32535e149bc8dcb2daa76236c707996e8
Signed-off-by: Amar Tumballi <amarts@redhat.com>

113 files changed, 0 insertions, 37439 deletions

diff --git a/xlators/cluster/dht/src/tier-common.c b/xlators/cluster/dht/src/tier-common.c
deleted file mode 100644
index b22f4776ada..00000000000
--- a/xlators/cluster/dht/src/tier-common.c
+++ /dev/null
@@ -1,1199 +0,0 @@
-/*
-  Copyright (c) 2015 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.
-*/
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include "libxlator.h"
-#include "dht-common.h"
-#include <glusterfs/defaults.h>
-#include "tier-common.h"
-#include "tier.h"
-
-int
-dht_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-             int op_errno, inode_t *inode, struct iatt *stbuf,
-             struct iatt *preparent, struct iatt *postparent, dict_t *xdata);
-
-int
-tier_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, inode_t *inode, struct iatt *stbuf,
-              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    loc_t *oldloc = NULL;
-    loc_t *newloc = NULL;
-
-    local = frame->local;
-
-    oldloc = &local->loc;
-    newloc = &local->loc2;
-
-    if (op_ret == -1) {
-        /* No continuation on DHT inode missing errors, as we should
-         * then have a good stbuf that states P2 happened. We would
-         * get inode missing if, the file completed migrated between
-         * the lookup and the link call */
-        goto out;
-    }
-
-    if (local->call_cnt != 1) {
-        goto out;
-    }
-
-    local->call_cnt = 2;
-
-    /* Do this on the hot tier now */
-
-    STACK_WIND(frame, tier_link_cbk, local->cached_subvol,
-               local->cached_subvol->fops->link, oldloc, newloc, xdata);
-
-    return 0;
-
-out:
-    DHT_STRIP_PHASE1_FLAGS(stbuf);
-
-    DHT_STACK_UNWIND(link, frame, op_ret, op_errno, inode, stbuf, preparent,
-                     postparent, NULL);
-
-    return 0;
-}
-
-int
-tier_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-          dict_t *xdata)
-{
-    xlator_t *cached_subvol = NULL;
-    xlator_t *hashed_subvol = NULL;
-    int op_errno = -1;
-    int ret = -1;
-    dht_local_t *local = NULL;
-    dht_conf_t *conf = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(oldloc, err);
-    VALIDATE_OR_GOTO(newloc, err);
-
-    conf = this->private;
-
-    local = dht_local_init(frame, oldloc, NULL, GF_FOP_LINK);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->call_cnt = 1;
-
-    cached_subvol = local->cached_subvol;
-
-    if (!cached_subvol) {
-        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
-                     oldloc->path);
-        op_errno = ENOENT;
-        goto err;
-    }
-
-    hashed_subvol = TIER_HASHED_SUBVOL;
-
-    ret = loc_copy(&local->loc2, newloc);
-    if (ret == -1) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    if (hashed_subvol == cached_subvol) {
-        STACK_WIND(frame, dht_link_cbk, cached_subvol,
-                   cached_subvol->fops->link, oldloc, newloc, xdata);
-        return 0;
-    }
-
-    /* Create hardlinks to both the data file on the hot tier
-       and the linkto file on the cold tier */
-
-    gf_uuid_copy(local->gfid, oldloc->inode->gfid);
-
-    STACK_WIND(frame, tier_link_cbk, hashed_subvol, hashed_subvol->fops->link,
-               oldloc, newloc, xdata);
-
-    return 0;
-err:
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    DHT_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL);
-    return 0;
-}
-
-int
-tier_create_unlink_stale_linkto_cbk(call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-
-    local = frame->local;
-
-    if (local->params) {
-        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-    }
-
-    DHT_STACK_UNWIND(create, frame, -1, local->op_errno, NULL, NULL, NULL, NULL,
-                     NULL, NULL);
-
-    return 0;
-}
-
-int
-tier_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    xlator_t *prev = NULL;
-    int ret = -1;
-    dht_local_t *local = NULL;
-    xlator_t *hashed_subvol = NULL;
-    dht_conf_t *conf = NULL;
-
-    local = frame->local;
-    conf = this->private;
-
-    hashed_subvol = TIER_HASHED_SUBVOL;
-
-    if (!local) {
-        op_ret = -1;
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    if (op_ret == -1) {
-        if (local->linked == _gf_true && local->xattr_req) {
-            local->op_errno = op_errno;
-            local->op_ret = op_ret;
-            ret = dht_fill_dict_to_avoid_unlink_of_migrating_file(
-                local->xattr_req);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                       "Failed to set dictionary value to "
-                       "unlink of migrating file");
-                goto out;
-            }
-
-            STACK_WIND(frame, tier_create_unlink_stale_linkto_cbk,
-                       hashed_subvol, hashed_subvol->fops->unlink, &local->loc,
-                       0, local->xattr_req);
-            return 0;
-        }
-        goto out;
-    }
-
-    prev = cookie;
-
-    if (local->loc.parent) {
-        dht_inode_ctx_time_update(local->loc.parent, this, preparent, 0);
-
-        dht_inode_ctx_time_update(local->loc.parent, this, postparent, 1);
-    }
-
-    ret = dht_layout_preset(this, prev, inode);
-    if (ret != 0) {
-        gf_msg_debug(this->name, 0, "could not set preset layout for subvol %s",
-                     prev->name);
-        op_ret = -1;
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    local->op_errno = op_errno;
-
-    if (local->linked == _gf_true) {
-        local->stbuf = *stbuf;
-        dht_linkfile_attr_heal(frame, this);
-    }
-out:
-    if (local) {
-        if (local->xattr_req) {
-            dict_del(local->xattr_req, TIER_LINKFILE_GFID);
-        }
-    }
-
-    DHT_STRIP_PHASE1_FLAGS(stbuf);
-
-    DHT_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
-                     preparent, postparent, xdata);
-
-    return 0;
-}
-
-int
-tier_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno, inode_t *inode,
-                                struct iatt *stbuf, struct iatt *preparent,
-                                struct iatt *postparent, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    xlator_t *cached_subvol = NULL;
-    dht_conf_t *conf = NULL;
-    int ret = -1;
-    unsigned char *gfid = NULL;
-
-    local = frame->local;
-    if (!local) {
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    if (op_ret == -1) {
-        local->op_errno = op_errno;
-        goto err;
-    }
-
-    conf = this->private;
-    if (!conf) {
-        local->op_errno = EINVAL;
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    cached_subvol = TIER_UNHASHED_SUBVOL;
-
-    if (local->params) {
-        dict_del(local->params, conf->link_xattr_name);
-        dict_del(local->params, GLUSTERFS_INTERNAL_FOP_KEY);
-    }
-
-    /*
-     * We will delete the linkfile if data file creation fails.
-     * When deleting this stale linkfile, there is a possibility
-     * for a race between this linkfile deletion and a stale
-     * linkfile deletion triggered by another lookup from different
-     * client.
-     *
-     * For eg:
-     *
-     *     Client 1                        Client 2
-     *
-     * 1   linkfile created for foo
-     *
-     * 2   data file creation failed
-     *
-     * 3                                   creating a file with same name
-     *
-     * 4                                   lookup before creation deleted
-     *                                     the linkfile created by client1
-     *                                     considering as a stale linkfile.
-     *
-     * 5                                   New linkfile created for foo
-     *                                     with different gfid.
-     *
-     * 6 Trigger linkfile deletion as
-     *   data file creation failed.
-     *
-     * 7 Linkfile deleted which is
-     *   created by client2.
-     *
-     * 8                                   Data file created.
-     *
-     * With this race, we will end up having a file in a non-hashed subvol
-     * without a linkfile in hashed subvol.
-     *
-     * To avoid this, we store the gfid of linkfile created by client, So
-     * If we delete the linkfile , we validate gfid of existing file with
-     * stored value from posix layer.
-     *
-     * Storing this value in local->xattr_req as local->params was also used
-     * to create the data file. During the linkfile deletion we will use
-     * local->xattr_req dictionary.
-     */
-    if (!local->xattr_req) {
-        local->xattr_req = dict_new();
-        if (!local->xattr_req) {
-            local->op_errno = ENOMEM;
-            op_errno = ENOMEM;
-            goto err;
-        }
-    }
-
-    gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char);
-    if (!gfid) {
-        local->op_errno = ENOMEM;
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    gf_uuid_copy(gfid, stbuf->ia_gfid);
-    ret = dict_set_dynptr(local->xattr_req, TIER_LINKFILE_GFID, gfid,
-                          sizeof(uuid_t));
-    if (ret) {
-        GF_FREE(gfid);
-        gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-               "Failed to set dictionary value"
-               " : key = %s",
-               TIER_LINKFILE_GFID);
-    }
-
-    STACK_WIND_COOKIE(frame, tier_create_cbk, cached_subvol, cached_subvol,
-                      cached_subvol->fops->create, &local->loc, local->flags,
-                      local->mode, local->umask, local->fd, local->params);
-
-    return 0;
-err:
-    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
-                     NULL);
-    return 0;
-}
-
-gf_boolean_t
-tier_is_hot_tier_decommissioned(xlator_t *this)
-{
-    dht_conf_t *conf = NULL;
-    xlator_t *hot_tier = NULL;
-    int i = 0;
-
-    conf = this->private;
-    hot_tier = conf->subvolumes[1];
-
-    if (conf->decommission_subvols_cnt) {
-        for (i = 0; i < conf->subvolume_cnt; i++) {
-            if (conf->decommissioned_bricks[i] &&
-                conf->decommissioned_bricks[i] == hot_tier)
-                return _gf_true;
-        }
-    }
-
-    return _gf_false;
-}
-
-int
-tier_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-            mode_t mode, mode_t umask, fd_t *fd, dict_t *params)
-{
-    int op_errno = -1;
-    dht_local_t *local = NULL;
-    dht_conf_t *conf = NULL;
-    xlator_t *hot_subvol = NULL;
-    xlator_t *cold_subvol = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-
-    conf = this->private;
-
-    dht_get_du_info(frame, this, loc);
-
-    local = dht_local_init(frame, loc, fd, GF_FOP_CREATE);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    cold_subvol = TIER_HASHED_SUBVOL;
-    hot_subvol = TIER_UNHASHED_SUBVOL;
-
-    if (conf->subvolumes[0] != cold_subvol) {
-        hot_subvol = conf->subvolumes[0];
-    }
-    /*
-     * if hot tier full, write to cold.
-     * Also if hot tier is full, create in cold
-     */
-    if (dht_is_subvol_filled(this, hot_subvol) ||
-        tier_is_hot_tier_decommissioned(this)) {
-        gf_msg_debug(this->name, 0, "creating %s on %s", loc->path,
-                     cold_subvol->name);
-
-        STACK_WIND_COOKIE(frame, tier_create_cbk, cold_subvol, cold_subvol,
-                          cold_subvol->fops->create, loc, flags, mode, umask,
-                          fd, params);
-    } else {
-        local->params = dict_ref(params);
-        local->flags = flags;
-        local->mode = mode;
-        local->umask = umask;
-        local->cached_subvol = hot_subvol;
-        local->hashed_subvol = cold_subvol;
-
-        gf_msg_debug(this->name, 0, "creating %s on %s (link at %s)", loc->path,
-                     hot_subvol->name, cold_subvol->name);
-
-        dht_linkfile_create(frame, tier_create_linkfile_create_cbk, this,
-                            hot_subvol, cold_subvol, loc);
-
-        goto out;
-    }
-out:
-    return 0;
-
-err:
-
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    DHT_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL,
-                     NULL);
-
-    return 0;
-}
-
-int
-tier_unlink_nonhashed_linkfile_cbk(call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int op_ret, int op_errno,
-                                   struct iatt *preparent,
-                                   struct iatt *postparent, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    xlator_t *prev = NULL;
-
-    local = frame->local;
-    prev = cookie;
-
-    LOCK(&frame->lock);
-    {
-        if ((op_ret == -1) && (op_errno != ENOENT)) {
-            local->op_errno = op_errno;
-            local->op_ret = op_ret;
-            gf_msg_debug(this->name, op_errno,
-                         "Unlink link: subvolume %s"
-                         " returned -1",
-                         prev->name);
-            goto unlock;
-        }
-
-        local->op_ret = 0;
-    }
-unlock:
-    UNLOCK(&frame->lock);
-
-    if (local->op_ret == -1)
-        goto err;
-    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                     &local->preparent, &local->postparent, NULL);
-
-    return 0;
-
-err:
-    DHT_STACK_UNWIND(unlink, frame, -1, local->op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int
-tier_unlink_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, inode_t *inode,
-                       struct iatt *preparent, dict_t *xdata,
-                       struct iatt *postparent)
-{
-    dht_local_t *local = NULL;
-    xlator_t *prev = NULL;
-    dht_conf_t *conf = NULL;
-    xlator_t *hot_subvol = NULL;
-
-    local = frame->local;
-    prev = cookie;
-    conf = this->private;
-    hot_subvol = TIER_UNHASHED_SUBVOL;
-
-    if (!op_ret) {
-        /*
-         * linkfile present on hot tier. unlinking the linkfile
-         */
-        STACK_WIND_COOKIE(frame, tier_unlink_nonhashed_linkfile_cbk, hot_subvol,
-                          hot_subvol, hot_subvol->fops->unlink, &local->loc,
-                          local->flags, NULL);
-        return 0;
-    }
-
-    LOCK(&frame->lock);
-    {
-        if (op_errno == ENOENT) {
-            local->op_ret = 0;
-            local->op_errno = op_errno;
-        } else {
-            local->op_ret = op_ret;
-            local->op_errno = op_errno;
-        }
-        gf_msg_debug(this->name, op_errno, "Lookup : subvolume %s returned -1",
-                     prev->name);
-    }
-
-    UNLOCK(&frame->lock);
-
-    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                     &local->preparent, &local->postparent, xdata);
-
-    return 0;
-}
-
-int
-tier_unlink_linkfile_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    xlator_t *prev = NULL;
-
-    local = frame->local;
-    prev = cookie;
-
-    LOCK(&frame->lock);
-    {
-        /* Ignore EINVAL for tier to ignore error when the file
-                does not exist on the other tier  */
-        if ((op_ret == -1) && !((op_errno == ENOENT) || (op_errno == EINVAL))) {
-            local->op_errno = op_errno;
-            local->op_ret = op_ret;
-            gf_msg_debug(this->name, op_errno,
-                         "Unlink link: subvolume %s"
-                         " returned -1",
-                         prev->name);
-            goto unlock;
-        }
-
-        local->op_ret = 0;
-    }
-unlock:
-    UNLOCK(&frame->lock);
-
-    if (local->op_ret == -1)
-        goto err;
-
-    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                     &local->preparent, &local->postparent, xdata);
-
-    return 0;
-
-err:
-    DHT_STACK_UNWIND(unlink, frame, -1, local->op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-tier_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, struct iatt *preparent, struct iatt *postparent,
-                dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    xlator_t *prev = NULL;
-    struct iatt *stbuf = NULL;
-    dht_conf_t *conf = NULL;
-    int ret = -1;
-    xlator_t *hot_tier = NULL;
-    xlator_t *cold_tier = NULL;
-
-    local = frame->local;
-    prev = cookie;
-    conf = this->private;
-
-    cold_tier = TIER_HASHED_SUBVOL;
-    hot_tier = TIER_UNHASHED_SUBVOL;
-
-    LOCK(&frame->lock);
-    {
-        if (op_ret == -1) {
-            if (op_errno == ENOENT) {
-                local->op_ret = 0;
-            } else {
-                local->op_ret = -1;
-                local->op_errno = op_errno;
-            }
-            gf_msg_debug(this->name, op_errno,
-                         "Unlink: subvolume %s returned -1"
-                         " with errno = %d",
-                         prev->name, op_errno);
-            goto unlock;
-        }
-
-        local->op_ret = 0;
-
-        local->postparent = *postparent;
-        local->preparent = *preparent;
-
-        if (local->loc.parent) {
-            dht_inode_ctx_time_update(local->loc.parent, this,
-                                      &local->preparent, 0);
-            dht_inode_ctx_time_update(local->loc.parent, this,
-                                      &local->postparent, 1);
-        }
-    }
-unlock:
-    UNLOCK(&frame->lock);
-
-    if (local->op_ret)
-        goto out;
-
-    if (cold_tier != local->cached_subvol) {
-        /*
-         * File is present in hot tier, so there will be
-         * a link file on cold tier, deleting the linkfile
-         * from cold tier
-         */
-        STACK_WIND_COOKIE(frame, tier_unlink_linkfile_cbk, cold_tier, cold_tier,
-                          cold_tier->fops->unlink, &local->loc, local->flags,
-                          xdata);
-        return 0;
-    }
-
-    ret = dict_get_bin(xdata, DHT_IATT_IN_XDATA_KEY, (void **)&stbuf);
-    if (!ret && stbuf &&
-        ((IS_DHT_MIGRATION_PHASE2(stbuf)) || IS_DHT_MIGRATION_PHASE1(stbuf))) {
-        /*
-         * File is migrating from cold to hot tier.
-         * Delete the destination linkfile.
-         */
-        STACK_WIND_COOKIE(frame, tier_unlink_lookup_cbk, hot_tier, hot_tier,
-                          hot_tier->fops->lookup, &local->loc, NULL);
-        return 0;
-    }
-
-out:
-    DHT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                     &local->preparent, &local->postparent, xdata);
-
-    return 0;
-}
-
-int
-tier_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-            dict_t *xdata)
-{
-    xlator_t *cached_subvol = NULL;
-    xlator_t *hashed_subvol = NULL;
-    dht_conf_t *conf = NULL;
-    int op_errno = -1;
-    dht_local_t *local = NULL;
-    int ret = -1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-
-    conf = this->private;
-
-    local = dht_local_init(frame, loc, NULL, GF_FOP_UNLINK);
-    if (!local) {
-        op_errno = ENOMEM;
-
-        goto err;
-    }
-
-    hashed_subvol = TIER_HASHED_SUBVOL;
-
-    cached_subvol = local->cached_subvol;
-    if (!cached_subvol) {
-        gf_msg_debug(this->name, 0, "no cached subvolume for path=%s",
-                     loc->path);
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    local->flags = xflag;
-    if (IA_ISREG(loc->inode->ia_type) && (hashed_subvol == cached_subvol)) {
-        /*
-         * File resides in cold tier. We need to stat
-         * the file to see if it is being promoted.
-         * If yes we need to delete the destination
-         * file as well.
-         *
-         * Currently we are doing this check only for
-         * regular files.
-         */
-        xdata = xdata ? dict_ref(xdata) : dict_new();
-        if (xdata) {
-            ret = dict_set_int8(xdata, DHT_IATT_IN_XDATA_KEY, 1);
-            if (ret) {
-                gf_msg_debug(this->name, 0, "Failed to set dictionary key %s",
-                             DHT_IATT_IN_XDATA_KEY);
-            }
-        }
-    }
-
-    /*
-     * File is on hot tier, delete the data file first, then
-     * linkfile from cold.
-     */
-    STACK_WIND_COOKIE(frame, tier_unlink_cbk, cached_subvol, cached_subvol,
-                      cached_subvol->fops->unlink, loc, xflag, xdata);
-    if (xdata)
-        dict_unref(xdata);
-    return 0;
-err:
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    DHT_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-
-    return 0;
-}
-
-int
-tier_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                 int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
-{
-    gf_dirent_t entries;
-    gf_dirent_t *orig_entry = NULL;
-    gf_dirent_t *entry = NULL;
-    int count = 0;
-
-    INIT_LIST_HEAD(&entries.list);
-
-    if (op_ret < 0)
-        goto unwind;
-
-    list_for_each_entry(orig_entry, (&orig_entries->list), list)
-    {
-        entry = gf_dirent_for_name(orig_entry->d_name);
-        if (!entry) {
-            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-                   "Memory allocation failed ");
-            goto unwind;
-        }
-
-        entry->d_off = orig_entry->d_off;
-        entry->d_ino = orig_entry->d_ino;
-        entry->d_type = orig_entry->d_type;
-        entry->d_len = orig_entry->d_len;
-
-        list_add_tail(&entry->list, &entries.list);
-        count++;
-    }
-    op_ret = count;
-
-unwind:
-    if (op_ret < 0)
-        op_ret = 0;
-
-    DHT_STACK_UNWIND(readdir, frame, op_ret, op_errno, &entries, NULL);
-
-    gf_dirent_free(&entries);
-
-    return 0;
-}
-
-int
-tier_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, gf_dirent_t *orig_entries, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    gf_dirent_t entries;
-    gf_dirent_t *orig_entry = NULL;
-    gf_dirent_t *entry = NULL;
-    xlator_t *prev = NULL;
-    xlator_t *next_subvol = NULL;
-    off_t next_offset = 0;
-    int count = 0;
-    dht_conf_t *conf = NULL;
-    int ret = 0;
-    inode_table_t *itable = NULL;
-    inode_t *inode = NULL;
-
-    INIT_LIST_HEAD(&entries.list);
-    prev = cookie;
-    local = frame->local;
-    itable = local->fd ? local->fd->inode->table : NULL;
-
-    conf = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, conf, unwind);
-
-    if (op_ret < 0)
-        goto done;
-
-    list_for_each_entry(orig_entry, (&orig_entries->list), list)
-    {
-        next_offset = orig_entry->d_off;
-
-        if (IA_ISINVAL(orig_entry->d_stat.ia_type)) {
-            /*stat failed somewhere- ignore this entry*/
-            continue;
-        }
-
-        entry = gf_dirent_for_name(orig_entry->d_name);
-        if (!entry) {
-            goto unwind;
-        }
-
-        entry->d_off = orig_entry->d_off;
-        entry->d_stat = orig_entry->d_stat;
-        entry->d_ino = orig_entry->d_ino;
-        entry->d_type = orig_entry->d_type;
-        entry->d_len = orig_entry->d_len;
-
-        if (orig_entry->dict)
-            entry->dict = dict_ref(orig_entry->dict);
-
-        if (check_is_linkfile(NULL, (&orig_entry->d_stat), orig_entry->dict,
-                              conf->link_xattr_name)) {
-            goto entries;
-
-        } else if (IA_ISDIR(entry->d_stat.ia_type)) {
-            if (orig_entry->inode) {
-                dht_inode_ctx_time_update(orig_entry->inode, this,
-                                          &entry->d_stat, 1);
-            }
-        } else {
-            if (orig_entry->inode) {
-                ret = dht_layout_preset(this, prev, orig_entry->inode);
-                if (ret)
-                    gf_msg(this->name, GF_LOG_WARNING, 0,
-                           DHT_MSG_LAYOUT_SET_FAILED,
-                           "failed to link the layout "
-                           "in inode");
-
-                entry->inode = inode_ref(orig_entry->inode);
-            } else if (itable) {
-                /*
-                 * orig_entry->inode might be null if any upper
-                 * layer xlators below client set to null, to
-                 * force a lookup on the inode even if the inode
-                 * is present in the inode table. In that case
-                 * we just update the ctx to make sure we didn't
-                 * missed anything.
-                 */
-                inode = inode_find(itable, orig_entry->d_stat.ia_gfid);
-                if (inode) {
-                    ret = dht_layout_preset(this, TIER_HASHED_SUBVOL, inode);
-                    if (ret)
-                        gf_msg(this->name, GF_LOG_WARNING, 0,
-                               DHT_MSG_LAYOUT_SET_FAILED,
-                               "failed to link the layout"
-                               " in inode");
-                    inode_unref(inode);
-                    inode = NULL;
-                }
-            }
-        }
-
-    entries:
-        list_add_tail(&entry->list, &entries.list);
-        count++;
-    }
-    op_ret = count;
-
-done:
-    if (count == 0) {
-        /* non-zero next_offset means that
-           EOF is not yet hit on the current subvol
-        */
-        if (next_offset != 0) {
-            next_subvol = prev;
-        } else {
-            goto unwind;
-        }
-
-        STACK_WIND_COOKIE(frame, tier_readdirp_cbk, next_subvol, next_subvol,
-                          next_subvol->fops->readdirp, local->fd, local->size,
-                          next_offset, local->xattr);
-        return 0;
-    }
-
-unwind:
-    if (op_ret < 0)
-        op_ret = 0;
-
-    DHT_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &entries, NULL);
-
-    gf_dirent_free(&entries);
-
-    return 0;
-}
-
-int
-tier_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                off_t yoff, int whichop, dict_t *dict)
-{
-    dht_local_t *local = NULL;
-    int op_errno = -1;
-    xlator_t *hashed_subvol = NULL;
-    int ret = 0;
-    dht_conf_t *conf = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(this->private, err);
-
-    conf = this->private;
-
-    local = dht_local_init(frame, NULL, NULL, whichop);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    local->fd = fd_ref(fd);
-    local->size = size;
-    local->xattr_req = (dict) ? dict_ref(dict) : NULL;
-
-    hashed_subvol = TIER_HASHED_SUBVOL;
-
-    /* TODO: do proper readdir */
-    if (whichop == GF_FOP_READDIRP) {
-        if (dict)
-            local->xattr = dict_ref(dict);
-        else
-            local->xattr = dict_new();
-
-        if (local->xattr) {
-            ret = dict_set_uint32(local->xattr, conf->link_xattr_name, 256);
-            if (ret)
-                gf_msg(this->name, GF_LOG_WARNING, 0, DHT_MSG_DICT_SET_FAILED,
-                       "Failed to set dictionary value"
-                       " : key = %s",
-                       conf->link_xattr_name);
-        }
-
-        STACK_WIND_COOKIE(frame, tier_readdirp_cbk, hashed_subvol,
-                          hashed_subvol, hashed_subvol->fops->readdirp, fd,
-                          size, yoff, local->xattr);
-
-    } else {
-        STACK_WIND_COOKIE(frame, tier_readdir_cbk, hashed_subvol, hashed_subvol,
-                          hashed_subvol->fops->readdir, fd, size, yoff,
-                          local->xattr);
-    }
-
-    return 0;
-
-err:
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    DHT_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
-
-    return 0;
-}
-
-int
-tier_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t yoff, dict_t *xdata)
-{
-    int op = GF_FOP_READDIR;
-    dht_conf_t *conf = NULL;
-    int i = 0;
-
-    conf = this->private;
-    if (!conf)
-        goto out;
-
-    for (i = 0; i < conf->subvolume_cnt; i++) {
-        if (!conf->subvolume_status[i]) {
-            op = GF_FOP_READDIRP;
-            break;
-        }
-    }
-
-    if (conf->use_readdirp)
-        op = GF_FOP_READDIRP;
-
-out:
-    tier_do_readdir(frame, this, fd, size, yoff, op, 0);
-    return 0;
-}
-
-int
-tier_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t yoff, dict_t *dict)
-{
-    tier_do_readdir(frame, this, fd, size, yoff, GF_FOP_READDIRP, dict);
-    return 0;
-}
-
-int
-tier_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, struct statvfs *statvfs, dict_t *xdata)
-{
-    gf_boolean_t event = _gf_false;
-    qdstatfs_action_t action = qdstatfs_action_OFF;
-    dht_local_t *local = NULL;
-    int this_call_cnt = 0;
-    int bsize = 0;
-    int frsize = 0;
-    GF_UNUSED int ret = 0;
-    unsigned long new_usage = 0;
-    unsigned long cur_usage = 0;
-    xlator_t *prev = NULL;
-    dht_conf_t *conf = NULL;
-    tier_statvfs_t *tier_stat = NULL;
-
-    prev = cookie;
-    local = frame->local;
-    GF_ASSERT(local);
-
-    conf = this->private;
-
-    if (xdata)
-        ret = dict_get_int8(xdata, "quota-deem-statfs", (int8_t *)&event);
-
-    tier_stat = &local->tier_statvfs;
-
-    LOCK(&frame->lock);
-    {
-        if (op_ret == -1) {
-            local->op_errno = op_errno;
-            goto unlock;
-        }
-        if (!statvfs) {
-            op_errno = EINVAL;
-            local->op_ret = -1;
-            goto unlock;
-        }
-        local->op_ret = 0;
-
-        if (local->quota_deem_statfs) {
-            if (event == _gf_true) {
-                action = qdstatfs_action_COMPARE;
-            } else {
-                action = qdstatfs_action_NEGLECT;
-            }
-        } else {
-            if (event == _gf_true) {
-                action = qdstatfs_action_REPLACE;
-                local->quota_deem_statfs = _gf_true;
-            }
-        }
-
-        if (local->quota_deem_statfs) {
-            switch (action) {
-                case qdstatfs_action_NEGLECT:
-                    goto unlock;
-
-                case qdstatfs_action_REPLACE:
-                    local->statvfs = *statvfs;
-                    goto unlock;
-
-                case qdstatfs_action_COMPARE:
-                    new_usage = statvfs->f_blocks - statvfs->f_bfree;
-                    cur_usage = local->statvfs.f_blocks -
-                                local->statvfs.f_bfree;
-
-                    /* Take the max of the usage from subvols */
-                    if (new_usage >= cur_usage)
-                        local->statvfs = *statvfs;
-                    goto unlock;
-
-                default:
-                    break;
-            }
-        }
-
-        if (local->statvfs.f_bsize != 0) {
-            bsize = max(local->statvfs.f_bsize, statvfs->f_bsize);
-            frsize = max(local->statvfs.f_frsize, statvfs->f_frsize);
-            dht_normalize_stats(&local->statvfs, bsize, frsize);
-            dht_normalize_stats(statvfs, bsize, frsize);
-        } else {
-            local->statvfs.f_bsize = statvfs->f_bsize;
-            local->statvfs.f_frsize = statvfs->f_frsize;
-        }
-
-        if (prev == TIER_HASHED_SUBVOL) {
-            local->statvfs.f_blocks = statvfs->f_blocks;
-            local->statvfs.f_files = statvfs->f_files;
-            local->statvfs.f_fsid = statvfs->f_fsid;
-            local->statvfs.f_flag = statvfs->f_flag;
-            local->statvfs.f_namemax = statvfs->f_namemax;
-            tier_stat->blocks_used = (statvfs->f_blocks - statvfs->f_bfree);
-            tier_stat->pblocks_used = (statvfs->f_blocks - statvfs->f_bavail);
-            tier_stat->files_used = (statvfs->f_files - statvfs->f_ffree);
-            tier_stat->pfiles_used = (statvfs->f_files - statvfs->f_favail);
-            tier_stat->hashed_fsid = statvfs->f_fsid;
-        } else {
-            tier_stat->unhashed_fsid = statvfs->f_fsid;
-            tier_stat->unhashed_blocks_used = (statvfs->f_blocks -
-                                               statvfs->f_bfree);
-            tier_stat->unhashed_pblocks_used = (statvfs->f_blocks -
-                                                statvfs->f_bavail);
-            tier_stat->unhashed_files_used = (statvfs->f_files -
-                                              statvfs->f_ffree);
-            tier_stat->unhashed_pfiles_used = (statvfs->f_files -
-                                               statvfs->f_favail);
-        }
-    }
-unlock:
-    UNLOCK(&frame->lock);
-
-    this_call_cnt = dht_frame_return(frame);
-    if (is_last_call(this_call_cnt)) {
-        if (tier_stat->unhashed_fsid != tier_stat->hashed_fsid) {
-            tier_stat->blocks_used += tier_stat->unhashed_blocks_used;
-            tier_stat->pblocks_used += tier_stat->unhashed_pblocks_used;
-            tier_stat->files_used += tier_stat->unhashed_files_used;
-            tier_stat->pfiles_used += tier_stat->unhashed_pfiles_used;
-        }
-        local->statvfs.f_bfree = local->statvfs.f_blocks -
-                                 tier_stat->blocks_used;
-        local->statvfs.f_bavail = local->statvfs.f_blocks -
-                                  tier_stat->pblocks_used;
-        local->statvfs.f_ffree = local->statvfs.f_files - tier_stat->files_used;
-        local->statvfs.f_favail = local->statvfs.f_files -
-                                  tier_stat->pfiles_used;
-        DHT_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
-                         &local->statvfs, xdata);
-    }
-
-    return 0;
-}
-
-int
-tier_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    dht_local_t *local = NULL;
-    dht_conf_t *conf = NULL;
-    int op_errno = -1;
-    int i = -1;
-    inode_t *inode = NULL;
-    inode_table_t *itable = NULL;
-    uuid_t root_gfid = {
-        0,
-    };
-    loc_t newloc = {
-        0,
-    };
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(this->private, err);
-
-    conf = this->private;
-
-    local = dht_local_init(frame, NULL, NULL, GF_FOP_STATFS);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    if (loc->inode && !IA_ISDIR(loc->inode->ia_type)) {
-        itable = loc->inode->table;
-        if (!itable) {
-            op_errno = EINVAL;
-            goto err;
-        }
-
-        loc = &local->loc2;
-        root_gfid[15] = 1;
-
-        inode = inode_find(itable, root_gfid);
-        if (!inode) {
-            op_errno = EINVAL;
-            goto err;
-        }
-
-        dht_build_root_loc(inode, &newloc);
-        loc = &newloc;
-    }
-
-    local->call_cnt = conf->subvolume_cnt;
-
-    for (i = 0; i < conf->subvolume_cnt; i++) {
-        STACK_WIND_COOKIE(frame, tier_statfs_cbk, conf->subvolumes[i],
-                          conf->subvolumes[i],
-                          conf->subvolumes[i]->fops->statfs, loc, xdata);
-    }
-
-    return 0;
-
-err:
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    DHT_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
-
-    return 0;
-}
diff --git a/xlators/cluster/dht/src/tier-common.h b/xlators/cluster/dht/src/tier-common.h
deleted file mode 100644
index b1ebaa8004d..00000000000
--- a/xlators/cluster/dht/src/tier-common.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (c) 2015 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 _TIER_COMMON_H_
-#define _TIER_COMMON_H_
-/* Function definitions */
-int
-tier_create_unlink_stale_linkto_cbk(call_frame_t *frame, void *cookie,
-                                    xlator_t *this, int op_ret, int op_errno,
-                                    struct iatt *preparent,
-                                    struct iatt *postparent, dict_t *xdata);
-
-int
-tier_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
-                struct iatt *preparent, struct iatt *postparent, dict_t *xdata);
-
-int
-tier_create_linkfile_create_cbk(call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno, inode_t *inode,
-                                struct iatt *stbuf, struct iatt *preparent,
-                                struct iatt *postparent, dict_t *xdata);
-
-int
-tier_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-            mode_t mode, mode_t umask, fd_t *fd, dict_t *params);
-
-int32_t
-tier_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-            dict_t *xdata);
-
-int32_t
-tier_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t off, dict_t *dict);
-
-int
-tier_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t yoff, dict_t *xdata);
-
-int
-tier_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-          dict_t *xdata);
-
-int
-tier_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata);
-
-#endif
diff --git a/xlators/cluster/dht/src/tier.c b/xlators/cluster/dht/src/tier.c
deleted file mode 100644
index a8cccaf019e..00000000000
--- a/xlators/cluster/dht/src/tier.c
+++ /dev/null
@@ -1,3090 +0,0 @@
-/*
-  Copyright (c) 2015 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.
-*/
-
-#include <dlfcn.h>
-
-#include "dht-common.h"
-#include "tier.h"
-#include "tier-common.h"
-#include <glusterfs/syscall.h>
-#include <glusterfs/events.h>
-#include "tier-ctr-interface.h"
-
-/*Hard coded DB info*/
-static gfdb_db_type_t dht_tier_db_type = GFDB_SQLITE3;
-/*Hard coded DB info*/
-
-/*Mutex for updating the data movement stats*/
-static pthread_mutex_t dm_stat_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-/* Stores the path location of promotion query files */
-static char *promotion_qfile;
-/* Stores the path location of demotion query files */
-static char *demotion_qfile;
-
-static void *libhandle;
-static gfdb_methods_t gfdb_methods;
-
-#define DB_QUERY_RECORD_SIZE 4096
-
-/*
- * Closes all the fds and frees the qfile_array
- * */
-static void
-qfile_array_free(tier_qfile_array_t *qfile_array)
-{
-    ssize_t i = 0;
-
-    if (qfile_array) {
-        if (qfile_array->fd_array) {
-            for (i = 0; i < qfile_array->array_size; i++) {
-                if (qfile_array->fd_array[i] != -1) {
-                    sys_close(qfile_array->fd_array[i]);
-                }
-            }
-        }
-        GF_FREE(qfile_array->fd_array);
-    }
-    GF_FREE(qfile_array);
-}
-
-/* Create a new query file list with given size */
-static tier_qfile_array_t *
-qfile_array_new(ssize_t array_size)
-{
-    int ret = -1;
-    tier_qfile_array_t *qfile_array = NULL;
-    ssize_t i = 0;
-
-    GF_VALIDATE_OR_GOTO("tier", (array_size > 0), out);
-
-    qfile_array = GF_CALLOC(1, sizeof(tier_qfile_array_t),
-                            gf_tier_mt_qfile_array_t);
-    if (!qfile_array) {
-        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to allocate memory for tier_qfile_array_t");
-        goto out;
-    }
-
-    qfile_array->fd_array = GF_MALLOC(array_size * sizeof(int),
-                                      gf_dht_mt_int32_t);
-    if (!qfile_array->fd_array) {
-        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to allocate memory for "
-               "tier_qfile_array_t->fd_array");
-        goto out;
-    }
-
-    /* Init all the fds to -1 */
-    for (i = 0; i < array_size; i++) {
-        qfile_array->fd_array[i] = -1;
-    }
-
-    qfile_array->array_size = array_size;
-    qfile_array->next_index = 0;
-
-    /* Set exhausted count to list size as the list is empty */
-    qfile_array->exhausted_count = qfile_array->array_size;
-
-    ret = 0;
-out:
-    if (ret) {
-        qfile_array_free(qfile_array);
-        qfile_array = NULL;
-    }
-    return qfile_array;
-}
-
-/* Checks if the query file list is empty or totally exhausted. */
-static gf_boolean_t
-is_qfile_array_empty(tier_qfile_array_t *qfile_array)
-{
-    return (qfile_array->exhausted_count == qfile_array->array_size)
-               ? _gf_true
-               : _gf_false;
-}
-
-/* Shifts the next_fd pointer to the next available fd in the list */
-static void
-shift_next_index(tier_qfile_array_t *qfile_array)
-{
-    int qfile_fd = 0;
-    int spin_count = 0;
-
-    if (is_qfile_array_empty(qfile_array)) {
-        return;
-    }
-
-    do {
-        /* change next_index in a rotional manner */
-        (qfile_array->next_index == (qfile_array->array_size - 1))
-            ? qfile_array->next_index = 0
-            : qfile_array->next_index++;
-
-        qfile_fd = (qfile_array->fd_array[qfile_array->next_index]);
-
-        spin_count++;
-
-    } while ((qfile_fd == -1) && (spin_count < qfile_array->array_size));
-}
-
-/*
- * This is a non-thread safe function to read query records
- * from a list of query files in a Round-Robin manner.
- * As in when the query files get exhuasted they are closed.
- * Returns:
- * 0   if all the query records in all the query files of the list are
- *     exhausted.
- * > 0 if a query record is successfully read. Indicates the size of the query
- *     record read.
- * < 0  if there was failure
- * */
-static int
-read_query_record_list(tier_qfile_array_t *qfile_array,
-                       gfdb_query_record_t **query_record)
-{
-    int ret = -1;
-    int qfile_fd = 0;
-
-    GF_VALIDATE_OR_GOTO("tier", qfile_array, out);
-    GF_VALIDATE_OR_GOTO("tier", qfile_array->fd_array, out);
-
-    do {
-        if (is_qfile_array_empty(qfile_array)) {
-            ret = 0;
-            break;
-        }
-
-        qfile_fd = qfile_array->fd_array[qfile_array->next_index];
-        ret = gfdb_methods.gfdb_read_query_record(qfile_fd, query_record);
-        if (ret <= 0) {
-            /*The qfile_fd has reached EOF or
-             * there was an error.
-             * 1. Close the exhausted fd
-             * 2. increment the exhausted count
-             * 3. shift next_qfile to next qfile
-             **/
-            sys_close(qfile_fd);
-            qfile_array->fd_array[qfile_array->next_index] = -1;
-            qfile_array->exhausted_count++;
-            /* shift next_qfile to next qfile */
-            shift_next_index(qfile_array);
-            continue;
-        } else {
-            /* shift next_qfile to next qfile */
-            shift_next_index(qfile_array);
-            break;
-        }
-    } while (1);
-out:
-    return ret;
-}
-
-/* Check and update the watermark every WM_INTERVAL seconds */
-#define WM_INTERVAL 5
-#define WM_INTERVAL_EMERG 1
-
-static int
-tier_check_same_node(xlator_t *this, loc_t *loc, gf_defrag_info_t *defrag)
-{
-    int ret = -1;
-    dict_t *dict = NULL;
-    char *uuid_str = NULL;
-    uuid_t node_uuid = {
-        0,
-    };
-
-    GF_VALIDATE_OR_GOTO("tier", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, loc, out);
-    GF_VALIDATE_OR_GOTO(this->name, defrag, out);
-
-    if (syncop_getxattr(this, loc, &dict, GF_XATTR_NODE_UUID_KEY, NULL, NULL)) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Unable to get NODE_UUID_KEY %s %s\n", loc->name, loc->path);
-        goto out;
-    }
-
-    if (dict_get_str(dict, GF_XATTR_NODE_UUID_KEY, &uuid_str) < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to get node-uuids for %s", loc->path);
-        goto out;
-    }
-
-    if (gf_uuid_parse(uuid_str, node_uuid)) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "uuid_parse failed for %s", loc->path);
-        goto out;
-    }
-
-    if (gf_uuid_compare(node_uuid, defrag->node_uuid)) {
-        gf_msg_debug(this->name, 0, "%s does not belong to this node",
-                     loc->path);
-        ret = 1;
-        goto out;
-    }
-
-    ret = 0;
-out:
-    if (dict)
-        dict_unref(dict);
-
-    return ret;
-}
-
-int
-tier_get_fs_stat(xlator_t *this, loc_t *root_loc)
-{
-    int ret = 0;
-    gf_defrag_info_t *defrag = NULL;
-    dht_conf_t *conf = NULL;
-    dict_t *xdata = NULL;
-    struct statvfs statfs = {
-        0,
-    };
-    gf_tier_conf_t *tier_conf = NULL;
-
-    conf = this->private;
-    if (!conf) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
-               "conf is NULL");
-        ret = -1;
-        goto exit;
-    }
-
-    defrag = conf->defrag;
-    if (!defrag) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
-               "defrag is NULL");
-        ret = -1;
-        goto exit;
-    }
-
-    tier_conf = &defrag->tier_conf;
-
-    xdata = dict_new();
-    if (!xdata) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, DHT_MSG_NO_MEMORY,
-               "failed to allocate dictionary");
-        ret = -1;
-        goto exit;
-    }
-
-    ret = dict_set_int8(xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, 1);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_DICT_SET_FAILED,
-               "Failed to set " GF_INTERNAL_IGNORE_DEEM_STATFS " in dict");
-        ret = -1;
-        goto exit;
-    }
-
-    /* Find how much free space is on the hot subvolume.
-     * Then see if that value */
-    /* is less than or greater than user defined watermarks.
-     * Stash results in */
-    /* the tier_conf data structure. */
-
-    ret = syncop_statfs(conf->subvolumes[1], root_loc, &statfs, xdata, NULL);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_STATUS,
-               "Unable to obtain statfs.");
-        goto exit;
-    }
-
-    pthread_mutex_lock(&dm_stat_mutex);
-
-    tier_conf->block_size = statfs.f_bsize;
-    tier_conf->blocks_total = statfs.f_blocks;
-    tier_conf->blocks_used = statfs.f_blocks - statfs.f_bfree;
-
-    tier_conf->percent_full = GF_PERCENTAGE(tier_conf->blocks_used,
-                                            statfs.f_blocks);
-    pthread_mutex_unlock(&dm_stat_mutex);
-
-exit:
-    if (xdata)
-        dict_unref(xdata);
-    return ret;
-}
-
-static void
-tier_send_watermark_event(const char *volname, tier_watermark_op_t old_wm,
-                          tier_watermark_op_t new_wm)
-{
-    if (old_wm == TIER_WM_LOW || old_wm == TIER_WM_NONE) {
-        if (new_wm == TIER_WM_MID) {
-            gf_event(EVENT_TIER_WATERMARK_RAISED_TO_MID, "vol=%s", volname);
-        } else if (new_wm == TIER_WM_HI) {
-            gf_event(EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
-        }
-    } else if (old_wm == TIER_WM_MID) {
-        if (new_wm == TIER_WM_LOW) {
-            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_LOW, "vol=%s", volname);
-        } else if (new_wm == TIER_WM_HI) {
-            gf_event(EVENT_TIER_WATERMARK_HI, "vol=%s", volname);
-        }
-    } else if (old_wm == TIER_WM_HI) {
-        if (new_wm == TIER_WM_MID) {
-            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_MID, "vol=%s", volname);
-        } else if (new_wm == TIER_WM_LOW) {
-            gf_event(EVENT_TIER_WATERMARK_DROPPED_TO_LOW, "vol=%s", volname);
-        }
-    }
-}
-
-int
-tier_check_watermark(xlator_t *this)
-{
-    int ret = -1;
-    gf_defrag_info_t *defrag = NULL;
-    dht_conf_t *conf = NULL;
-    gf_tier_conf_t *tier_conf = NULL;
-    tier_watermark_op_t wm = TIER_WM_NONE;
-
-    conf = this->private;
-    if (!conf)
-        goto exit;
-
-    defrag = conf->defrag;
-    if (!defrag)
-        goto exit;
-
-    tier_conf = &defrag->tier_conf;
-
-    if (tier_conf->percent_full < tier_conf->watermark_low) {
-        wm = TIER_WM_LOW;
-
-    } else if (tier_conf->percent_full < tier_conf->watermark_hi) {
-        wm = TIER_WM_MID;
-
-    } else {
-        wm = TIER_WM_HI;
-    }
-
-    if (wm != tier_conf->watermark_last) {
-        tier_send_watermark_event(tier_conf->volname, tier_conf->watermark_last,
-                                  wm);
-
-        tier_conf->watermark_last = wm;
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Tier watermark now %d", wm);
-    }
-
-    ret = 0;
-
-exit:
-    return ret;
-}
-
-static gf_boolean_t
-is_hot_tier_full(gf_tier_conf_t *tier_conf)
-{
-    if (tier_conf && (tier_conf->mode == TIER_MODE_WM) &&
-        (tier_conf->watermark_last == TIER_WM_HI))
-        return _gf_true;
-
-    return _gf_false;
-}
-
-int
-tier_do_migration(xlator_t *this, int promote)
-{
-    gf_defrag_info_t *defrag = NULL;
-    dht_conf_t *conf = NULL;
-    long rand = 0;
-    int migrate = 0;
-    gf_tier_conf_t *tier_conf = NULL;
-
-    conf = this->private;
-    if (!conf)
-        goto exit;
-
-    defrag = conf->defrag;
-    if (!defrag)
-        goto exit;
-
-    if (tier_check_watermark(this) != 0) {
-        gf_msg(this->name, GF_LOG_CRITICAL, errno, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to get watermark");
-        goto exit;
-    }
-
-    tier_conf = &defrag->tier_conf;
-
-    switch (tier_conf->watermark_last) {
-        case TIER_WM_LOW:
-            migrate = promote ? 1 : 0;
-            break;
-        case TIER_WM_HI:
-            migrate = promote ? 0 : 1;
-            break;
-        case TIER_WM_MID:
-            /* coverity[DC.WEAK_CRYPTO] */
-            rand = random() % 100;
-            if (promote) {
-                migrate = (rand > tier_conf->percent_full);
-            } else {
-                migrate = (rand <= tier_conf->percent_full);
-            }
-            break;
-    }
-
-exit:
-    return migrate;
-}
-
-int
-tier_migrate(xlator_t *this, int is_promotion, dict_t *migrate_data, loc_t *loc,
-             gf_tier_conf_t *tier_conf)
-{
-    int ret = -1;
-
-    pthread_mutex_lock(&tier_conf->pause_mutex);
-    if (is_promotion)
-        tier_conf->promote_in_progress = 1;
-    else
-        tier_conf->demote_in_progress = 1;
-    pthread_mutex_unlock(&tier_conf->pause_mutex);
-
-    /* Data migration */
-    ret = syncop_setxattr(this, loc, migrate_data, 0, NULL, NULL);
-
-    pthread_mutex_lock(&tier_conf->pause_mutex);
-    if (is_promotion)
-        tier_conf->promote_in_progress = 0;
-    else
-        tier_conf->demote_in_progress = 0;
-    pthread_mutex_unlock(&tier_conf->pause_mutex);
-
-    return ret;
-}
-
-/* returns  _gf_true: if file can be promoted
- * returns _gf_false: if file cannot be promoted
- */
-static gf_boolean_t
-tier_can_promote_file(xlator_t *this, char const *file_name,
-                      struct iatt *current, gf_defrag_info_t *defrag)
-{
-    gf_boolean_t ret = _gf_false;
-    fsblkcnt_t estimated_usage = 0;
-
-    if (defrag->tier_conf.tier_max_promote_size &&
-        (current->ia_size > defrag->tier_conf.tier_max_promote_size)) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "File %s (gfid:%s) with size (%" PRIu64
-               ") exceeds maxsize "
-               "(%d) for promotion. File will not be promoted.",
-               file_name, uuid_utoa(current->ia_gfid), current->ia_size,
-               defrag->tier_conf.tier_max_promote_size);
-        goto err;
-    }
-
-    /* bypass further validations for TEST mode */
-    if (defrag->tier_conf.mode != TIER_MODE_WM) {
-        ret = _gf_true;
-        goto err;
-    }
-
-    /* convert the file size to blocks as per the block size of the
-     * destination tier
-     * NOTE: add (block_size - 1) to get the correct block size when
-     *       there is a remainder after a modulo
-     */
-    estimated_usage = ((current->ia_size + defrag->tier_conf.block_size - 1) /
-                       defrag->tier_conf.block_size) +
-                      defrag->tier_conf.blocks_used;
-
-    /* test if the estimated block usage goes above HI watermark */
-    if (GF_PERCENTAGE(estimated_usage, defrag->tier_conf.blocks_total) >=
-        defrag->tier_conf.watermark_hi) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Estimated block count consumption on "
-               "hot tier (%" PRIu64
-               ") exceeds hi watermark (%d%%). "
-               "File will not be promoted.",
-               estimated_usage, defrag->tier_conf.watermark_hi);
-        goto err;
-    }
-    ret = _gf_true;
-err:
-    return ret;
-}
-
-static int
-tier_set_migrate_data(dict_t *migrate_data)
-{
-    int failed = 1;
-
-    failed = dict_set_str(migrate_data, GF_XATTR_FILE_MIGRATE_KEY, "force");
-    if (failed) {
-        goto bail_out;
-    }
-
-    /* Flag to suggest the xattr call is from migrator */
-    failed = dict_set_str(migrate_data, "from.migrator", "yes");
-    if (failed) {
-        goto bail_out;
-    }
-
-    /* Flag to suggest its a tiering migration
-     * The reason for this dic key-value is that
-     * promotions and demotions are multithreaded
-     * so the original frame from gf_defrag_start()
-     * is not carried. A new frame will be created when
-     * we do syncop_setxattr(). This does not have the
-     * frame->root->pid of the original frame. So we pass
-     * this dic key-value when we do syncop_setxattr() to do
-     * data migration and set the frame->root->pid to
-     * GF_CLIENT_PID_TIER_DEFRAG in dht_setxattr() just before
-     * calling dht_start_rebalance_task() */
-    failed = dict_set_str(migrate_data, TIERING_MIGRATION_KEY, "yes");
-    if (failed) {
-        goto bail_out;
-    }
-
-    failed = 0;
-
-bail_out:
-    return failed;
-}
-
-static char *
-tier_get_parent_path(xlator_t *this, loc_t *p_loc, struct iatt *par_stbuf,
-                     int *per_link_status)
-{
-    int ret = -1;
-    char *parent_path = NULL;
-    dict_t *xdata_request = NULL;
-    dict_t *xdata_response = NULL;
-
-    xdata_request = dict_new();
-    if (!xdata_request) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to create xdata_request dict");
-        goto err;
-    }
-    ret = dict_set_int32(xdata_request, GET_ANCESTRY_PATH_KEY, 42);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to set value to dict : key %s \n",
-               GET_ANCESTRY_PATH_KEY);
-        goto err;
-    }
-
-    ret = syncop_lookup(this, p_loc, par_stbuf, NULL, xdata_request,
-                        &xdata_response);
-    /* When the parent gfid is a stale entry, the lookup
-     * will fail and stop the demotion process.
-     * The parent gfid can be stale when a huge folder is
-     * deleted while the files within it are being migrated
-     */
-    if (ret == -ESTALE) {
-        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_STALE_LOOKUP,
-               "Stale entry in parent lookup for %s", uuid_utoa(p_loc->gfid));
-        *per_link_status = 1;
-        goto err;
-    } else if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
-               "Error in parent lookup for %s", uuid_utoa(p_loc->gfid));
-        *per_link_status = -1;
-        goto err;
-    }
-    ret = dict_get_str(xdata_response, GET_ANCESTRY_PATH_KEY, &parent_path);
-    if (ret || !parent_path) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to get parent path for %s", uuid_utoa(p_loc->gfid));
-        *per_link_status = -1;
-        goto err;
-    }
-
-err:
-    if (xdata_request) {
-        dict_unref(xdata_request);
-    }
-
-    if (xdata_response) {
-        dict_unref(xdata_response);
-        xdata_response = NULL;
-    }
-
-    return parent_path;
-}
-
-static int
-tier_get_file_name_and_path(xlator_t *this, uuid_t gfid,
-                            gfdb_link_info_t *link_info,
-                            char const *parent_path, loc_t *loc,
-                            int *per_link_status)
-{
-    int ret = -1;
-
-    loc->name = gf_strdup(link_info->file_name);
-    if (!loc->name) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Memory "
-               "allocation failed for %s",
-               uuid_utoa(gfid));
-        *per_link_status = -1;
-        goto err;
-    }
-    ret = gf_asprintf((char **)&(loc->path), "%s/%s", parent_path, loc->name);
-    if (ret < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to "
-               "construct file path for %s %s\n",
-               parent_path, loc->name);
-        *per_link_status = -1;
-        goto err;
-    }
-
-    ret = 0;
-
-err:
-    return ret;
-}
-
-static int
-tier_lookup_file(xlator_t *this, loc_t *p_loc, loc_t *loc, struct iatt *current,
-                 int *per_link_status)
-{
-    int ret = -1;
-
-    ret = syncop_lookup(this, loc, current, NULL, NULL, NULL);
-
-    /* The file may be deleted even when the parent
-     * is available and the lookup will
-     * return a stale entry which would stop the
-     * migration. so if its a stale entry, then skip
-     * the file and keep migrating.
-     */
-    if (ret == -ESTALE) {
-        gf_msg(this->name, GF_LOG_WARNING, -ret, DHT_MSG_STALE_LOOKUP,
-               "Stale lookup for %s", uuid_utoa(p_loc->gfid));
-        *per_link_status = 1;
-        goto err;
-    } else if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to "
-               "lookup file %s\n",
-               loc->name);
-        *per_link_status = -1;
-        goto err;
-    }
-    ret = 0;
-
-err:
-    return ret;
-}
-
-static gf_boolean_t
-tier_is_file_already_at_destination(xlator_t *src_subvol,
-                                    query_cbk_args_t *query_cbk_args,
-                                    dht_conf_t *conf, int *per_link_status)
-{
-    gf_boolean_t at_destination = _gf_true;
-
-    if (src_subvol == NULL) {
-        *per_link_status = 1;
-        goto err;
-    }
-    if (query_cbk_args->is_promotion && src_subvol == conf->subvolumes[1]) {
-        *per_link_status = 1;
-        goto err;
-    }
-
-    if (!query_cbk_args->is_promotion && src_subvol == conf->subvolumes[0]) {
-        *per_link_status = 1;
-        goto err;
-    }
-    at_destination = _gf_false;
-
-err:
-    return at_destination;
-}
-
-static void
-tier_update_migration_counters(query_cbk_args_t *query_cbk_args,
-                               gf_defrag_info_t *defrag,
-                               uint64_t *total_migrated_bytes, int *total_files)
-{
-    if (query_cbk_args->is_promotion) {
-        defrag->total_files_promoted++;
-        *total_migrated_bytes += defrag->tier_conf.st_last_promoted_size;
-        pthread_mutex_lock(&dm_stat_mutex);
-        defrag->tier_conf.blocks_used += defrag->tier_conf
-                                             .st_last_promoted_size;
-        pthread_mutex_unlock(&dm_stat_mutex);
-    } else {
-        defrag->total_files_demoted++;
-        *total_migrated_bytes += defrag->tier_conf.st_last_demoted_size;
-        pthread_mutex_lock(&dm_stat_mutex);
-        defrag->tier_conf.blocks_used -= defrag->tier_conf.st_last_demoted_size;
-        pthread_mutex_unlock(&dm_stat_mutex);
-    }
-    if (defrag->tier_conf.blocks_total) {
-        pthread_mutex_lock(&dm_stat_mutex);
-        defrag->tier_conf.percent_full = GF_PERCENTAGE(
-            defrag->tier_conf.blocks_used, defrag->tier_conf.blocks_total);
-        pthread_mutex_unlock(&dm_stat_mutex);
-    }
-
-    (*total_files)++;
-}
-
-static int
-tier_migrate_link(xlator_t *this, dht_conf_t *conf, uuid_t gfid,
-                  gfdb_link_info_t *link_info, gf_defrag_info_t *defrag,
-                  query_cbk_args_t *query_cbk_args, dict_t *migrate_data,
-                  int *per_link_status, int *total_files,
-                  uint64_t *total_migrated_bytes)
-{
-    int ret = -1;
-    struct iatt current = {
-        0,
-    };
-    struct iatt par_stbuf = {
-        0,
-    };
-    loc_t p_loc = {
-        0,
-    };
-    loc_t loc = {
-        0,
-    };
-    xlator_t *src_subvol = NULL;
-    inode_t *linked_inode = NULL;
-    char *parent_path = NULL;
-
-    /* Lookup for parent and get the path of parent */
-    gf_uuid_copy(p_loc.gfid, link_info->pargfid);
-    p_loc.inode = inode_new(defrag->root_inode->table);
-    if (!p_loc.inode) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to create reference to inode"
-               " for %s",
-               uuid_utoa(p_loc.gfid));
-
-        *per_link_status = -1;
-        goto err;
-    }
-
-    parent_path = tier_get_parent_path(this, &p_loc, &par_stbuf,
-                                       per_link_status);
-    if (!parent_path) {
-        goto err;
-    }
-
-    linked_inode = inode_link(p_loc.inode, NULL, NULL, &par_stbuf);
-    inode_unref(p_loc.inode);
-    p_loc.inode = linked_inode;
-
-    /* Preparing File Inode */
-    gf_uuid_copy(loc.gfid, gfid);
-    loc.inode = inode_new(defrag->root_inode->table);
-    gf_uuid_copy(loc.pargfid, link_info->pargfid);
-    loc.parent = inode_ref(p_loc.inode);
-
-    /* Get filename and Construct file path */
-    if (tier_get_file_name_and_path(this, gfid, link_info, parent_path, &loc,
-                                    per_link_status) != 0) {
-        goto err;
-    }
-    gf_uuid_copy(loc.parent->gfid, link_info->pargfid);
-
-    /* lookup file inode */
-    if (tier_lookup_file(this, &p_loc, &loc, &current, per_link_status) != 0) {
-        goto err;
-    }
-
-    if (query_cbk_args->is_promotion) {
-        if (!tier_can_promote_file(this, link_info->file_name, &current,
-                                   defrag)) {
-            *per_link_status = 1;
-            goto err;
-        }
-    }
-
-    linked_inode = inode_link(loc.inode, NULL, NULL, &current);
-    inode_unref(loc.inode);
-    loc.inode = linked_inode;
-
-    /*
-     * Do not promote/demote if file already is where it
-     * should be. It means another brick moved the file
-     * so is not an error. So we set per_link_status = 1
-     * so that we ignore counting this.
-     */
-    src_subvol = dht_subvol_get_cached(this, loc.inode);
-
-    if (tier_is_file_already_at_destination(src_subvol, query_cbk_args, conf,
-                                            per_link_status)) {
-        goto err;
-    }
-
-    gf_msg_debug(this->name, 0, "Tier %s: src_subvol %s file %s",
-                 (query_cbk_args->is_promotion ? "promote" : "demote"),
-                 src_subvol->name, loc.path);
-
-    ret = tier_check_same_node(this, &loc, defrag);
-    if (ret != 0) {
-        if (ret < 0) {
-            *per_link_status = -1;
-            goto err;
-        }
-        ret = 0;
-        /* By setting per_link_status to 1 we are
-         * ignoring this status and will not be counting
-         * this file for migration */
-        *per_link_status = 1;
-        goto err;
-    }
-
-    gf_uuid_copy(loc.gfid, loc.inode->gfid);
-
-    if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Tiering paused. "
-               "Exiting tier_migrate_link");
-        goto err;
-    }
-
-    ret = tier_migrate(this, query_cbk_args->is_promotion, migrate_data, &loc,
-                       &defrag->tier_conf);
-
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, -ret, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to "
-               "migrate %s ",
-               loc.path);
-        *per_link_status = -1;
-        goto err;
-    }
-
-    tier_update_migration_counters(query_cbk_args, defrag, total_migrated_bytes,
-                                   total_files);
-
-    ret = 0;
-
-err:
-    GF_FREE((char *)loc.name);
-    loc.name = NULL;
-    loc_wipe(&loc);
-    loc_wipe(&p_loc);
-
-    if ((*total_files >= defrag->tier_conf.max_migrate_files) ||
-        (*total_migrated_bytes > defrag->tier_conf.max_migrate_bytes)) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Reached cycle migration limit."
-               "migrated bytes %" PRId64 " files %d",
-               *total_migrated_bytes, *total_files);
-        ret = -1;
-    }
-
-    return ret;
-}
-
-static int
-tier_migrate_using_query_file(void *_args)
-{
-    int ret = -1;
-    query_cbk_args_t *query_cbk_args = (query_cbk_args_t *)_args;
-    xlator_t *this = NULL;
-    gf_defrag_info_t *defrag = NULL;
-    gfdb_query_record_t *query_record = NULL;
-    gfdb_link_info_t *link_info = NULL;
-    dict_t *migrate_data = NULL;
-    /*
-     * per_file_status and per_link_status
-     *  0  : success
-     * -1 : failure
-     *  1  : ignore the status and don't count for migration
-     * */
-    int per_file_status = 0;
-    int per_link_status = 0;
-    int total_status = 0;
-    dht_conf_t *conf = NULL;
-    uint64_t total_migrated_bytes = 0;
-    int total_files = 0;
-    loc_t root_loc = {0};
-    gfdb_time_t start_time = {0};
-    gfdb_time_t current_time = {0};
-    int total_time = 0;
-    int max_time = 0;
-    gf_boolean_t emergency_demote_mode = _gf_false;
-
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args, out);
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
-    this = query_cbk_args->this;
-    GF_VALIDATE_OR_GOTO(this->name, query_cbk_args->defrag, out);
-    GF_VALIDATE_OR_GOTO(this->name, query_cbk_args->qfile_array, out);
-    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
-
-    conf = this->private;
-
-    defrag = query_cbk_args->defrag;
-    migrate_data = dict_new();
-    if (!migrate_data)
-        goto out;
-
-    emergency_demote_mode = (!query_cbk_args->is_promotion &&
-                             is_hot_tier_full(&defrag->tier_conf));
-
-    if (tier_set_migrate_data(migrate_data) != 0) {
-        goto out;
-    }
-
-    dht_build_root_loc(defrag->root_inode, &root_loc);
-
-    ret = gettimeofday(&start_time, NULL);
-    if (query_cbk_args->is_promotion) {
-        max_time = defrag->tier_conf.tier_promote_frequency;
-    } else {
-        max_time = defrag->tier_conf.tier_demote_frequency;
-    }
-
-    /* Per file */
-    while ((ret = read_query_record_list(query_cbk_args->qfile_array,
-                                         &query_record)) != 0) {
-        if (ret < 0) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "Failed to fetch query record "
-                   "from query file");
-            goto out;
-        }
-
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-            ret = -1;
-            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "Exiting tier migration as"
-                   "defrag status is not started");
-            goto out;
-        }
-
-        ret = gettimeofday(&current_time, NULL);
-        if (ret < 0) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "Could not get current time.");
-            goto out;
-        }
-
-        total_time = current_time.tv_sec - start_time.tv_sec;
-        if (total_time > max_time) {
-            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                   "Max cycle time reached. Exiting migration.");
-            goto out;
-        }
-
-        per_file_status = 0;
-        per_link_status = 0;
-
-        if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING) {
-            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                   "Tiering paused. "
-                   "Exiting tier_migrate_using_query_file");
-            break;
-        }
-
-        if (defrag->tier_conf.mode == TIER_MODE_WM) {
-            ret = tier_get_fs_stat(this, &root_loc);
-            if (ret != 0) {
-                gfdb_methods.gfdb_query_record_free(query_record);
-                query_record = NULL;
-                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
-                       "tier_get_fs_stat() FAILED ... "
-                       "skipping file migrations until next cycle");
-                break;
-            }
-
-            if (!tier_do_migration(this, query_cbk_args->is_promotion)) {
-                gfdb_methods.gfdb_query_record_free(query_record);
-                query_record = NULL;
-
-                /* We have crossed the high watermark. Stop processing
-                 * files if this is a promotion cycle so demotion gets
-                 * a chance to start if not already running*/
-
-                if (query_cbk_args->is_promotion &&
-                    is_hot_tier_full(&defrag->tier_conf)) {
-                    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                           "High watermark crossed during "
-                           "promotion. Exiting "
-                           "tier_migrate_using_query_file");
-                    break;
-                }
-                continue;
-            }
-        }
-
-        per_link_status = 0;
-
-        /* For now we only support single link migration. And we will
-         * ignore other hard links in the link info list of query record
-         * TODO: Multiple hard links migration */
-        if (!list_empty(&query_record->link_list)) {
-            link_info = list_first_entry(&query_record->link_list,
-                                         gfdb_link_info_t, list);
-        }
-        if (link_info != NULL) {
-            if (tier_migrate_link(this, conf, query_record->gfid, link_info,
-                                  defrag, query_cbk_args, migrate_data,
-                                  &per_link_status, &total_files,
-                                  &total_migrated_bytes) != 0) {
-                gf_msg(
-                    this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                    "%s failed for %s(gfid:%s)",
-                    (query_cbk_args->is_promotion ? "Promotion" : "Demotion"),
-                    link_info->file_name, uuid_utoa(query_record->gfid));
-            }
-        }
-        per_file_status = per_link_status;
-
-        if (per_file_status < 0) { /* Failure */
-            pthread_mutex_lock(&dm_stat_mutex);
-            defrag->total_failures++;
-            pthread_mutex_unlock(&dm_stat_mutex);
-        } else if (per_file_status == 0) { /* Success */
-            pthread_mutex_lock(&dm_stat_mutex);
-            defrag->total_files++;
-            pthread_mutex_unlock(&dm_stat_mutex);
-        } else if (per_file_status == 1) { /* Ignore */
-            per_file_status = 0;
-            /* Since this attempt was ignored we
-             * decrement the lookup count*/
-            pthread_mutex_lock(&dm_stat_mutex);
-            defrag->num_files_lookedup--;
-            pthread_mutex_unlock(&dm_stat_mutex);
-        }
-        total_status = total_status + per_file_status;
-        per_link_status = 0;
-        per_file_status = 0;
-
-        gfdb_methods.gfdb_query_record_free(query_record);
-        query_record = NULL;
-
-        /* If we are demoting and the entry watermark was HI, then
-         * we are done with emergency demotions if the current
-         * watermark has fallen below hi-watermark level
-         */
-        if (emergency_demote_mode) {
-            if (tier_check_watermark(this) == 0) {
-                if (!is_hot_tier_full(&defrag->tier_conf)) {
-                    break;
-                }
-            }
-        }
-    }
-
-out:
-    if (migrate_data)
-        dict_unref(migrate_data);
-
-    gfdb_methods.gfdb_query_record_free(query_record);
-    query_record = NULL;
-
-    return total_status;
-}
-
-/* This is the call back function per record/file from data base */
-static int
-tier_gf_query_callback(gfdb_query_record_t *gfdb_query_record, void *_args)
-{
-    int ret = -1;
-    query_cbk_args_t *query_cbk_args = _args;
-
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args, out);
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->defrag, out);
-    GF_VALIDATE_OR_GOTO("tier", (query_cbk_args->query_fd > 0), out);
-
-    ret = gfdb_methods.gfdb_write_query_record(query_cbk_args->query_fd,
-                                               gfdb_query_record);
-    if (ret) {
-        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed writing query record to query file");
-        goto out;
-    }
-
-    pthread_mutex_lock(&dm_stat_mutex);
-    query_cbk_args->defrag->num_files_lookedup++;
-    pthread_mutex_unlock(&dm_stat_mutex);
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/* Create query file in tier process */
-static int
-tier_process_self_query(tier_brick_list_t *local_brick, void *args)
-{
-    int ret = -1;
-    char *db_path = NULL;
-    query_cbk_args_t *query_cbk_args = NULL;
-    xlator_t *this = NULL;
-    gfdb_conn_node_t *conn_node = NULL;
-    dict_t *params_dict = NULL;
-    dict_t *ctr_ipc_dict = NULL;
-    gfdb_brick_info_t *gfdb_brick_info = args;
-
-    /*Init of all the essentials*/
-    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
-    query_cbk_args = gfdb_brick_info->_query_cbk_args;
-
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
-    this = query_cbk_args->this;
-
-    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
-
-    db_path = local_brick->brick_db_path;
-
-    /*Preparing DB parameters before init_db i.e getting db connection*/
-    params_dict = dict_new();
-    if (!params_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "DB Params cannot initialized");
-        goto out;
-    }
-    SET_DB_PARAM_TO_DICT(this->name, params_dict,
-                         (char *)gfdb_methods.get_db_path_key(), db_path, ret,
-                         out);
-
-    /*Get the db connection*/
-    conn_node = gfdb_methods.init_db((void *)params_dict, dht_tier_db_type);
-    if (!conn_node) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "FATAL: Failed initializing db operations");
-        goto out;
-    }
-
-    /* Query for eligible files from db */
-    query_cbk_args->query_fd = open(local_brick->qfile_path,
-                                    O_WRONLY | O_CREAT | O_APPEND,
-                                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-    if (query_cbk_args->query_fd < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, errno, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to open query file %s", local_brick->qfile_path);
-        goto out;
-    }
-    if (!gfdb_brick_info->_gfdb_promote) {
-        if (query_cbk_args->defrag->tier_conf.watermark_last == TIER_WM_HI) {
-            /* emergency demotion mode */
-            ret = gfdb_methods.find_all(
-                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
-                query_cbk_args->defrag->tier_conf.query_limit);
-        } else {
-            if (query_cbk_args->defrag->write_freq_threshold == 0 &&
-                query_cbk_args->defrag->read_freq_threshold == 0) {
-                ret = gfdb_methods.find_unchanged_for_time(
-                    conn_node, tier_gf_query_callback, (void *)query_cbk_args,
-                    gfdb_brick_info->time_stamp);
-            } else {
-                ret = gfdb_methods.find_unchanged_for_time_freq(
-                    conn_node, tier_gf_query_callback, (void *)query_cbk_args,
-                    gfdb_brick_info->time_stamp,
-                    query_cbk_args->defrag->write_freq_threshold,
-                    query_cbk_args->defrag->read_freq_threshold, _gf_false);
-            }
-        }
-    } else {
-        if (query_cbk_args->defrag->write_freq_threshold == 0 &&
-            query_cbk_args->defrag->read_freq_threshold == 0) {
-            ret = gfdb_methods.find_recently_changed_files(
-                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
-                gfdb_brick_info->time_stamp);
-        } else {
-            ret = gfdb_methods.find_recently_changed_files_freq(
-                conn_node, tier_gf_query_callback, (void *)query_cbk_args,
-                gfdb_brick_info->time_stamp,
-                query_cbk_args->defrag->write_freq_threshold,
-                query_cbk_args->defrag->read_freq_threshold, _gf_false);
-        }
-    }
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "FATAL: query from db failed");
-        goto out;
-    }
-
-    /*Clear the heat on the DB entries*/
-    /*Preparing ctr_ipc_dict*/
-    ctr_ipc_dict = dict_new();
-    if (!ctr_ipc_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "ctr_ipc_dict cannot initialized");
-        goto out;
-    }
-
-    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict, GFDB_IPC_CTR_KEY,
-                         GFDB_IPC_CTR_CLEAR_OPS, ret, out);
-
-    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
-                     NULL);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed clearing the heat "
-               "on db %s error %d",
-               local_brick->brick_db_path, ret);
-        goto out;
-    }
-
-    ret = 0;
-out:
-    if (params_dict) {
-        dict_unref(params_dict);
-        params_dict = NULL;
-    }
-
-    if (ctr_ipc_dict) {
-        dict_unref(ctr_ipc_dict);
-        ctr_ipc_dict = NULL;
-    }
-
-    if (query_cbk_args && query_cbk_args->query_fd >= 0) {
-        sys_close(query_cbk_args->query_fd);
-        query_cbk_args->query_fd = -1;
-    }
-    gfdb_methods.fini_db(conn_node);
-
-    return ret;
-}
-
-/*Ask CTR to create the query file*/
-static int
-tier_process_ctr_query(tier_brick_list_t *local_brick, void *args)
-{
-    int ret = -1;
-    query_cbk_args_t *query_cbk_args = NULL;
-    xlator_t *this = NULL;
-    dict_t *ctr_ipc_in_dict = NULL;
-    dict_t *ctr_ipc_out_dict = NULL;
-    gfdb_brick_info_t *gfdb_brick_info = args;
-    gfdb_ipc_ctr_params_t *ipc_ctr_params = NULL;
-    int count = 0;
-
-    /*Init of all the essentials*/
-    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
-    query_cbk_args = gfdb_brick_info->_query_cbk_args;
-
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
-    this = query_cbk_args->this;
-
-    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
-
-    /*Preparing ctr_ipc_in_dict*/
-    ctr_ipc_in_dict = dict_new();
-    if (!ctr_ipc_in_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "ctr_ipc_in_dict cannot initialized");
-        goto out;
-    }
-
-    ipc_ctr_params = GF_CALLOC(1, sizeof(gfdb_ipc_ctr_params_t),
-                               gf_tier_mt_ipc_ctr_params_t);
-    if (!ipc_ctr_params) {
-        goto out;
-    }
-
-    /* set all the query params*/
-    ipc_ctr_params->is_promote = gfdb_brick_info->_gfdb_promote;
-
-    ipc_ctr_params->write_freq_threshold = query_cbk_args->defrag
-                                               ->write_freq_threshold;
-
-    ipc_ctr_params->read_freq_threshold = query_cbk_args->defrag
-                                              ->read_freq_threshold;
-
-    ipc_ctr_params->query_limit = query_cbk_args->defrag->tier_conf.query_limit;
-
-    ipc_ctr_params->emergency_demote = (!gfdb_brick_info->_gfdb_promote &&
-                                        query_cbk_args->defrag->tier_conf
-                                                .watermark_last == TIER_WM_HI);
-
-    memcpy(&ipc_ctr_params->time_stamp, gfdb_brick_info->time_stamp,
-           sizeof(gfdb_time_t));
-
-    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_in_dict, GFDB_IPC_CTR_KEY,
-                         GFDB_IPC_CTR_QUERY_OPS, ret, out);
-
-    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_in_dict,
-                         GFDB_IPC_CTR_GET_QFILE_PATH, local_brick->qfile_path,
-                         ret, out);
-
-    ret = dict_set_bin(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_QUERY_PARAMS,
-                       ipc_ctr_params, sizeof(*ipc_ctr_params));
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-               "Failed setting %s to params dictionary",
-               GFDB_IPC_CTR_GET_QUERY_PARAMS);
-        GF_FREE(ipc_ctr_params);
-        goto out;
-    }
-    ipc_ctr_params = NULL;
-
-    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_in_dict,
-                     &ctr_ipc_out_dict);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_IPC_TIER_ERROR,
-               "Failed query on %s ret %d", local_brick->brick_db_path, ret);
-        goto out;
-    }
-
-    ret = dict_get_int32(ctr_ipc_out_dict, GFDB_IPC_CTR_RET_QUERY_COUNT,
-                         &count);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed getting count "
-               "of records on %s",
-               local_brick->brick_db_path);
-        goto out;
-    }
-
-    if (count < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed query on %s", local_brick->brick_db_path);
-        ret = -1;
-        goto out;
-    }
-
-    pthread_mutex_lock(&dm_stat_mutex);
-    query_cbk_args->defrag->num_files_lookedup = count;
-    pthread_mutex_unlock(&dm_stat_mutex);
-
-    ret = 0;
-out:
-
-    if (ctr_ipc_in_dict) {
-        dict_unref(ctr_ipc_in_dict);
-        ctr_ipc_in_dict = NULL;
-    }
-
-    if (ctr_ipc_out_dict) {
-        dict_unref(ctr_ipc_out_dict);
-        ctr_ipc_out_dict = NULL;
-    }
-
-    GF_FREE(ipc_ctr_params);
-
-    return ret;
-}
-
-/* This is the call back function for each brick from hot/cold bricklist
- * It picks up each bricks db and queries for eligible files for migration.
- * The list of eligible files are populated in appropriate query files*/
-static int
-tier_process_brick(tier_brick_list_t *local_brick, void *args)
-{
-    int ret = -1;
-    dict_t *ctr_ipc_in_dict = NULL;
-    dict_t *ctr_ipc_out_dict = NULL;
-    char *strval = NULL;
-
-    GF_VALIDATE_OR_GOTO("tier", local_brick, out);
-
-    GF_VALIDATE_OR_GOTO("tier", local_brick->xlator, out);
-
-    if (dht_tier_db_type == GFDB_SQLITE3) {
-        /*Preparing ctr_ipc_in_dict*/
-        ctr_ipc_in_dict = dict_new();
-        if (!ctr_ipc_in_dict) {
-            gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "ctr_ipc_in_dict cannot initialized");
-            goto out;
-        }
-
-        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_KEY,
-                           GFDB_IPC_CTR_GET_DB_PARAM_OPS);
-        if (ret) {
-            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-                   "Failed to set %s "
-                   "to params dictionary",
-                   GFDB_IPC_CTR_KEY);
-            goto out;
-        }
-
-        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_DB_PARAM_OPS, "");
-        if (ret) {
-            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-                   "Failed to set %s "
-                   "to params dictionary",
-                   GFDB_IPC_CTR_GET_DB_PARAM_OPS);
-            goto out;
-        }
-
-        ret = dict_set_str(ctr_ipc_in_dict, GFDB_IPC_CTR_GET_DB_KEY,
-                           "journal_mode");
-        if (ret) {
-            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-                   "Failed to set %s "
-                   "to params dictionary",
-                   GFDB_IPC_CTR_GET_DB_KEY);
-            goto out;
-        }
-
-        ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR,
-                         ctr_ipc_in_dict, &ctr_ipc_out_dict);
-        if (ret || ctr_ipc_out_dict == NULL) {
-            gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "Failed to get "
-                   "journal_mode of sql db %s",
-                   local_brick->brick_db_path);
-            goto out;
-        }
-
-        ret = dict_get_str(ctr_ipc_out_dict, "journal_mode", &strval);
-        if (ret) {
-            gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_GET_PARAM_FAILED,
-                   "Failed to get %s "
-                   "from params dictionary"
-                   "journal_mode",
-                   strval);
-            goto out;
-        }
-
-        if (strval && (strncmp(strval, "wal", SLEN("wal")) == 0)) {
-            ret = tier_process_self_query(local_brick, args);
-            if (ret) {
-                goto out;
-            }
-        } else {
-            ret = tier_process_ctr_query(local_brick, args);
-            if (ret) {
-                goto out;
-            }
-        }
-        ret = 0;
-
-    } else {
-        ret = tier_process_self_query(local_brick, args);
-        if (ret) {
-            goto out;
-        }
-    }
-
-    ret = 0;
-out:
-    if (ctr_ipc_in_dict)
-        dict_unref(ctr_ipc_in_dict);
-
-    if (ctr_ipc_out_dict)
-        dict_unref(ctr_ipc_out_dict);
-
-    return ret;
-}
-
-static int
-tier_build_migration_qfile(migration_args_t *args,
-                           query_cbk_args_t *query_cbk_args,
-                           gf_boolean_t is_promotion)
-{
-    gfdb_time_t current_time;
-    gfdb_brick_info_t gfdb_brick_info;
-    gfdb_time_t time_in_past;
-    int ret = -1;
-    tier_brick_list_t *local_brick = NULL;
-    int i = 0;
-    time_in_past.tv_sec = args->freq_time;
-    time_in_past.tv_usec = 0;
-
-    ret = gettimeofday(&current_time, NULL);
-    if (ret == -1) {
-        gf_msg(args->this->name, GF_LOG_ERROR, errno,
-               DHT_MSG_SYS_CALL_GET_TIME_FAILED, "Failed to get current time");
-        goto out;
-    }
-    time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
-
-    /* The migration daemon may run a varying numberof usec after the */
-    /* sleep call triggers. A file may be registered in CTR some number */
-    /* of usec X after the daemon started and missed in the subsequent */
-    /* cycle if the daemon starts Y usec after the period in seconds */
-    /* where Y>X. Normalize away this problem by always setting usec */
-    /* to 0. */
-    time_in_past.tv_usec = 0;
-
-    gfdb_brick_info.time_stamp = &time_in_past;
-    gfdb_brick_info._gfdb_promote = is_promotion;
-    gfdb_brick_info._query_cbk_args = query_cbk_args;
-
-    list_for_each_entry(local_brick, args->brick_list, list)
-    {
-        /* Construct query file path for this brick
-         * i.e
-         * /var/run/gluster/xlator_name/
-         * {promote/demote}-brickname-indexinbricklist
-         * So that no two query files will have same path even
-         * bricks have the same name
-         * */
-        snprintf(local_brick->qfile_path, PATH_MAX, "%s-%s-%d",
-                 GET_QFILE_PATH(gfdb_brick_info._gfdb_promote),
-                 local_brick->brick_name, i);
-
-        /* Delete any old query files for this brick */
-        sys_unlink(local_brick->qfile_path);
-
-        ret = tier_process_brick(local_brick, &gfdb_brick_info);
-        if (ret) {
-            gf_msg(args->this->name, GF_LOG_ERROR, 0,
-                   DHT_MSG_BRICK_QUERY_FAILED, "Brick %s query failed\n",
-                   local_brick->brick_db_path);
-        }
-        i++;
-    }
-    ret = 0;
-out:
-    return ret;
-}
-
-static int
-tier_migrate_files_using_qfile(migration_args_t *comp,
-                               query_cbk_args_t *query_cbk_args)
-{
-    int ret = -1;
-    tier_brick_list_t *local_brick = NULL;
-    tier_brick_list_t *temp = NULL;
-    gfdb_time_t current_time = {
-        0,
-    };
-    ssize_t qfile_array_size = 0;
-    int count = 0;
-    int temp_fd = 0;
-    gf_tier_conf_t *tier_conf = NULL;
-
-    tier_conf = &(query_cbk_args->defrag->tier_conf);
-
-    /* Time for error query files */
-    gettimeofday(&current_time, NULL);
-
-    /* Build the qfile list */
-    list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
-    {
-        qfile_array_size++;
-    }
-    query_cbk_args->qfile_array = qfile_array_new(qfile_array_size);
-    if (!query_cbk_args->qfile_array) {
-        gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to create new "
-               "qfile_array");
-        goto out;
-    }
-
-    /*Open all qfiles*/
-    count = 0;
-    query_cbk_args->qfile_array->exhausted_count = 0;
-    list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
-    {
-        temp_fd = query_cbk_args->qfile_array->fd_array[count];
-        temp_fd = open(local_brick->qfile_path, O_RDONLY,
-                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-        if (temp_fd < 0) {
-            gf_msg("tier", GF_LOG_ERROR, errno, DHT_MSG_LOG_TIER_ERROR,
-                   "Failed to open "
-                   "%s to the query file",
-                   local_brick->qfile_path);
-            query_cbk_args->qfile_array->exhausted_count++;
-        }
-        query_cbk_args->qfile_array->fd_array[count] = temp_fd;
-        count++;
-    }
-
-    /* Moving the query file index to the next, so that we won't the same
-     * query file every cycle as the first one */
-    query_cbk_args->qfile_array
-        ->next_index = (query_cbk_args->is_promotion)
-                           ? tier_conf->last_promote_qfile_index
-                           : tier_conf->last_demote_qfile_index;
-    shift_next_index(query_cbk_args->qfile_array);
-    if (query_cbk_args->is_promotion) {
-        tier_conf->last_promote_qfile_index = query_cbk_args->qfile_array
-                                                  ->next_index;
-    } else {
-        tier_conf->last_demote_qfile_index = query_cbk_args->qfile_array
-                                                 ->next_index;
-    }
-
-    /* Migrate files using query file list */
-    ret = tier_migrate_using_query_file((void *)query_cbk_args);
-out:
-    qfile_array_free(query_cbk_args->qfile_array);
-
-    /* If there is an error rename all the query files to .err files
-     * with a timestamp for better debugging */
-    if (ret) {
-        struct tm tm = {
-            0,
-        };
-        char time_str[128] = {
-            0,
-        };
-        char query_file_path_err[PATH_MAX] = {
-            0,
-        };
-        int32_t len = 0;
-
-        /* Time format for error query files */
-        gmtime_r(&current_time.tv_sec, &tm);
-        strftime(time_str, sizeof(time_str), "%F-%T", &tm);
-
-        list_for_each_entry_safe(local_brick, temp, comp->brick_list, list)
-        {
-            /* rename error qfile*/
-            len = snprintf(query_file_path_err, sizeof(query_file_path_err),
-                           "%s-%s.err", local_brick->qfile_path, time_str);
-            if ((len >= 0) && (len < sizeof(query_file_path_err))) {
-                if (sys_rename(local_brick->qfile_path, query_file_path_err) ==
-                    -1)
-                    gf_msg_debug("tier", 0,
-                                 "rename "
-                                 "failed");
-            }
-        }
-    }
-
-    query_cbk_args->qfile_array = NULL;
-
-    return ret;
-}
-
-int
-tier_demote(migration_args_t *demotion_args)
-{
-    query_cbk_args_t query_cbk_args;
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("tier", demotion_args, out);
-    GF_VALIDATE_OR_GOTO("tier", demotion_args->this, out);
-    GF_VALIDATE_OR_GOTO(demotion_args->this->name, demotion_args->brick_list,
-                        out);
-    GF_VALIDATE_OR_GOTO(demotion_args->this->name, demotion_args->defrag, out);
-
-    THIS = demotion_args->this;
-
-    query_cbk_args.this = demotion_args->this;
-    query_cbk_args.defrag = demotion_args->defrag;
-    query_cbk_args.is_promotion = 0;
-
-    /*Build the query file using bricklist*/
-    ret = tier_build_migration_qfile(demotion_args, &query_cbk_args, _gf_false);
-    if (ret)
-        goto out;
-
-    /* Migrate files using the query file */
-    ret = tier_migrate_files_using_qfile(demotion_args, &query_cbk_args);
-    if (ret)
-        goto out;
-
-out:
-    demotion_args->return_value = ret;
-    return ret;
-}
-
-int
-tier_promote(migration_args_t *promotion_args)
-{
-    int ret = -1;
-    query_cbk_args_t query_cbk_args;
-
-    GF_VALIDATE_OR_GOTO("tier", promotion_args->this, out);
-    GF_VALIDATE_OR_GOTO(promotion_args->this->name, promotion_args->brick_list,
-                        out);
-    GF_VALIDATE_OR_GOTO(promotion_args->this->name, promotion_args->defrag,
-                        out);
-
-    THIS = promotion_args->this;
-
-    query_cbk_args.this = promotion_args->this;
-    query_cbk_args.defrag = promotion_args->defrag;
-    query_cbk_args.is_promotion = 1;
-
-    /*Build the query file using bricklist*/
-    ret = tier_build_migration_qfile(promotion_args, &query_cbk_args, _gf_true);
-    if (ret)
-        goto out;
-
-    /* Migrate files using the query file */
-    ret = tier_migrate_files_using_qfile(promotion_args, &query_cbk_args);
-    if (ret)
-        goto out;
-
-out:
-    promotion_args->return_value = ret;
-    return ret;
-}
-
-/*
- * Command the CTR on a brick to compact the local database using an IPC
- */
-static int
-tier_process_self_compact(tier_brick_list_t *local_brick, void *args)
-{
-    int ret = -1;
-    char *db_path = NULL;
-    query_cbk_args_t *query_cbk_args = NULL;
-    xlator_t *this = NULL;
-    gfdb_conn_node_t *conn_node = NULL;
-    dict_t *params_dict = NULL;
-    dict_t *ctr_ipc_dict = NULL;
-    gfdb_brick_info_t *gfdb_brick_info = args;
-
-    /*Init of all the essentials*/
-    GF_VALIDATE_OR_GOTO("tier", gfdb_brick_info, out);
-    query_cbk_args = gfdb_brick_info->_query_cbk_args;
-
-    GF_VALIDATE_OR_GOTO("tier", query_cbk_args->this, out);
-    this = query_cbk_args->this;
-
-    GF_VALIDATE_OR_GOTO(this->name, gfdb_brick_info->_query_cbk_args, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->xlator, out);
-
-    GF_VALIDATE_OR_GOTO(this->name, local_brick->brick_db_path, out);
-
-    db_path = local_brick->brick_db_path;
-
-    /*Preparing DB parameters before init_db i.e getting db connection*/
-    params_dict = dict_new();
-    if (!params_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "DB Params cannot initialized");
-        goto out;
-    }
-    SET_DB_PARAM_TO_DICT(this->name, params_dict,
-                         (char *)gfdb_methods.get_db_path_key(), db_path, ret,
-                         out);
-
-    /*Get the db connection*/
-    conn_node = gfdb_methods.init_db((void *)params_dict, dht_tier_db_type);
-    if (!conn_node) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "FATAL: Failed initializing db operations");
-        goto out;
-    }
-
-    ret = 0;
-
-    /*Preparing ctr_ipc_dict*/
-    ctr_ipc_dict = dict_new();
-    if (!ctr_ipc_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "ctr_ipc_dict cannot initialized");
-        goto out;
-    }
-
-    ret = dict_set_int32(ctr_ipc_dict, "compact_active",
-                         query_cbk_args->defrag->tier_conf.compact_active);
-
-    if (ret) {
-        gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-               "Failed to set %s "
-               "to params dictionary",
-               "compact_active");
-        goto out;
-    }
-
-    ret = dict_set_int32(
-        ctr_ipc_dict, "compact_mode_switched",
-        query_cbk_args->defrag->tier_conf.compact_mode_switched);
-
-    if (ret) {
-        gf_msg("tier", GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,
-               "Failed to set %s "
-               "to params dictionary",
-               "compact_mode_switched");
-        goto out;
-    }
-
-    SET_DB_PARAM_TO_DICT(this->name, ctr_ipc_dict, GFDB_IPC_CTR_KEY,
-                         GFDB_IPC_CTR_SET_COMPACT_PRAGMA, ret, out);
-
-    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-           "Starting Compaction IPC");
-
-    ret = syncop_ipc(local_brick->xlator, GF_IPC_TARGET_CTR, ctr_ipc_dict,
-                     NULL);
-
-    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-           "Ending Compaction IPC");
-
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed compaction "
-               "on db %s error %d",
-               local_brick->brick_db_path, ret);
-        goto out;
-    }
-
-    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-           "SUCCESS: %s Compaction", local_brick->brick_name);
-
-    ret = 0;
-out:
-    if (params_dict) {
-        dict_unref(params_dict);
-        params_dict = NULL;
-    }
-
-    if (ctr_ipc_dict) {
-        dict_unref(ctr_ipc_dict);
-        ctr_ipc_dict = NULL;
-    }
-
-    gfdb_methods.fini_db(conn_node);
-
-    return ret;
-}
-
-/*
- * This is the call back function for each brick from hot/cold bricklist.
- * It determines the database type on each brick and calls the corresponding
- * function to prepare the compaction IPC.
- */
-static int
-tier_compact_db_brick(tier_brick_list_t *local_brick, void *args)
-{
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("tier", local_brick, out);
-
-    GF_VALIDATE_OR_GOTO("tier", local_brick->xlator, out);
-
-    ret = tier_process_self_compact(local_brick, args);
-    if (ret) {
-        gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Brick %s did not compact", local_brick->brick_name);
-        goto out;
-    }
-
-    ret = 0;
-
-out:
-
-    return ret;
-}
-
-static int
-tier_send_compact(migration_args_t *args, query_cbk_args_t *query_cbk_args)
-{
-    gfdb_time_t current_time;
-    gfdb_brick_info_t gfdb_brick_info;
-    gfdb_time_t time_in_past;
-    int ret = -1;
-    tier_brick_list_t *local_brick = NULL;
-
-    time_in_past.tv_sec = args->freq_time;
-    time_in_past.tv_usec = 0;
-
-    ret = gettimeofday(&current_time, NULL);
-    if (ret == -1) {
-        gf_msg(args->this->name, GF_LOG_ERROR, errno,
-               DHT_MSG_SYS_CALL_GET_TIME_FAILED, "Failed to get current time");
-        goto out;
-    }
-    time_in_past.tv_sec = current_time.tv_sec - time_in_past.tv_sec;
-
-    /* The migration daemon may run a varying numberof usec after the sleep
-       call triggers. A file may be registered in CTR some number of usec X
-       after the daemon started and missed in the subsequent cycle if the
-       daemon starts Y usec after the period in seconds where Y>X. Normalize
-       away this problem by always setting usec to 0. */
-    time_in_past.tv_usec = 0;
-
-    gfdb_brick_info.time_stamp = &time_in_past;
-
-    /* This is meant to say we are always compacting at this point */
-    /* We simply borrow the promotion flag to do this */
-    gfdb_brick_info._gfdb_promote = 1;
-
-    gfdb_brick_info._query_cbk_args = query_cbk_args;
-
-    list_for_each_entry(local_brick, args->brick_list, list)
-    {
-        gf_msg(args->this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Start compaction for %s", local_brick->brick_name);
-
-        ret = tier_compact_db_brick(local_brick, &gfdb_brick_info);
-        if (ret) {
-            gf_msg(args->this->name, GF_LOG_ERROR, 0,
-                   DHT_MSG_BRICK_QUERY_FAILED, "Brick %s compaction failed\n",
-                   local_brick->brick_db_path);
-        }
-
-        gf_msg(args->this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-               "End compaction for %s", local_brick->brick_name);
-    }
-    ret = 0;
-out:
-    return ret;
-}
-
-static int
-tier_compact(void *args)
-{
-    int ret = -1;
-    query_cbk_args_t query_cbk_args;
-    migration_args_t *compaction_args = args;
-
-    GF_VALIDATE_OR_GOTO("tier", compaction_args->this, out);
-    GF_VALIDATE_OR_GOTO(compaction_args->this->name,
-                        compaction_args->brick_list, out);
-    GF_VALIDATE_OR_GOTO(compaction_args->this->name, compaction_args->defrag,
-                        out);
-
-    THIS = compaction_args->this;
-
-    query_cbk_args.this = compaction_args->this;
-    query_cbk_args.defrag = compaction_args->defrag;
-    query_cbk_args.is_compaction = 1;
-
-    /* Send the compaction pragma out to all the bricks on the bricklist. */
-    /* tier_get_bricklist ensures all bricks on the list are local to */
-    /* this node. */
-    ret = tier_send_compact(compaction_args, &query_cbk_args);
-    if (ret)
-        goto out;
-
-    ret = 0;
-out:
-    compaction_args->return_value = ret;
-    return ret;
-}
-
-static int
-tier_get_bricklist(xlator_t *xl, struct list_head *local_bricklist_head)
-{
-    xlator_list_t *child = NULL;
-    char *rv = NULL;
-    char *rh = NULL;
-    char *brickname = NULL;
-    char db_name[PATH_MAX] = "";
-    int ret = 0;
-    tier_brick_list_t *local_brick = NULL;
-    int32_t len = 0;
-
-    GF_VALIDATE_OR_GOTO("tier", xl, out);
-    GF_VALIDATE_OR_GOTO("tier", local_bricklist_head, out);
-
-    /*
-     * This function obtains remote subvolumes and filters out only
-     * those running on the same node as the tier daemon.
-     */
-    if (strcmp(xl->type, "protocol/client") == 0) {
-        ret = dict_get_str(xl->options, "remote-host", &rh);
-        if (ret < 0)
-            goto out;
-
-        if (gf_is_local_addr(rh)) {
-            local_brick = GF_CALLOC(1, sizeof(tier_brick_list_t),
-                                    gf_tier_mt_bricklist_t);
-            if (!local_brick) {
-                goto out;
-            }
-
-            ret = dict_get_str(xl->options, "remote-subvolume", &rv);
-            if (ret < 0)
-                goto out;
-
-            brickname = strrchr(rv, '/') + 1;
-            snprintf(db_name, sizeof(db_name), "%s.db", brickname);
-
-            local_brick->brick_db_path = GF_MALLOC(PATH_MAX, gf_common_mt_char);
-            if (!local_brick->brick_db_path) {
-                gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
-                       "Failed to allocate memory for"
-                       " bricklist.");
-                ret = -1;
-                goto out;
-            }
-
-            len = snprintf(local_brick->brick_db_path, PATH_MAX, "%s/%s/%s", rv,
-                           GF_HIDDEN_PATH, db_name);
-            if ((len < 0) || (len >= PATH_MAX)) {
-                gf_msg("tier", GF_LOG_ERROR, EINVAL, DHT_MSG_LOG_TIER_STATUS,
-                       "DB path too long");
-                ret = -1;
-                goto out;
-            }
-
-            local_brick->xlator = xl;
-
-            snprintf(local_brick->brick_name, NAME_MAX, "%s", brickname);
-
-            list_add_tail(&(local_brick->list), local_bricklist_head);
-
-            ret = 0;
-            goto out;
-        }
-    }
-
-    for (child = xl->children; child; child = child->next) {
-        ret = tier_get_bricklist(child->xlator, local_bricklist_head);
-        if (ret) {
-            goto out;
-        }
-    }
-
-    ret = 0;
-out:
-
-    if (ret) {
-        if (local_brick) {
-            GF_FREE(local_brick->brick_db_path);
-        }
-        GF_FREE(local_brick);
-    }
-
-    return ret;
-}
-
-int
-tier_get_freq_demote(gf_tier_conf_t *tier_conf)
-{
-    if ((tier_conf->mode == TIER_MODE_WM) &&
-        (tier_conf->watermark_last == TIER_WM_HI))
-        return DEFAULT_DEMOTE_DEGRADED;
-    else
-        return tier_conf->tier_demote_frequency;
-}
-
-int
-tier_get_freq_promote(gf_tier_conf_t *tier_conf)
-{
-    return tier_conf->tier_promote_frequency;
-}
-
-int
-tier_get_freq_compact_hot(gf_tier_conf_t *tier_conf)
-{
-    return tier_conf->tier_compact_hot_frequency;
-}
-
-int
-tier_get_freq_compact_cold(gf_tier_conf_t *tier_conf)
-{
-    return tier_conf->tier_compact_cold_frequency;
-}
-
-static int
-tier_check_demote(gfdb_time_t current_time, int freq)
-{
-    return ((current_time.tv_sec % freq) == 0) ? _gf_true : _gf_false;
-}
-
-static gf_boolean_t
-tier_check_promote(gf_tier_conf_t *tier_conf, gfdb_time_t current_time,
-                   int freq)
-{
-    if ((tier_conf->mode == TIER_MODE_WM) &&
-        (tier_conf->watermark_last == TIER_WM_HI))
-        return _gf_false;
-
-    else
-        return ((current_time.tv_sec % freq) == 0) ? _gf_true : _gf_false;
-}
-
-static gf_boolean_t
-tier_check_compact(gf_tier_conf_t *tier_conf, gfdb_time_t current_time,
-                   int freq_compact)
-{
-    if (!(tier_conf->compact_active || tier_conf->compact_mode_switched))
-        return _gf_false;
-
-    return ((current_time.tv_sec % freq_compact) == 0) ? _gf_true : _gf_false;
-}
-
-void
-clear_bricklist(struct list_head *brick_list)
-{
-    tier_brick_list_t *local_brick = NULL;
-    tier_brick_list_t *temp = NULL;
-
-    if (list_empty(brick_list)) {
-        return;
-    }
-
-    list_for_each_entry_safe(local_brick, temp, brick_list, list)
-    {
-        list_del(&local_brick->list);
-        GF_FREE(local_brick->brick_db_path);
-        GF_FREE(local_brick);
-    }
-}
-
-static void
-set_brick_list_qpath(struct list_head *brick_list, gf_boolean_t is_cold)
-{
-    tier_brick_list_t *local_brick = NULL;
-    int i = 0;
-
-    GF_VALIDATE_OR_GOTO("tier", brick_list, out);
-
-    list_for_each_entry(local_brick, brick_list, list)
-    {
-        /* Construct query file path for this brick
-         * i.e
-         * /var/run/gluster/xlator_name/
-         * {promote/demote}-brickname-indexinbricklist
-         * So that no two query files will have same path even
-         * bricks have the same name
-         * */
-        snprintf(local_brick->qfile_path, PATH_MAX, "%s-%s-%d",
-                 GET_QFILE_PATH(is_cold), local_brick->brick_name, i);
-        i++;
-    }
-out:
-    return;
-}
-
-static int
-tier_prepare_compact(migration_args_t *args, gfdb_time_t current_time)
-{
-    xlator_t *this = NULL;
-    dht_conf_t *conf = NULL;
-    gf_defrag_info_t *defrag = NULL;
-    gf_tier_conf_t *tier_conf = NULL;
-    gf_boolean_t is_hot_tier = args->is_hot_tier;
-    int freq = 0;
-    int ret = -1;
-    const char *tier_type = is_hot_tier ? "hot" : "cold";
-
-    this = args->this;
-
-    conf = this->private;
-
-    defrag = conf->defrag;
-
-    tier_conf = &defrag->tier_conf;
-
-    freq = is_hot_tier ? tier_get_freq_compact_hot(tier_conf)
-                       : tier_get_freq_compact_cold(tier_conf);
-
-    defrag->tier_conf.compact_mode_switched =
-        is_hot_tier ? defrag->tier_conf.compact_mode_switched_hot
-                    : defrag->tier_conf.compact_mode_switched_cold;
-
-    gf_msg(this->name, GF_LOG_TRACE, 0, DHT_MSG_LOG_TIER_STATUS,
-           "Compact mode %i", defrag->tier_conf.compact_mode_switched);
-
-    if (tier_check_compact(tier_conf, current_time, freq)) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "Start compaction on %s tier", tier_type);
-
-        args->freq_time = freq;
-        ret = tier_compact(args);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "Compaction failed on "
-                   "%s tier",
-                   tier_type);
-            goto out;
-        }
-
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-               "End compaction on %s tier", tier_type);
-
-        if (is_hot_tier) {
-            defrag->tier_conf.compact_mode_switched_hot = _gf_false;
-        } else {
-            defrag->tier_conf.compact_mode_switched_cold = _gf_false;
-        }
-    }
-
-out:
-    return ret;
-}
-
-static int
-tier_get_wm_interval(tier_mode_t mode, tier_watermark_op_t wm)
-{
-    if (mode == TIER_MODE_WM && wm == TIER_WM_HI)
-        return WM_INTERVAL_EMERG;
-
-    return WM_INTERVAL;
-}
-
-/*
- * Main tiering loop. This is called from the promotion and the
- * demotion threads spawned in tier_start().
- *
- * Every second, wake from sleep to perform tasks.
- * 1. Check trigger to migrate data.
- * 2. Check for state changes (pause, unpause, stop).
- */
-static void *
-tier_run(void *in_args)
-{
-    dht_conf_t *conf = NULL;
-    gfdb_time_t current_time = {0};
-    int freq = 0;
-    int ret = 0;
-    xlator_t *any = NULL;
-    xlator_t *xlator = NULL;
-    gf_tier_conf_t *tier_conf = NULL;
-    loc_t root_loc = {0};
-    int check_watermark = 0;
-    gf_defrag_info_t *defrag = NULL;
-    xlator_t *this = NULL;
-    migration_args_t *args = in_args;
-    GF_VALIDATE_OR_GOTO("tier", args, out);
-    GF_VALIDATE_OR_GOTO("tier", args->brick_list, out);
-
-    this = args->this;
-    GF_VALIDATE_OR_GOTO("tier", this, out);
-
-    conf = this->private;
-    GF_VALIDATE_OR_GOTO("tier", conf, out);
-
-    defrag = conf->defrag;
-    GF_VALIDATE_OR_GOTO("tier", defrag, out);
-
-    if (list_empty(args->brick_list)) {
-        gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Brick list for tier is empty. Exiting.");
-        goto out;
-    }
-
-    defrag->defrag_status = GF_DEFRAG_STATUS_STARTED;
-    tier_conf = &defrag->tier_conf;
-
-    dht_build_root_loc(defrag->root_inode, &root_loc);
-
-    while (1) {
-        /*
-         * Check if a graph switch occurred. If so, stop migration
-         * thread. It will need to be restarted manually.
-         */
-        any = THIS->ctx->active->first;
-        xlator = xlator_search_by_name(any, this->name);
-
-        if (xlator != this) {
-            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                   "Detected graph switch. Exiting migration "
-                   "daemon.");
-            goto out;
-        }
-
-        gf_defrag_check_pause_tier(tier_conf);
-
-        sleep(1);
-
-        if (defrag->defrag_status != GF_DEFRAG_STATUS_STARTED) {
-            ret = 1;
-            gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "defrag->defrag_status != "
-                   "GF_DEFRAG_STATUS_STARTED");
-            goto out;
-        }
-
-        if (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER ||
-            defrag->cmd == GF_DEFRAG_CMD_DETACH_START) {
-            ret = 0;
-            defrag->defrag_status = GF_DEFRAG_STATUS_COMPLETE;
-            gf_msg(this->name, GF_LOG_DEBUG, 0, DHT_MSG_LOG_TIER_ERROR,
-                   "defrag->defrag_cmd == "
-                   "GF_DEFRAG_CMD_START_DETACH_TIER");
-            goto out;
-        }
-
-        if (gf_defrag_get_pause_state(&defrag->tier_conf) != TIER_RUNNING)
-            continue;
-
-        /* To have proper synchronization amongst all
-         * brick holding nodes, so that promotion and demotions
-         * start atomically w.r.t promotion/demotion frequency
-         * period, all nodes should have their system time
-         * in-sync with each other either manually set or
-         * using a NTP server*/
-        ret = gettimeofday(&current_time, NULL);
-        if (ret == -1) {
-            gf_msg(this->name, GF_LOG_ERROR, errno,
-                   DHT_MSG_SYS_CALL_GET_TIME_FAILED,
-                   "Failed to get current time");
-            goto out;
-        }
-
-        check_watermark++;
-
-        /* emergency demotion requires frequent watermark monitoring */
-        if (check_watermark >=
-            tier_get_wm_interval(tier_conf->mode, tier_conf->watermark_last)) {
-            check_watermark = 0;
-            if (tier_conf->mode == TIER_MODE_WM) {
-                ret = tier_get_fs_stat(this, &root_loc);
-                if (ret != 0) {
-                    continue;
-                }
-                ret = tier_check_watermark(this);
-                if (ret != 0) {
-                    gf_msg(this->name, GF_LOG_CRITICAL, errno,
-                           DHT_MSG_LOG_TIER_ERROR, "Failed to get watermark");
-                    continue;
-                }
-            }
-        }
-
-        if (args->is_promotion) {
-            freq = tier_get_freq_promote(tier_conf);
-
-            if (tier_check_promote(tier_conf, current_time, freq)) {
-                args->freq_time = freq;
-                ret = tier_promote(args);
-                if (ret) {
-                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                           "Promotion failed");
-                }
-            }
-        } else if (args->is_compaction) {
-            tier_prepare_compact(args, current_time);
-        } else {
-            freq = tier_get_freq_demote(tier_conf);
-
-            if (tier_check_demote(current_time, freq)) {
-                args->freq_time = freq;
-                ret = tier_demote(args);
-                if (ret) {
-                    gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                           "Demotion failed");
-                }
-            }
-        }
-
-        /* Check the statfs immediately after the processing threads
-           return */
-        check_watermark = WM_INTERVAL;
-    }
-
-    ret = 0;
-out:
-
-    args->return_value = ret;
-
-    return NULL;
-}
-
-int
-tier_start(xlator_t *this, gf_defrag_info_t *defrag)
-{
-    pthread_t promote_thread;
-    pthread_t demote_thread;
-    pthread_t hot_compact_thread;
-    pthread_t cold_compact_thread;
-    int ret = -1;
-    struct list_head bricklist_hot = {0};
-    struct list_head bricklist_cold = {0};
-    migration_args_t promotion_args = {0};
-    migration_args_t demotion_args = {0};
-    migration_args_t hot_compaction_args = {0};
-    migration_args_t cold_compaction_args = {0};
-    dht_conf_t *conf = NULL;
-
-    INIT_LIST_HEAD((&bricklist_hot));
-    INIT_LIST_HEAD((&bricklist_cold));
-
-    conf = this->private;
-
-    tier_get_bricklist(conf->subvolumes[1], &bricklist_hot);
-    set_brick_list_qpath(&bricklist_hot, _gf_false);
-
-    demotion_args.this = this;
-    demotion_args.brick_list = &bricklist_hot;
-    demotion_args.defrag = defrag;
-    demotion_args.is_promotion = _gf_false;
-    demotion_args.is_compaction = _gf_false;
-
-    ret = gf_thread_create(&demote_thread, NULL, &tier_run, &demotion_args,
-                           "tierdem");
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to start demotion thread.");
-        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-        goto cleanup;
-    }
-
-    tier_get_bricklist(conf->subvolumes[0], &bricklist_cold);
-    set_brick_list_qpath(&bricklist_cold, _gf_true);
-
-    promotion_args.this = this;
-    promotion_args.brick_list = &bricklist_cold;
-    promotion_args.defrag = defrag;
-    promotion_args.is_promotion = _gf_true;
-
-    ret = gf_thread_create(&promote_thread, NULL, &tier_run, &promotion_args,
-                           "tierpro");
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to start promotion thread.");
-        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-        goto waitforspawned;
-    }
-
-    hot_compaction_args.this = this;
-    hot_compaction_args.brick_list = &bricklist_hot;
-    hot_compaction_args.defrag = defrag;
-    hot_compaction_args.is_promotion = _gf_false;
-    hot_compaction_args.is_compaction = _gf_true;
-    hot_compaction_args.is_hot_tier = _gf_true;
-
-    ret = gf_thread_create(&hot_compact_thread, NULL, &tier_run,
-                           &hot_compaction_args, "tierhcom");
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to start compaction thread.");
-        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-        goto waitforspawnedpromote;
-    }
-
-    cold_compaction_args.this = this;
-    cold_compaction_args.brick_list = &bricklist_cold;
-    cold_compaction_args.defrag = defrag;
-    cold_compaction_args.is_promotion = _gf_false;
-    cold_compaction_args.is_compaction = _gf_true;
-    cold_compaction_args.is_hot_tier = _gf_false;
-
-    ret = gf_thread_create(&cold_compact_thread, NULL, &tier_run,
-                           &cold_compaction_args, "tierccom");
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Failed to start compaction thread.");
-        defrag->defrag_status = GF_DEFRAG_STATUS_FAILED;
-        goto waitforspawnedhotcompact;
-    }
-    pthread_join(cold_compact_thread, NULL);
-
-waitforspawnedhotcompact:
-    pthread_join(hot_compact_thread, NULL);
-
-waitforspawnedpromote:
-    pthread_join(promote_thread, NULL);
-
-waitforspawned:
-    pthread_join(demote_thread, NULL);
-
-cleanup:
-    clear_bricklist(&bricklist_cold);
-    clear_bricklist(&bricklist_hot);
-    return ret;
-}
-
-int32_t
-tier_migration_needed(xlator_t *this)
-{
-    gf_defrag_info_t *defrag = NULL;
-    dht_conf_t *conf = NULL;
-    int ret = 0;
-
-    conf = this->private;
-
-    GF_VALIDATE_OR_GOTO(this->name, conf, out);
-    GF_VALIDATE_OR_GOTO(this->name, conf->defrag, out);
-
-    defrag = conf->defrag;
-
-    if ((defrag->cmd == GF_DEFRAG_CMD_START_TIER) ||
-        (defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER))
-        ret = 1;
-out:
-    return ret;
-}
-
-int32_t
-tier_migration_get_dst(xlator_t *this, dht_local_t *local)
-{
-    dht_conf_t *conf = NULL;
-    int32_t ret = -1;
-    gf_defrag_info_t *defrag = NULL;
-
-    GF_VALIDATE_OR_GOTO("tier", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
-
-    conf = this->private;
-
-    defrag = conf->defrag;
-
-    if (defrag && defrag->cmd == GF_DEFRAG_CMD_START_DETACH_TIER) {
-        local->rebalance.target_node = conf->subvolumes[0];
-
-    } else if (conf->subvolumes[0] == local->cached_subvol)
-        local->rebalance.target_node = conf->subvolumes[1];
-    else
-        local->rebalance.target_node = conf->subvolumes[0];
-
-    if (local->rebalance.target_node)
-        ret = 0;
-
-out:
-    return ret;
-}
-
-xlator_t *
-tier_search(xlator_t *this, dht_layout_t *layout, const char *name)
-{
-    xlator_t *subvol = NULL;
-    dht_conf_t *conf = NULL;
-
-    GF_VALIDATE_OR_GOTO("tier", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
-
-    conf = this->private;
-
-    subvol = TIER_HASHED_SUBVOL;
-
-out:
-    return subvol;
-}
-
-static int
-tier_load_externals(xlator_t *this)
-{
-    int ret = -1;
-    char *libpathfull = (LIBDIR "/libgfdb.so.0");
-    get_gfdb_methods_t get_gfdb_methods;
-
-    GF_VALIDATE_OR_GOTO("this", this, out);
-
-    libhandle = dlopen(libpathfull, RTLD_NOW);
-    if (!libhandle) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Error loading libgfdb.so %s\n", dlerror());
-        ret = -1;
-        goto out;
-    }
-
-    get_gfdb_methods = dlsym(libhandle, "get_gfdb_methods");
-    if (!get_gfdb_methods) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Error loading get_gfdb_methods()");
-        ret = -1;
-        goto out;
-    }
-
-    get_gfdb_methods(&gfdb_methods);
-
-    ret = 0;
-
-out:
-    if (ret && libhandle)
-        dlclose(libhandle);
-
-    return ret;
-}
-
-static tier_mode_t
-tier_validate_mode(char *mode)
-{
-    int ret = -1;
-
-    if (strcmp(mode, "test") == 0) {
-        ret = TIER_MODE_TEST;
-    } else {
-        ret = TIER_MODE_WM;
-    }
-
-    return ret;
-}
-
-static gf_boolean_t
-tier_validate_compact_mode(char *mode)
-{
-    gf_boolean_t ret = _gf_false;
-
-    gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-           "tier_validate_compact_mode: mode = %s", mode);
-
-    if (!strcmp(mode, "on")) {
-        ret = _gf_true;
-    } else {
-        ret = _gf_false;
-    }
-
-    gf_msg("tier", GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_STATUS,
-           "tier_validate_compact_mode: ret = %i", ret);
-
-    return ret;
-}
-
-int
-tier_init_methods(xlator_t *this)
-{
-    int ret = -1;
-    dht_conf_t *conf = NULL;
-    dht_methods_t *methods = NULL;
-
-    GF_VALIDATE_OR_GOTO("tier", this, err);
-
-    conf = this->private;
-
-    methods = &(conf->methods);
-
-    methods->migration_get_dst_subvol = tier_migration_get_dst;
-    methods->migration_other = tier_start;
-    methods->migration_needed = tier_migration_needed;
-    methods->layout_search = tier_search;
-
-    ret = 0;
-err:
-    return ret;
-}
-
-static void
-tier_save_vol_name(xlator_t *this)
-{
-    dht_conf_t *conf = NULL;
-    gf_defrag_info_t *defrag = NULL;
-    char *suffix = NULL;
-    int name_len = 0;
-
-    conf = this->private;
-    defrag = conf->defrag;
-
-    suffix = strstr(this->name, "-tier-dht");
-
-    if (suffix)
-        name_len = suffix - this->name;
-    else
-        name_len = strlen(this->name);
-
-    if (name_len > GD_VOLUME_NAME_MAX)
-        name_len = GD_VOLUME_NAME_MAX;
-
-    strncpy(defrag->tier_conf.volname, this->name, name_len);
-    defrag->tier_conf.volname[name_len] = 0;
-}
-
-int
-tier_init(xlator_t *this)
-{
-    int ret = -1;
-    int freq = 0;
-    int maxsize = 0;
-    dht_conf_t *conf = NULL;
-    gf_defrag_info_t *defrag = NULL;
-    char *voldir = NULL;
-    char *mode = NULL;
-    char *paused = NULL;
-    tier_mode_t tier_mode = DEFAULT_TIER_MODE;
-    gf_boolean_t compact_mode = _gf_false;
-
-    ret = dht_init(this);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "tier_init failed");
-        goto out;
-    }
-
-    conf = this->private;
-
-    ret = tier_init_methods(this);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "tier_init_methods failed");
-        goto out;
-    }
-
-    if (conf->subvolume_cnt != 2) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Invalid number of subvolumes %d", conf->subvolume_cnt);
-        goto out;
-    }
-
-    /* if instatiated from client side initialization is complete. */
-    if (!conf->defrag) {
-        ret = 0;
-        goto out;
-    }
-
-    /* if instatiated from server side, load db libraries */
-    ret = tier_load_externals(this);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "Could not load externals. Aborting");
-        goto out;
-    }
-
-    defrag = conf->defrag;
-
-    defrag->tier_conf.last_demote_qfile_index = 0;
-    defrag->tier_conf.last_promote_qfile_index = 0;
-
-    defrag->tier_conf.is_tier = 1;
-    defrag->this = this;
-
-    ret = dict_get_int32(this->options, "tier-max-promote-file-size", &maxsize);
-    if (ret) {
-        maxsize = 0;
-    }
-
-    defrag->tier_conf.tier_max_promote_size = maxsize;
-
-    ret = dict_get_int32(this->options, "tier-promote-frequency", &freq);
-    if (ret) {
-        freq = DEFAULT_PROMOTE_FREQ_SEC;
-    }
-
-    defrag->tier_conf.tier_promote_frequency = freq;
-
-    ret = dict_get_int32(this->options, "tier-demote-frequency", &freq);
-    if (ret) {
-        freq = DEFAULT_DEMOTE_FREQ_SEC;
-    }
-
-    defrag->tier_conf.tier_demote_frequency = freq;
-
-    ret = dict_get_int32(this->options, "tier-hot-compact-frequency", &freq);
-    if (ret) {
-        freq = DEFAULT_HOT_COMPACT_FREQ_SEC;
-    }
-
-    defrag->tier_conf.tier_compact_hot_frequency = freq;
-
-    ret = dict_get_int32(this->options, "tier-cold-compact-frequency", &freq);
-    if (ret) {
-        freq = DEFAULT_COLD_COMPACT_FREQ_SEC;
-    }
-
-    defrag->tier_conf.tier_compact_cold_frequency = freq;
-
-    ret = dict_get_int32(this->options, "watermark-hi", &freq);
-    if (ret) {
-        freq = DEFAULT_WM_HI;
-    }
-
-    defrag->tier_conf.watermark_hi = freq;
-
-    ret = dict_get_int32(this->options, "watermark-low", &freq);
-    if (ret) {
-        freq = DEFAULT_WM_LOW;
-    }
-
-    defrag->tier_conf.watermark_low = freq;
-
-    ret = dict_get_int32(this->options, "write-freq-threshold", &freq);
-    if (ret) {
-        freq = DEFAULT_WRITE_FREQ_SEC;
-    }
-
-    defrag->write_freq_threshold = freq;
-
-    ret = dict_get_int32(this->options, "read-freq-threshold", &freq);
-    if (ret) {
-        freq = DEFAULT_READ_FREQ_SEC;
-    }
-
-    defrag->read_freq_threshold = freq;
-
-    ret = dict_get_int32(this->options, "tier-max-mb", &freq);
-    if (ret) {
-        freq = DEFAULT_TIER_MAX_MIGRATE_MB;
-    }
-
-    defrag->tier_conf.max_migrate_bytes = (uint64_t)freq * 1024 * 1024;
-
-    ret = dict_get_int32(this->options, "tier-max-files", &freq);
-    if (ret) {
-        freq = DEFAULT_TIER_MAX_MIGRATE_FILES;
-    }
-
-    defrag->tier_conf.max_migrate_files = freq;
-
-    ret = dict_get_int32(this->options, "tier-query-limit",
-                         &(defrag->tier_conf.query_limit));
-    if (ret) {
-        defrag->tier_conf.query_limit = DEFAULT_TIER_QUERY_LIMIT;
-    }
-
-    ret = dict_get_str(this->options, "tier-compact", &mode);
-
-    if (ret) {
-        defrag->tier_conf.compact_active = DEFAULT_COMP_MODE;
-    } else {
-        compact_mode = tier_validate_compact_mode(mode);
-        /* If compaction is now active, we need to inform the bricks on
-           the hot and cold tier of this. See dht-common.h for more. */
-        defrag->tier_conf.compact_active = compact_mode;
-        if (compact_mode) {
-            defrag->tier_conf.compact_mode_switched_hot = _gf_true;
-            defrag->tier_conf.compact_mode_switched_cold = _gf_true;
-        }
-    }
-
-    ret = dict_get_str(this->options, "tier-mode", &mode);
-    if (ret) {
-        defrag->tier_conf.mode = DEFAULT_TIER_MODE;
-    } else {
-        tier_mode = tier_validate_mode(mode);
-        defrag->tier_conf.mode = tier_mode;
-    }
-
-    pthread_mutex_init(&defrag->tier_conf.pause_mutex, 0);
-
-    gf_defrag_set_pause_state(&defrag->tier_conf, TIER_RUNNING);
-
-    ret = dict_get_str(this->options, "tier-pause", &paused);
-
-    if (paused && strcmp(paused, "on") == 0)
-        gf_defrag_set_pause_state(&defrag->tier_conf, TIER_REQUEST_PAUSE);
-
-    ret = gf_asprintf(&voldir, "%s/%s", DEFAULT_VAR_RUN_DIRECTORY, this->name);
-    if (ret < 0)
-        goto out;
-
-    ret = mkdir_p(voldir, 0777, _gf_true);
-    if (ret == -1 && errno != EEXIST) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-               "tier_init failed");
-
-        GF_FREE(voldir);
-        goto out;
-    }
-
-    GF_FREE(voldir);
-
-    ret = gf_asprintf(&promotion_qfile, "%s/%s/promote",
-                      DEFAULT_VAR_RUN_DIRECTORY, this->name);
-    if (ret < 0)
-        goto out;
-
-    ret = gf_asprintf(&demotion_qfile, "%s/%s/demote",
-                      DEFAULT_VAR_RUN_DIRECTORY, this->name);
-    if (ret < 0) {
-        GF_FREE(promotion_qfile);
-        goto out;
-    }
-
-    gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-           "Promote/demote frequency %d/%d "
-           "Write/Read freq thresholds %d/%d",
-           defrag->tier_conf.tier_promote_frequency,
-           defrag->tier_conf.tier_demote_frequency,
-           defrag->write_freq_threshold, defrag->read_freq_threshold);
-
-    tier_save_vol_name(this);
-
-    ret = 0;
-
-out:
-
-    return ret;
-}
-
-int
-tier_cli_pause_done(int op_ret, call_frame_t *sync_frame, void *data)
-{
-    gf_msg("tier", GF_LOG_INFO, 0, DHT_MSG_TIER_PAUSED,
-           "Migrate file paused with op_ret %d", op_ret);
-
-    return op_ret;
-}
-
-int
-tier_cli_pause(void *data)
-{
-    gf_defrag_info_t *defrag = NULL;
-    xlator_t *this = NULL;
-    dht_conf_t *conf = NULL;
-    int ret = -1;
-
-    this = data;
-
-    conf = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, conf, exit);
-
-    defrag = conf->defrag;
-    GF_VALIDATE_OR_GOTO(this->name, defrag, exit);
-
-    gf_defrag_pause_tier(this, defrag);
-
-    ret = 0;
-exit:
-    return ret;
-}
-
-int
-tier_reconfigure(xlator_t *this, dict_t *options)
-{
-    dht_conf_t *conf = NULL;
-    gf_defrag_info_t *defrag = NULL;
-    char *mode = NULL;
-    int migrate_mb = 0;
-    gf_boolean_t req_pause = _gf_false;
-    int ret = 0;
-    call_frame_t *frame = NULL;
-    gf_boolean_t last_compact_setting = _gf_false;
-
-    conf = this->private;
-
-    if (conf->defrag) {
-        defrag = conf->defrag;
-        GF_OPTION_RECONF("tier-max-promote-file-size",
-                         defrag->tier_conf.tier_max_promote_size, options,
-                         int32, out);
-
-        GF_OPTION_RECONF("tier-promote-frequency",
-                         defrag->tier_conf.tier_promote_frequency, options,
-                         int32, out);
-
-        GF_OPTION_RECONF("tier-demote-frequency",
-                         defrag->tier_conf.tier_demote_frequency, options,
-                         int32, out);
-
-        GF_OPTION_RECONF("write-freq-threshold", defrag->write_freq_threshold,
-                         options, int32, out);
-
-        GF_OPTION_RECONF("read-freq-threshold", defrag->read_freq_threshold,
-                         options, int32, out);
-
-        GF_OPTION_RECONF("watermark-hi", defrag->tier_conf.watermark_hi,
-                         options, int32, out);
-
-        GF_OPTION_RECONF("watermark-low", defrag->tier_conf.watermark_low,
-                         options, int32, out);
-
-        last_compact_setting = defrag->tier_conf.compact_active;
-
-        GF_OPTION_RECONF("tier-compact", defrag->tier_conf.compact_active,
-                         options, bool, out);
-
-        if (last_compact_setting != defrag->tier_conf.compact_active) {
-            defrag->tier_conf.compact_mode_switched_hot = _gf_true;
-            defrag->tier_conf.compact_mode_switched_cold = _gf_true;
-            gf_msg(this->name, GF_LOG_INFO, 0, DHT_MSG_LOG_TIER_STATUS,
-                   "compact mode switched");
-        }
-
-        GF_OPTION_RECONF("tier-hot-compact-frequency",
-                         defrag->tier_conf.tier_compact_hot_frequency, options,
-                         int32, out);
-
-        GF_OPTION_RECONF("tier-cold-compact-frequency",
-                         defrag->tier_conf.tier_compact_cold_frequency, options,
-                         int32, out);
-
-        GF_OPTION_RECONF("tier-mode", mode, options, str, out);
-        defrag->tier_conf.mode = tier_validate_mode(mode);
-
-        GF_OPTION_RECONF("tier-max-mb", migrate_mb, options, int32, out);
-        defrag->tier_conf.max_migrate_bytes = (uint64_t)migrate_mb * 1024 *
-                                              1024;
-
-        GF_OPTION_RECONF("tier-max-files", defrag->tier_conf.max_migrate_files,
-                         options, int32, out);
-
-        GF_OPTION_RECONF("tier-query-limit", defrag->tier_conf.query_limit,
-                         options, int32, out);
-
-        GF_OPTION_RECONF("tier-pause", req_pause, options, bool, out);
-
-        if (req_pause == _gf_true) {
-            frame = create_frame(this, this->ctx->pool);
-            if (!frame)
-                goto out;
-
-            frame->root->pid = GF_CLIENT_PID_DEFRAG;
-
-            ret = synctask_new(this->ctx->env, tier_cli_pause,
-                               tier_cli_pause_done, frame, this);
-
-            if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                       "pause tier failed on reconfigure");
-            }
-        } else {
-            ret = gf_defrag_resume_tier(this, defrag);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0, DHT_MSG_LOG_TIER_ERROR,
-                       "resume tier failed on reconfigure");
-            }
-        }
-    }
-
-out:
-    return dht_reconfigure(this, options);
-}
-
-void
-tier_fini(xlator_t *this)
-{
-    if (libhandle)
-        dlclose(libhandle);
-
-    GF_FREE(demotion_qfile);
-    GF_FREE(promotion_qfile);
-
-    dht_fini(this);
-}
-
-class_methods_t class_methods = {.init = tier_init,
-                                 .fini = tier_fini,
-                                 .reconfigure = tier_reconfigure,
-                                 .notify = dht_notify};
-
-struct xlator_fops fops = {
-
-    .lookup = dht_lookup,
-    .create = tier_create,
-    .mknod = dht_mknod,
-
-    .open = dht_open,
-    .statfs = tier_statfs,
-    .opendir = dht_opendir,
-    .readdir = tier_readdir,
-    .readdirp = tier_readdirp,
-    .fsyncdir = dht_fsyncdir,
-    .symlink = dht_symlink,
-    .unlink = tier_unlink,
-    .link = tier_link,
-    .mkdir = dht_mkdir,
-    .rmdir = dht_rmdir,
-    .rename = dht_rename,
-    .entrylk = dht_entrylk,
-    .fentrylk = dht_fentrylk,
-
-    /* Inode read operations */
-    .stat = dht_stat,
-    .fstat = dht_fstat,
-    .access = dht_access,
-    .readlink = dht_readlink,
-    .getxattr = dht_getxattr,
-    .fgetxattr = dht_fgetxattr,
-    .readv = dht_readv,
-    .flush = dht_flush,
-    .fsync = dht_fsync,
-    .inodelk = dht_inodelk,
-    .finodelk = dht_finodelk,
-    .lk = dht_lk,
-
-    /* Inode write operations */
-    .fremovexattr = dht_fremovexattr,
-    .removexattr = dht_removexattr,
-    .setxattr = dht_setxattr,
-    .fsetxattr = dht_fsetxattr,
-    .truncate = dht_truncate,
-    .ftruncate = dht_ftruncate,
-    .writev = dht_writev,
-    .xattrop = dht_xattrop,
-    .fxattrop = dht_fxattrop,
-    .setattr = dht_setattr,
-    .fsetattr = dht_fsetattr,
-    .fallocate = dht_fallocate,
-    .discard = dht_discard,
-    .zerofill = dht_zerofill,
-};
-
-struct xlator_cbks cbks = {.release = dht_release, .forget = dht_forget};
diff --git a/xlators/cluster/dht/src/tier.h b/xlators/cluster/dht/src/tier.h
deleted file mode 100644
index a20b1db07e0..00000000000
--- a/xlators/cluster/dht/src/tier.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (c) 2015 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 _TIER_H_
-#define _TIER_H_
-
-/******************************************************************************/
-/* This is from dht-rebalancer.c as we don't have dht-rebalancer.h */
-#include "dht-common.h"
-#include <glusterfs/xlator.h>
-#include <signal.h>
-#include <fnmatch.h>
-#include <signal.h>
-
-/*
- * Size of timer wheel. We would not promote or demote less
- * frequently than this number.
- */
-#define TIMER_SECS 3600
-
-#include "gfdb_data_store.h"
-#include <ctype.h>
-#include <sys/stat.h>
-
-#define PROMOTION_QFILE "promotequeryfile"
-#define DEMOTION_QFILE "demotequeryfile"
-
-#define TIER_HASHED_SUBVOL conf->subvolumes[0]
-#define TIER_UNHASHED_SUBVOL conf->subvolumes[1]
-
-#define GET_QFILE_PATH(is_promotion)                                           \
-    (is_promotion) ? promotion_qfile : demotion_qfile
-
-typedef struct tier_qfile_array {
-    int *fd_array;
-    ssize_t array_size;
-    ssize_t next_index;
-    /* Indicate the number of exhuasted FDs*/
-    ssize_t exhausted_count;
-} tier_qfile_array_t;
-
-typedef struct _query_cbk_args {
-    xlator_t *this;
-    gf_defrag_info_t *defrag;
-    /* This is write */
-    int query_fd;
-    int is_promotion;
-    int is_compaction;
-    /* This is for read */
-    tier_qfile_array_t *qfile_array;
-} query_cbk_args_t;
-
-int
-gf_run_tier(xlator_t *this, gf_defrag_info_t *defrag);
-
-typedef struct gfdb_brick_info {
-    gfdb_time_t *time_stamp;
-    gf_boolean_t _gfdb_promote;
-    query_cbk_args_t *_query_cbk_args;
-} gfdb_brick_info_t;
-
-typedef struct brick_list {
-    xlator_t *xlator;
-    char *brick_db_path;
-    char brick_name[NAME_MAX];
-    char qfile_path[PATH_MAX];
-    struct list_head list;
-} tier_brick_list_t;
-
-typedef struct _dm_thread_args {
-    xlator_t *this;
-    gf_defrag_info_t *defrag;
-    struct list_head *brick_list;
-    int freq_time;
-    int return_value;
-    int is_promotion;
-    int is_compaction;
-    gf_boolean_t is_hot_tier;
-} migration_args_t;
-
-typedef enum tier_watermark_op_ {
-    TIER_WM_NONE = 0,
-    TIER_WM_LOW,
-    TIER_WM_HI,
-    TIER_WM_MID
-} tier_watermark_op_t;
-
-#define DEFAULT_PROMOTE_FREQ_SEC 120
-#define DEFAULT_DEMOTE_FREQ_SEC 120
-#define DEFAULT_HOT_COMPACT_FREQ_SEC 604800
-#define DEFAULT_COLD_COMPACT_FREQ_SEC 604800
-#define DEFAULT_DEMOTE_DEGRADED 1
-#define DEFAULT_WRITE_FREQ_SEC 0
-#define DEFAULT_READ_FREQ_SEC 0
-#define DEFAULT_WM_LOW 75
-#define DEFAULT_WM_HI 90
-#define DEFAULT_TIER_MODE TIER_MODE_TEST
-#define DEFAULT_COMP_MODE _gf_true
-#define DEFAULT_TIER_MAX_MIGRATE_MB 1000
-#define DEFAULT_TIER_MAX_MIGRATE_FILES 5000
-#define DEFAULT_TIER_QUERY_LIMIT 100
-
-#endif
diff --git a/xlators/cluster/dht/src/tier.sym b/xlators/cluster/dht/src/tier.sym
deleted file mode 100644
index 60205d145b6..00000000000
--- a/xlators/cluster/dht/src/tier.sym
+++ /dev/null
@@ -1,9 +0,0 @@
-fops
-cbks
-class_methods
-dht_methods
-tier_methods
-options
-mem_acct_init
-reconfigure
-dumpops
diff --git a/xlators/cluster/stripe/src/Makefile.am b/xlators/cluster/stripe/src/Makefile.am
deleted file mode 100644
index 2b594567db1..00000000000
--- a/xlators/cluster/stripe/src/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-xlator_LTLIBRARIES = stripe.la
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/cluster
-
-stripe_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-
-
-stripe_la_SOURCES = stripe.c stripe-helpers.c \
-	$(top_builddir)/xlators/lib/src/libxlator.c
-
-stripe_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-noinst_HEADERS = stripe.h stripe-mem-types.h \
-	$(top_builddir)/xlators/lib/src/libxlator.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/xlators/lib/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-CLEANFILES = 
-
diff --git a/xlators/cluster/stripe/src/stripe-helpers.c b/xlators/cluster/stripe/src/stripe-helpers.c
deleted file mode 100644
index 35342378985..00000000000
--- a/xlators/cluster/stripe/src/stripe-helpers.c
+++ /dev/null
@@ -1,658 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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.
-*/
-
-#include <fnmatch.h>
-
-#include "stripe.h"
-#include <glusterfs/byte-order.h>
-#include <glusterfs/mem-types.h>
-#include <glusterfs/logging.h>
-
-void
-stripe_local_wipe(stripe_local_t *local)
-{
-    if (!local)
-        goto out;
-
-    loc_wipe(&local->loc);
-    loc_wipe(&local->loc2);
-
-    if (local->fd)
-        fd_unref(local->fd);
-
-    if (local->inode)
-        inode_unref(local->inode);
-
-    if (local->xattr)
-        dict_unref(local->xattr);
-
-    if (local->xdata)
-        dict_unref(local->xdata);
-
-out:
-    return;
-}
-
-int
-stripe_aggregate(dict_t *this, char *key, data_t *value, void *data)
-{
-    dict_t *dst = NULL;
-    int64_t *ptr = 0, *size = NULL;
-    int32_t ret = -1;
-
-    dst = data;
-
-    if (strcmp(key, QUOTA_SIZE_KEY) == 0) {
-        ret = dict_get_bin(dst, key, (void **)&size);
-        if (ret < 0) {
-            size = GF_CALLOC(1, sizeof(int64_t), gf_common_mt_char);
-            if (size == NULL) {
-                gf_log("stripe", GF_LOG_WARNING, "memory allocation failed");
-                goto out;
-            }
-            ret = dict_set_bin(dst, key, size, sizeof(int64_t));
-            if (ret < 0) {
-                gf_log("stripe", GF_LOG_WARNING,
-                       "stripe aggregate dict set failed");
-                GF_FREE(size);
-                goto out;
-            }
-        }
-
-        ptr = data_to_bin(value);
-        if (ptr == NULL) {
-            gf_log("stripe", GF_LOG_WARNING, "data to bin failed");
-            goto out;
-        }
-
-        *size = hton64(ntoh64(*size) + ntoh64(*ptr));
-    } else if (strcmp(key, GF_CONTENT_KEY)) {
-        /* No need to aggregate 'CONTENT' data */
-        ret = dict_set(dst, key, value);
-        if (ret)
-            gf_log("stripe", GF_LOG_WARNING, "xattr dict set failed");
-    }
-
-out:
-    return 0;
-}
-
-void
-stripe_aggregate_xattr(dict_t *dst, dict_t *src)
-{
-    if ((dst == NULL) || (src == NULL)) {
-        goto out;
-    }
-
-    dict_foreach(src, stripe_aggregate, dst);
-out:
-    return;
-}
-
-int32_t
-stripe_xattr_aggregate(char *buffer, stripe_local_t *local, int32_t *total)
-{
-    int32_t i = 0;
-    int32_t ret = -1;
-    int32_t len = 0;
-    char *sbuf = NULL;
-    stripe_xattr_sort_t *xattr = NULL;
-
-    if (!buffer || !local || !local->xattr_list)
-        goto out;
-
-    sbuf = buffer;
-
-    for (i = 0; i < local->nallocs; i++) {
-        xattr = local->xattr_list + i;
-        len = xattr->xattr_len - 1; /* length includes \0 */
-
-        if (len && xattr && xattr->xattr_value) {
-            memcpy(buffer, xattr->xattr_value, len);
-            buffer += len;
-            *buffer++ = ' ';
-        }
-    }
-
-    *--buffer = '\0';
-    if (total)
-        *total = buffer - sbuf;
-    ret = 0;
-
-out:
-    return ret;
-}
-
-int32_t
-stripe_free_xattr_str(stripe_local_t *local)
-{
-    int32_t i = 0;
-    int32_t ret = -1;
-    stripe_xattr_sort_t *xattr = NULL;
-
-    if (!local || !local->xattr_list)
-        goto out;
-
-    for (i = 0; i < local->nallocs; i++) {
-        xattr = local->xattr_list + i;
-
-        if (xattr && xattr->xattr_value)
-            GF_FREE(xattr->xattr_value);
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-stripe_fill_lockinfo_xattr(xlator_t *this, stripe_local_t *local,
-                           void **xattr_serz)
-{
-    int32_t ret = -1, i = 0, len = 0;
-    dict_t *tmp1 = NULL, *tmp2 = NULL;
-    char *buf = NULL;
-    stripe_xattr_sort_t *xattr = NULL;
-
-    if (xattr_serz == NULL) {
-        goto out;
-    }
-
-    tmp2 = dict_new();
-
-    if (tmp2 == NULL) {
-        goto out;
-    }
-
-    for (i = 0; i < local->nallocs; i++) {
-        xattr = local->xattr_list + i;
-        len = xattr->xattr_len;
-
-        if (len && xattr && xattr->xattr_value) {
-            ret = dict_reset(tmp2);
-            if (ret < 0) {
-                gf_log(this->name, GF_LOG_DEBUG, "dict_reset failed (%s)",
-                       strerror(-ret));
-            }
-
-            ret = dict_unserialize(xattr->xattr_value, xattr->xattr_len, &tmp2);
-            if (ret < 0) {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "dict_unserialize failed (%s)", strerror(-ret));
-                ret = -1;
-                goto out;
-            }
-
-            tmp1 = dict_copy(tmp2, tmp1);
-            if (tmp1 == NULL) {
-                gf_log(this->name, GF_LOG_WARNING, "dict_copy failed (%s)",
-                       strerror(-ret));
-                ret = -1;
-                goto out;
-            }
-        }
-    }
-
-    len = dict_serialized_length(tmp1);
-    if (len > 0) {
-        buf = GF_CALLOC(1, len, gf_common_mt_dict_t);
-        if (buf == NULL) {
-            ret = -1;
-            goto out;
-        }
-
-        ret = dict_serialize(tmp1, buf);
-        if (ret < 0) {
-            gf_log(this->name, GF_LOG_WARNING, "dict_serialize failed (%s)",
-                   strerror(-ret));
-            GF_FREE(buf);
-            ret = -1;
-            goto out;
-        }
-
-        *xattr_serz = buf;
-    }
-
-    ret = 0;
-out:
-    if (tmp1 != NULL) {
-        dict_unref(tmp1);
-    }
-
-    if (tmp2 != NULL) {
-        dict_unref(tmp2);
-    }
-
-    return ret;
-}
-
-int32_t
-stripe_fill_pathinfo_xattr(xlator_t *this, stripe_local_t *local,
-                           char **xattr_serz)
-{
-    int ret = -1;
-    int32_t padding = 0;
-    int32_t tlen = 0;
-    int len = 0;
-    char stripe_size_str[20] = {
-        0,
-    };
-    char *pathinfo_serz = NULL;
-
-    if (!local) {
-        gf_log(this->name, GF_LOG_ERROR, "Possible NULL deref");
-        goto out;
-    }
-
-    len = snprintf(stripe_size_str, sizeof(stripe_size_str), "%" PRId64,
-                   local->fctx ? local->fctx->stripe_size : 0);
-    if (len < 0 || len >= sizeof(stripe_size_str))
-        goto out;
-    /* extra bytes for decorations (brackets and <>'s) */
-    padding = strlen(this->name) + SLEN(STRIPE_PATHINFO_HEADER) + len + 7;
-    local->xattr_total_len += (padding + 2);
-
-    pathinfo_serz = GF_MALLOC(local->xattr_total_len, gf_common_mt_char);
-    if (!pathinfo_serz)
-        goto out;
-
-    /* xlator info */
-    (void)sprintf(pathinfo_serz, "(<" STRIPE_PATHINFO_HEADER "%s:[%s]> ",
-                  this->name, stripe_size_str);
-
-    ret = stripe_xattr_aggregate(pathinfo_serz + padding, local, &tlen);
-    if (ret) {
-        gf_log(this->name, GF_LOG_ERROR, "Cannot aggregate pathinfo list");
-        GF_FREE(pathinfo_serz);
-        goto out;
-    }
-
-    *(pathinfo_serz + padding + tlen) = ')';
-    *(pathinfo_serz + padding + tlen + 1) = '\0';
-
-    *xattr_serz = pathinfo_serz;
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/**
- * stripe_get_matching_bs - Get the matching block size for the given path.
- */
-int32_t
-stripe_get_matching_bs(const char *path, stripe_private_t *priv)
-{
-    struct stripe_options *trav = NULL;
-    uint64_t block_size = 0;
-
-    GF_VALIDATE_OR_GOTO("stripe", priv, out);
-    GF_VALIDATE_OR_GOTO("stripe", path, out);
-
-    LOCK(&priv->lock);
-    {
-        block_size = priv->block_size;
-        trav = priv->pattern;
-        while (trav) {
-            if (!fnmatch(trav->path_pattern, path, FNM_NOESCAPE)) {
-                block_size = trav->block_size;
-                break;
-            }
-            trav = trav->next;
-        }
-    }
-    UNLOCK(&priv->lock);
-
-out:
-    return block_size;
-}
-
-int32_t
-stripe_ctx_handle(xlator_t *this, call_frame_t *prev, stripe_local_t *local,
-                  dict_t *dict)
-{
-    char key[256] = {
-        0,
-    };
-    data_t *data = NULL;
-    int32_t index = 0;
-    stripe_private_t *priv = NULL;
-
-    priv = this->private;
-
-    if (!local->fctx) {
-        local->fctx = GF_CALLOC(1, sizeof(stripe_fd_ctx_t),
-                                gf_stripe_mt_stripe_fd_ctx_t);
-        if (!local->fctx) {
-            local->op_errno = ENOMEM;
-            local->op_ret = -1;
-            goto out;
-        }
-
-        local->fctx->static_array = 0;
-    }
-    /* Stripe block size */
-    sprintf(key, "trusted.%s.stripe-size", this->name);
-    data = dict_get(dict, key);
-    if (!data) {
-        local->xattr_self_heal_needed = 1;
-        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-size");
-        goto out;
-    } else {
-        if (!local->fctx->stripe_size) {
-            local->fctx->stripe_size = data_to_int64(data);
-        }
-
-        if (local->fctx->stripe_size != data_to_int64(data)) {
-            gf_log(this->name, GF_LOG_WARNING,
-                   "stripe-size mismatch in blocks");
-            local->xattr_self_heal_needed = 1;
-        }
-    }
-
-    /* Stripe count */
-    sprintf(key, "trusted.%s.stripe-count", this->name);
-    data = dict_get(dict, key);
-
-    if (!data) {
-        local->xattr_self_heal_needed = 1;
-        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-count");
-        goto out;
-    }
-    if (!local->fctx->xl_array) {
-        local->fctx->stripe_count = data_to_int32(data);
-        if (!local->fctx->stripe_count) {
-            gf_log(this->name, GF_LOG_ERROR, "error with stripe-count xattr");
-            local->op_ret = -1;
-            local->op_errno = EIO;
-            goto out;
-        }
-
-        local->fctx->xl_array = GF_CALLOC(local->fctx->stripe_count,
-                                          sizeof(xlator_t *),
-                                          gf_stripe_mt_xlator_t);
-
-        if (!local->fctx->xl_array) {
-            local->op_errno = ENOMEM;
-            local->op_ret = -1;
-            goto out;
-        }
-    }
-    if (local->fctx->stripe_count != data_to_int32(data)) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "error with stripe-count xattr (%d != %d)",
-               local->fctx->stripe_count, data_to_int32(data));
-        local->op_ret = -1;
-        local->op_errno = EIO;
-        goto out;
-    }
-
-    /* index */
-    sprintf(key, "trusted.%s.stripe-index", this->name);
-    data = dict_get(dict, key);
-    if (!data) {
-        local->xattr_self_heal_needed = 1;
-        gf_log(this->name, GF_LOG_ERROR, "Failed to get stripe-index");
-        goto out;
-    }
-    index = data_to_int32(data);
-    if (index > priv->child_count) {
-        gf_log(this->name, GF_LOG_ERROR, "error with stripe-index xattr (%d)",
-               index);
-        local->op_ret = -1;
-        local->op_errno = EIO;
-        goto out;
-    }
-    if (local->fctx->xl_array) {
-        if (!local->fctx->xl_array[index])
-            local->fctx->xl_array[index] = prev->this;
-    }
-
-    sprintf(key, "trusted.%s.stripe-coalesce", this->name);
-    data = dict_get(dict, key);
-    if (!data) {
-        /*
-         * The file was probably created prior to coalesce support.
-         * Assume non-coalesce mode for this file to maintain backwards
-         * compatibility.
-         */
-        gf_log(this->name, GF_LOG_DEBUG,
-               "missing stripe-coalesce "
-               "attr, assume non-coalesce mode");
-        local->fctx->stripe_coalesce = 0;
-    } else {
-        local->fctx->stripe_coalesce = data_to_int32(data);
-    }
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_xattr_request_build(xlator_t *this, dict_t *dict, uint64_t stripe_size,
-                           uint32_t stripe_count, uint32_t stripe_index,
-                           uint32_t stripe_coalesce)
-{
-    char key[256] = {
-        0,
-    };
-    int32_t ret = -1;
-
-    sprintf(key, "trusted.%s.stripe-size", this->name);
-    ret = dict_set_int64(dict, key, stripe_size);
-    if (ret) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
-               key);
-        goto out;
-    }
-
-    sprintf(key, "trusted.%s.stripe-count", this->name);
-    ret = dict_set_int32(dict, key, stripe_count);
-    if (ret) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
-               key);
-        goto out;
-    }
-
-    sprintf(key, "trusted.%s.stripe-index", this->name);
-    ret = dict_set_int32(dict, key, stripe_index);
-    if (ret) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req dict",
-               key);
-        goto out;
-    }
-
-    sprintf(key, "trusted.%s.stripe-coalesce", this->name);
-    ret = dict_set_int32(dict, key, stripe_coalesce);
-    if (ret) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set %s in xattr_req_dict",
-               key);
-        goto out;
-    }
-out:
-    return ret;
-}
-
-static int
-set_default_block_size(stripe_private_t *priv, char *num)
-{
-    int ret = -1;
-    GF_VALIDATE_OR_GOTO("stripe", THIS, out);
-    GF_VALIDATE_OR_GOTO(THIS->name, priv, out);
-    GF_VALIDATE_OR_GOTO(THIS->name, num, out);
-
-    if (gf_string2bytesize_uint64(num, &priv->block_size) != 0) {
-        gf_log(THIS->name, GF_LOG_ERROR, "invalid number format \"%s\"", num);
-        goto out;
-    }
-
-    ret = 0;
-
-out:
-    return ret;
-}
-
-int
-set_stripe_block_size(xlator_t *this, stripe_private_t *priv, char *data)
-{
-    int ret = -1;
-    char *tmp_str = NULL;
-    char *tmp_str1 = NULL;
-    char *dup_str = NULL;
-    char *stripe_str = NULL;
-    char *pattern = NULL;
-    char *num = NULL;
-    struct stripe_options *temp_stripeopt = NULL;
-    struct stripe_options *stripe_opt = NULL;
-
-    if (!this || !priv || !data)
-        goto out;
-
-    /* Get the pattern for striping.
-       "option block-size *avi:10MB" etc */
-    stripe_str = strtok_r(data, ",", &tmp_str);
-    while (stripe_str) {
-        dup_str = gf_strdup(stripe_str);
-        stripe_opt = GF_CALLOC(1, sizeof(struct stripe_options),
-                               gf_stripe_mt_stripe_options);
-        if (!stripe_opt) {
-            goto out;
-        }
-
-        pattern = strtok_r(dup_str, ":", &tmp_str1);
-        num = strtok_r(NULL, ":", &tmp_str1);
-        if (!num) {
-            num = pattern;
-            pattern = "*";
-            ret = set_default_block_size(priv, num);
-            if (ret)
-                goto out;
-        }
-        if (gf_string2bytesize_uint64(num, &stripe_opt->block_size) != 0) {
-            gf_log(this->name, GF_LOG_ERROR, "invalid number format \"%s\"",
-                   num);
-            goto out;
-        }
-
-        if (stripe_opt->block_size < STRIPE_MIN_BLOCK_SIZE) {
-            gf_log(this->name, GF_LOG_ERROR,
-                   "Invalid Block-size: "
-                   "%s. Should be at least %llu bytes",
-                   num, STRIPE_MIN_BLOCK_SIZE);
-            goto out;
-        }
-        if (stripe_opt->block_size % 512) {
-            gf_log(this->name, GF_LOG_ERROR,
-                   "Block-size: %s should"
-                   " be a multiple of 512 bytes",
-                   num);
-            goto out;
-        }
-
-        memcpy(stripe_opt->path_pattern, pattern, strlen(pattern));
-
-        gf_log(this->name, GF_LOG_DEBUG,
-               "block-size : pattern %s : size %" PRId64,
-               stripe_opt->path_pattern, stripe_opt->block_size);
-
-        if (priv->pattern)
-            temp_stripeopt = NULL;
-        else
-            temp_stripeopt = priv->pattern;
-
-        stripe_opt->next = temp_stripeopt;
-
-        priv->pattern = stripe_opt;
-        stripe_opt = NULL;
-
-        GF_FREE(dup_str);
-        dup_str = NULL;
-
-        stripe_str = strtok_r(NULL, ",", &tmp_str);
-    }
-
-    ret = 0;
-out:
-
-    GF_FREE(dup_str);
-
-    GF_FREE(stripe_opt);
-
-    return ret;
-}
-
-int32_t
-stripe_iatt_merge(struct iatt *from, struct iatt *to)
-{
-    if (to->ia_size < from->ia_size)
-        to->ia_size = from->ia_size;
-    if (to->ia_mtime < from->ia_mtime)
-        to->ia_mtime = from->ia_mtime;
-    if (to->ia_ctime < from->ia_ctime)
-        to->ia_ctime = from->ia_ctime;
-    if (to->ia_atime < from->ia_atime)
-        to->ia_atime = from->ia_atime;
-    return 0;
-}
-
-off_t
-coalesced_offset(off_t offset, uint64_t stripe_size, int stripe_count)
-{
-    size_t line_size = 0;
-    uint64_t stripe_num = 0;
-    off_t coalesced_offset = 0;
-
-    line_size = stripe_size * stripe_count;
-    stripe_num = offset / line_size;
-
-    coalesced_offset = (stripe_num * stripe_size) + (offset % stripe_size);
-
-    return coalesced_offset;
-}
-
-off_t
-uncoalesced_size(off_t size, uint64_t stripe_size, int stripe_count,
-                 int stripe_index)
-{
-    uint64_t nr_full_stripe_chunks = 0, mod = 0;
-
-    if (!size)
-        return size;
-
-    /*
-     * Estimate the number of fully written stripes from the
-     * local file size. Each stripe_size chunk corresponds to
-     * a stripe.
-     */
-    nr_full_stripe_chunks = (size / stripe_size) * stripe_count;
-    mod = size % stripe_size;
-
-    if (!mod) {
-        /*
-         * There is no remainder, thus we could have overestimated
-         * the size of the file in terms of chunks. Trim the number
-         * of chunks by the following stripe members and leave it
-         * up to those nodes to respond with a larger size (if
-         * necessary).
-         */
-        nr_full_stripe_chunks -= stripe_count - (stripe_index + 1);
-        size = nr_full_stripe_chunks * stripe_size;
-    } else {
-        /*
-         * There is a remainder and thus we own the last chunk of the
-         * file. Add the preceding stripe members of the final stripe
-         * along with the remainder to calculate the exact size.
-         */
-        nr_full_stripe_chunks += stripe_index;
-        size = nr_full_stripe_chunks * stripe_size + mod;
-    }
-
-    return size;
-}
diff --git a/xlators/cluster/stripe/src/stripe-mem-types.h b/xlators/cluster/stripe/src/stripe-mem-types.h
deleted file mode 100644
index 3ca6ecc7a41..00000000000
--- a/xlators/cluster/stripe/src/stripe-mem-types.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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 __STRIPE_MEM_TYPES_H__
-#define __STRIPE_MEM_TYPES_H__
-
-#include <glusterfs/mem-types.h>
-
-enum gf_stripe_mem_types_ {
-    gf_stripe_mt_iovec = gf_common_mt_end + 1,
-    gf_stripe_mt_stripe_replies,
-    gf_stripe_mt_stripe_fd_ctx_t,
-    gf_stripe_mt_char,
-    gf_stripe_mt_int8_t,
-    gf_stripe_mt_int32_t,
-    gf_stripe_mt_xlator_t,
-    gf_stripe_mt_stripe_private_t,
-    gf_stripe_mt_stripe_options,
-    gf_stripe_mt_xattr_sort_t,
-    gf_stripe_mt_end
-};
-#endif
diff --git a/xlators/cluster/stripe/src/stripe.c b/xlators/cluster/stripe/src/stripe.c
deleted file mode 100644
index 557a8185352..00000000000
--- a/xlators/cluster/stripe/src/stripe.c
+++ /dev/null
@@ -1,5612 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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.
-*/
-
-/**
- * xlators/cluster/stripe:
- *    Stripe translator, stripes the data across its child nodes,
- *    as per the options given in the volfile. The striping works
- *    fairly simple. It writes files at different offset as per
- *    calculation. So, 'ls -l' output at the real posix level will
- *    show file size bigger than the actual size. But when one does
- *    'df' or 'du <file>', real size of the file on the server is shown.
- *
- * WARNING:
- *  Stripe translator can't regenerate data if a child node gets disconnected.
- *  So, no 'self-heal' for stripe. Hence the advice, use stripe only when its
- *  very much necessary, or else, use it in combination with AFR, to have a
- *  backup copy.
- */
-#include <fnmatch.h>
-#include "stripe.h"
-#include "libxlator.h"
-#include <glusterfs/byte-order.h>
-#include <glusterfs/statedump.h>
-
-struct volume_options options[];
-
-int32_t
-stripe_sh_chown_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *preop,
-                    struct iatt *postop, dict_t *xdata)
-{
-    int callcnt = -1;
-    stripe_local_t *local = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        STRIPE_STACK_DESTROY(frame);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_sh_make_entry_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, inode_t *inode,
-                         struct iatt *buf, struct iatt *preparent,
-                         struct iatt *postparent, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!frame || !frame->local || !cookie || !this) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    STACK_WIND(frame, stripe_sh_chown_cbk, prev->this,
-               prev->this->fops->setattr, &local->loc, &local->stbuf,
-               (GF_SET_ATTR_UID | GF_SET_ATTR_GID), NULL);
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_entry_self_heal(call_frame_t *frame, xlator_t *this,
-                       stripe_local_t *local)
-{
-    xlator_list_t *trav = NULL;
-    call_frame_t *rframe = NULL;
-    stripe_local_t *rlocal = NULL;
-    stripe_private_t *priv = NULL;
-    dict_t *xdata = NULL;
-    int ret = 0;
-
-    if (!local || !this || !frame) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    if (!(IA_ISREG(local->stbuf.ia_type) || IA_ISDIR(local->stbuf.ia_type)))
-        return 0;
-
-    priv = this->private;
-    trav = this->children;
-    rframe = copy_frame(frame);
-    if (!rframe) {
-        goto out;
-    }
-    rlocal = mem_get0(this->local_pool);
-    if (!rlocal) {
-        goto out;
-    }
-    rframe->local = rlocal;
-    rlocal->call_count = priv->child_count;
-    loc_copy(&rlocal->loc, &local->loc);
-    memcpy(&rlocal->stbuf, &local->stbuf, sizeof(struct iatt));
-
-    xdata = dict_new();
-    if (!xdata)
-        goto out;
-
-    ret = dict_set_gfuuid(xdata, "gfid-req", local->stbuf.ia_gfid, true);
-    if (ret)
-        gf_log(this->name, GF_LOG_WARNING, "%s: failed to set gfid-req",
-               local->loc.path);
-
-    while (trav) {
-        if (IA_ISREG(local->stbuf.ia_type)) {
-            STACK_WIND(
-                rframe, stripe_sh_make_entry_cbk, trav->xlator,
-                trav->xlator->fops->mknod, &local->loc,
-                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
-                0, xdata);
-        }
-        if (IA_ISDIR(local->stbuf.ia_type)) {
-            STACK_WIND(
-                rframe, stripe_sh_make_entry_cbk, trav->xlator,
-                trav->xlator->fops->mkdir, &local->loc,
-                st_mode_from_ia(local->stbuf.ia_prot, local->stbuf.ia_type), 0,
-                xdata);
-        }
-        trav = trav->next;
-    }
-
-    if (xdata)
-        dict_unref(xdata);
-    return 0;
-
-out:
-    if (rframe)
-        STRIPE_STACK_DESTROY(rframe);
-
-    return 0;
-}
-
-int32_t
-stripe_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, dict_t *xdata, struct iatt *postparent)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-    int ret = 0;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            if ((op_errno != ENOENT) && (op_errno != ESTALE))
-                gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                       prev->this->name, strerror(op_errno));
-            if (local->op_errno != ESTALE)
-                local->op_errno = op_errno;
-            if (((op_errno != ENOENT) && (op_errno != ENOTCONN) &&
-                 (op_errno != ESTALE)) ||
-                (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-            if (op_errno == ENOENT)
-                local->entry_self_heal_needed = 1;
-        }
-
-        if (op_ret >= 0) {
-            local->op_ret = 0;
-            if (IA_ISREG(buf->ia_type)) {
-                ret = stripe_ctx_handle(this, prev, local, xdata);
-                if (ret)
-                    gf_log(this->name, GF_LOG_ERROR,
-                           "Error getting fctx info from"
-                           " dict");
-            }
-
-            if (FIRST_CHILD(this) == prev->this) {
-                local->stbuf = *buf;
-                local->postparent = *postparent;
-                local->inode = inode_ref(inode);
-                if (xdata)
-                    local->xdata = dict_ref(xdata);
-                if (local->xattr) {
-                    stripe_aggregate_xattr(local->xdata, local->xattr);
-                    dict_unref(local->xattr);
-                    local->xattr = NULL;
-                }
-            }
-
-            if (!local->xdata && !local->xattr) {
-                local->xattr = dict_ref(xdata);
-            } else if (local->xdata) {
-                stripe_aggregate_xattr(local->xdata, xdata);
-            } else if (local->xattr) {
-                stripe_aggregate_xattr(local->xattr, xdata);
-            }
-
-            local->stbuf_blocks += buf->ia_blocks;
-            local->postparent_blocks += postparent->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-            if (local->postparent_size < postparent->ia_size)
-                local->postparent_size = postparent->ia_size;
-
-            if (gf_uuid_is_null(local->ia_gfid))
-                gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
-
-            /* Make sure the gfid on all the nodes are same */
-            if (gf_uuid_compare(local->ia_gfid, buf->ia_gfid)) {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "%s: gfid different on subvolume %s", local->loc.path,
-                       prev->this->name);
-            }
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->op_ret == 0 && local->entry_self_heal_needed &&
-            !gf_uuid_is_null(local->loc.inode->gfid))
-            stripe_entry_self_heal(frame, this, local);
-
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-            local->stbuf.ia_size = local->stbuf_size;
-            local->postparent.ia_blocks = local->postparent_blocks;
-            local->postparent.ia_size = local->postparent_size;
-            inode_ctx_put(local->inode, this, (uint64_t)(long)local->fctx);
-        }
-
-        STRIPE_STACK_UNWIND(lookup, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, local->xdata,
-                            &local->postparent);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-    int64_t filesize = 0;
-    int ret = 0;
-    uint64_t tmpctx = 0;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    loc_copy(&local->loc, loc);
-
-    inode_ctx_get(local->inode, this, &tmpctx);
-    if (tmpctx)
-        local->fctx = (stripe_fd_ctx_t *)(long)tmpctx;
-
-    /* quick-read friendly changes */
-    if (xdata && dict_get(xdata, GF_CONTENT_KEY)) {
-        ret = dict_get_int64(xdata, GF_CONTENT_KEY, &filesize);
-        if (!ret && (filesize > priv->block_size))
-            dict_del(xdata, GF_CONTENT_KEY);
-    }
-
-    /* get stripe-size xattr on lookup. This would be required for
-     * open/read/write/pathinfo calls. Hence we send down the request
-     * even when type == IA_INVAL */
-
-    /*
-     * We aren't guaranteed to have xdata here. We need the format info for
-     * the file, so allocate xdata if necessary.
-     */
-    if (!xdata)
-        xdata = dict_new();
-    else
-        xdata = dict_ref(xdata);
-
-    if (xdata &&
-        (IA_ISREG(loc->inode->ia_type) || (loc->inode->ia_type == IA_INVAL))) {
-        ret = stripe_xattr_request_build(this, xdata, 8, 4, 4, 0);
-        if (ret)
-            gf_log(this->name, GF_LOG_ERROR,
-                   "Failed to build"
-                   " xattr request for %s",
-                   loc->path);
-    }
-
-    /* Every time in stripe lookup, all child nodes
-       should be looked up */
-    local->call_count = priv->child_count;
-    while (trav) {
-        STACK_WIND(frame, stripe_lookup_cbk, trav->xlator,
-                   trav->xlator->fops->lookup, loc, xdata);
-        trav = trav->next;
-    }
-
-    dict_unref(xdata);
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret == 0) {
-            local->op_ret = 0;
-
-            if (FIRST_CHILD(this) == prev->this) {
-                local->stbuf = *buf;
-            }
-
-            local->stbuf_blocks += buf->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-        }
-
-        STRIPE_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
-                            &local->stbuf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    if (IA_ISREG(loc->inode->ia_type)) {
-        inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
-        if (!fctx)
-            goto err;
-        local->fctx = fctx;
-    }
-
-    while (trav) {
-        STACK_WIND(frame, stripe_stat_cbk, trav->xlator,
-                   trav->xlator->fops->stat, loc, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-
-err:
-    STRIPE_STACK_UNWIND(stat, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct statvfs *stbuf,
-                  dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    int32_t callcnt = 0;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret && (op_errno != ENOTCONN)) {
-            local->op_errno = op_errno;
-        }
-        if (op_ret == 0) {
-            struct statvfs *dict_buf = &local->statvfs_buf;
-            dict_buf->f_bsize = stbuf->f_bsize;
-            dict_buf->f_frsize = stbuf->f_frsize;
-            dict_buf->f_blocks += stbuf->f_blocks;
-            dict_buf->f_bfree += stbuf->f_bfree;
-            dict_buf->f_bavail += stbuf->f_bavail;
-            dict_buf->f_files += stbuf->f_files;
-            dict_buf->f_ffree += stbuf->f_ffree;
-            dict_buf->f_favail += stbuf->f_favail;
-            dict_buf->f_fsid = stbuf->f_fsid;
-            dict_buf->f_flag = stbuf->f_flag;
-            dict_buf->f_namemax = stbuf->f_namemax;
-            local->op_ret = 0;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        STRIPE_STACK_UNWIND(statfs, frame, local->op_ret, local->op_errno,
-                            &local->statvfs_buf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-
-    trav = this->children;
-    priv = this->private;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    local->op_errno = ENOTCONN;
-    frame->local = local;
-
-    local->call_count = priv->child_count;
-    while (trav) {
-        STACK_WIND(frame, stripe_statfs_cbk, trav->xlator,
-                   trav->xlator->fops->statfs, loc, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret == 0) {
-            local->op_ret = 0;
-            if (FIRST_CHILD(this) == prev->this) {
-                local->pre_buf = *prebuf;
-                local->post_buf = *postbuf;
-            }
-
-            local->prebuf_blocks += prebuf->ia_blocks;
-            local->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, local->fctx, prev);
-            correct_file_size(postbuf, local->fctx, prev);
-
-            if (local->prebuf_size < prebuf->ia_size)
-                local->prebuf_size = prebuf->ia_size;
-
-            if (local->postbuf_size < postbuf->ia_size)
-                local->postbuf_size = postbuf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->pre_buf.ia_blocks = local->prebuf_blocks;
-            local->pre_buf.ia_size = local->prebuf_size;
-            local->post_buf.ia_blocks = local->postbuf_blocks;
-            local->post_buf.ia_size = local->postbuf_size;
-        }
-
-        STRIPE_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
-                            &local->pre_buf, &local->post_buf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-                dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = EINVAL;
-    int i, eof_idx;
-    off_t dest_offset, tmp_offset;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
-    if (!fctx) {
-        gf_log(this->name, GF_LOG_ERROR, "no stripe context");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    local->fctx = fctx;
-    eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
-
-    for (i = 0; i < fctx->stripe_count; i++) {
-        if (!fctx->xl_array[i]) {
-            gf_log(this->name, GF_LOG_ERROR, "no xlator at index %d", i);
-            op_errno = EINVAL;
-            goto err;
-        }
-
-        if (fctx->stripe_coalesce) {
-            /*
-             * The node that owns EOF is truncated to the exact
-             * coalesced offset. Nodes prior to this index should
-             * be rounded up to the size of the complete stripe,
-             * while nodes after this index should be rounded down
-             * to the size of the previous stripe.
-             */
-            if (i < eof_idx)
-                tmp_offset = gf_roof(offset,
-                                     fctx->stripe_size * fctx->stripe_count);
-            else if (i > eof_idx)
-                tmp_offset = gf_floor(offset,
-                                      fctx->stripe_size * fctx->stripe_count);
-            else
-                tmp_offset = offset;
-
-            dest_offset = coalesced_offset(tmp_offset, fctx->stripe_size,
-                                           fctx->stripe_count);
-        } else {
-            dest_offset = offset;
-        }
-
-        STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
-                   fctx->xl_array[i]->fops->truncate, loc, dest_offset, NULL);
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *preop,
-                   struct iatt *postop, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret == 0) {
-            local->op_ret = 0;
-
-            if (FIRST_CHILD(this) == prev->this) {
-                local->pre_buf = *preop;
-                local->post_buf = *postop;
-            }
-
-            local->prebuf_blocks += preop->ia_blocks;
-            local->postbuf_blocks += postop->ia_blocks;
-
-            correct_file_size(preop, local->fctx, prev);
-            correct_file_size(postop, local->fctx, prev);
-
-            if (local->prebuf_size < preop->ia_size)
-                local->prebuf_size = preop->ia_size;
-            if (local->postbuf_size < postop->ia_size)
-                local->postbuf_size = postop->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->pre_buf.ia_blocks = local->prebuf_blocks;
-            local->pre_buf.ia_size = local->prebuf_size;
-            local->post_buf.ia_blocks = local->postbuf_blocks;
-            local->post_buf.ia_size = local->postbuf_size;
-        }
-
-        STRIPE_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
-                            &local->pre_buf, &local->post_buf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-               struct iatt *stbuf, int32_t valid, dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    if (!IA_ISDIR(loc->inode->ia_type) && !IA_ISREG(loc->inode->ia_type)) {
-        local->call_count = 1;
-        STACK_WIND(frame, stripe_setattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, NULL);
-        return 0;
-    }
-
-    if (IA_ISREG(loc->inode->ia_type)) {
-        inode_ctx_get(loc->inode, this, (uint64_t *)&fctx);
-        if (!fctx)
-            goto err;
-        local->fctx = fctx;
-    }
-
-    local->call_count = priv->child_count;
-    while (trav) {
-        STACK_WIND(frame, stripe_setattr_cbk, trav->xlator,
-                   trav->xlator->fops->setattr, loc, stbuf, valid, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(setattr, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                struct iatt *stbuf, int32_t valid, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_setattr_cbk, trav->xlator,
-                   trav->xlator->fops->fsetattr, fd, stbuf, valid, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fsetattr, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_stack_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                        struct iatt *preoldparent, struct iatt *postoldparent,
-                        struct iatt *prenewparent, struct iatt *postnewparent,
-                        dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret == 0) {
-            local->op_ret = 0;
-
-            local->stbuf.ia_blocks += buf->ia_blocks;
-            local->preparent.ia_blocks += preoldparent->ia_blocks;
-            local->postparent.ia_blocks += postoldparent->ia_blocks;
-            local->pre_buf.ia_blocks += prenewparent->ia_blocks;
-            local->post_buf.ia_blocks += postnewparent->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf.ia_size < buf->ia_size)
-                local->stbuf.ia_size = buf->ia_size;
-
-            if (local->preparent.ia_size < preoldparent->ia_size)
-                local->preparent.ia_size = preoldparent->ia_size;
-
-            if (local->postparent.ia_size < postoldparent->ia_size)
-                local->postparent.ia_size = postoldparent->ia_size;
-
-            if (local->pre_buf.ia_size < prenewparent->ia_size)
-                local->pre_buf.ia_size = prenewparent->ia_size;
-
-            if (local->post_buf.ia_size < postnewparent->ia_size)
-                local->post_buf.ia_size = postnewparent->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        STRIPE_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
-                            &local->stbuf, &local->preparent,
-                            &local->postparent, &local->pre_buf,
-                            &local->post_buf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_first_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                        struct iatt *preoldparent, struct iatt *postoldparent,
-                        struct iatt *prenewparent, struct iatt *postnewparent,
-                        dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        op_errno = EINVAL;
-        goto unwind;
-    }
-
-    if (op_ret == -1) {
-        goto unwind;
-    }
-
-    local = frame->local;
-    trav = this->children;
-
-    local->stbuf = *buf;
-    local->preparent = *preoldparent;
-    local->postparent = *postoldparent;
-    local->pre_buf = *prenewparent;
-    local->post_buf = *postnewparent;
-
-    local->op_ret = 0;
-    local->call_count--;
-
-    trav = trav->next; /* Skip first child */
-    while (trav) {
-        STACK_WIND(frame, stripe_stack_rename_cbk, trav->xlator,
-                   trav->xlator->fops->rename, &local->loc, &local->loc2, NULL);
-        trav = trav->next;
-    }
-    return 0;
-
-unwind:
-    STRIPE_STACK_UNWIND(rename, frame, -1, op_errno, buf, preoldparent,
-                        postoldparent, prenewparent, postnewparent, NULL);
-    return 0;
-}
-
-int32_t
-stripe_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-              dict_t *xdata)
-{
-    stripe_private_t *priv = NULL;
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(oldloc, err);
-    VALIDATE_OR_GOTO(oldloc->path, err);
-    VALIDATE_OR_GOTO(oldloc->inode, err);
-    VALIDATE_OR_GOTO(newloc, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* If any one node is down, don't allow rename */
-    if (priv->nodes_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    frame->local = local;
-
-    local->op_ret = -1;
-    loc_copy(&local->loc, oldloc);
-    loc_copy(&local->loc2, newloc);
-
-    local->call_count = priv->child_count;
-
-    if (IA_ISREG(oldloc->inode->ia_type)) {
-        inode_ctx_get(oldloc->inode, this, (uint64_t *)&fctx);
-        if (!fctx)
-            goto err;
-        local->fctx = fctx;
-    }
-
-    STACK_WIND(frame, stripe_first_rename_cbk, trav->xlator,
-               trav->xlator->fops->rename, oldloc, newloc, NULL);
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL, NULL);
-    return 0;
-}
-int32_t
-stripe_first_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno,
-                        struct iatt *preparent, struct iatt *postparent,
-                        dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    if (op_ret == -1) {
-        gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-               strerror(op_errno));
-        goto out;
-    }
-    local->op_ret = 0;
-    local->preparent = *preparent;
-    local->postparent = *postparent;
-    local->preparent_blocks += preparent->ia_blocks;
-    local->postparent_blocks += postparent->ia_blocks;
-
-    STRIPE_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                        &local->preparent, &local->postparent, xdata);
-    return 0;
-out:
-    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-
-    return 0;
-}
-
-int32_t
-stripe_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-                   strerror(op_errno));
-            local->op_errno = op_errno;
-            if (op_errno != ENOENT) {
-                local->failed = 1;
-                local->op_ret = op_ret;
-            }
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (callcnt == 1) {
-        if (local->failed) {
-            op_errno = local->op_errno;
-            goto out;
-        }
-        STACK_WIND(frame, stripe_first_unlink_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
-                   local->xdata);
-    }
-    return 0;
-out:
-    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-
-    return 0;
-}
-
-int32_t
-stripe_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-              dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Don't unlink a file if a node is down */
-    if (priv->nodes_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    loc_copy(&local->loc, loc);
-    local->xflag = xflag;
-
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    frame->local = local;
-    local->call_count = priv->child_count;
-    trav = trav->next; /* Skip the first child */
-
-    while (trav) {
-        STACK_WIND(frame, stripe_unlink_cbk, trav->xlator,
-                   trav->xlator->fops->unlink, loc, xflag, xdata);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_first_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    if (op_ret == -1) {
-        goto err;
-    }
-
-    local = frame->local;
-    local->op_ret = 0;
-
-    local->call_count--; /* First child successful */
-
-    local->preparent = *preparent;
-    local->postparent = *postparent;
-    local->preparent_size = preparent->ia_size;
-    local->postparent_size = postparent->ia_size;
-    local->preparent_blocks += preparent->ia_blocks;
-    local->postparent_blocks += postparent->ia_blocks;
-
-    STRIPE_STACK_UNWIND(rmdir, frame, local->op_ret, local->op_errno,
-                        &local->preparent, &local->postparent, xdata);
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(rmdir, frame, op_ret, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-                   strerror(op_errno));
-            if (op_errno != ENOENT)
-                local->failed = 1;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (callcnt == 1) {
-        if (local->failed)
-            goto out;
-        STACK_WIND(frame, stripe_first_rmdir_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->rmdir, &local->loc, local->flags,
-                   NULL);
-    }
-    return 0;
-out:
-    STRIPE_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-             dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* don't delete a directory if any of the subvolume is down */
-    if (priv->nodes_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    loc_copy(&local->loc, loc);
-    local->flags = flags;
-    local->call_count = priv->child_count;
-    trav = trav->next; /* skip the first child */
-
-    while (trav) {
-        STACK_WIND(frame, stripe_rmdir_cbk, trav->xlator,
-                   trav->xlator->fops->rmdir, loc, flags, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(rmdir, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_mknod_ifreg_fail_unlink_cbk(call_frame_t *frame, void *cookie,
-                                   xlator_t *this, int32_t op_ret,
-                                   int32_t op_errno, struct iatt *preparent,
-                                   struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, &local->preparent,
-                            &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-/**
- */
-int32_t
-stripe_mknod_ifreg_setxattr_cbk(call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,
-                                int32_t op_errno, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    priv = this->private;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_ret = -1;
-            local->op_errno = op_errno;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->op_ret == -1) {
-            local->call_count = priv->child_count;
-            while (trav) {
-                STACK_WIND(frame, stripe_mknod_ifreg_fail_unlink_cbk,
-                           trav->xlator, trav->xlator->fops->unlink,
-                           &local->loc, 0, NULL);
-                trav = trav->next;
-            }
-            return 0;
-        }
-
-        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, &local->preparent,
-                            &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_mknod_ifreg_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, inode_t *inode,
-                       struct iatt *buf, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    call_frame_t *prev = NULL;
-    xlator_list_t *trav = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    priv = this->private;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-            local->op_errno = op_errno;
-        }
-        if (op_ret >= 0) {
-            local->op_ret = op_ret;
-
-            /* Can be used as a mechanism to understand if mknod
-               was successful in at least one place */
-            if (gf_uuid_is_null(local->ia_gfid))
-                gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
-
-            if (stripe_ctx_handle(this, prev, local, xdata))
-                gf_log(this->name, GF_LOG_ERROR,
-                       "Error getting fctx info from dict");
-
-            local->stbuf_blocks += buf->ia_blocks;
-            local->preparent_blocks += preparent->ia_blocks;
-            local->postparent_blocks += postparent->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-            if (local->preparent_size < preparent->ia_size)
-                local->preparent_size = preparent->ia_size;
-            if (local->postparent_size < postparent->ia_size)
-                local->postparent_size = postparent->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if ((local->op_ret == -1) && !gf_uuid_is_null(local->ia_gfid)) {
-            /* ia_gfid set means, at least on one node 'mknod'
-               is successful */
-            local->call_count = priv->child_count;
-            trav = this->children;
-            while (trav) {
-                STACK_WIND(frame, stripe_mknod_ifreg_fail_unlink_cbk,
-                           trav->xlator, trav->xlator->fops->unlink,
-                           &local->loc, 0, NULL);
-                trav = trav->next;
-            }
-            return 0;
-        }
-
-        if (local->op_ret != -1) {
-            local->preparent.ia_blocks = local->preparent_blocks;
-            local->preparent.ia_size = local->preparent_size;
-            local->postparent.ia_blocks = local->postparent_blocks;
-            local->postparent.ia_size = local->postparent_size;
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-            inode_ctx_put(local->inode, this, (uint64_t)(long)local->fctx);
-        }
-        STRIPE_STACK_UNWIND(mknod, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, &local->preparent,
-                            &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_mknod_first_ifreg_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, inode_t *inode,
-                             struct iatt *buf, struct iatt *preparent,
-                             struct iatt *postparent, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    call_frame_t *prev = NULL;
-    xlator_list_t *trav = NULL;
-    int i = 1;
-    dict_t *dict = NULL;
-    int ret = 0;
-    int need_unref = 0;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    priv = this->private;
-    local = frame->local;
-    trav = this->children;
-
-    local->call_count--;
-
-    if (op_ret == -1) {
-        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-               prev->this->name, strerror(op_errno));
-        local->failed = 1;
-        local->op_errno = op_errno;
-        goto out;
-    }
-
-    local->op_ret = op_ret;
-
-    local->stbuf = *buf;
-    local->preparent = *preparent;
-    local->postparent = *postparent;
-
-    if (gf_uuid_is_null(local->ia_gfid))
-        gf_uuid_copy(local->ia_gfid, buf->ia_gfid);
-    local->preparent.ia_blocks = local->preparent_blocks;
-    local->preparent.ia_size = local->preparent_size;
-    local->postparent.ia_blocks = local->postparent_blocks;
-    local->postparent.ia_size = local->postparent_size;
-    local->stbuf.ia_size = local->stbuf_size;
-    local->stbuf.ia_blocks = local->stbuf_blocks;
-
-    trav = trav->next;
-    while (trav) {
-        if (priv->xattr_supported) {
-            dict = dict_new();
-            if (!dict) {
-                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
-                       local->loc.path);
-            }
-            need_unref = 1;
-
-            dict_copy(local->xattr, dict);
-
-            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
-                                             priv->child_count, i,
-                                             priv->coalesce);
-            if (ret)
-                gf_log(this->name, GF_LOG_ERROR,
-                       "Failed to build xattr request");
-
-        } else {
-            dict = local->xattr;
-        }
-
-        STACK_WIND(frame, stripe_mknod_ifreg_cbk, trav->xlator,
-                   trav->xlator->fops->mknod, &local->loc, local->mode,
-                   local->rdev, 0, dict);
-        trav = trav->next;
-        i++;
-
-        if (dict && need_unref)
-            dict_unref(dict);
-    }
-
-    return 0;
-
-out:
-
-    STRIPE_STACK_UNWIND(mknod, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
-                        NULL);
-    return 0;
-}
-
-int32_t
-stripe_single_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, inode_t *inode,
-                        struct iatt *buf, struct iatt *preparent,
-                        struct iatt *postparent, dict_t *xdata)
-{
-    STRIPE_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int
-stripe_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-             dev_t rdev, mode_t umask, dict_t *xdata)
-{
-    stripe_private_t *priv = NULL;
-    stripe_local_t *local = NULL;
-    int32_t op_errno = EINVAL;
-    int32_t i = 0;
-    dict_t *dict = NULL;
-    int ret = 0;
-    int need_unref = 0;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    if (S_ISREG(mode)) {
-        /* NOTE: on older kernels (older than 2.6.9),
-           creat() fops is sent as mknod() + open(). Hence handling
-           S_IFREG files is necessary */
-        if (priv->nodes_down) {
-            gf_log(this->name, GF_LOG_WARNING, "Some node down, returning EIO");
-            op_errno = EIO;
-            goto err;
-        }
-
-        /* Initialization */
-        local = mem_get0(this->local_pool);
-        if (!local) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        local->op_ret = -1;
-        local->op_errno = ENOTCONN;
-        local->stripe_size = stripe_get_matching_bs(loc->path, priv);
-        frame->local = local;
-        local->inode = inode_ref(loc->inode);
-        loc_copy(&local->loc, loc);
-        local->xattr = dict_copy_with_ref(xdata, NULL);
-        local->mode = mode;
-        local->umask = umask;
-        local->rdev = rdev;
-
-        /* Every time in stripe lookup, all child nodes should
-           be looked up */
-        local->call_count = priv->child_count;
-
-        if (priv->xattr_supported) {
-            dict = dict_new();
-            if (!dict) {
-                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
-                       loc->path);
-            }
-            need_unref = 1;
-
-            dict_copy(xdata, dict);
-
-            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
-                                             priv->child_count, i,
-                                             priv->coalesce);
-            if (ret)
-                gf_log(this->name, GF_LOG_ERROR,
-                       "failed to build xattr request");
-        } else {
-            dict = xdata;
-        }
-
-        STACK_WIND(frame, stripe_mknod_first_ifreg_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask,
-                   dict);
-
-        if (dict && need_unref)
-            dict_unref(dict);
-        return 0;
-    }
-
-    STACK_WIND(frame, stripe_single_mknod_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata);
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL);
-    return 0;
-}
-
-int32_t
-stripe_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret >= 0) {
-            local->op_ret = 0;
-
-            local->stbuf_blocks += buf->ia_blocks;
-            local->preparent_blocks += preparent->ia_blocks;
-            local->postparent_blocks += postparent->ia_blocks;
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-            if (local->preparent_size < preparent->ia_size)
-                local->preparent_size = preparent->ia_size;
-            if (local->postparent_size < postparent->ia_size)
-                local->postparent_size = postparent->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed != -1) {
-            local->preparent.ia_blocks = local->preparent_blocks;
-            local->preparent.ia_size = local->preparent_size;
-            local->postparent.ia_blocks = local->postparent_blocks;
-            local->postparent.ia_size = local->postparent_size;
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-        }
-        STRIPE_STACK_UNWIND(mkdir, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, &local->preparent,
-                            &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_first_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, inode_t *inode,
-                       struct iatt *buf, struct iatt *preparent,
-                       struct iatt *postparent, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-    xlator_list_t *trav = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-    trav = this->children;
-
-    local->call_count--; /* first child is successful */
-    trav = trav->next;   /* skip first child */
-
-    if (op_ret == -1) {
-        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-               prev->this->name, strerror(op_errno));
-        local->op_errno = op_errno;
-        goto out;
-    }
-
-    local->op_ret = 0;
-
-    local->inode = inode_ref(inode);
-    local->stbuf = *buf;
-    local->postparent = *postparent;
-    local->preparent = *preparent;
-
-    local->stbuf_blocks += buf->ia_blocks;
-    local->preparent_blocks += preparent->ia_blocks;
-    local->postparent_blocks += postparent->ia_blocks;
-
-    local->stbuf_size = buf->ia_size;
-    local->preparent_size = preparent->ia_size;
-    local->postparent_size = postparent->ia_size;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_mkdir_cbk, trav->xlator,
-                   trav->xlator->fops->mkdir, &local->loc, local->mode,
-                   local->umask, local->xdata);
-        trav = trav->next;
-    }
-    return 0;
-out:
-    STRIPE_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL);
-
-    return 0;
-}
-
-int
-stripe_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-             mode_t umask, dict_t *xdata)
-{
-    stripe_private_t *priv = NULL;
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    local->call_count = priv->child_count;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    local->mode = mode;
-    local->umask = umask;
-    loc_copy(&local->loc, loc);
-    frame->local = local;
-
-    /* Every time in stripe lookup, all child nodes should be looked up */
-    STACK_WIND(frame, stripe_first_mkdir_cbk, trav->xlator,
-               trav->xlator->fops->mkdir, loc, mode, umask, xdata);
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL);
-    return 0;
-}
-
-int32_t
-stripe_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, inode_t *inode,
-                struct iatt *buf, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret >= 0) {
-            local->op_ret = 0;
-
-            if (IA_ISREG(inode->ia_type)) {
-                inode_ctx_get(inode, this, (uint64_t *)&fctx);
-                if (!fctx) {
-                    gf_log(this->name, GF_LOG_ERROR,
-                           "failed to get stripe context");
-                    op_ret = -1;
-                    op_errno = EINVAL;
-                }
-            }
-
-            if (FIRST_CHILD(this) == prev->this) {
-                local->inode = inode_ref(inode);
-                local->stbuf = *buf;
-                local->postparent = *postparent;
-                local->preparent = *preparent;
-            }
-            local->stbuf_blocks += buf->ia_blocks;
-            local->preparent_blocks += preparent->ia_blocks;
-            local->postparent_blocks += postparent->ia_blocks;
-
-            correct_file_size(buf, fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-            if (local->preparent_size < preparent->ia_size)
-                local->preparent_size = preparent->ia_size;
-            if (local->postparent_size < postparent->ia_size)
-                local->postparent_size = postparent->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->preparent.ia_blocks = local->preparent_blocks;
-            local->preparent.ia_size = local->preparent_size;
-            local->postparent.ia_blocks = local->postparent_blocks;
-            local->postparent.ia_size = local->postparent_size;
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-        }
-        STRIPE_STACK_UNWIND(link, frame, local->op_ret, local->op_errno,
-                            local->inode, &local->stbuf, &local->preparent,
-                            &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-            dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(oldloc, err);
-    VALIDATE_OR_GOTO(oldloc->path, err);
-    VALIDATE_OR_GOTO(oldloc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* If any one node is down, don't allow link operation */
-    if (priv->nodes_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    /* Every time in stripe lookup, all child
-       nodes should be looked up */
-    while (trav) {
-        STACK_WIND(frame, stripe_link_cbk, trav->xlator,
-                   trav->xlator->fops->link, oldloc, newloc, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL);
-    return 0;
-}
-
-int32_t
-stripe_create_fail_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno,
-                              struct iatt *preparent, struct iatt *postparent,
-                              dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        STRIPE_STACK_UNWIND(create, frame, local->op_ret, local->op_errno,
-                            local->fd, local->inode, &local->stbuf,
-                            &local->preparent, &local->postparent, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    call_frame_t *prev = NULL;
-    xlator_list_t *trav = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    priv = this->private;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->failed = 1;
-            local->op_errno = op_errno;
-        }
-
-        if (op_ret >= 0) {
-            if (IA_ISREG(buf->ia_type)) {
-                if (stripe_ctx_handle(this, prev, local, xdata))
-                    gf_log(this->name, GF_LOG_ERROR,
-                           "Error getting fctx info from "
-                           "dict");
-            }
-
-            local->op_ret = op_ret;
-
-            local->stbuf_blocks += buf->ia_blocks;
-            local->preparent_blocks += preparent->ia_blocks;
-            local->postparent_blocks += postparent->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-            if (local->preparent_size < preparent->ia_size)
-                local->preparent_size = preparent->ia_size;
-            if (local->postparent_size < postparent->ia_size)
-                local->postparent_size = postparent->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret == -1) {
-            local->call_count = priv->child_count;
-            trav = this->children;
-            while (trav) {
-                STACK_WIND(frame, stripe_create_fail_unlink_cbk, trav->xlator,
-                           trav->xlator->fops->unlink, &local->loc, 0, NULL);
-                trav = trav->next;
-            }
-
-            return 0;
-        }
-
-        if (local->op_ret >= 0) {
-            local->preparent.ia_blocks = local->preparent_blocks;
-            local->preparent.ia_size = local->preparent_size;
-            local->postparent.ia_blocks = local->postparent_blocks;
-            local->postparent.ia_size = local->postparent_size;
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-
-            stripe_copy_xl_array(local->fctx->xl_array, priv->xl_array,
-                                 local->fctx->stripe_count);
-            inode_ctx_put(local->inode, this, (uint64_t)(uintptr_t)local->fctx);
-        }
-
-        /* Create itself has failed.. so return
-           without setxattring */
-        STRIPE_STACK_UNWIND(create, frame, local->op_ret, local->op_errno,
-                            local->fd, local->inode, &local->stbuf,
-                            &local->preparent, &local->postparent, NULL);
-    }
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_first_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, fd_t *fd,
-                        inode_t *inode, struct iatt *buf,
-                        struct iatt *preparent, struct iatt *postparent,
-                        dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    call_frame_t *prev = NULL;
-    xlator_list_t *trav = NULL;
-    int i = 1;
-    dict_t *dict = NULL;
-    loc_t *loc = NULL;
-    int32_t need_unref = 0;
-    int32_t ret = -1;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    priv = this->private;
-    local = frame->local;
-    trav = this->children;
-    loc = &local->loc;
-
-    --local->call_count;
-
-    if (op_ret == -1) {
-        gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-               prev->this->name, strerror(op_errno));
-        local->failed = 1;
-        local->op_errno = op_errno;
-    }
-
-    local->op_ret = 0;
-    /* Get the mapping in inode private */
-    /* Get the stat buf right */
-    local->stbuf = *buf;
-    local->preparent = *preparent;
-    local->postparent = *postparent;
-
-    local->stbuf_blocks += buf->ia_blocks;
-    local->preparent_blocks += preparent->ia_blocks;
-    local->postparent_blocks += postparent->ia_blocks;
-
-    if (local->stbuf_size < buf->ia_size)
-        local->stbuf_size = buf->ia_size;
-    if (local->preparent_size < preparent->ia_size)
-        local->preparent_size = preparent->ia_size;
-    if (local->postparent_size < postparent->ia_size)
-        local->postparent_size = postparent->ia_size;
-
-    if (local->failed)
-        local->op_ret = -1;
-
-    if (local->op_ret == -1) {
-        local->call_count = 1;
-        STACK_WIND(frame, stripe_create_fail_unlink_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
-        return 0;
-    }
-
-    if (local->op_ret >= 0) {
-        local->preparent.ia_blocks = local->preparent_blocks;
-        local->preparent.ia_size = local->preparent_size;
-        local->postparent.ia_blocks = local->postparent_blocks;
-        local->postparent.ia_size = local->postparent_size;
-        local->stbuf.ia_size = local->stbuf_size;
-        local->stbuf.ia_blocks = local->stbuf_blocks;
-    }
-
-    /* Send a setxattr request to nodes where the
-       files are created */
-    trav = trav->next;
-    while (trav) {
-        if (priv->xattr_supported) {
-            dict = dict_new();
-            if (!dict) {
-                gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
-                       loc->path);
-            }
-            need_unref = 1;
-
-            dict_copy(local->xattr, dict);
-
-            ret = stripe_xattr_request_build(this, dict, local->stripe_size,
-                                             priv->child_count, i,
-                                             priv->coalesce);
-            if (ret)
-                gf_log(this->name, GF_LOG_ERROR,
-                       "failed to build xattr request");
-        } else {
-            dict = local->xattr;
-        }
-
-        STACK_WIND(frame, stripe_create_cbk, trav->xlator,
-                   trav->xlator->fops->create, &local->loc, local->flags,
-                   local->mode, local->umask, local->fd, dict);
-        trav = trav->next;
-        if (need_unref && dict)
-            dict_unref(dict);
-        i++;
-    }
-
-out:
-    return 0;
-}
-
-/**
- * stripe_create - If a block-size is specified for the 'name', create the
- *    file in all the child nodes. If not, create it in only first child.
- *
- * @name- complete path of the file to be created.
- */
-int32_t
-stripe_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-              mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
-{
-    stripe_private_t *priv = NULL;
-    stripe_local_t *local = NULL;
-    int32_t op_errno = EINVAL;
-    int ret = 0;
-    int need_unref = 0;
-    int i = 0;
-    dict_t *dict = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-
-    /* files created in O_APPEND mode does not allow lseek() on fd */
-    flags &= ~O_APPEND;
-
-    if (priv->first_child_down || priv->nodes_down) {
-        gf_log(this->name, GF_LOG_DEBUG, "First node down, returning EIO");
-        op_errno = EIO;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    local->op_errno = ENOTCONN;
-    local->stripe_size = stripe_get_matching_bs(loc->path, priv);
-    frame->local = local;
-    local->inode = inode_ref(loc->inode);
-    loc_copy(&local->loc, loc);
-    local->fd = fd_ref(fd);
-    local->flags = flags;
-    local->mode = mode;
-    local->umask = umask;
-    if (xdata)
-        local->xattr = dict_ref(xdata);
-
-    local->call_count = priv->child_count;
-    /* Send a setxattr request to nodes where the
-       files are created */
-
-    if (priv->xattr_supported) {
-        dict = dict_new();
-        if (!dict) {
-            gf_log(this->name, GF_LOG_ERROR, "failed to allocate dict %s",
-                   loc->path);
-        }
-        need_unref = 1;
-
-        dict_copy(xdata, dict);
-
-        ret = stripe_xattr_request_build(this, dict, local->stripe_size,
-                                         priv->child_count, i, priv->coalesce);
-        if (ret)
-            gf_log(this->name, GF_LOG_ERROR, "failed to build xattr request");
-    } else {
-        dict = xdata;
-    }
-
-    STACK_WIND(frame, stripe_first_create_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
-               dict);
-
-    if (need_unref && dict)
-        dict_unref(dict);
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL,
-                        NULL, xdata);
-    return 0;
-}
-
-int32_t
-stripe_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-            local->op_errno = op_errno;
-        }
-
-        if (op_ret >= 0)
-            local->op_ret = op_ret;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        STRIPE_STACK_UNWIND(open, frame, local->op_ret, local->op_errno,
-                            local->fd, xdata);
-    }
-out:
-    return 0;
-}
-
-/**
- * stripe_open -
- */
-int32_t
-stripe_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-            fd_t *fd, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    /* files opened in O_APPEND mode does not allow lseek() on fd */
-    flags &= ~O_APPEND;
-
-    local->fd = fd_ref(fd);
-    frame->local = local;
-    loc_copy(&local->loc, loc);
-
-    /* Striped files */
-    local->flags = flags;
-    local->call_count = priv->child_count;
-    local->stripe_size = stripe_get_matching_bs(loc->path, priv);
-
-    while (trav) {
-        STACK_WIND(frame, stripe_open_cbk, trav->xlator,
-                   trav->xlator->fops->open, &local->loc, local->flags,
-                   local->fd, xdata);
-        trav = trav->next;
-    }
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(open, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_ret = -1;
-            local->op_errno = op_errno;
-        }
-
-        if (op_ret >= 0)
-            local->op_ret = op_ret;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        STRIPE_STACK_UNWIND(opendir, frame, local->op_ret, local->op_errno,
-                            local->fd, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-               dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-    local->call_count = priv->child_count;
-    local->fd = fd_ref(fd);
-
-    while (trav) {
-        STACK_WIND(frame, stripe_opendir_cbk, trav->xlator,
-                   trav->xlator->fops->opendir, loc, fd, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(opendir, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-        if (op_ret >= 0) {
-            if (FIRST_CHILD(this) == prev->this) {
-                /* First successful call, copy the *lock */
-                local->op_ret = op_ret;
-                local->lock = *lock;
-            }
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-        STRIPE_STACK_UNWIND(lk, frame, local->op_ret, local->op_errno,
-                            &local->lock, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-          struct gf_flock *lock, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    trav = this->children;
-    priv = this->private;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_lk_cbk, trav->xlator, trav->xlator->fops->lk,
-                   fd, cmd, lock, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(lk, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-                   strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-        if (op_ret >= 0)
-            local->op_ret = op_ret;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        STRIPE_STACK_UNWIND(flush, frame, local->op_ret, local->op_errno, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_flush_cbk, trav->xlator,
-                   trav->xlator->fops->flush, fd, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(flush, frame, -1, op_errno, NULL);
-    return 0;
-}
-
-int32_t
-stripe_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                 struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-                   strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-        if (op_ret >= 0) {
-            local->op_ret = op_ret;
-            if (FIRST_CHILD(this) == prev->this) {
-                local->pre_buf = *prebuf;
-                local->post_buf = *postbuf;
-            }
-            local->prebuf_blocks += prebuf->ia_blocks;
-            local->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, local->fctx, prev);
-            correct_file_size(postbuf, local->fctx, prev);
-
-            if (local->prebuf_size < prebuf->ia_size)
-                local->prebuf_size = prebuf->ia_size;
-
-            if (local->postbuf_size < postbuf->ia_size)
-                local->postbuf_size = postbuf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->pre_buf.ia_blocks = local->prebuf_blocks;
-            local->pre_buf.ia_size = local->prebuf_size;
-            local->post_buf.ia_blocks = local->postbuf_blocks;
-            local->post_buf.ia_size = local->postbuf_size;
-        }
-
-        STRIPE_STACK_UNWIND(fsync, frame, local->op_ret, local->op_errno,
-                            &local->pre_buf, &local->post_buf, NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-             dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    frame->local = local;
-
-    inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
-    if (!fctx) {
-        op_errno = EINVAL;
-        goto err;
-    }
-    local->fctx = fctx;
-    local->op_ret = -1;
-    local->call_count = priv->child_count;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_fsync_cbk, trav->xlator,
-                   trav->xlator->fops->fsync, fd, flags, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fsync, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                 dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned error %s",
-                   prev->this->name, strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-
-        if (op_ret == 0) {
-            local->op_ret = 0;
-
-            if (FIRST_CHILD(this) == prev->this)
-                local->stbuf = *buf;
-
-            local->stbuf_blocks += buf->ia_blocks;
-
-            correct_file_size(buf, local->fctx, prev);
-
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        if (local->op_ret != -1) {
-            local->stbuf.ia_size = local->stbuf_size;
-            local->stbuf.ia_blocks = local->stbuf_blocks;
-        }
-
-        STRIPE_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno,
-                            &local->stbuf, NULL);
-    }
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    if (IA_ISREG(fd->inode->ia_type)) {
-        inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
-        if (!fctx)
-            goto err;
-        local->fctx = fctx;
-    }
-
-    while (trav) {
-        STACK_WIND(frame, stripe_fstat_cbk, trav->xlator,
-                   trav->xlator->fops->fstat, fd, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                 dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int i, eof_idx;
-    off_t dest_offset, tmp_offset;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    inode_ctx_get(fd->inode, this, (uint64_t *)&fctx);
-    if (!fctx) {
-        gf_log(this->name, GF_LOG_ERROR, "no stripe context");
-        op_errno = EINVAL;
-        goto err;
-    }
-    if (!fctx->stripe_count) {
-        gf_log(this->name, GF_LOG_ERROR, "no stripe count");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    local->fctx = fctx;
-    eof_idx = (offset / fctx->stripe_size) % fctx->stripe_count;
-
-    for (i = 0; i < fctx->stripe_count; i++) {
-        if (!fctx->xl_array[i]) {
-            gf_log(this->name, GF_LOG_ERROR,
-                   "no xlator at index "
-                   "%d",
-                   i);
-            op_errno = EINVAL;
-            goto err;
-        }
-
-        if (fctx->stripe_coalesce) {
-            if (i < eof_idx)
-                tmp_offset = gf_roof(offset,
-                                     fctx->stripe_size * fctx->stripe_count);
-            else if (i > eof_idx)
-                tmp_offset = gf_floor(offset,
-                                      fctx->stripe_size * fctx->stripe_count);
-            else
-                tmp_offset = offset;
-
-            dest_offset = coalesced_offset(tmp_offset, fctx->stripe_size,
-                                           fctx->stripe_count);
-        } else {
-            dest_offset = offset;
-        }
-
-        STACK_WIND(frame, stripe_truncate_cbk, fctx->xl_array[i],
-                   fctx->xl_array[i]->fops->ftruncate, fd, dest_offset, NULL);
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-
-        if (op_ret == -1) {
-            gf_log(this->name, GF_LOG_DEBUG, "%s returned %s", prev->this->name,
-                   strerror(op_errno));
-            local->op_errno = op_errno;
-            if ((op_errno != ENOENT) || (prev->this == FIRST_CHILD(this)))
-                local->failed = 1;
-        }
-        if (op_ret >= 0)
-            local->op_ret = op_ret;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (local->failed)
-            local->op_ret = -1;
-
-        STRIPE_STACK_UNWIND(fsyncdir, frame, local->op_ret, local->op_errno,
-                            NULL);
-    }
-out:
-    return 0;
-}
-
-int32_t
-stripe_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-                dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    int32_t op_errno = 1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    local->call_count = priv->child_count;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_fsyncdir_cbk, trav->xlator,
-                   trav->xlator->fops->fsyncdir, fd, flags, NULL);
-        trav = trav->next;
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fsyncdir, frame, -1, op_errno, NULL);
-    return 0;
-}
-
-int32_t
-stripe_readv_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                       dict_t *xdata)
-{
-    int32_t i = 0;
-    int32_t callcnt = 0;
-    int32_t count = 0;
-    stripe_local_t *local = NULL;
-    struct iovec *vec = NULL;
-    struct iatt tmp_stbuf = {
-        0,
-    };
-    struct iobref *tmp_iobref = NULL;
-    struct iobuf *iobuf = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    local = frame->local;
-    prev = cookie;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->call_count;
-        if (op_ret != -1) {
-            correct_file_size(buf, local->fctx, prev);
-            if (local->stbuf_size < buf->ia_size)
-                local->stbuf_size = buf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        op_ret = 0;
-
-        /* Keep extra space for filling in '\0's */
-        vec = GF_CALLOC((local->count * 2), sizeof(struct iovec),
-                        gf_stripe_mt_iovec);
-        if (!vec) {
-            op_ret = -1;
-            goto done;
-        }
-
-        for (i = 0; i < local->wind_count; i++) {
-            if (local->replies[i].op_ret) {
-                memcpy((vec + count), local->replies[i].vector,
-                       (local->replies[i].count * sizeof(struct iovec)));
-                count += local->replies[i].count;
-                op_ret += local->replies[i].op_ret;
-            }
-            if ((local->replies[i].op_ret < local->replies[i].requested_size) &&
-                (local->stbuf_size > (local->offset + op_ret))) {
-                /* Fill in 0s here */
-                vec[count].iov_len = (local->replies[i].requested_size -
-                                      local->replies[i].op_ret);
-                iobuf = iobuf_get2(this->ctx->iobuf_pool, vec[count].iov_len);
-                if (!iobuf) {
-                    gf_log(this->name, GF_LOG_ERROR, "Out of memory.");
-                    op_ret = -1;
-                    op_errno = ENOMEM;
-                    goto done;
-                }
-                memset(iobuf->ptr, 0, vec[count].iov_len);
-                vec[count].iov_base = iobuf->ptr;
-
-                iobref_add(local->iobref, iobuf);
-                iobuf_unref(iobuf);
-
-                op_ret += vec[count].iov_len;
-                count++;
-            }
-            GF_FREE(local->replies[i].vector);
-        }
-
-        /* ENOENT signals EOF to the NFS-server */
-        if (op_ret != -1 && op_ret < local->readv_size &&
-            (local->offset + op_ret == buf->ia_size))
-            op_errno = ENOENT;
-
-        /* FIXME: notice that st_ino, and st_dev (gen) will be
-         * different than what inode will have. Make sure this doesn't
-         * cause any bugs at higher levels */
-        memcpy(&tmp_stbuf, &local->replies[0].stbuf, sizeof(struct iatt));
-        tmp_stbuf.ia_size = local->stbuf_size;
-
-    done:
-        GF_FREE(local->replies);
-        tmp_iobref = local->iobref;
-        STRIPE_STACK_UNWIND(readv, frame, op_ret, op_errno, vec, count,
-                            &tmp_stbuf, tmp_iobref, NULL);
-
-        iobref_unref(tmp_iobref);
-        GF_FREE(vec);
-    }
-out:
-    return 0;
-}
-
-/**
- * stripe_readv_cbk - get all the striped reads, and order it properly, send it
- *        to above layer after putting it in a single vector.
- */
-int32_t
-stripe_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                 int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                 dict_t *xdata)
-{
-    int32_t index = 0;
-    int32_t callcnt = 0;
-    int32_t final_count = 0;
-    int32_t need_to_check_proper_size = 0;
-    call_frame_t *mframe = NULL;
-    stripe_local_t *mlocal = NULL;
-    stripe_local_t *local = NULL;
-    struct iovec *final_vec = NULL;
-    struct iatt tmp_stbuf = {
-        0,
-    };
-    struct iatt *tmp_stbuf_p = NULL;  // need it for a warning
-    struct iobref *tmp_iobref = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    call_frame_t *prev = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto end;
-    }
-
-    local = frame->local;
-    index = local->node_index;
-    prev = cookie;
-    mframe = local->orig_frame;
-    if (!mframe)
-        goto out;
-
-    mlocal = mframe->local;
-    if (!mlocal)
-        goto out;
-
-    fctx = mlocal->fctx;
-
-    LOCK(&mframe->lock);
-    {
-        mlocal->replies[index].op_ret = op_ret;
-        mlocal->replies[index].op_errno = op_errno;
-        mlocal->replies[index].requested_size = local->readv_size;
-        if (op_ret >= 0) {
-            mlocal->replies[index].stbuf = *stbuf;
-            mlocal->replies[index].count = count;
-            mlocal->replies[index].vector = iov_dup(vector, count);
-
-            correct_file_size(stbuf, fctx, prev);
-
-            if (local->stbuf_size < stbuf->ia_size)
-                local->stbuf_size = stbuf->ia_size;
-            local->stbuf_blocks += stbuf->ia_blocks;
-
-            if (!mlocal->iobref)
-                mlocal->iobref = iobref_new();
-            iobref_merge(mlocal->iobref, iobref);
-        }
-        callcnt = ++mlocal->call_count;
-    }
-    UNLOCK(&mframe->lock);
-
-    if (callcnt == mlocal->wind_count) {
-        op_ret = 0;
-
-        for (index = 0; index < mlocal->wind_count; index++) {
-            /* check whether each stripe returned
-             * 'expected' number of bytes */
-            if (mlocal->replies[index].op_ret == -1) {
-                op_ret = -1;
-                op_errno = mlocal->replies[index].op_errno;
-                break;
-            }
-            /* TODO: handle the 'holes' within the read range
-               properly */
-            if (mlocal->replies[index].op_ret <
-                mlocal->replies[index].requested_size) {
-                need_to_check_proper_size = 1;
-            }
-
-            op_ret += mlocal->replies[index].op_ret;
-            mlocal->count += mlocal->replies[index].count;
-        }
-        if (op_ret == -1)
-            goto done;
-        if (need_to_check_proper_size)
-            goto check_size;
-
-        final_vec = GF_CALLOC(mlocal->count, sizeof(struct iovec),
-                              gf_stripe_mt_iovec);
-
-        if (!final_vec) {
-            op_ret = -1;
-            goto done;
-        }
-
-        for (index = 0; index < mlocal->wind_count; index++) {
-            memcpy((final_vec + final_count), mlocal->replies[index].vector,
-                   (mlocal->replies[index].count * sizeof(struct iovec)));
-            final_count += mlocal->replies[index].count;
-            GF_FREE(mlocal->replies[index].vector);
-        }
-
-        /* FIXME: notice that st_ino, and st_dev (gen) will be
-         * different than what inode will have. Make sure this doesn't
-         * cause any bugs at higher levels */
-        memcpy(&tmp_stbuf, &mlocal->replies[0].stbuf, sizeof(struct iatt));
-        tmp_stbuf.ia_size = local->stbuf_size;
-        tmp_stbuf.ia_blocks = local->stbuf_blocks;
-
-    done:
-        /* */
-        GF_FREE(mlocal->replies);
-        tmp_iobref = mlocal->iobref;
-        /* work around for nfs truncated read. Bug 3774 */
-        tmp_stbuf_p = &tmp_stbuf;
-        WIPE(tmp_stbuf_p);
-        STRIPE_STACK_UNWIND(readv, mframe, op_ret, op_errno, final_vec,
-                            final_count, &tmp_stbuf, tmp_iobref, NULL);
-
-        iobref_unref(tmp_iobref);
-        GF_FREE(final_vec);
-    }
-
-    goto out;
-
-check_size:
-    mlocal->call_count = fctx->stripe_count;
-
-    for (index = 0; index < fctx->stripe_count; index++) {
-        STACK_WIND(mframe, stripe_readv_fstat_cbk, (fctx->xl_array[index]),
-                   (fctx->xl_array[index])->fops->fstat, mlocal->fd, NULL);
-    }
-
-out:
-    STRIPE_STACK_DESTROY(frame);
-end:
-    return 0;
-}
-
-int32_t
-stripe_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, uint32_t flags, dict_t *xdata)
-{
-    int32_t op_errno = EINVAL;
-    int32_t idx = 0;
-    int32_t index = 0;
-    int32_t num_stripe = 0;
-    int32_t off_index = 0;
-    size_t frame_size = 0;
-    off_t rounded_end = 0;
-    uint64_t tmp_fctx = 0;
-    uint64_t stripe_size = 0;
-    off_t rounded_start = 0;
-    off_t frame_offset = offset;
-    off_t dest_offset = 0;
-    stripe_local_t *local = NULL;
-    call_frame_t *rframe = NULL;
-    stripe_local_t *rlocal = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    inode_ctx_get(fd->inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        op_errno = EBADFD;
-        goto err;
-    }
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-    stripe_size = fctx->stripe_size;
-
-    STRIPE_VALIDATE_FCTX(fctx, err);
-
-    if (!stripe_size) {
-        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
-        goto err;
-    }
-    /* The file is stripe across the child nodes. Send the read request
-     * to the child nodes appropriately after checking which region of
-     * the file is in which child node. Always '0-<stripe_size>' part of
-     * the file resides in the first child.
-     */
-    rounded_start = gf_floor(offset, stripe_size);
-    rounded_end = gf_roof(offset + size, stripe_size);
-    num_stripe = (rounded_end - rounded_start) / stripe_size;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-
-    /* This is where all the vectors should be copied. */
-    local->replies = GF_CALLOC(num_stripe, sizeof(struct stripe_replies),
-                               gf_stripe_mt_stripe_replies);
-    if (!local->replies) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    off_index = (offset / stripe_size) % fctx->stripe_count;
-    local->wind_count = num_stripe;
-    local->readv_size = size;
-    local->offset = offset;
-    local->fd = fd_ref(fd);
-    local->fctx = fctx;
-
-    for (index = off_index; index < (num_stripe + off_index); index++) {
-        rframe = copy_frame(frame);
-        rlocal = mem_get0(this->local_pool);
-        if (!rlocal) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-
-        frame_size = min(gf_roof(frame_offset + 1, stripe_size),
-                         (offset + size)) -
-                     frame_offset;
-
-        rlocal->node_index = index - off_index;
-        rlocal->orig_frame = frame;
-        rlocal->readv_size = frame_size;
-        rframe->local = rlocal;
-        idx = (index % fctx->stripe_count);
-
-        if (fctx->stripe_coalesce)
-            dest_offset = coalesced_offset(frame_offset, stripe_size,
-                                           fctx->stripe_count);
-        else
-            dest_offset = frame_offset;
-
-        STACK_WIND(rframe, stripe_readv_cbk, fctx->xl_array[idx],
-                   fctx->xl_array[idx]->fops->readv, fd, frame_size,
-                   dest_offset, flags, xdata);
-
-        frame_offset += frame_size;
-    }
-
-    return 0;
-err:
-    if (rframe)
-        STRIPE_STACK_DESTROY(rframe);
-
-    STRIPE_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_local_t *mlocal = NULL;
-    call_frame_t *prev = NULL;
-    call_frame_t *mframe = NULL;
-    struct stripe_replies *reply = NULL;
-    int32_t i = 0;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-    mframe = local->orig_frame;
-    mlocal = mframe->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = ++mlocal->call_count;
-
-        mlocal->replies[local->node_index].op_ret = op_ret;
-        mlocal->replies[local->node_index].op_errno = op_errno;
-
-        if (op_ret >= 0) {
-            mlocal->post_buf = *postbuf;
-            mlocal->pre_buf = *prebuf;
-
-            mlocal->prebuf_blocks += prebuf->ia_blocks;
-            mlocal->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, mlocal->fctx, prev);
-            correct_file_size(postbuf, mlocal->fctx, prev);
-
-            if (mlocal->prebuf_size < prebuf->ia_size)
-                mlocal->prebuf_size = prebuf->ia_size;
-            if (mlocal->postbuf_size < postbuf->ia_size)
-                mlocal->postbuf_size = postbuf->ia_size;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-        mlocal->post_buf.ia_size = mlocal->postbuf_size;
-        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
-
-        /*
-         * Only return the number of consecutively written bytes up until
-         * the first error. Only return an error if it occurs first.
-         *
-         * When a short write occurs, the application should retry at the
-         * appropriate offset, at which point we'll potentially pass back
-         * the error.
-         */
-        for (i = 0, reply = mlocal->replies; i < mlocal->wind_count;
-             i++, reply++) {
-            if (reply->op_ret == -1) {
-                gf_log(this->name, GF_LOG_DEBUG,
-                       "reply %d "
-                       "returned error %s",
-                       i, strerror(reply->op_errno));
-                if (!mlocal->op_ret) {
-                    mlocal->op_ret = -1;
-                    mlocal->op_errno = reply->op_errno;
-                }
-                break;
-            }
-
-            mlocal->op_ret += reply->op_ret;
-
-            if (reply->op_ret < reply->requested_size)
-                break;
-        }
-
-        GF_FREE(mlocal->replies);
-
-        STRIPE_STACK_UNWIND(writev, mframe, mlocal->op_ret, mlocal->op_errno,
-                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
-    }
-out:
-    if (frame)
-        STRIPE_STACK_DESTROY(frame);
-    return 0;
-}
-
-int32_t
-stripe_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
-              struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
-              struct iobref *iobref, dict_t *xdata)
-{
-    struct iovec *tmp_vec = NULL;
-    stripe_local_t *local = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-    int32_t idx = 0;
-    int32_t total_size = 0;
-    int32_t offset_offset = 0;
-    int32_t remaining_size = 0;
-    int32_t tmp_count = count;
-    off_t fill_size = 0;
-    uint64_t stripe_size = 0;
-    uint64_t tmp_fctx = 0;
-    off_t dest_offset = 0;
-    off_t rounded_start = 0;
-    off_t rounded_end = 0;
-    int32_t total_chunks = 0;
-    call_frame_t *wframe = NULL;
-    stripe_local_t *wlocal = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    inode_ctx_get(fd->inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        op_errno = EINVAL;
-        goto err;
-    }
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-    stripe_size = fctx->stripe_size;
-
-    STRIPE_VALIDATE_FCTX(fctx, err);
-
-    /* File has to be stripped across the child nodes */
-    total_size = iov_length(vector, count);
-    remaining_size = total_size;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-    local->stripe_size = stripe_size;
-    local->fctx = fctx;
-
-    if (!stripe_size) {
-        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    rounded_start = gf_floor(offset, stripe_size);
-    rounded_end = gf_roof(offset + total_size, stripe_size);
-    total_chunks = (rounded_end - rounded_start) / stripe_size;
-    local->replies = GF_CALLOC(total_chunks, sizeof(struct stripe_replies),
-                               gf_stripe_mt_stripe_replies);
-    if (!local->replies) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    total_chunks = 0;
-    while (1) {
-        wframe = copy_frame(frame);
-        wlocal = mem_get0(this->local_pool);
-        if (!wlocal) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        wlocal->orig_frame = frame;
-        wframe->local = wlocal;
-
-        /* Send striped chunk of the vector to child
-           nodes appropriately. */
-        idx = (((offset + offset_offset) / local->stripe_size) %
-               fctx->stripe_count);
-
-        fill_size = (local->stripe_size -
-                     ((offset + offset_offset) % local->stripe_size));
-        if (fill_size > remaining_size)
-            fill_size = remaining_size;
-
-        remaining_size -= fill_size;
-
-        tmp_count = iov_subset(vector, count, offset_offset,
-                               offset_offset + fill_size, NULL);
-        tmp_vec = GF_CALLOC(tmp_count, sizeof(struct iovec),
-                            gf_stripe_mt_iovec);
-        if (!tmp_vec) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        tmp_count = iov_subset(vector, count, offset_offset,
-                               offset_offset + fill_size, tmp_vec);
-
-        local->wind_count++;
-        if (remaining_size == 0)
-            local->unwind = 1;
-
-        /*
-         * Store off the request index (with respect to the chunk of the
-         * initial offset) and the size of the request. This is required
-         * in the callback to calculate an appropriate return value in
-         * the event of a write failure in one or more requests.
-         */
-        wlocal->node_index = total_chunks;
-        local->replies[total_chunks].requested_size = fill_size;
-
-        dest_offset = offset + offset_offset;
-        if (fctx->stripe_coalesce)
-            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
-                                           fctx->stripe_count);
-
-        STACK_WIND(wframe, stripe_writev_cbk, fctx->xl_array[idx],
-                   fctx->xl_array[idx]->fops->writev, fd, tmp_vec, tmp_count,
-                   dest_offset, flags, iobref, xdata);
-
-        GF_FREE(tmp_vec);
-        offset_offset += fill_size;
-        total_chunks++;
-        if (remaining_size == 0)
-            break;
-    }
-
-    return 0;
-err:
-    if (wframe)
-        STRIPE_STACK_DESTROY(wframe);
-
-    STRIPE_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_local_t *mlocal = NULL;
-    call_frame_t *prev = NULL;
-    call_frame_t *mframe = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-    mframe = local->orig_frame;
-    mlocal = mframe->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = ++mlocal->call_count;
-
-        if (op_ret == 0) {
-            mlocal->post_buf = *postbuf;
-            mlocal->pre_buf = *prebuf;
-
-            mlocal->prebuf_blocks += prebuf->ia_blocks;
-            mlocal->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, mlocal->fctx, prev);
-            correct_file_size(postbuf, mlocal->fctx, prev);
-
-            if (mlocal->prebuf_size < prebuf->ia_size)
-                mlocal->prebuf_size = prebuf->ia_size;
-            if (mlocal->postbuf_size < postbuf->ia_size)
-                mlocal->postbuf_size = postbuf->ia_size;
-        }
-
-        /* return the first failure */
-        if (mlocal->op_ret == 0) {
-            mlocal->op_ret = op_ret;
-            mlocal->op_errno = op_errno;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-        mlocal->post_buf.ia_size = mlocal->postbuf_size;
-        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
-
-        STRIPE_STACK_UNWIND(fallocate, mframe, mlocal->op_ret, mlocal->op_errno,
-                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
-    }
-out:
-    if (frame)
-        STRIPE_STACK_DESTROY(frame);
-    return 0;
-}
-
-int32_t
-stripe_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode,
-                 off_t offset, size_t len, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-    int32_t idx = 0;
-    int32_t offset_offset = 0;
-    int32_t remaining_size = 0;
-    off_t fill_size = 0;
-    uint64_t stripe_size = 0;
-    uint64_t tmp_fctx = 0;
-    off_t dest_offset = 0;
-    call_frame_t *fframe = NULL;
-    stripe_local_t *flocal = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    inode_ctx_get(fd->inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        op_errno = EINVAL;
-        goto err;
-    }
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-    stripe_size = fctx->stripe_size;
-
-    STRIPE_VALIDATE_FCTX(fctx, err);
-
-    remaining_size = len;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-    local->stripe_size = stripe_size;
-    local->fctx = fctx;
-
-    if (!stripe_size) {
-        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    while (1) {
-        fframe = copy_frame(frame);
-        flocal = mem_get0(this->local_pool);
-        if (!flocal) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        flocal->orig_frame = frame;
-        fframe->local = flocal;
-
-        /* send fallocate request to the associated child node */
-        idx = (((offset + offset_offset) / local->stripe_size) %
-               fctx->stripe_count);
-
-        fill_size = (local->stripe_size -
-                     ((offset + offset_offset) % local->stripe_size));
-        if (fill_size > remaining_size)
-            fill_size = remaining_size;
-
-        remaining_size -= fill_size;
-
-        local->wind_count++;
-        if (remaining_size == 0)
-            local->unwind = 1;
-
-        dest_offset = offset + offset_offset;
-        if (fctx->stripe_coalesce)
-            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
-                                           fctx->stripe_count);
-
-        /*
-         * TODO: Create a separate handler for coalesce mode that sends a
-         * single fallocate per-child (since the ranges are linear).
-         */
-        STACK_WIND(fframe, stripe_fallocate_cbk, fctx->xl_array[idx],
-                   fctx->xl_array[idx]->fops->fallocate, fd, mode, dest_offset,
-                   fill_size, xdata);
-
-        offset_offset += fill_size;
-        if (remaining_size == 0)
-            break;
-    }
-
-    return 0;
-err:
-    if (fframe)
-        STRIPE_STACK_DESTROY(fframe);
-
-    STRIPE_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_local_t *mlocal = NULL;
-    call_frame_t *prev = NULL;
-    call_frame_t *mframe = NULL;
-
-    if (!this || !frame || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-    mframe = local->orig_frame;
-    mlocal = mframe->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = ++mlocal->call_count;
-
-        if (op_ret == 0) {
-            mlocal->post_buf = *postbuf;
-            mlocal->pre_buf = *prebuf;
-
-            mlocal->prebuf_blocks += prebuf->ia_blocks;
-            mlocal->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, mlocal->fctx, prev);
-            correct_file_size(postbuf, mlocal->fctx, prev);
-
-            if (mlocal->prebuf_size < prebuf->ia_size)
-                mlocal->prebuf_size = prebuf->ia_size;
-            if (mlocal->postbuf_size < postbuf->ia_size)
-                mlocal->postbuf_size = postbuf->ia_size;
-        }
-
-        /* return the first failure */
-        if (mlocal->op_ret == 0) {
-            mlocal->op_ret = op_ret;
-            mlocal->op_errno = op_errno;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-        mlocal->post_buf.ia_size = mlocal->postbuf_size;
-        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
-
-        STRIPE_STACK_UNWIND(discard, mframe, mlocal->op_ret, mlocal->op_errno,
-                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
-    }
-out:
-    if (frame)
-        STRIPE_STACK_DESTROY(frame);
-
-    return 0;
-}
-
-int32_t
-stripe_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               size_t len, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-    int32_t idx = 0;
-    int32_t offset_offset = 0;
-    int32_t remaining_size = 0;
-    off_t fill_size = 0;
-    uint64_t stripe_size = 0;
-    uint64_t tmp_fctx = 0;
-    off_t dest_offset = 0;
-    call_frame_t *fframe = NULL;
-    stripe_local_t *flocal = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    inode_ctx_get(fd->inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        op_errno = EINVAL;
-        goto err;
-    }
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-    stripe_size = fctx->stripe_size;
-
-    STRIPE_VALIDATE_FCTX(fctx, err);
-
-    remaining_size = len;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-    local->stripe_size = stripe_size;
-    local->fctx = fctx;
-
-    if (!stripe_size) {
-        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    while (1) {
-        fframe = copy_frame(frame);
-        flocal = mem_get0(this->local_pool);
-        if (!flocal) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        flocal->orig_frame = frame;
-        fframe->local = flocal;
-
-        /* send discard request to the associated child node */
-        idx = (((offset + offset_offset) / local->stripe_size) %
-               fctx->stripe_count);
-
-        fill_size = (local->stripe_size -
-                     ((offset + offset_offset) % local->stripe_size));
-        if (fill_size > remaining_size)
-            fill_size = remaining_size;
-
-        remaining_size -= fill_size;
-
-        local->wind_count++;
-        if (remaining_size == 0)
-            local->unwind = 1;
-
-        dest_offset = offset + offset_offset;
-        if (fctx->stripe_coalesce)
-            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
-                                           fctx->stripe_count);
-
-        /*
-         * TODO: Create a separate handler for coalesce mode that sends a
-         * single discard per-child (since the ranges are linear).
-         */
-        STACK_WIND(fframe, stripe_discard_cbk, fctx->xl_array[idx],
-                   fctx->xl_array[idx]->fops->discard, fd, dest_offset,
-                   fill_size, xdata);
-
-        offset_offset += fill_size;
-        if (remaining_size == 0)
-            break;
-    }
-
-    return 0;
-err:
-    if (fframe)
-        STRIPE_STACK_DESTROY(fframe);
-
-    STRIPE_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
-{
-    int32_t callcnt = 0;
-    stripe_local_t *local = NULL;
-    stripe_local_t *mlocal = NULL;
-    call_frame_t *prev = NULL;
-    call_frame_t *mframe = NULL;
-
-    GF_ASSERT(frame);
-
-    if (!this || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-
-    prev = cookie;
-    local = frame->local;
-    mframe = local->orig_frame;
-    mlocal = mframe->local;
-
-    LOCK(&frame->lock);
-    {
-        callcnt = ++mlocal->call_count;
-
-        if (op_ret == 0) {
-            mlocal->post_buf = *postbuf;
-            mlocal->pre_buf = *prebuf;
-
-            mlocal->prebuf_blocks += prebuf->ia_blocks;
-            mlocal->postbuf_blocks += postbuf->ia_blocks;
-
-            correct_file_size(prebuf, mlocal->fctx, prev);
-            correct_file_size(postbuf, mlocal->fctx, prev);
-
-            if (mlocal->prebuf_size < prebuf->ia_size)
-                mlocal->prebuf_size = prebuf->ia_size;
-            if (mlocal->postbuf_size < postbuf->ia_size)
-                mlocal->postbuf_size = postbuf->ia_size;
-        }
-
-        /* return the first failure */
-        if (mlocal->op_ret == 0) {
-            mlocal->op_ret = op_ret;
-            mlocal->op_errno = op_errno;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if ((callcnt == mlocal->wind_count) && mlocal->unwind) {
-        mlocal->pre_buf.ia_size = mlocal->prebuf_size;
-        mlocal->pre_buf.ia_blocks = mlocal->prebuf_blocks;
-        mlocal->post_buf.ia_size = mlocal->postbuf_size;
-        mlocal->post_buf.ia_blocks = mlocal->postbuf_blocks;
-
-        STRIPE_STACK_UNWIND(zerofill, mframe, mlocal->op_ret, mlocal->op_errno,
-                            &mlocal->pre_buf, &mlocal->post_buf, NULL);
-    }
-out:
-    STRIPE_STACK_DESTROY(frame);
-    return 0;
-}
-
-int32_t
-stripe_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                off_t len, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_fd_ctx_t *fctx = NULL;
-    int32_t op_errno = 1;
-    int32_t idx = 0;
-    int32_t offset_offset = 0;
-    int32_t remaining_size = 0;
-    off_t fill_size = 0;
-    uint64_t stripe_size = 0;
-    uint64_t tmp_fctx = 0;
-    off_t dest_offset = 0;
-    call_frame_t *fframe = NULL;
-    stripe_local_t *flocal = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-    VALIDATE_OR_GOTO(fd->inode, err);
-
-    inode_ctx_get(fd->inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        op_errno = EINVAL;
-        goto err;
-    }
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-    stripe_size = fctx->stripe_size;
-
-    STRIPE_VALIDATE_FCTX(fctx, err);
-
-    remaining_size = len;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    frame->local = local;
-    local->stripe_size = stripe_size;
-    local->fctx = fctx;
-
-    if (!stripe_size) {
-        gf_log(this->name, GF_LOG_DEBUG, "Wrong stripe size for the file");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    while (1) {
-        fframe = copy_frame(frame);
-        flocal = mem_get0(this->local_pool);
-        if (!flocal) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-        flocal->orig_frame = frame;
-        fframe->local = flocal;
-
-        idx = (((offset + offset_offset) / local->stripe_size) %
-               fctx->stripe_count);
-
-        fill_size = (local->stripe_size -
-                     ((offset + offset_offset) % local->stripe_size));
-        if (fill_size > remaining_size)
-            fill_size = remaining_size;
-
-        remaining_size -= fill_size;
-
-        local->wind_count++;
-        if (remaining_size == 0)
-            local->unwind = 1;
-
-        dest_offset = offset + offset_offset;
-        if (fctx->stripe_coalesce)
-            dest_offset = coalesced_offset(dest_offset, local->stripe_size,
-                                           fctx->stripe_count);
-
-        STACK_WIND(fframe, stripe_zerofill_cbk, fctx->xl_array[idx],
-                   fctx->xl_array[idx]->fops->zerofill, fd, dest_offset,
-                   fill_size, xdata);
-        offset_offset += fill_size;
-        if (remaining_size == 0)
-            break;
-    }
-
-    return 0;
-err:
-    if (fframe)
-        STRIPE_STACK_DESTROY(fframe);
-
-    STRIPE_STACK_UNWIND(zerofill, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-stripe_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            gf_seek_what_t what, dict_t *xdata)
-{
-    /* TBD */
-    gf_log(this->name, GF_LOG_INFO, "seek called on %s.",
-           uuid_utoa(fd->inode->gfid));
-    STRIPE_STACK_UNWIND(seek, frame, -1, ENOTSUP, 0, NULL);
-    return 0;
-}
-
-int32_t
-stripe_release(xlator_t *this, fd_t *fd)
-{
-    return 0;
-}
-
-int
-stripe_forget(xlator_t *this, inode_t *inode)
-{
-    uint64_t tmp_fctx = 0;
-    stripe_fd_ctx_t *fctx = NULL;
-
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(inode, err);
-
-    (void)inode_ctx_del(inode, this, &tmp_fctx);
-    if (!tmp_fctx) {
-        goto err;
-    }
-
-    fctx = (stripe_fd_ctx_t *)(long)tmp_fctx;
-
-    if (!fctx->static_array)
-        GF_FREE(fctx->xl_array);
-
-    GF_FREE(fctx);
-err:
-    return 0;
-}
-
-int32_t
-notify(xlator_t *this, int32_t event, void *data, ...)
-{
-    stripe_private_t *priv = NULL;
-    int down_client = 0;
-    int i = 0;
-    gf_boolean_t heard_from_all_children = _gf_false;
-
-    if (!this)
-        return 0;
-
-    priv = this->private;
-    if (!priv)
-        return 0;
-
-    switch (event) {
-        case GF_EVENT_CHILD_UP: {
-            /* get an index number to set */
-            for (i = 0; i < priv->child_count; i++) {
-                if (data == priv->xl_array[i])
-                    break;
-            }
-
-            if (priv->child_count == i) {
-                gf_log(this->name, GF_LOG_ERROR,
-                       "got GF_EVENT_CHILD_UP bad subvolume %s",
-                       data ? ((xlator_t *)data)->name : NULL);
-                break;
-            }
-
-            LOCK(&priv->lock);
-            {
-                if (data == FIRST_CHILD(this))
-                    priv->first_child_down = 0;
-                priv->last_event[i] = event;
-            }
-            UNLOCK(&priv->lock);
-        } break;
-        case GF_EVENT_CHILD_CONNECTING: {
-            // 'CONNECTING' doesn't ensure its CHILD_UP, so do nothing
-            goto out;
-        }
-        case GF_EVENT_CHILD_DOWN: {
-            /* get an index number to set */
-            for (i = 0; i < priv->child_count; i++) {
-                if (data == priv->xl_array[i])
-                    break;
-            }
-
-            if (priv->child_count == i) {
-                gf_log(this->name, GF_LOG_ERROR,
-                       "got GF_EVENT_CHILD_DOWN bad subvolume %s",
-                       data ? ((xlator_t *)data)->name : NULL);
-                break;
-            }
-
-            LOCK(&priv->lock);
-            {
-                if (data == FIRST_CHILD(this))
-                    priv->first_child_down = 1;
-                priv->last_event[i] = event;
-            }
-            UNLOCK(&priv->lock);
-        } break;
-
-        default: {
-            /* */
-            default_notify(this, event, data);
-            goto out;
-        } break;
-    }
-
-    // Consider child as down if it's last_event is not CHILD_UP
-    for (i = 0, down_client = 0; i < priv->child_count; i++)
-        if (priv->last_event[i] != GF_EVENT_CHILD_UP)
-            down_client++;
-
-    LOCK(&priv->lock);
-    {
-        priv->nodes_down = down_client;
-    }
-    UNLOCK(&priv->lock);
-
-    heard_from_all_children = _gf_true;
-    for (i = 0; i < priv->child_count; i++)
-        if (!priv->last_event[i])
-            heard_from_all_children = _gf_false;
-
-    if (heard_from_all_children)
-        default_notify(this, event, data);
-out:
-    return 0;
-}
-
-int
-stripe_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, dict_t *xdata)
-{
-    int ret = -1;
-    int call_cnt = 0;
-    stripe_local_t *local = NULL;
-
-    if (!frame || !frame->local || !this) {
-        gf_log("", GF_LOG_ERROR, "Possible NULL deref");
-        return ret;
-    }
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        call_cnt = --local->wind_count;
-
-        /**
-         * We overwrite ->op_* values here for subsequent failure
-         * conditions, hence we propagate the last errno down the
-         * stack.
-         */
-        if (op_ret < 0) {
-            local->op_ret = op_ret;
-            local->op_errno = op_errno;
-            goto unlock;
-        }
-    }
-
-unlock:
-    UNLOCK(&frame->lock);
-
-    if (!call_cnt) {
-        STRIPE_STACK_UNWIND(setxattr, frame, local->op_ret, local->op_errno,
-                            xdata);
-    }
-
-    return 0;
-}
-
-#ifdef HAVE_BD_XLATOR
-int
-stripe_is_bd(dict_t *this, char *key, data_t *value, void *data)
-{
-    gf_boolean_t *is_bd = data;
-
-    if (data == NULL)
-        return 0;
-
-    if (XATTR_IS_BD(key))
-        *is_bd = _gf_true;
-
-    return 0;
-}
-
-static gf_boolean_t
-stripe_setxattr_is_bd(dict_t *dict)
-{
-    gf_boolean_t is_bd = _gf_false;
-
-    if (dict == NULL)
-        goto out;
-
-    dict_foreach(dict, stripe_is_bd, &is_bd);
-out:
-    return is_bd;
-}
-#else
-#define stripe_setxattr_is_bd(dict) _gf_false
-#endif
-
-int
-stripe_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-                int flags, dict_t *xdata)
-{
-    int32_t op_errno = EINVAL;
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    stripe_local_t *local = NULL;
-    int i = 0;
-    gf_boolean_t is_bd = _gf_false;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    GF_IF_INTERNAL_XATTR_GOTO("trusted.*stripe*", dict, op_errno, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    frame->local = local;
-    local->wind_count = priv->child_count;
-    local->op_ret = local->op_errno = 0;
-
-    is_bd = stripe_setxattr_is_bd(dict);
-
-    /**
-     * Set xattrs for directories on all subvolumes. Additionally
-     * this power is only given to a special client. Bd xlator
-     * also needs xattrs for regular files (ie LVs)
-     */
-    if (((frame->root->pid == GF_CLIENT_PID_GSYNCD) &&
-         IA_ISDIR(loc->inode->ia_type)) ||
-        is_bd) {
-        for (i = 0; i < priv->child_count; i++, trav = trav->next) {
-            STACK_WIND(frame, stripe_setxattr_cbk, trav->xlator,
-                       trav->xlator->fops->setxattr, loc, dict, flags, xdata);
-        }
-    } else {
-        local->wind_count = 1;
-        STACK_WIND(frame, stripe_setxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
-    }
-
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
-    return 0;
-}
-
-int
-stripe_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
-{
-    STRIPE_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int
-stripe_is_special_key(dict_t *this, char *key, data_t *value, void *data)
-{
-    gf_boolean_t *is_special = NULL;
-
-    if (data == NULL) {
-        goto out;
-    }
-
-    is_special = data;
-
-    if (XATTR_IS_LOCKINFO(key) || XATTR_IS_BD(key))
-        *is_special = _gf_true;
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_fsetxattr_everyone_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int call_count = 0;
-    stripe_local_t *local = NULL;
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        call_count = --local->wind_count;
-
-        if (op_ret < 0) {
-            local->op_ret = op_ret;
-            local->op_errno = op_errno;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (call_count == 0) {
-        STRIPE_STACK_UNWIND(fsetxattr, frame, local->op_ret, local->op_errno,
-                            NULL);
-    }
-    return 0;
-}
-
-int
-stripe_fsetxattr_to_everyone(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                             dict_t *dict, int flags, dict_t *xdata)
-{
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    int ret = -1;
-    stripe_local_t *local = NULL;
-
-    priv = this->private;
-
-    local = mem_get0(this->local_pool);
-    if (local == NULL) {
-        goto out;
-    }
-
-    frame->local = local;
-
-    local->wind_count = priv->child_count;
-
-    trav = this->children;
-
-    while (trav) {
-        STACK_WIND(frame, stripe_fsetxattr_everyone_cbk, trav->xlator,
-                   trav->xlator->fops->fsetxattr, fd, dict, flags, xdata);
-        trav = trav->next;
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-static gf_boolean_t
-stripe_fsetxattr_is_special(dict_t *dict)
-{
-    gf_boolean_t is_spl = _gf_false;
-
-    if (dict == NULL) {
-        goto out;
-    }
-
-    dict_foreach(dict, stripe_is_special_key, &is_spl);
-
-out:
-    return is_spl;
-}
-
-int
-stripe_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                 int flags, dict_t *xdata)
-{
-    int32_t op_ret = -1, ret = -1, op_errno = EINVAL;
-    gf_boolean_t is_spl = _gf_false;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-
-    GF_IF_INTERNAL_XATTR_GOTO("trusted.*stripe*", dict, op_errno, err);
-
-    is_spl = stripe_fsetxattr_is_special(dict);
-    if (is_spl) {
-        ret = stripe_fsetxattr_to_everyone(frame, this, fd, dict, flags, xdata);
-        if (ret < 0) {
-            op_errno = ENOMEM;
-            goto err;
-        }
-
-        goto out;
-    }
-
-    STACK_WIND(frame, stripe_fsetxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
-out:
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
-    return 0;
-}
-
-int
-stripe_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    STRIPE_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int
-stripe_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   const char *name, dict_t *xdata)
-{
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(this, err);
-
-    GF_IF_NATIVE_XATTR_GOTO("trusted.*stripe*", name, op_errno, err);
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(loc, err);
-
-    STACK_WIND(frame, stripe_removexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL);
-    return 0;
-}
-
-int
-stripe_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    STRIPE_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int
-stripe_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    const char *name, dict_t *xdata)
-{
-    int32_t op_ret = -1;
-    int32_t op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-
-    GF_IF_NATIVE_XATTR_GOTO("trusted.*stripe*", name, op_errno, err);
-
-    STACK_WIND(frame, stripe_fremovexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
-    return 0;
-err:
-    STRIPE_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int32_t
-stripe_readdirp_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, inode_t *inode,
-                           struct iatt *stbuf, dict_t *xattr,
-                           struct iatt *parent)
-{
-    stripe_local_t *local = NULL;
-    call_frame_t *main_frame = NULL;
-    stripe_local_t *main_local = NULL;
-    gf_dirent_t *entry = NULL;
-    call_frame_t *prev = NULL;
-    int done = 0;
-
-    local = frame->local;
-    prev = cookie;
-
-    entry = local->dirent;
-
-    main_frame = local->orig_frame;
-    main_local = main_frame->local;
-    LOCK(&frame->lock);
-    {
-        local->call_count--;
-        if (!local->call_count)
-            done = 1;
-        if (op_ret == -1) {
-            local->op_errno = op_errno;
-            local->op_ret = op_ret;
-            goto unlock;
-        }
-
-        if (stripe_ctx_handle(this, prev, local, xattr))
-            gf_log(this->name, GF_LOG_ERROR,
-                   "Error getting fctx info from dict.");
-
-        correct_file_size(stbuf, local->fctx, prev);
-
-        stripe_iatt_merge(stbuf, &entry->d_stat);
-        local->stbuf_blocks += stbuf->ia_blocks;
-    }
-unlock:
-    UNLOCK(&frame->lock);
-
-    if (done) {
-        inode_ctx_put(entry->inode, this, (uint64_t)(long)local->fctx);
-
-        done = 0;
-        LOCK(&main_frame->lock);
-        {
-            main_local->wind_count--;
-            if (!main_local->wind_count)
-                done = 1;
-            if (local->op_ret == -1) {
-                main_local->op_errno = local->op_errno;
-                main_local->op_ret = local->op_ret;
-            }
-            entry->d_stat.ia_blocks = local->stbuf_blocks;
-        }
-        UNLOCK(&main_frame->lock);
-        if (done) {
-            main_frame->local = NULL;
-            STRIPE_STACK_UNWIND(readdir, main_frame, main_local->op_ret,
-                                main_local->op_errno, &main_local->entries,
-                                NULL);
-            gf_dirent_free(&main_local->entries);
-            stripe_local_wipe(main_local);
-            mem_put(main_local);
-        }
-        frame->local = NULL;
-        stripe_local_wipe(local);
-        mem_put(local);
-        STRIPE_STACK_DESTROY(frame);
-    }
-
-    return 0;
-}
-
-int32_t
-stripe_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, gf_dirent_t *orig_entries,
-                    dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    call_frame_t *prev = NULL;
-    gf_dirent_t *local_entry = NULL;
-    gf_dirent_t *tmp_entry = NULL;
-    xlator_list_t *trav = NULL;
-    loc_t loc = {
-        0,
-    };
-    int32_t count = 0;
-    stripe_private_t *priv = NULL;
-    int32_t subvols = 0;
-    dict_t *xattrs = NULL;
-    call_frame_t *local_frame = NULL;
-    stripe_local_t *local_ent = NULL;
-
-    if (!this || !frame->local || !cookie) {
-        gf_log("stripe", GF_LOG_DEBUG, "possible NULL deref");
-        goto out;
-    }
-    prev = cookie;
-    local = frame->local;
-    trav = this->children;
-    priv = this->private;
-
-    subvols = priv->child_count;
-
-    LOCK(&frame->lock);
-    {
-        local->op_errno = op_errno;
-        local->op_ret = op_ret;
-
-        if (op_ret != -1) {
-            list_splice_init(&orig_entries->list, &local->entries.list);
-            local->wind_count = op_ret;
-        }
-    }
-    UNLOCK(&frame->lock);
-
-    if (op_ret == -1) {
-        gf_log(this->name, GF_LOG_WARNING, "%s returned error %s",
-               prev->this->name, strerror(op_errno));
-        goto out;
-    }
-
-    xattrs = dict_new();
-    if (xattrs)
-        (void)stripe_xattr_request_build(this, xattrs, 0, 0, 0, 0);
-    count = op_ret;
-    list_for_each_entry_safe(local_entry, tmp_entry, (&local->entries.list),
-                             list)
-    {
-        if (!local_entry)
-            break;
-        if (!IA_ISREG(local_entry->d_stat.ia_type) || !local_entry->inode) {
-            LOCK(&frame->lock);
-            {
-                local->wind_count--;
-                count = local->wind_count;
-            }
-            UNLOCK(&frame->lock);
-            continue;
-        }
-
-        local_frame = copy_frame(frame);
-
-        if (!local_frame) {
-            op_errno = ENOMEM;
-            op_ret = -1;
-            goto out;
-        }
-
-        local_ent = mem_get0(this->local_pool);
-        if (!local_ent) {
-            op_errno = ENOMEM;
-            op_ret = -1;
-            goto out;
-        }
-
-        loc.inode = inode_ref(local_entry->inode);
-
-        gf_uuid_copy(loc.gfid, local_entry->d_stat.ia_gfid);
-
-        local_ent->orig_frame = frame;
-
-        local_ent->call_count = subvols;
-
-        local_ent->dirent = local_entry;
-
-        local_frame->local = local_ent;
-
-        trav = this->children;
-        while (trav) {
-            STACK_WIND(local_frame, stripe_readdirp_lookup_cbk, trav->xlator,
-                       trav->xlator->fops->lookup, &loc, xattrs);
-            trav = trav->next;
-        }
-        loc_wipe(&loc);
-    }
-out:
-    if (!count) {
-        /* all entries are directories */
-        frame->local = NULL;
-        STRIPE_STACK_UNWIND(readdir, frame, (local ? local->op_ret : -1),
-                            (local ? local->op_errno : EINVAL),
-                            (local ? &local->entries : NULL), NULL);
-        gf_dirent_free(&local->entries);
-        stripe_local_wipe(local);
-        mem_put(local);
-    }
-    if (xattrs)
-        dict_unref(xattrs);
-    return 0;
-}
-int32_t
-stripe_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                off_t off, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-    int op_errno = -1;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    if (priv->first_child_down) {
-        op_errno = ENOTCONN;
-        goto err;
-    }
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    frame->local = local;
-
-    local->fd = fd_ref(fd);
-
-    local->wind_count = 0;
-
-    local->count = 0;
-    local->op_ret = -1;
-    INIT_LIST_HEAD(&local->entries);
-
-    if (!trav)
-        goto err;
-
-    STACK_WIND(frame, stripe_readdirp_cbk, trav->xlator,
-               trav->xlator->fops->readdirp, fd, size, off, xdata);
-    return 0;
-err:
-    op_errno = (op_errno == -1) ? errno : op_errno;
-    STRIPE_STACK_UNWIND(readdir, frame, -1, op_errno, NULL, NULL);
-
-    return 0;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    if (!this)
-        goto out;
-
-    ret = xlator_mem_acct_init(this, gf_stripe_mt_end + 1);
-
-    if (ret != 0) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Memory accounting init"
-               "failed");
-        goto out;
-    }
-
-out:
-    return ret;
-}
-
-static int
-clear_pattern_list(stripe_private_t *priv)
-{
-    struct stripe_options *prev = NULL;
-    struct stripe_options *trav = NULL;
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("stripe", priv, out);
-
-    trav = priv->pattern;
-    priv->pattern = NULL;
-    while (trav) {
-        prev = trav;
-        trav = trav->next;
-        GF_FREE(prev);
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int
-reconfigure(xlator_t *this, dict_t *options)
-{
-    stripe_private_t *priv = NULL;
-    data_t *data = NULL;
-    int ret = -1;
-    volume_option_t *opt = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(this->private);
-
-    priv = this->private;
-
-    ret = 0;
-    LOCK(&priv->lock);
-    {
-        ret = clear_pattern_list(priv);
-        if (ret)
-            goto unlock;
-
-        data = dict_get(options, "block-size");
-        if (data) {
-            ret = set_stripe_block_size(this, priv, data->data);
-            if (ret)
-                goto unlock;
-        } else {
-            opt = xlator_volume_option_get(this, "block-size");
-            if (!opt) {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "option 'block-size' not found");
-                ret = -1;
-                goto unlock;
-            }
-
-            if (gf_string2bytesize_uint64(opt->default_value,
-                                          &priv->block_size)) {
-                gf_log(this->name, GF_LOG_ERROR,
-                       "Unable to set default block-size ");
-                ret = -1;
-                goto unlock;
-            }
-        }
-
-        GF_OPTION_RECONF("coalesce", priv->coalesce, options, bool, unlock);
-    }
-unlock:
-    UNLOCK(&priv->lock);
-    if (ret)
-        goto out;
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/**
- * init - This function is called when xlator-graph gets initialized.
- *     The option given in volfiles are parsed here.
- * @this -
- */
-int32_t
-init(xlator_t *this)
-{
-    stripe_private_t *priv = NULL;
-    volume_option_t *opt = NULL;
-    xlator_list_t *trav = NULL;
-    data_t *data = NULL;
-    int32_t count = 0;
-    int ret = -1;
-
-    if (!this)
-        goto out;
-
-    trav = this->children;
-    while (trav) {
-        count++;
-        trav = trav->next;
-    }
-
-    if (!count) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "stripe configured without \"subvolumes\" option. "
-               "exiting");
-        goto out;
-    }
-
-    if (!this->parents) {
-        gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile ");
-    }
-
-    if (count == 1) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "stripe configured with only one \"subvolumes\" option."
-               " please check the volume. exiting");
-        goto out;
-    }
-
-    priv = GF_CALLOC(1, sizeof(stripe_private_t),
-                     gf_stripe_mt_stripe_private_t);
-
-    if (!priv)
-        goto out;
-    priv->xl_array = GF_CALLOC(count, sizeof(xlator_t *),
-                               gf_stripe_mt_xlator_t);
-    if (!priv->xl_array)
-        goto out;
-
-    priv->last_event = GF_CALLOC(count, sizeof(int), gf_stripe_mt_int32_t);
-    if (!priv->last_event)
-        goto out;
-
-    priv->child_count = count;
-    LOCK_INIT(&priv->lock);
-
-    trav = this->children;
-    count = 0;
-    while (trav) {
-        priv->xl_array[count++] = trav->xlator;
-        trav = trav->next;
-    }
-
-    if (count > 256) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "maximum number of stripe subvolumes supported "
-               "is 256");
-        goto out;
-    }
-
-    ret = 0;
-    LOCK(&priv->lock);
-    {
-        opt = xlator_volume_option_get(this, "block-size");
-        if (!opt) {
-            gf_log(this->name, GF_LOG_WARNING, "option 'block-size' not found");
-            ret = -1;
-            goto unlock;
-        }
-        if (gf_string2bytesize_uint64(opt->default_value, &priv->block_size)) {
-            gf_log(this->name, GF_LOG_ERROR,
-                   "Unable to set default block-size ");
-            ret = -1;
-            goto unlock;
-        }
-        /* option stripe-pattern *avi:1GB,*pdf:16K */
-        data = dict_get(this->options, "block-size");
-        if (data) {
-            ret = set_stripe_block_size(this, priv, data->data);
-            if (ret)
-                goto unlock;
-        }
-    }
-unlock:
-    UNLOCK(&priv->lock);
-    if (ret)
-        goto out;
-
-    GF_OPTION_INIT("use-xattr", priv->xattr_supported, bool, out);
-    /* notify related */
-    priv->nodes_down = priv->child_count;
-
-    GF_OPTION_INIT("coalesce", priv->coalesce, bool, out);
-
-    this->local_pool = mem_pool_new(stripe_local_t, 128);
-    if (!this->local_pool) {
-        ret = -1;
-        gf_log(this->name, GF_LOG_ERROR,
-               "failed to create local_t's memory pool");
-        goto out;
-    }
-
-    this->private = priv;
-
-    ret = 0;
-out:
-    if (ret) {
-        if (priv) {
-            GF_FREE(priv->xl_array);
-            GF_FREE(priv);
-        }
-    }
-    return ret;
-}
-
-/**
- * fini -   Free all the private variables
- * @this -
- */
-void
-fini(xlator_t *this)
-{
-    stripe_private_t *priv = NULL;
-    struct stripe_options *prev = NULL;
-    struct stripe_options *trav = NULL;
-
-    if (!this)
-        goto out;
-
-    priv = this->private;
-    if (priv) {
-        this->private = NULL;
-        GF_FREE(priv->xl_array);
-
-        trav = priv->pattern;
-        while (trav) {
-            prev = trav;
-            trav = trav->next;
-            GF_FREE(prev);
-        }
-        GF_FREE(priv->last_event);
-        LOCK_DESTROY(&priv->lock);
-        GF_FREE(priv);
-    }
-
-out:
-    return;
-}
-
-int32_t
-stripe_getxattr_unwind(call_frame_t *frame, int op_ret, int op_errno,
-                       dict_t *dict, dict_t *xdata)
-
-{
-    STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
-    return 0;
-}
-
-int
-stripe_internal_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int op_ret, int op_errno, dict_t *xattr,
-                             dict_t *xdata)
-{
-    char size_key[256] = {
-        0,
-    };
-    char index_key[256] = {
-        0,
-    };
-    char count_key[256] = {
-        0,
-    };
-    char coalesce_key[256] = {
-        0,
-    };
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(frame->local, out);
-
-    if (!xattr || (op_ret == -1))
-        goto out;
-
-    sprintf(size_key, "trusted.%s.stripe-size", this->name);
-    sprintf(count_key, "trusted.%s.stripe-count", this->name);
-    sprintf(index_key, "trusted.%s.stripe-index", this->name);
-    sprintf(coalesce_key, "trusted.%s.stripe-coalesce", this->name);
-
-    dict_del(xattr, size_key);
-    dict_del(xattr, count_key);
-    dict_del(xattr, index_key);
-    dict_del(xattr, coalesce_key);
-
-out:
-    STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
-
-    return 0;
-}
-
-int
-stripe_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
-{
-    int call_cnt = 0;
-    stripe_local_t *local = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(frame->local, out);
-
-    local = frame->local;
-
-    LOCK(&frame->lock);
-    {
-        call_cnt = --local->wind_count;
-    }
-    UNLOCK(&frame->lock);
-
-    if (!xattr || (op_ret < 0))
-        goto out;
-
-    local->op_ret = 0;
-
-    if (!local->xattr) {
-        local->xattr = dict_ref(xattr);
-    } else {
-        stripe_aggregate_xattr(local->xattr, xattr);
-    }
-
-out:
-    if (!call_cnt) {
-        STRIPE_STACK_UNWIND(getxattr, frame, (local ? local->op_ret : -1),
-                            op_errno, (local ? local->xattr : NULL), xdata);
-    }
-
-    return 0;
-}
-
-int32_t
-stripe_vgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict,
-                     dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    int32_t callcnt = 0;
-    int32_t ret = -1;
-    long cky = 0;
-    void *xattr_val = NULL;
-    void *xattr_serz = NULL;
-    stripe_xattr_sort_t *xattr = NULL;
-    dict_t *stripe_xattr = NULL;
-
-    if (!frame || !frame->local || !this) {
-        gf_log("", GF_LOG_ERROR, "Possible NULL deref");
-        return ret;
-    }
-
-    local = frame->local;
-    cky = (long)cookie;
-
-    if (local->xsel[0] == '\0') {
-        gf_log(this->name, GF_LOG_ERROR, "Empty xattr in cbk");
-        return ret;
-    }
-
-    LOCK(&frame->lock);
-    {
-        callcnt = --local->wind_count;
-
-        if (!dict || (op_ret < 0))
-            goto out;
-
-        if (!local->xattr_list)
-            local->xattr_list = (stripe_xattr_sort_t *)GF_CALLOC(
-                local->nallocs, sizeof(stripe_xattr_sort_t),
-                gf_stripe_mt_xattr_sort_t);
-
-        if (local->xattr_list) {
-            xattr = local->xattr_list + (int32_t)cky;
-
-            ret = dict_get_ptr_and_len(dict, local->xsel, &xattr_val,
-                                       &xattr->xattr_len);
-            if (xattr->xattr_len == 0)
-                goto out;
-
-            xattr->pos = cky;
-            xattr->xattr_value = gf_memdup(xattr_val, xattr->xattr_len);
-
-            if (xattr->xattr_value != NULL)
-                local->xattr_total_len += xattr->xattr_len + 1;
-        }
-    }
-out:
-    UNLOCK(&frame->lock);
-
-    if (!callcnt) {
-        if (!local->xattr_total_len)
-            goto unwind;
-
-        stripe_xattr = dict_new();
-        if (!stripe_xattr)
-            goto unwind;
-
-        /* select filler based on ->xsel */
-        if (XATTR_IS_PATHINFO(local->xsel))
-            ret = stripe_fill_pathinfo_xattr(this, local, (char **)&xattr_serz);
-        else if (XATTR_IS_LOCKINFO(local->xsel)) {
-            ret = stripe_fill_lockinfo_xattr(this, local, &xattr_serz);
-        } else {
-            gf_log(this->name, GF_LOG_WARNING,
-                   "Unknown xattr in xattr request");
-            goto unwind;
-        }
-
-        if (!ret) {
-            ret = dict_set_dynptr(stripe_xattr, local->xsel, xattr_serz,
-                                  local->xattr_total_len);
-            if (ret)
-                gf_log(this->name, GF_LOG_ERROR, "Can't set %s key in dict",
-                       local->xsel);
-        }
-
-    unwind:
-        /*
-         * Among other things, STRIPE_STACK_UNWIND will free "local"
-         * for us.  That means we can't dereference it afterward.
-         * Fortunately, the actual result is in stripe_xattr now, so we
-         * can simply clean up before unwinding.
-         */
-        ret = stripe_free_xattr_str(local);
-        GF_FREE(local->xattr_list);
-        local->xattr_list = NULL;
-
-        STRIPE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, stripe_xattr,
-                            NULL);
-
-        if (stripe_xattr)
-            dict_unref(stripe_xattr);
-    }
-
-    return ret;
-}
-
-int
-stripe_marker_populate_args(call_frame_t *frame, int type, int *gauge,
-                            xlator_t **subvols)
-{
-    xlator_t *this = frame->this;
-    stripe_private_t *priv = this->private;
-    stripe_local_t *local = frame->local;
-    int count = 0;
-
-    count = priv->child_count;
-    if (MARKER_XTIME_TYPE == type) {
-        if (!IA_FILE_OR_DIR(local->loc.inode->ia_type))
-            count = 1;
-    }
-    memcpy(subvols, priv->xl_array, sizeof(*subvols) * count);
-
-    return count;
-}
-
-int32_t
-stripe_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    xlator_list_t *trav = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t op_errno = EINVAL;
-    int i = 0;
-    int ret = 0;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(loc, err);
-    VALIDATE_OR_GOTO(loc->path, err);
-    VALIDATE_OR_GOTO(loc->inode, err);
-
-    priv = this->private;
-    trav = this->children;
-
-    /* Initialization */
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-    local->op_ret = -1;
-    frame->local = local;
-    loc_copy(&local->loc, loc);
-
-    if (name && strncmp(name, QUOTA_SIZE_KEY, SLEN(QUOTA_SIZE_KEY)) == 0) {
-        local->wind_count = priv->child_count;
-
-        for (i = 0, trav = this->children; i < priv->child_count;
-             i++, trav = trav->next) {
-            STACK_WIND(frame, stripe_getxattr_cbk, trav->xlator,
-                       trav->xlator->fops->getxattr, loc, name, xdata);
-        }
-
-        return 0;
-    }
-
-    if (name && (XATTR_IS_PATHINFO(name))) {
-        if (IA_ISREG(loc->inode->ia_type)) {
-            ret = inode_ctx_get(loc->inode, this, (uint64_t *)&local->fctx);
-            if (ret)
-                gf_log(this->name, GF_LOG_ERROR,
-                       "stripe size unavailable from fctx"
-                       " relying on pathinfo could lead to"
-                       " wrong results");
-        }
-
-        local->nallocs = local->wind_count = priv->child_count;
-        (void)strncpy(local->xsel, name, strlen(name));
-
-        /**
-         * for xattrs that need info from all children, fill ->xsel
-         * as above and call the filler function in cbk based on
-         * it
-         */
-        for (i = 0, trav = this->children; i < priv->child_count;
-             i++, trav = trav->next) {
-            STACK_WIND_COOKIE(frame, stripe_vgetxattr_cbk, (void *)(long)i,
-                              trav->xlator, trav->xlator->fops->getxattr, loc,
-                              name, xdata);
-        }
-
-        return 0;
-    }
-
-    if (cluster_handle_marker_getxattr(frame, loc, name, priv->vol_uuid,
-                                       stripe_getxattr_unwind,
-                                       stripe_marker_populate_args) == 0)
-        return 0;
-
-    STACK_WIND(frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
-
-    return 0;
-
-err:
-    STRIPE_STACK_UNWIND(getxattr, frame, -1, op_errno, NULL, NULL);
-    return 0;
-}
-
-static gf_boolean_t
-stripe_is_special_xattr(const char *name)
-{
-    gf_boolean_t is_spl = _gf_false;
-
-    if (!name) {
-        goto out;
-    }
-
-    if (!strncmp(name, GF_XATTR_LOCKINFO_KEY, SLEN(GF_XATTR_LOCKINFO_KEY)) ||
-        XATTR_IS_PATHINFO(name))
-        is_spl = _gf_true;
-out:
-    return is_spl;
-}
-
-int32_t
-stripe_fgetxattr_from_everyone(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                               const char *name, dict_t *xdata)
-{
-    stripe_local_t *local = NULL;
-    stripe_private_t *priv = NULL;
-    int32_t ret = -1, op_errno = 0;
-    int i = 0;
-    xlator_list_t *trav = NULL;
-
-    priv = this->private;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    local->op_ret = -1;
-    frame->local = local;
-
-    strncpy(local->xsel, name, strlen(name));
-    local->nallocs = local->wind_count = priv->child_count;
-
-    for (i = 0, trav = this->children; i < priv->child_count;
-         i++, trav = trav->next) {
-        STACK_WIND_COOKIE(frame, stripe_vgetxattr_cbk, (void *)(long)i,
-                          trav->xlator, trav->xlator->fops->fgetxattr, fd, name,
-                          xdata);
-    }
-
-    return 0;
-
-err:
-    STACK_UNWIND_STRICT(fgetxattr, frame, -1, op_errno, NULL, NULL);
-    return ret;
-}
-
-int32_t
-stripe_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name, dict_t *xdata)
-{
-    if (stripe_is_special_xattr(name)) {
-        stripe_fgetxattr_from_everyone(frame, this, fd, name, xdata);
-        goto out;
-    }
-
-    STACK_WIND(frame, stripe_internal_getxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
-
-out:
-    return 0;
-}
-
-int32_t
-stripe_priv_dump(xlator_t *this)
-{
-    char key[GF_DUMP_MAX_BUF_LEN];
-    int i = 0;
-    stripe_private_t *priv = NULL;
-    int ret = -1;
-    struct stripe_options *options = NULL;
-
-    GF_VALIDATE_OR_GOTO("stripe", this, out);
-
-    priv = this->private;
-    if (!priv)
-        goto out;
-
-    ret = TRY_LOCK(&priv->lock);
-    if (ret != 0)
-        goto out;
-
-    gf_proc_dump_add_section("xlator.cluster.stripe.%s.priv", this->name);
-    gf_proc_dump_write("child_count", "%d", priv->child_count);
-
-    for (i = 0; i < priv->child_count; i++) {
-        sprintf(key, "subvolumes[%d]", i);
-        gf_proc_dump_write(key, "%s.%s", priv->xl_array[i]->type,
-                           priv->xl_array[i]->name);
-    }
-
-    options = priv->pattern;
-    while (options != NULL) {
-        gf_proc_dump_write("path_pattern", "%s", priv->pattern->path_pattern);
-        gf_proc_dump_write("options_block_size", "%ul", options->block_size);
-
-        options = options->next;
-    }
-
-    gf_proc_dump_write("block_size", "%ul", priv->block_size);
-    gf_proc_dump_write("nodes-down", "%d", priv->nodes_down);
-    gf_proc_dump_write("first-child_down", "%d", priv->first_child_down);
-    gf_proc_dump_write("xattr_supported", "%d", priv->xattr_supported);
-
-    UNLOCK(&priv->lock);
-
-out:
-    return ret;
-}
-
-struct xlator_fops fops = {
-    .stat = stripe_stat,
-    .unlink = stripe_unlink,
-    .rename = stripe_rename,
-    .link = stripe_link,
-    .truncate = stripe_truncate,
-    .create = stripe_create,
-    .open = stripe_open,
-    .readv = stripe_readv,
-    .writev = stripe_writev,
-    .statfs = stripe_statfs,
-    .flush = stripe_flush,
-    .fsync = stripe_fsync,
-    .ftruncate = stripe_ftruncate,
-    .fstat = stripe_fstat,
-    .mkdir = stripe_mkdir,
-    .rmdir = stripe_rmdir,
-    .lk = stripe_lk,
-    .opendir = stripe_opendir,
-    .fsyncdir = stripe_fsyncdir,
-    .setattr = stripe_setattr,
-    .fsetattr = stripe_fsetattr,
-    .lookup = stripe_lookup,
-    .mknod = stripe_mknod,
-    .setxattr = stripe_setxattr,
-    .fsetxattr = stripe_fsetxattr,
-    .getxattr = stripe_getxattr,
-    .fgetxattr = stripe_fgetxattr,
-    .removexattr = stripe_removexattr,
-    .fremovexattr = stripe_fremovexattr,
-    .readdirp = stripe_readdirp,
-    .fallocate = stripe_fallocate,
-    .discard = stripe_discard,
-    .zerofill = stripe_zerofill,
-    .seek = stripe_seek,
-};
-
-struct xlator_cbks cbks = {
-    .release = stripe_release,
-    .forget = stripe_forget,
-};
-
-struct xlator_dumpops dumpops = {
-    .priv = stripe_priv_dump,
-};
-
-struct volume_options options[] = {
-    {
-        .key = {"block-size"},
-        .type = GF_OPTION_TYPE_SIZE_LIST,
-        .default_value = "128KB",
-        .min = STRIPE_MIN_BLOCK_SIZE,
-        .description = "Size of the stripe unit that would be read "
-                       "from or written to the striped servers.",
-        .op_version = {1},
-        .tags = {"stripe"},
-        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-    },
-    {
-        .key = {"use-xattr"},
-        .type = GF_OPTION_TYPE_BOOL,
-        .default_value = "true",
-        .description = "handle the stripe without the xattr",
-        .tags = {"stripe", "dev-only"},
-        .flags = OPT_FLAG_CLIENT_OPT,
-    },
-    {
-        .key = {"coalesce"},
-        .type = GF_OPTION_TYPE_BOOL,
-        .default_value = "true",
-        .description = "Enable/Disable coalesce mode to flatten striped "
-                       "files as stored on the server (i.e., eliminate holes "
-                       "caused by the traditional format).",
-        .op_version = {1},
-        .flags = OPT_FLAG_CLIENT_OPT | OPT_FLAG_SETTABLE,
-        .tags = {"stripe"},
-    },
-    {.key = {NULL}},
-};
diff --git a/xlators/cluster/stripe/src/stripe.h b/xlators/cluster/stripe/src/stripe.h
deleted file mode 100644
index 88c24b682b8..00000000000
--- a/xlators/cluster/stripe/src/stripe.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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 _STRIPE_H_
-#define _STRIPE_H_
-
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/defaults.h>
-#include <glusterfs/common-utils.h>
-#include <glusterfs/compat.h>
-#include <glusterfs/compat-errno.h>
-#include "stripe-mem-types.h"
-#include "libxlator.h"
-#include <fnmatch.h>
-#include <signal.h>
-
-#define STRIPE_PATHINFO_HEADER "STRIPE:"
-#define STRIPE_MIN_BLOCK_SIZE (16 * GF_UNIT_KB)
-
-#define STRIPE_STACK_UNWIND(fop, frame, params...)                             \
-    do {                                                                       \
-        stripe_local_t *__local = NULL;                                        \
-        if (frame) {                                                           \
-            __local = frame->local;                                            \
-            frame->local = NULL;                                               \
-        }                                                                      \
-        STACK_UNWIND_STRICT(fop, frame, params);                               \
-        if (__local) {                                                         \
-            stripe_local_wipe(__local);                                        \
-            mem_put(__local);                                                  \
-        }                                                                      \
-    } while (0)
-
-#define STRIPE_STACK_DESTROY(frame)                                            \
-    do {                                                                       \
-        stripe_local_t *__local = NULL;                                        \
-        __local = frame->local;                                                \
-        frame->local = NULL;                                                   \
-        STACK_DESTROY(frame->root);                                            \
-        if (__local) {                                                         \
-            stripe_local_wipe(__local);                                        \
-            mem_put(__local);                                                  \
-        }                                                                      \
-    } while (0)
-
-#define STRIPE_VALIDATE_FCTX(fctx, label)                                      \
-    do {                                                                       \
-        int idx = 0;                                                           \
-        if (!fctx) {                                                           \
-            op_errno = EINVAL;                                                 \
-            goto label;                                                        \
-        }                                                                      \
-        for (idx = 0; idx < fctx->stripe_count; idx++) {                       \
-            if (!fctx->xl_array[idx]) {                                        \
-                gf_log(this->name, GF_LOG_ERROR, "fctx->xl_array[%d] is NULL", \
-                       idx);                                                   \
-                op_errno = ESTALE;                                             \
-                goto label;                                                    \
-            }                                                                  \
-        }                                                                      \
-    } while (0)
-
-typedef struct stripe_xattr_sort {
-    int pos;
-    int xattr_len;
-    char *xattr_value;
-} stripe_xattr_sort_t;
-
-/**
- * struct stripe_options : This keeps the pattern and the block-size
- *     information, which is used for striping on a file.
- */
-struct stripe_options {
-    struct stripe_options *next;
-    char path_pattern[256];
-    uint64_t block_size;
-};
-
-/**
- * Private structure for stripe translator
- */
-struct stripe_private {
-    struct stripe_options *pattern;
-    xlator_t **xl_array;
-    uint64_t block_size;
-    gf_lock_t lock;
-    uint8_t nodes_down;
-    int8_t first_child_down;
-    int *last_event;
-    int8_t child_count;
-    gf_boolean_t xattr_supported; /* default yes */
-    gf_boolean_t coalesce;
-    char vol_uuid[UUID_SIZE + 1];
-};
-
-/**
- * Used to keep info about the replies received from readv/writev calls
- */
-struct stripe_replies {
-    struct iovec *vector;
-    int32_t count;   // count of vector
-    int32_t op_ret;  // op_ret of readv
-    int32_t op_errno;
-    int32_t requested_size;
-    struct iatt stbuf; /* 'stbuf' is also a part of reply */
-};
-
-typedef struct _stripe_fd_ctx {
-    off_t stripe_size;
-    int stripe_count;
-    int stripe_coalesce;
-    int static_array;
-    xlator_t **xl_array;
-} stripe_fd_ctx_t;
-
-/**
- * Local structure to be passed with all the frames in case of STACK_WIND
- */
-struct stripe_local; /* this itself is used inside the structure; */
-
-struct stripe_local {
-    struct stripe_local *next;
-    call_frame_t *orig_frame;
-
-    stripe_fd_ctx_t *fctx;
-
-    /* Used by _cbk functions */
-    struct iatt stbuf;
-    struct iatt pre_buf;
-    struct iatt post_buf;
-    struct iatt preparent;
-    struct iatt postparent;
-
-    off_t stbuf_size;
-    off_t prebuf_size;
-    off_t postbuf_size;
-    off_t preparent_size;
-    off_t postparent_size;
-
-    blkcnt_t stbuf_blocks;
-    blkcnt_t prebuf_blocks;
-    blkcnt_t postbuf_blocks;
-    blkcnt_t preparent_blocks;
-    blkcnt_t postparent_blocks;
-
-    struct stripe_replies *replies;
-    struct statvfs statvfs_buf;
-    dir_entry_t *entry;
-
-    int8_t revalidate;
-    int8_t failed;
-    int8_t unwind;
-
-    size_t readv_size;
-    int32_t entry_count;
-    int32_t node_index;
-    int32_t call_count;
-    int32_t wind_count; /* used instead of child_cound
-                           in case of read and write */
-    int32_t op_ret;
-    int32_t op_errno;
-    int32_t count;
-    int32_t flags;
-    char *name;
-    inode_t *inode;
-
-    loc_t loc;
-    loc_t loc2;
-
-    mode_t mode;
-    dev_t rdev;
-    /* For File I/O fops */
-    dict_t *xdata;
-
-    stripe_xattr_sort_t *xattr_list;
-    int32_t xattr_total_len;
-    int32_t nallocs;
-    char xsel[256];
-
-    /* General usage */
-    off_t offset;
-    off_t stripe_size;
-
-    int xattr_self_heal_needed;
-    int entry_self_heal_needed;
-
-    int8_t *list;
-    struct gf_flock lock;
-    fd_t *fd;
-    void *value;
-    struct iobref *iobref;
-    gf_dirent_t entries;
-    gf_dirent_t *dirent;
-    dict_t *xattr;
-    uuid_t ia_gfid;
-
-    int xflag;
-    mode_t umask;
-};
-
-typedef struct stripe_local stripe_local_t;
-typedef struct stripe_private stripe_private_t;
-
-/*
- * Determine the stripe index of a particular frame based on the translator.
- */
-static inline int32_t
-stripe_get_frame_index(stripe_fd_ctx_t *fctx, call_frame_t *prev)
-{
-    int32_t i, idx = -1;
-
-    for (i = 0; i < fctx->stripe_count; i++) {
-        if (fctx->xl_array[i] == prev->this) {
-            idx = i;
-            break;
-        }
-    }
-
-    return idx;
-}
-
-static inline void
-stripe_copy_xl_array(xlator_t **dst, xlator_t **src, int count)
-{
-    int i;
-
-    for (i = 0; i < count; i++)
-        dst[i] = src[i];
-}
-
-void
-stripe_local_wipe(stripe_local_t *local);
-int32_t
-stripe_ctx_handle(xlator_t *this, call_frame_t *prev, stripe_local_t *local,
-                  dict_t *dict);
-void
-stripe_aggregate_xattr(dict_t *dst, dict_t *src);
-int32_t
-stripe_xattr_request_build(xlator_t *this, dict_t *dict, uint64_t stripe_size,
-                           uint32_t stripe_count, uint32_t stripe_index,
-                           uint32_t stripe_coalesce);
-int32_t
-stripe_get_matching_bs(const char *path, stripe_private_t *priv);
-int
-set_stripe_block_size(xlator_t *this, stripe_private_t *priv, char *data);
-int32_t
-stripe_iatt_merge(struct iatt *from, struct iatt *to);
-int32_t
-stripe_fill_pathinfo_xattr(xlator_t *this, stripe_local_t *local,
-                           char **xattr_serz);
-int32_t
-stripe_free_xattr_str(stripe_local_t *local);
-int32_t
-stripe_xattr_aggregate(char *buffer, stripe_local_t *local, int32_t *total);
-off_t
-coalesced_offset(off_t offset, uint64_t stripe_size, int stripe_count);
-off_t
-uncoalesced_size(off_t size, uint64_t stripe_size, int stripe_count,
-                 int stripe_index);
-int32_t
-stripe_fill_lockinfo_xattr(xlator_t *this, stripe_local_t *local,
-                           void **xattr_serz);
-
-/*
- * Adjust the size attribute for files if coalesce is enabled.
- */
-static inline void
-correct_file_size(struct iatt *buf, stripe_fd_ctx_t *fctx, call_frame_t *prev)
-{
-    int index;
-
-    if (!IA_ISREG(buf->ia_type))
-        return;
-
-    if (!fctx || !fctx->stripe_coalesce)
-        return;
-
-    index = stripe_get_frame_index(fctx, prev);
-    buf->ia_size = uncoalesced_size(buf->ia_size, fctx->stripe_size,
-                                    fctx->stripe_count, index);
-}
-
-#endif /* _STRIPE_H_ */
diff --git a/xlators/encryption/Makefile.am b/xlators/encryption/Makefile.am
deleted file mode 100644
index 36efc6698bd..00000000000
--- a/xlators/encryption/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = rot-13 crypt
-
-CLEANFILES = 
diff --git a/xlators/encryption/crypt/Makefile.am b/xlators/encryption/crypt/Makefile.am
deleted file mode 100644
index d471a3f9243..00000000000
--- a/xlators/encryption/crypt/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES = 
diff --git a/xlators/encryption/crypt/src/Makefile.am b/xlators/encryption/crypt/src/Makefile.am
deleted file mode 100644
index 05fd3d5096b..00000000000
--- a/xlators/encryption/crypt/src/Makefile.am
+++ /dev/null
@@ -1,26 +0,0 @@
-if ENABLE_CRYPT_XLATOR
-
-xlator_LTLIBRARIES = crypt.la
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/encryption
-
-crypt_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-
-crypt_la_SOURCES = keys.c data.c metadata.c atom.c crypt.c
-crypt_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	-lssl -lcrypto
-
-noinst_HEADERS = crypt-common.h crypt-mem-types.h crypt.h metadata.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-CLEANFILES =
-
-else
-
-noinst_DIST = keys.c data.c metadata.c atom.c crypt.c
-noinst_HEADERS = crypt-common.h crypt-mem-types.h crypt.h metadata.h
-
-endif
diff --git a/xlators/encryption/crypt/src/atom.c b/xlators/encryption/crypt/src/atom.c
deleted file mode 100644
index bdc37c500a3..00000000000
--- a/xlators/encryption/crypt/src/atom.c
+++ /dev/null
@@ -1,861 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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.
-*/
-
-#include <glusterfs/defaults.h>
-#include "crypt-common.h"
-#include "crypt.h"
-
-/*
- *                              Glossary
- *
- *
- * cblock            (or cipher block). A logical unit in a file.
- *                   cblock size is defined as the number of bits
- *                   in an input (or output) block of the block
- *                   cipher (*). Cipher block size is a property of
- *                   cipher algorithm. E.g. cblock size is 64 bits
- *                   for DES, 128 bits for AES, etc.
- *
- * atomic cipher     A cipher algorithm, which requires some chunks of
- * algorithm         text to be padded at left and(or) right sides before
- *                   cipher transaform.
- *
- *
- * block (atom)      Minimal chunk of file's data, which doesn't require
- *                   padding. We'll consider logical units in a file of
- *                   block size (atom size).
- *
- * cipher algorithm  Atomic cipher algorithm, which requires the last
- * with EOF issue    incomplete cblock in a file to be padded with some
- *                   data (usually zeros).
- *
- *
- * operation, which  reading/writing from offset, which is not aligned to
- * forms a gap at    to atom size
- * the beginning
- *
- *
- * operation, which  reading/writing count bytes starting from offset off,
- * forms a gap at    so that off+count is not aligned to atom_size
- * the end
- *
- * head block        the first atom affected by an operation, which forms
- *                   a gap at the beginning, or(and) at the end.
- *                   Сomment. Head block has at least one gap (either at
- *                   the beginning, or at the end)
- *
- *
- * tail block        the last atom different from head, affected by an
- *                   operation, which forms a gap at the end.
- *                   Сomment: Tail block has exactly one gap (at the end).
- *
- *
- * partial block     head or tail block
- *
- *
- * full block        block without gaps.
- *
- *
- * (*) Recommendation for Block Cipher Modes of Operation
- *     Methods and Techniques
- *     NIST Special Publication 800-38A Edition 2001
- */
-
-/*
- * atom->offset_at()
- */
-static off_t
-offset_at_head(struct avec_config *conf)
-{
-    return conf->aligned_offset;
-}
-
-static off_t
-offset_at_hole_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_head(get_hole_conf(frame));
-}
-
-static off_t
-offset_at_data_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_head(get_data_conf(frame));
-}
-
-static off_t
-offset_at_tail(struct avec_config *conf, struct object_cipher_info *object)
-{
-    return conf->aligned_offset +
-           (conf->off_in_head ? get_atom_size(object) : 0) +
-           (conf->nr_full_blocks << get_atom_bits(object));
-}
-
-static off_t
-offset_at_hole_tail(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_tail(get_hole_conf(frame), object);
-}
-
-static off_t
-offset_at_data_tail(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_tail(get_data_conf(frame), object);
-}
-
-static off_t
-offset_at_full(struct avec_config *conf, struct object_cipher_info *object)
-{
-    return conf->aligned_offset +
-           (conf->off_in_head ? get_atom_size(object) : 0);
-}
-
-static off_t
-offset_at_data_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_full(get_data_conf(frame), object);
-}
-
-static off_t
-offset_at_hole_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_at_full(get_hole_conf(frame), object);
-}
-
-/*
- * atom->io_size_nopad()
- */
-
-static uint32_t
-io_size_nopad_head(struct avec_config *conf, struct object_cipher_info *object)
-{
-    uint32_t gap_at_beg;
-    uint32_t gap_at_end;
-
-    check_head_block(conf);
-
-    gap_at_beg = conf->off_in_head;
-
-    if (has_tail_block(conf) || has_full_blocks(conf) || conf->off_in_tail == 0)
-        gap_at_end = 0;
-    else
-        gap_at_end = get_atom_size(object) - conf->off_in_tail;
-
-    return get_atom_size(object) - (gap_at_beg + gap_at_end);
-}
-
-static uint32_t
-io_size_nopad_tail(struct avec_config *conf, struct object_cipher_info *object)
-{
-    check_tail_block(conf);
-    return conf->off_in_tail;
-}
-
-static uint32_t
-io_size_nopad_full(struct avec_config *conf, struct object_cipher_info *object)
-{
-    check_full_block(conf);
-    return get_atom_size(object);
-}
-
-static uint32_t
-io_size_nopad_data_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_head(get_data_conf(frame), object);
-}
-
-static uint32_t
-io_size_nopad_hole_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_head(get_hole_conf(frame), object);
-}
-
-static uint32_t
-io_size_nopad_data_tail(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_tail(get_data_conf(frame), object);
-}
-
-static uint32_t
-io_size_nopad_hole_tail(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_tail(get_hole_conf(frame), object);
-}
-
-static uint32_t
-io_size_nopad_data_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_full(get_data_conf(frame), object);
-}
-
-static uint32_t
-io_size_nopad_hole_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return io_size_nopad_full(get_hole_conf(frame), object);
-}
-
-static uint32_t
-offset_in_head(struct avec_config *conf)
-{
-    check_cursor_head(conf);
-
-    return conf->off_in_head;
-}
-
-static uint32_t
-offset_in_tail(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return 0;
-}
-
-static uint32_t
-offset_in_full(struct avec_config *conf, struct object_cipher_info *object)
-{
-    check_cursor_full(conf);
-
-    if (has_head_block(conf))
-        return (conf->cursor - 1) << get_atom_bits(object);
-    else
-        return conf->cursor << get_atom_bits(object);
-}
-
-static uint32_t
-offset_in_data_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_in_head(get_data_conf(frame));
-}
-
-static uint32_t
-offset_in_hole_head(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_in_head(get_hole_conf(frame));
-}
-
-static uint32_t
-offset_in_data_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_in_full(get_data_conf(frame), object);
-}
-
-static uint32_t
-offset_in_hole_full(call_frame_t *frame, struct object_cipher_info *object)
-{
-    return offset_in_full(get_hole_conf(frame), object);
-}
-
-/*
- * atom->rmw()
- */
-/*
- * Pre-conditions:
- * @vec contains plain text of the latest
- * version.
- *
- * Uptodate gaps of the @partial block with
- * this plain text, encrypt the whole block
- * and write the result to disk.
- */
-static int32_t
-rmw_partial_block(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iovec *vec,
-                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                  struct rmw_atom *atom)
-{
-    size_t was_read = 0;
-    uint64_t file_size;
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    struct iovec *partial = atom->get_iovec(frame, 0);
-    struct avec_config *conf = atom->get_config(frame);
-    end_writeback_handler_t end_writeback_partial_block;
-#if DEBUG_CRYPT
-    gf_boolean_t check_last_cblock = _gf_false;
-#endif
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0)
-        goto exit;
-
-    file_size = local->cur_file_size;
-    was_read = op_ret;
-
-    if (atom->locality == HEAD_ATOM && conf->off_in_head) {
-        /*
-         * head atom with a non-uptodate gap
-         * at the beginning
-         *
-         * fill the gap with plain text of the
-         * latest version. Convert a part of hole
-         * (if any) to zeros.
-         */
-        int32_t i;
-        int32_t copied = 0;
-        int32_t to_gap; /* amount of data needed to uptodate
-                           the gap at the beginning */
-#if 0
-		int32_t hole = 0; /* The part of the hole which
-				   * got in the head block */
-#endif /* 0 */
-        to_gap = conf->off_in_head;
-
-        if (was_read < to_gap) {
-            if (file_size > offset_at_head(conf) + was_read) {
-                /*
-                 * It is impossible to uptodate
-                 * head block: too few bytes have
-                 * been read from disk, so that
-                 * partial write is impossible.
-                 *
-                 * It could happen because of many
-                 * reasons: IO errors, (meta)data
-                 * corruption in the local file system,
-                 * etc.
-                 */
-                gf_log(this->name, GF_LOG_WARNING,
-                       "Can not uptodate a gap at the beginning");
-                local->op_ret = -1;
-                local->op_errno = EIO;
-                goto exit;
-            }
-#if 0
-			hole = to_gap - was_read;
-#endif /* 0 */
-            to_gap = was_read;
-        }
-        /*
-         * uptodate the gap at the beginning
-         */
-        for (i = 0; i < count && copied < to_gap; i++) {
-            int32_t to_copy;
-
-            to_copy = vec[i].iov_len;
-            if (to_copy > to_gap - copied)
-                to_copy = to_gap - copied;
-
-            memcpy(partial->iov_base, vec[i].iov_base, to_copy);
-            copied += to_copy;
-        }
-#if 0
-		/*
-		 * If possible, convert part of the
-		 * hole, which got in the head block
-		 */
-		ret = TRY_LOCK(&local->hole_lock);
-		if (!ret) {
-			if (local->hole_handled)
-				/*
-				 * already converted by
-				 * crypt_writev_cbk()
-				 */
-				UNLOCK(&local->hole_lock);
-			else {
-				/*
-				 * convert the part of the hole
-				 * which got in the head block
-				 * to zeros.
-				 *
-				 * Update the orig_offset to make
-				 * sure writev_cbk() won't care
-				 * about this part of the hole.
-				 *
-				 */
-				memset(partial->iov_base + to_gap, 0, hole);
-
-				conf->orig_offset -= hole;
-				conf->orig_size += hole;
-				UNLOCK(&local->hole_lock);
-			}
-		}
-		else /*
-		      * conversion is being performed
-		      * by crypt_writev_cbk()
-		      */
-			;
-#endif /* 0 */
-    }
-    if (atom->locality == TAIL_ATOM ||
-        (!has_tail_block(conf) && conf->off_in_tail)) {
-        /*
-         * tail atom, or head atom with a non-uptodate
-         * gap at the end.
-         *
-         * fill the gap at the end of the block
-         * with plain text of the latest version.
-         * Pad the result, (if needed)
-         */
-        int32_t i;
-        int32_t to_gap;
-        int copied;
-        off_t off_in_tail;
-        int32_t to_copy;
-
-        off_in_tail = conf->off_in_tail;
-        to_gap = conf->gap_in_tail;
-
-        if (to_gap && was_read < off_in_tail + to_gap) {
-            /*
-             * It is impossible to uptodate
-             * the gap at the end: too few bytes
-             * have been read from disk, so that
-             * partial write is impossible.
-             *
-             * It could happen because of many
-             * reasons: IO errors, (meta)data
-             * corruption in the local file system,
-             * etc.
-             */
-            gf_log(this->name, GF_LOG_WARNING,
-                   "Can not uptodate a gap at the end");
-            local->op_ret = -1;
-            local->op_errno = EIO;
-            goto exit;
-        }
-        /*
-         * uptodate the gap at the end
-         */
-        copied = 0;
-        to_copy = to_gap;
-        for (i = count - 1; i >= 0 && to_copy > 0; i--) {
-            uint32_t from_vec, off_in_vec;
-
-            off_in_vec = 0;
-            from_vec = vec[i].iov_len;
-            if (from_vec > to_copy) {
-                off_in_vec = from_vec - to_copy;
-                from_vec = to_copy;
-            }
-            memcpy(partial->iov_base + off_in_tail + to_gap - copied - from_vec,
-                   vec[i].iov_base + off_in_vec, from_vec);
-
-            gf_log(
-                this->name, GF_LOG_DEBUG,
-                "uptodate %d bytes at tail. Offset at target(source): %d(%d)",
-                (int)from_vec, (int)off_in_tail + to_gap - copied - from_vec,
-                (int)off_in_vec);
-
-            copied += from_vec;
-            to_copy -= from_vec;
-        }
-        partial->iov_len = off_in_tail + to_gap;
-
-        if (object_alg_should_pad(object)) {
-            int32_t resid = 0;
-            resid = partial->iov_len & (object_alg_blksize(object) - 1);
-            if (resid) {
-                /*
-                 * append a new EOF padding
-                 */
-                local->eof_padding_size = object_alg_blksize(object) - resid;
-
-                gf_log(this->name, GF_LOG_DEBUG, "set padding size %d",
-                       local->eof_padding_size);
-
-                memset(partial->iov_base + partial->iov_len, 1,
-                       local->eof_padding_size);
-                partial->iov_len += local->eof_padding_size;
-#if DEBUG_CRYPT
-                gf_log(this->name, GF_LOG_DEBUG,
-                       "pad cblock with %d zeros:", local->eof_padding_size);
-                dump_cblock(this, (unsigned char *)partial->iov_base +
-                                      partial->iov_len -
-                                      object_alg_blksize(object));
-                check_last_cblock = _gf_true;
-#endif
-            }
-        }
-    }
-    /*
-     * encrypt the whole block
-     */
-    encrypt_aligned_iov(object, partial, 1, atom->offset_at(frame, object));
-#if DEBUG_CRYPT
-    if (check_last_cblock == _gf_true) {
-        gf_log(this->name, GF_LOG_DEBUG, "encrypt last cblock with offset %llu",
-               (unsigned long long)atom->offset_at(frame, object));
-        dump_cblock(this, (unsigned char *)partial->iov_base +
-                              partial->iov_len - object_alg_blksize(object));
-    }
-#endif
-    set_local_io_params_writev(frame, object, atom,
-                               atom->offset_at(frame, object),
-                               iov_length(partial, 1));
-    /*
-     * write the whole block to disk
-     */
-    end_writeback_partial_block = dispatch_end_writeback(local->fop);
-    conf->cursor++;
-    STACK_WIND(frame, end_writeback_partial_block, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->writev, local->fd, partial, 1,
-               atom->offset_at(frame, object), local->flags, local->iobref_data,
-               local->xdata);
-
-    gf_log("crypt", GF_LOG_DEBUG,
-           "submit partial block: %d bytes from %d offset",
-           (int)iov_length(partial, 1), (int)atom->offset_at(frame, object));
-exit:
-    return 0;
-}
-
-/*
- * Perform a (read-)modify-write sequence.
- * This should be performed only after approval
- * of upper server-side manager, i.e. the caller
- * needs to make sure this is his turn to rmw.
- */
-void
-submit_partial(call_frame_t *frame, xlator_t *this, fd_t *fd,
-               atom_locality_type ltype)
-{
-    int32_t ret;
-    dict_t *dict;
-    struct rmw_atom *atom;
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    atom = atom_by_types(local->active_setup, ltype);
-    /*
-     * To perform the "read" component of the read-modify-write
-     * sequence the crypt translator does stack_wind to itself.
-     *
-     * Pass current file size to crypt_readv()
-     */
-    dict = dict_new();
-    if (!dict) {
-        /*
-         * FIXME: Handle the error
-         */
-        gf_log("crypt", GF_LOG_WARNING, "Can not alloc dict");
-        return;
-    }
-    ret = dict_set(dict, FSIZE_XATTR_PREFIX,
-                   data_from_uint64(local->cur_file_size));
-    if (ret) {
-        /*
-         * FIXME: Handle the error
-         */
-        dict_unref(dict);
-        gf_log("crypt", GF_LOG_WARNING, "Can not set dict");
-        goto exit;
-    }
-    STACK_WIND(frame, atom->rmw, this, this->fops->readv,  /* crypt_readv */
-               fd, atom->count_to_uptodate(frame, object), /* count */
-               atom->offset_at(frame, object), /* offset to read from */
-               0, dict);
-exit:
-    dict_unref(dict);
-}
-
-/*
- * submit blocks of FULL_ATOM type
- */
-void
-submit_full(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-    struct rmw_atom *atom = atom_by_types(local->active_setup, FULL_ATOM);
-    uint32_t count;       /* total number of full blocks to submit */
-    uint32_t granularity; /* number of blocks to submit in one iteration */
-
-    uint64_t off_in_file;        /* start offset in the file, bytes */
-    uint32_t off_in_atom;        /* start offset in the atom, blocks */
-    uint32_t blocks_written = 0; /* blocks written for this submit */
-
-    struct avec_config *conf = atom->get_config(frame);
-    end_writeback_handler_t end_writeback_full_block;
-    /*
-     * Write full blocks by groups of granularity size.
-     */
-    end_writeback_full_block = dispatch_end_writeback(local->fop);
-
-    if (is_ordered_mode(frame)) {
-        uint32_t skip = has_head_block(conf) ? 1 : 0;
-        count = 1;
-        granularity = 1;
-        /*
-         * calculate start offset using cursor value;
-         * here we should take into account head block,
-         * which corresponds to cursor value 0.
-         */
-        off_in_file = atom->offset_at(frame, object) +
-                      ((conf->cursor - skip) << get_atom_bits(object));
-        off_in_atom = conf->cursor - skip;
-    } else {
-        /*
-         * in parallel mode
-         */
-        count = conf->nr_full_blocks;
-        granularity = MAX_IOVEC;
-        off_in_file = atom->offset_at(frame, object);
-        off_in_atom = 0;
-    }
-    while (count) {
-        uint32_t blocks_to_write = count;
-
-        if (blocks_to_write > granularity)
-            blocks_to_write = granularity;
-        if (conf->type == HOLE_ATOM)
-            /*
-             * reset iovec before encryption
-             */
-            memset(atom->get_iovec(frame, 0)->iov_base, 0,
-                   get_atom_size(object));
-        /*
-         * encrypt the group
-         */
-        encrypt_aligned_iov(
-            object, atom->get_iovec(frame, off_in_atom + blocks_written),
-            blocks_to_write,
-            off_in_file + (blocks_written << get_atom_bits(object)));
-
-        set_local_io_params_writev(
-            frame, object, atom,
-            off_in_file + (blocks_written << get_atom_bits(object)),
-            blocks_to_write << get_atom_bits(object));
-
-        conf->cursor += blocks_to_write;
-
-        STACK_WIND(frame, end_writeback_full_block, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->writev, local->fd,
-                   atom->get_iovec(frame, off_in_atom + blocks_written),
-                   blocks_to_write,
-                   off_in_file + (blocks_written << get_atom_bits(object)),
-                   local->flags,
-                   local->iobref_data ? local->iobref_data : local->iobref,
-                   local->xdata);
-
-        gf_log("crypt", GF_LOG_DEBUG, "submit %d full blocks from %d offset",
-               blocks_to_write,
-               (int)(off_in_file + (blocks_written << get_atom_bits(object))));
-
-        count -= blocks_to_write;
-        blocks_written += blocks_to_write;
-    }
-    return;
-}
-
-static int32_t
-rmw_data_head(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iovec *vec, int32_t count,
-              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
-                             stbuf, iobref,
-                             atom_by_types(DATA_ATOM, HEAD_ATOM));
-}
-
-static int32_t
-rmw_data_tail(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iovec *vec, int32_t count,
-              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
-                             stbuf, iobref,
-                             atom_by_types(DATA_ATOM, TAIL_ATOM));
-}
-
-static int32_t
-rmw_hole_head(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iovec *vec, int32_t count,
-              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
-                             stbuf, iobref,
-                             atom_by_types(HOLE_ATOM, HEAD_ATOM));
-}
-
-static int32_t
-rmw_hole_tail(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iovec *vec, int32_t count,
-              struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    return rmw_partial_block(frame, cookie, this, op_ret, op_errno, vec, count,
-                             stbuf, iobref,
-                             atom_by_types(HOLE_ATOM, TAIL_ATOM));
-}
-
-/*
- * atom->count_to_uptodate()
- */
-static uint32_t
-count_to_uptodate_head(struct avec_config *conf,
-                       struct object_cipher_info *object)
-{
-    if (conf->acount == 1 && conf->off_in_tail)
-        return get_atom_size(object);
-    else
-        /* there is no need to read the whole head block */
-        return conf->off_in_head;
-}
-
-static uint32_t
-count_to_uptodate_tail(struct avec_config *conf,
-                       struct object_cipher_info *object)
-{
-    /* we need to read the whole tail block */
-    return get_atom_size(object);
-}
-
-static uint32_t
-count_to_uptodate_data_head(call_frame_t *frame,
-                            struct object_cipher_info *object)
-{
-    return count_to_uptodate_head(get_data_conf(frame), object);
-}
-
-static uint32_t
-count_to_uptodate_data_tail(call_frame_t *frame,
-                            struct object_cipher_info *object)
-{
-    return count_to_uptodate_tail(get_data_conf(frame), object);
-}
-
-static uint32_t
-count_to_uptodate_hole_head(call_frame_t *frame,
-                            struct object_cipher_info *object)
-{
-    return count_to_uptodate_head(get_hole_conf(frame), object);
-}
-
-static uint32_t
-count_to_uptodate_hole_tail(call_frame_t *frame,
-                            struct object_cipher_info *object)
-{
-    return count_to_uptodate_tail(get_hole_conf(frame), object);
-}
-
-/* atom->get_config() */
-
-static struct avec_config *
-get_config_data(call_frame_t *frame)
-{
-    return &((crypt_local_t *)frame->local)->data_conf;
-}
-
-static struct avec_config *
-get_config_hole(call_frame_t *frame)
-{
-    return &((crypt_local_t *)frame->local)->hole_conf;
-}
-
-/*
- * atom->get_iovec()
- */
-static struct iovec *
-get_iovec_hole_head(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_hole_conf(frame);
-
-    return conf->avec;
-}
-
-static struct iovec *
-get_iovec_hole_full(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_hole_conf(frame);
-
-    return conf->avec + (conf->off_in_head ? 1 : 0);
-}
-
-static struct iovec *
-get_iovec_hole_tail(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_hole_conf(frame);
-
-    return conf->avec + (conf->blocks_in_pool - 1);
-}
-
-static struct iovec *
-get_iovec_data_head(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_data_conf(frame);
-
-    return conf->avec;
-}
-
-static struct iovec *
-get_iovec_data_full(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_data_conf(frame);
-
-    return conf->avec + (conf->off_in_head ? 1 : 0) + count;
-}
-
-static struct iovec *
-get_iovec_data_tail(call_frame_t *frame, uint32_t count)
-{
-    struct avec_config *conf = get_data_conf(frame);
-
-    return conf->avec + (conf->off_in_head ? 1 : 0) + conf->nr_full_blocks;
-}
-
-static struct rmw_atom atoms[LAST_DATA_TYPE][LAST_LOCALITY_TYPE] = {
-    [DATA_ATOM][HEAD_ATOM] = {.locality = HEAD_ATOM,
-                              .rmw = rmw_data_head,
-                              .offset_at = offset_at_data_head,
-                              .offset_in = offset_in_data_head,
-                              .get_iovec = get_iovec_data_head,
-                              .io_size_nopad = io_size_nopad_data_head,
-                              .count_to_uptodate = count_to_uptodate_data_head,
-                              .get_config = get_config_data},
-    [DATA_ATOM][TAIL_ATOM] = {.locality = TAIL_ATOM,
-                              .rmw = rmw_data_tail,
-                              .offset_at = offset_at_data_tail,
-                              .offset_in = offset_in_tail,
-                              .get_iovec = get_iovec_data_tail,
-                              .io_size_nopad = io_size_nopad_data_tail,
-                              .count_to_uptodate = count_to_uptodate_data_tail,
-                              .get_config = get_config_data},
-    [DATA_ATOM][FULL_ATOM] = {.locality = FULL_ATOM,
-                              .offset_at = offset_at_data_full,
-                              .offset_in = offset_in_data_full,
-                              .get_iovec = get_iovec_data_full,
-                              .io_size_nopad = io_size_nopad_data_full,
-                              .get_config = get_config_data},
-    [HOLE_ATOM][HEAD_ATOM] = {.locality = HEAD_ATOM,
-                              .rmw = rmw_hole_head,
-                              .offset_at = offset_at_hole_head,
-                              .offset_in = offset_in_hole_head,
-                              .get_iovec = get_iovec_hole_head,
-                              .io_size_nopad = io_size_nopad_hole_head,
-                              .count_to_uptodate = count_to_uptodate_hole_head,
-                              .get_config = get_config_hole},
-    [HOLE_ATOM][TAIL_ATOM] = {.locality = TAIL_ATOM,
-                              .rmw = rmw_hole_tail,
-                              .offset_at = offset_at_hole_tail,
-                              .offset_in = offset_in_tail,
-                              .get_iovec = get_iovec_hole_tail,
-                              .io_size_nopad = io_size_nopad_hole_tail,
-                              .count_to_uptodate = count_to_uptodate_hole_tail,
-                              .get_config = get_config_hole},
-    [HOLE_ATOM][FULL_ATOM] = {.locality = FULL_ATOM,
-                              .offset_at = offset_at_hole_full,
-                              .offset_in = offset_in_hole_full,
-                              .get_iovec = get_iovec_hole_full,
-                              .io_size_nopad = io_size_nopad_hole_full,
-                              .get_config = get_config_hole}};
-
-struct rmw_atom *
-atom_by_types(atom_data_type data, atom_locality_type locality)
-{
-    return &atoms[data][locality];
-}
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/crypt-common.h b/xlators/encryption/crypt/src/crypt-common.h
deleted file mode 100644
index 123d5c2a631..00000000000
--- a/xlators/encryption/crypt/src/crypt-common.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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 __CRYPT_COMMON_H__
-#define __CRYPT_COMMON_H__
-
-#define INVAL_SUBVERSION_NUMBER (0xff)
-#define CRYPT_INVAL_OP (GF_FOP_NULL)
-
-#define CRYPTO_FORMAT_PREFIX "trusted.glusterfs.crypt.att.cfmt"
-#define FSIZE_XATTR_PREFIX "trusted.glusterfs.crypt.att.size"
-#define SUBREQ_PREFIX "trusted.glusterfs.crypt.msg.sreq"
-#define FSIZE_MSG_PREFIX "trusted.glusterfs.crypt.msg.size"
-#define DE_MSG_PREFIX "trusted.glusterfs.crypt.msg.dent"
-#define REQUEST_ID_PREFIX "trusted.glusterfs.crypt.msg.rqid"
-#define MSGFLAGS_PREFIX "trusted.glusterfs.crypt.msg.xfgs"
-
-/* messages for crypt_open() */
-#define MSGFLAGS_REQUEST_MTD_RLOCK 1 /* take read lock and don't unlock */
-#define MSGFLAGS_REQUEST_MTD_WLOCK 2 /* take write lock and don't unlock */
-
-#define AES_BLOCK_BITS (4) /* AES_BLOCK_SIZE == 1 << AES_BLOCK_BITS */
-
-#define noop                                                                   \
-    do {                                                                       \
-        ;                                                                      \
-    } while (0)
-#define cassert(cond)                                                          \
-    ({                                                                         \
-        switch (-1) {                                                          \
-            case (cond):                                                       \
-            case 0:                                                            \
-                break;                                                         \
-        }                                                                      \
-    })
-#define __round_mask(x, y) ((__typeof__(x))((y)-1))
-#define round_up(x, y) ((((x)-1) | __round_mask(x, y)) + 1)
-
-/*
- * Format of file's metadata
- */
-struct crypt_format {
-    uint8_t loader_id;    /* version of metadata loader */
-    uint8_t versioned[0]; /* file's metadata of specific version */
-} __attribute__((packed));
-
-typedef enum { AES_CIPHER_ALG, LAST_CIPHER_ALG } cipher_alg_t;
-
-typedef enum { XTS_CIPHER_MODE, LAST_CIPHER_MODE } cipher_mode_t;
-
-typedef enum { MTD_LOADER_V1, LAST_MTD_LOADER } mtd_loader_id;
-
-static inline void
-msgflags_set_mtd_rlock(uint32_t *flags)
-{
-    *flags |= MSGFLAGS_REQUEST_MTD_RLOCK;
-}
-
-static inline void
-msgflags_set_mtd_wlock(uint32_t *flags)
-{
-    *flags |= MSGFLAGS_REQUEST_MTD_WLOCK;
-}
-
-static inline gf_boolean_t
-msgflags_check_mtd_rlock(uint32_t *flags)
-{
-    return *flags & MSGFLAGS_REQUEST_MTD_RLOCK;
-}
-
-static inline gf_boolean_t
-msgflags_check_mtd_wlock(uint32_t *flags)
-{
-    return *flags & MSGFLAGS_REQUEST_MTD_WLOCK;
-}
-
-static inline gf_boolean_t
-msgflags_check_mtd_lock(uint32_t *flags)
-{
-    return msgflags_check_mtd_rlock(flags) || msgflags_check_mtd_wlock(flags);
-}
-
-/*
- * returns number of logical blocks occupied
- * (maybe partially) by @count bytes
- * at offset @start.
- */
-static inline off_t
-logical_blocks_occupied(uint64_t start, off_t count, int blkbits)
-{
-    return ((start + count - 1) >> blkbits) - (start >> blkbits) + 1;
-}
-
-/*
- * are two bytes (represented by offsets @off1
- * and @off2 respectively) in the same logical
- * block.
- */
-static inline int
-in_same_lblock(uint64_t off1, uint64_t off2, int blkbits)
-{
-    return off1 >> blkbits == off2 >> blkbits;
-}
-
-static inline void
-dump_cblock(xlator_t *this, unsigned char *buf)
-{
-    gf_log(this->name, GF_LOG_DEBUG,
-           "dump cblock: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
-           (buf)[0], (buf)[1], (buf)[2], (buf)[3], (buf)[4], (buf)[5], (buf)[6],
-           (buf)[7], (buf)[8], (buf)[9], (buf)[10], (buf)[11], (buf)[12],
-           (buf)[13], (buf)[14], (buf)[15]);
-}
-
-#endif /* __CRYPT_COMMON_H__ */
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/crypt-mem-types.h b/xlators/encryption/crypt/src/crypt-mem-types.h
deleted file mode 100644
index e756ea4a23c..00000000000
--- a/xlators/encryption/crypt/src/crypt-mem-types.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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 __CRYPT_MEM_TYPES_H__
-#define __CRYPT_MEM_TYPES_H__
-
-#include <glusterfs/mem-types.h>
-
-enum gf_crypt_mem_types_ {
-    gf_crypt_mt_priv = gf_common_mt_end + 1,
-    gf_crypt_mt_inode,
-    gf_crypt_mt_data,
-    gf_crypt_mt_mtd,
-    gf_crypt_mt_loc,
-    gf_crypt_mt_iatt,
-    gf_crypt_mt_key,
-    gf_crypt_mt_iovec,
-    gf_crypt_mt_char,
-    gf_crypt_mt_local,
-    gf_crypt_mt_end,
-};
-
-#endif /* __CRYPT_MEM_TYPES_H__ */
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/crypt.c b/xlators/encryption/crypt/src/crypt.c
deleted file mode 100644
index 02253642cc9..00000000000
--- a/xlators/encryption/crypt/src/crypt.c
+++ /dev/null
@@ -1,3906 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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.
-*/
-#include <ctype.h>
-#include <sys/uio.h>
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/defaults.h>
-
-#include "crypt-common.h"
-#include "crypt.h"
-
-static void
-init_inode_info_head(struct crypt_inode_info *info, fd_t *fd);
-static int32_t
-init_inode_info_tail(struct crypt_inode_info *info,
-                     struct master_cipher_info *master);
-static int32_t
-prepare_for_submit_hole(call_frame_t *frame, xlator_t *this, uint64_t from,
-                        off_t size);
-static int32_t
-load_file_size(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata);
-static void
-do_ordered_submit(call_frame_t *frame, xlator_t *this, atom_data_type dtype);
-static void
-do_parallel_submit(call_frame_t *frame, xlator_t *this, atom_data_type dtype);
-static void
-put_one_call_open(call_frame_t *frame);
-static void
-put_one_call_readv(call_frame_t *frame, xlator_t *this);
-static void
-put_one_call_writev(call_frame_t *frame, xlator_t *this);
-static void
-put_one_call_ftruncate(call_frame_t *frame, xlator_t *this);
-static void
-free_avec(struct iovec *avec, char **pool, int blocks_in_pool);
-static void
-free_avec_data(crypt_local_t *local);
-static void
-free_avec_hole(crypt_local_t *local);
-
-static crypt_local_t *
-crypt_alloc_local(call_frame_t *frame, xlator_t *this, glusterfs_fop_t fop)
-{
-    crypt_local_t *local = NULL;
-
-    local = GF_CALLOC(1, sizeof(crypt_local_t), gf_crypt_mt_local);
-    if (!local) {
-        gf_log(this->name, GF_LOG_ERROR, "out of memory");
-        return NULL;
-    }
-    local->fop = fop;
-    LOCK_INIT(&local->hole_lock);
-    LOCK_INIT(&local->call_lock);
-    LOCK_INIT(&local->rw_count_lock);
-
-    frame->local = local;
-    return local;
-}
-
-struct crypt_inode_info *
-get_crypt_inode_info(inode_t *inode, xlator_t *this)
-{
-    int ret;
-    uint64_t value = 0;
-    struct crypt_inode_info *info;
-
-    ret = inode_ctx_get(inode, this, &value);
-    if (ret == -1) {
-        gf_log(this->name, GF_LOG_WARNING, "Can not get inode info");
-        return NULL;
-    }
-    info = (struct crypt_inode_info *)(long)value;
-    if (info == NULL) {
-        gf_log(this->name, GF_LOG_WARNING, "Can not obtain inode info");
-        return NULL;
-    }
-    return info;
-}
-
-static struct crypt_inode_info *
-local_get_inode_info(crypt_local_t *local, xlator_t *this)
-{
-    if (local->info)
-        return local->info;
-    local->info = get_crypt_inode_info(local->fd->inode, this);
-    return local->info;
-}
-
-static struct crypt_inode_info *
-alloc_inode_info(crypt_local_t *local, loc_t *loc)
-{
-    struct crypt_inode_info *info;
-
-    info = GF_CALLOC(1, sizeof(struct crypt_inode_info), gf_crypt_mt_inode);
-    if (!info) {
-        local->op_ret = -1;
-        local->op_errno = ENOMEM;
-        gf_log("crypt", GF_LOG_WARNING, "Can not allocate inode info");
-        return NULL;
-    }
-#if DEBUG_CRYPT
-    info->loc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-    if (!info->loc) {
-        gf_log("crypt", GF_LOG_WARNING, "Can not allocate loc");
-        GF_FREE(info);
-        return NULL;
-    }
-    if (loc_copy(info->loc, loc)) {
-        GF_FREE(info->loc);
-        GF_FREE(info);
-        return NULL;
-    }
-#endif /* DEBUG_CRYPT */
-
-    local->info = info;
-    return info;
-}
-
-static void
-free_inode_info(struct crypt_inode_info *info)
-{
-#if DEBUG_CRYPT
-    loc_wipe(info->loc);
-    GF_FREE(info->loc);
-#endif
-    memset(info, 0, sizeof(*info));
-    GF_FREE(info);
-}
-
-int
-crypt_forget(xlator_t *this, inode_t *inode)
-{
-    uint64_t ctx_addr = 0;
-    if (!inode_ctx_del(inode, this, &ctx_addr))
-        free_inode_info((struct crypt_inode_info *)(long)ctx_addr);
-    return 0;
-}
-
-#if DEBUG_CRYPT
-static void
-check_read(call_frame_t *frame, xlator_t *this, int32_t read, struct iovec *vec,
-           int32_t count, struct iatt *stbuf)
-{
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = get_object_cinfo(local->info);
-    struct avec_config *conf = &local->data_conf;
-    uint32_t resid = stbuf->ia_size & (object_alg_blksize(object) - 1);
-
-    if (read <= 0)
-        return;
-    if (read != iov_length(vec, count))
-        gf_log("crypt", GF_LOG_DEBUG,
-               "op_ret differs from amount of read bytes");
-
-    if (object_alg_should_pad(object) &&
-        (read & (object_alg_blksize(object) - 1)))
-        gf_log("crypt", GF_LOG_DEBUG,
-               "bad amount of read bytes (!= 0 mod(cblock size))");
-
-    if (conf->aligned_offset + read >
-        stbuf->ia_size + (resid ? object_alg_blksize(object) - resid : 0))
-        gf_log("crypt", GF_LOG_DEBUG, "bad amount of read bytes (too large))");
-}
-
-#define PT_BYTES_TO_DUMP (32)
-static void
-dump_plain_text(crypt_local_t *local, struct iovec *avec)
-{
-    int32_t to_dump;
-    char str[PT_BYTES_TO_DUMP + 1];
-
-    if (!avec)
-        return;
-    to_dump = avec->iov_len;
-    if (to_dump > PT_BYTES_TO_DUMP)
-        to_dump = PT_BYTES_TO_DUMP;
-    memcpy(str, avec->iov_base, to_dump);
-    memset(str + to_dump, '0', 1);
-    gf_log("crypt", GF_LOG_DEBUG, "Read file: %s", str);
-}
-
-static int32_t
-data_conf_invariant(struct avec_config *conf)
-{
-    return conf->acount == !!has_head_block(conf) + !!has_tail_block(conf) +
-                               conf->nr_full_blocks;
-}
-
-static int32_t
-hole_conf_invariant(struct avec_config *conf)
-{
-    return conf->blocks_in_pool == !!has_head_block(conf) +
-                                       !!has_tail_block(conf) +
-                                       !!has_full_blocks(conf);
-}
-
-static void
-crypt_check_conf(struct avec_config *conf)
-{
-    int32_t ret = 0;
-    const char *msg;
-
-    switch (conf->type) {
-        case DATA_ATOM:
-            msg = "data";
-            ret = data_conf_invariant(conf);
-            break;
-        case HOLE_ATOM:
-            msg = "hole";
-            ret = hole_conf_invariant(conf);
-            break;
-        default:
-            msg = "unknown";
-    }
-    if (!ret)
-        gf_log("crypt", GF_LOG_DEBUG, "bad %s conf", msg);
-}
-
-static void
-check_buf(call_frame_t *frame, xlator_t *this, struct iatt *buf)
-{
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-    uint64_t local_file_size;
-
-    switch (local->fop) {
-        case GF_FOP_FTRUNCATE:
-            return;
-        case GF_FOP_WRITE:
-            local_file_size = local->new_file_size;
-            break;
-        case GF_FOP_READ:
-            if (parent_is_crypt_xlator(frame, this))
-                return;
-            local_file_size = local->cur_file_size;
-            break;
-        default:
-            gf_log("crypt", GF_LOG_DEBUG, "bad file operation");
-            return;
-    }
-    if (buf->ia_size != round_up(local_file_size, object_alg_blksize(object)))
-        gf_log("crypt", GF_LOG_DEBUG,
-               "bad ia_size in buf (%llu), should be %llu",
-               (unsigned long long)buf->ia_size,
-               (unsigned long long)round_up(local_file_size,
-                                            object_alg_blksize(object)));
-}
-
-#else
-#define check_read(frame, this, op_ret, vec, count, stbuf) noop
-#define dump_plain_text(local, avec) noop
-#define crypt_check_conf(conf) noop
-#define check_buf(frame, this, buf) noop
-#endif /* DEBUG_CRYPT */
-
-/*
- * Pre-conditions:
- * @vec represents a ciphertext of expanded size and
- * aligned offset.
- *
- * Compound a temporal vector @avec with block-aligned
- * components, decrypt and fix it up to represent a chunk
- * of data corresponding to the original size and offset.
- * Pass the result to the next translator.
- */
-int32_t
-crypt_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iovec *vec,
-                int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    struct iovec *avec;
-    uint32_t i;
-    uint32_t to_vec;
-    uint32_t to_user;
-
-    check_buf(frame, this, stbuf);
-    check_read(frame, this, op_ret, vec, count, stbuf);
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-    local->iobref = iobref_ref(iobref);
-
-    local->buf = *stbuf;
-    local->buf.ia_size = local->cur_file_size;
-
-    if (op_ret <= 0 || count == 0 || vec[0].iov_len == 0)
-        goto put_one_call;
-
-    if (conf->orig_offset >= local->cur_file_size) {
-        local->op_ret = 0;
-        goto put_one_call;
-    }
-    /*
-     * correct config params with real file size
-     * and actual amount of bytes read
-     */
-    set_config_offsets(frame, this, conf->orig_offset, op_ret, DATA_ATOM, 0);
-
-    if (conf->orig_offset + conf->orig_size > local->cur_file_size)
-        conf->orig_size = local->cur_file_size - conf->orig_offset;
-    /*
-     * calculate amount of data to be returned
-     * to user.
-     */
-    to_user = op_ret;
-    if (conf->aligned_offset + to_user <= conf->orig_offset) {
-        gf_log(this->name, GF_LOG_WARNING, "Incomplete read");
-        local->op_ret = -1;
-        local->op_errno = EIO;
-        goto put_one_call;
-    }
-    to_user -= (conf->aligned_offset - conf->orig_offset);
-
-    if (to_user > conf->orig_size)
-        to_user = conf->orig_size;
-    local->rw_count = to_user;
-
-    op_errno = set_config_avec_data(this, local, conf, object, vec, count);
-    if (op_errno) {
-        local->op_ret = -1;
-        local->op_errno = op_errno;
-        goto put_one_call;
-    }
-    avec = conf->avec;
-#if DEBUG_CRYPT
-    if (conf->off_in_tail != 0 &&
-        conf->off_in_tail < object_alg_blksize(object) &&
-        object_alg_should_pad(object))
-        gf_log(this->name, GF_LOG_DEBUG, "Bad offset in tail %d",
-               conf->off_in_tail);
-    if (iov_length(vec, count) != 0 &&
-        in_same_lblock(conf->orig_offset + iov_length(vec, count) - 1,
-                       local->cur_file_size - 1, object_alg_blkbits(object))) {
-        gf_log(this->name, GF_LOG_DEBUG, "Compound last cblock");
-        dump_cblock(this, (unsigned char *)(avec[conf->acount - 1].iov_base) +
-                              avec[conf->acount - 1].iov_len -
-                              object_alg_blksize(object));
-        dump_cblock(this, (unsigned char *)(vec[count - 1].iov_base) +
-                              vec[count - 1].iov_len -
-                              object_alg_blksize(object));
-    }
-#endif
-    decrypt_aligned_iov(object, avec, conf->acount, conf->aligned_offset);
-    /*
-     * pass proper plain data to user
-     */
-    avec[0].iov_base += (conf->aligned_offset - conf->orig_offset);
-    avec[0].iov_len -= (conf->aligned_offset - conf->orig_offset);
-
-    to_vec = to_user;
-    for (i = 0; i < conf->acount; i++) {
-        if (avec[i].iov_len > to_vec)
-            avec[i].iov_len = to_vec;
-        to_vec -= avec[i].iov_len;
-    }
-put_one_call:
-    put_one_call_readv(frame, this);
-    return 0;
-}
-
-static int32_t
-do_readv(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-         int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    data_t *data;
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto error;
-    /*
-     * extract regular file size
-     */
-    data = dict_get(dict, FSIZE_XATTR_PREFIX);
-    if (!data) {
-        gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-        op_errno = EIO;
-        goto error;
-    }
-    local->cur_file_size = data_to_uint64(data);
-
-    get_one_call(frame);
-    STACK_WIND(frame, crypt_readv_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readv, local->fd,
-               /*
-                * FIXME: read amount can be reduced
-                */
-               local->data_conf.expanded_size, local->data_conf.aligned_offset,
-               local->flags, local->xdata);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-
-    get_one_call(frame);
-    put_one_call_readv(frame, this);
-    return 0;
-}
-
-static int32_t
-crypt_readv_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto error;
-    /*
-     * An access has been granted,
-     * retrieve file size
-     */
-    STACK_WIND(frame, do_readv, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, local->fd,
-               FSIZE_XATTR_PREFIX, NULL);
-    return 0;
-error:
-    fd_unref(local->fd);
-    if (local->xdata)
-        dict_unref(local->xdata);
-    CRYPT_STACK_UNWIND(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL);
-    return 0;
-}
-
-static int32_t
-readv_trivial_completion(call_frame_t *frame, void *cookie, xlator_t *this,
-                         int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                         dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "stat failed (%d)", op_errno);
-        goto error;
-    }
-    local->buf = *buf;
-    STACK_WIND(frame, load_file_size, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->getxattr, local->loc,
-               FSIZE_XATTR_PREFIX, NULL);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(readv, frame, op_ret, op_errno, NULL, 0, NULL, NULL,
-                       NULL);
-    return 0;
-}
-
-int32_t
-crypt_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-            off_t offset, uint32_t flags, dict_t *xdata)
-{
-    int32_t ret;
-    crypt_local_t *local;
-    struct crypt_inode_info *info;
-    struct gf_flock lock = {
-        0,
-    };
-
-#if DEBUG_CRYPT
-    gf_log("crypt", GF_LOG_DEBUG, "reading %d bytes from offset %llu",
-           (int)size, (long long)offset);
-    if (parent_is_crypt_xlator(frame, this))
-        gf_log("crypt", GF_LOG_DEBUG, "parent is crypt");
-#endif
-    local = crypt_alloc_local(frame, this, GF_FOP_READ);
-    if (!local) {
-        ret = ENOMEM;
-        goto error;
-    }
-    if (size == 0)
-        goto trivial;
-
-    local->fd = fd_ref(fd);
-    local->flags = flags;
-
-    info = local_get_inode_info(local, this);
-    if (info == NULL) {
-        ret = EINVAL;
-        fd_unref(fd);
-        goto error;
-    }
-    if (!object_alg_atomic(&info->cinfo)) {
-        ret = EINVAL;
-        fd_unref(fd);
-        goto error;
-    }
-    set_config_offsets(frame, this, offset, size, DATA_ATOM, 0);
-    if (parent_is_crypt_xlator(frame, this)) {
-        data_t *data;
-        /*
-         * We are called by crypt_writev (or cypt_ftruncate)
-         * to perform the "read" component of the read-modify-write
-         * (or read-prune-write) sequence for some atom;
-         *
-         * don't ask for access:
-         * it has already been acquired
-         *
-         * Retrieve current file size
-         */
-        if (!xdata) {
-            gf_log("crypt", GF_LOG_WARNING,
-                   "Regular file size hasn't been passed");
-            ret = EIO;
-            goto error;
-        }
-        data = dict_get(xdata, FSIZE_XATTR_PREFIX);
-        if (!data) {
-            gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-            ret = EIO;
-            goto error;
-        }
-        local->old_file_size = local->cur_file_size = data_to_uint64(data);
-
-        get_one_call(frame);
-        STACK_WIND(frame, crypt_readv_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->readv, local->fd,
-                   /*
-                    * FIXME: read amount can be reduced
-                    */
-                   local->data_conf.expanded_size,
-                   local->data_conf.aligned_offset, flags, NULL);
-        return 0;
-    }
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    lock.l_len = 0;
-    lock.l_start = 0;
-    lock.l_type = F_RDLCK;
-    lock.l_whence = SEEK_SET;
-
-    STACK_WIND(frame, crypt_readv_finodelk_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, fd, F_SETLKW,
-               &lock, NULL);
-    return 0;
-trivial:
-    STACK_WIND(frame, readv_trivial_completion, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, NULL);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(readv, frame, -1, ret, NULL, 0, NULL, NULL, NULL);
-    return 0;
-}
-
-void
-set_local_io_params_writev(call_frame_t *frame,
-                           struct object_cipher_info *object,
-                           struct rmw_atom *atom, off_t io_offset,
-                           uint32_t io_size)
-{
-    crypt_local_t *local = frame->local;
-
-    local->io_offset = io_offset;
-    local->io_size = io_size;
-
-    local->io_offset_nopad = atom->offset_at(frame, object) +
-                             atom->offset_in(frame, object);
-
-    gf_log("crypt", GF_LOG_DEBUG, "set nopad offset to %llu",
-           (unsigned long long)local->io_offset_nopad);
-
-    local->io_size_nopad = atom->io_size_nopad(frame, object);
-
-    gf_log("crypt", GF_LOG_DEBUG, "set nopad size to %llu",
-           (unsigned long long)local->io_size_nopad);
-
-    local->update_disk_file_size = 0;
-    /*
-     * NOTE: eof_padding_size is 0 for all full atoms;
-     * For head and tail atoms it will be set up at rmw_partial block()
-     */
-    local->new_file_size = local->cur_file_size;
-
-    if (local->io_offset_nopad + local->io_size_nopad > local->cur_file_size) {
-        local->new_file_size = local->io_offset_nopad + local->io_size_nopad;
-
-        gf_log("crypt", GF_LOG_DEBUG, "set new file size to %llu",
-               (unsigned long long)local->new_file_size);
-
-        local->update_disk_file_size = 1;
-    }
-}
-
-void
-set_local_io_params_ftruncate(call_frame_t *frame,
-                              struct object_cipher_info *object)
-{
-    uint32_t resid;
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-
-    resid = conf->orig_offset & (object_alg_blksize(object) - 1);
-    if (resid) {
-        local->eof_padding_size = object_alg_blksize(object) - resid;
-        local->new_file_size = conf->aligned_offset;
-        local->update_disk_file_size = 0;
-        /*
-         * file size will be updated
-         * in the ->writev() stack,
-         * when submitting file tail
-         */
-    } else {
-        local->eof_padding_size = 0;
-        local->new_file_size = conf->orig_offset;
-        local->update_disk_file_size = 1;
-        /*
-         * file size will be updated
-         * in this ->ftruncate stack
-         */
-    }
-}
-
-static void
-submit_head(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    submit_partial(frame, this, local->fd, HEAD_ATOM);
-}
-
-static void
-submit_tail(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    submit_partial(frame, this, local->fd, TAIL_ATOM);
-}
-
-static void
-submit_hole(call_frame_t *frame, xlator_t *this)
-{
-    /*
-     * hole conversion always means
-     * appended write and goes in ordered fashion
-     */
-    do_ordered_submit(frame, this, HOLE_ATOM);
-}
-
-static void
-submit_data(call_frame_t *frame, xlator_t *this)
-{
-    if (is_ordered_mode(frame)) {
-        do_ordered_submit(frame, this, DATA_ATOM);
-        return;
-    }
-    gf_log("crypt", GF_LOG_WARNING, "Bad submit mode");
-    get_nr_calls(frame, nr_calls_data(frame));
-    do_parallel_submit(frame, this, DATA_ATOM);
-    return;
-}
-
-/*
- * heplers called by writev_cbk, fruncate_cbk in ordered mode
- */
-
-static int32_t
-should_submit_hole(crypt_local_t *local)
-{
-    struct avec_config *conf = &local->hole_conf;
-
-    return conf->avec != NULL;
-}
-
-static int32_t
-should_resume_submit_hole(crypt_local_t *local)
-{
-    struct avec_config *conf = &local->hole_conf;
-
-    if (local->fop == GF_FOP_WRITE && has_tail_block(conf))
-        /*
-         * Don't submit a part of hole, which
-         * fits into a data block:
-         * this part of hole will be converted
-         * as a gap filled by zeros in data head
-         * block.
-         */
-        return conf->cursor < conf->acount - 1;
-    else
-        return conf->cursor < conf->acount;
-}
-
-static int32_t
-should_resume_submit_data(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-
-    if (is_ordered_mode(frame))
-        return conf->cursor < conf->acount;
-    /*
-     * parallel writes
-     */
-    return 0;
-}
-
-static int32_t
-should_submit_data_after_hole(crypt_local_t *local)
-{
-    return local->data_conf.avec != NULL;
-}
-
-static void
-update_local_file_params(call_frame_t *frame, xlator_t *this,
-                         struct iatt *prebuf, struct iatt *postbuf)
-{
-    crypt_local_t *local = frame->local;
-
-    check_buf(frame, this, postbuf);
-
-    local->prebuf = *prebuf;
-    local->postbuf = *postbuf;
-
-    local->prebuf.ia_size = local->cur_file_size;
-    local->postbuf.ia_size = local->new_file_size;
-
-    local->cur_file_size = local->new_file_size;
-}
-
-static int32_t
-end_writeback_writev(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret <= 0) {
-        gf_log(this->name, GF_LOG_WARNING, "writev iteration failed");
-        goto put_one_call;
-    }
-    /*
-     * op_ret includes paddings (atom's head, atom's tail and EOF)
-     */
-    if (op_ret < local->io_size) {
-        gf_log(this->name, GF_LOG_WARNING, "Incomplete writev iteration");
-        goto put_one_call;
-    }
-    op_ret -= local->eof_padding_size;
-    local->op_ret = op_ret;
-
-    update_local_file_params(frame, this, prebuf, postbuf);
-
-    if (data_write_in_progress(local)) {
-        LOCK(&local->rw_count_lock);
-        local->rw_count += op_ret;
-        UNLOCK(&local->rw_count_lock);
-
-        if (should_resume_submit_data(frame))
-            submit_data(frame, this);
-    } else {
-        /*
-         * hole conversion is going on;
-         * don't take into account written zeros
-         */
-        if (should_resume_submit_hole(local))
-            submit_hole(frame, this);
-
-        else if (should_submit_data_after_hole(local))
-            submit_data(frame, this);
-    }
-put_one_call:
-    put_one_call_writev(frame, this);
-    return 0;
-}
-
-#define crypt_writev_cbk end_writeback_writev
-
-#define HOLE_WRITE_CHUNK_BITS 12
-#define HOLE_WRITE_CHUNK_SIZE (1 << HOLE_WRITE_CHUNK_BITS)
-
-/*
- * Convert hole of size @size at offset @off to
- * zeros and prepare respective iovecs for submit.
- * The hole lock should be held.
- *
- * Pre-conditions:
- * @local->file_size is set and valid.
- */
-int32_t
-prepare_for_submit_hole(call_frame_t *frame, xlator_t *this, uint64_t off,
-                        off_t size)
-{
-    int32_t ret;
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    set_config_offsets(frame, this, off, size, HOLE_ATOM, 1);
-
-    ret = set_config_avec_hole(this, local, &local->hole_conf, object,
-                               local->fop);
-    crypt_check_conf(&local->hole_conf);
-
-    return ret;
-}
-
-/*
- * prepare for submit @count bytes at offset @from
- */
-int32_t
-prepare_for_submit_data(call_frame_t *frame, xlator_t *this, off_t from,
-                        int32_t size, struct iovec *vec, int32_t vec_count,
-                        int32_t setup_gap)
-{
-    uint32_t ret;
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    set_config_offsets(frame, this, from, size, DATA_ATOM, setup_gap);
-
-    ret = set_config_avec_data(this, local, &local->data_conf, object, vec,
-                               vec_count);
-    crypt_check_conf(&local->data_conf);
-
-    return ret;
-}
-
-static void
-free_avec(struct iovec *avec, char **pool, int blocks_in_pool)
-{
-    if (!avec)
-        return;
-    GF_FREE(pool);
-    GF_FREE(avec);
-}
-
-static void
-free_avec_data(crypt_local_t *local)
-{
-    return free_avec(local->data_conf.avec, local->data_conf.pool,
-                     local->data_conf.blocks_in_pool);
-}
-
-static void
-free_avec_hole(crypt_local_t *local)
-{
-    return free_avec(local->hole_conf.avec, local->hole_conf.pool,
-                     local->hole_conf.blocks_in_pool);
-}
-
-static void
-do_parallel_submit(call_frame_t *frame, xlator_t *this, atom_data_type dtype)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf;
-
-    local->active_setup = dtype;
-    conf = conf_by_type(frame, dtype);
-
-    if (has_head_block(conf))
-        submit_head(frame, this);
-
-    if (has_full_blocks(conf))
-        submit_full(frame, this);
-
-    if (has_tail_block(conf))
-        submit_tail(frame, this);
-    return;
-}
-
-static void
-do_ordered_submit(call_frame_t *frame, xlator_t *this, atom_data_type dtype)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf;
-
-    local->active_setup = dtype;
-    conf = conf_by_type(frame, dtype);
-
-    if (should_submit_head_block(conf)) {
-        get_one_call_nolock(frame);
-        submit_head(frame, this);
-    } else if (should_submit_full_block(conf)) {
-        get_one_call_nolock(frame);
-        submit_full(frame, this);
-    } else if (should_submit_tail_block(conf)) {
-        get_one_call_nolock(frame);
-        submit_tail(frame, this);
-    } else
-        gf_log("crypt", GF_LOG_DEBUG,
-               "nothing has been submitted in ordered mode");
-    return;
-}
-
-static int32_t
-do_writev(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-          int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    data_t *data;
-    crypt_local_t *local = frame->local;
-    struct object_cipher_info *object = &local->info->cinfo;
-    /*
-     * extract regular file size
-     */
-    data = dict_get(dict, FSIZE_XATTR_PREFIX);
-    if (!data) {
-        gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-        op_ret = -1;
-        op_errno = EIO;
-        goto error;
-    }
-    local->old_file_size = local->cur_file_size = data_to_uint64(data);
-
-    set_gap_at_end(frame, object, &local->data_conf, DATA_ATOM);
-
-    if (local->cur_file_size < local->data_conf.orig_offset) {
-        /*
-         * Set up hole config
-         */
-        op_errno = prepare_for_submit_hole(
-            frame, this, local->cur_file_size,
-            local->data_conf.orig_offset - local->cur_file_size);
-        if (op_errno) {
-            local->op_ret = -1;
-            local->op_errno = op_errno;
-            goto error;
-        }
-    }
-    if (should_submit_hole(local))
-        submit_hole(frame, this);
-    else
-        submit_data(frame, this);
-    return 0;
-error:
-    get_one_call_nolock(frame);
-    put_one_call_writev(frame, this);
-    return 0;
-}
-
-static int32_t
-crypt_writev_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0)
-        goto error;
-    /*
-     * An access has been granted,
-     * retrieve file size first
-     */
-    STACK_WIND(frame, do_writev, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, local->fd,
-               FSIZE_XATTR_PREFIX, NULL);
-    return 0;
-error:
-    get_one_call_nolock(frame);
-    put_one_call_writev(frame, this);
-    return 0;
-}
-
-static int32_t
-writev_trivial_completion(call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                          dict_t *dict)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-    local->prebuf = *buf;
-    local->postbuf = *buf;
-
-    local->prebuf.ia_size = local->cur_file_size;
-    local->postbuf.ia_size = local->cur_file_size;
-
-    get_one_call(frame);
-    put_one_call_writev(frame, this);
-    return 0;
-}
-
-int
-crypt_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vec,
-             int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
-             dict_t *xdata)
-{
-    int32_t ret;
-    crypt_local_t *local;
-    struct crypt_inode_info *info;
-    struct gf_flock lock = {
-        0,
-    };
-#if DEBUG_CRYPT
-    gf_log("crypt", GF_LOG_DEBUG, "writing %d bytes from offset %llu",
-           (int)iov_length(vec, count), (long long)offset);
-#endif
-    local = crypt_alloc_local(frame, this, GF_FOP_WRITE);
-    if (!local) {
-        ret = ENOMEM;
-        goto error;
-    }
-    local->fd = fd_ref(fd);
-
-    if (iobref)
-        local->iobref = iobref_ref(iobref);
-    /*
-     * to update real file size on the server
-     */
-    local->xattr = dict_new();
-    if (!local->xattr) {
-        ret = ENOMEM;
-        goto error;
-    }
-    local->flags = flags;
-
-    info = local_get_inode_info(local, this);
-    if (info == NULL) {
-        ret = EINVAL;
-        goto error;
-    }
-    if (!object_alg_atomic(&info->cinfo)) {
-        ret = EINVAL;
-        goto error;
-    }
-    if (iov_length(vec, count) == 0)
-        goto trivial;
-
-    ret = prepare_for_submit_data(frame, this, offset,
-				      iov_length(vec, count),
-				      vec, count, 0 /* don't setup gup
-						       in tail: we don't
-						       know file size yet */);
-    if (ret) {
-        ret = ENOMEM;
-        goto error;
-    }
-
-    if (parent_is_crypt_xlator(frame, this)) {
-        data_t *data;
-        /*
-         * we are called by shinking crypt_ftruncate(),
-         * which doesn't perform hole conversion;
-         *
-         * don't ask for access:
-         * it has already been acquired
-         */
-
-        /*
-         * extract file size
-         */
-        if (!xdata) {
-            gf_log("crypt", GF_LOG_WARNING,
-                   "Regular file size hasn't been passed");
-            ret = EIO;
-            goto error;
-        }
-        data = dict_get(xdata, FSIZE_XATTR_PREFIX);
-        if (!data) {
-            gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-            ret = EIO;
-            goto error;
-        }
-        local->old_file_size = local->cur_file_size = data_to_uint64(data);
-
-        submit_data(frame, this);
-        return 0;
-    }
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    /*
-     * lock the file and retrieve its size
-     */
-    lock.l_len = 0;
-    lock.l_start = 0;
-    lock.l_type = F_WRLCK;
-    lock.l_whence = SEEK_SET;
-
-    STACK_WIND(frame, crypt_writev_finodelk_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, fd, F_SETLKW,
-               &lock, NULL);
-    return 0;
-trivial:
-    STACK_WIND(frame, writev_trivial_completion, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, NULL);
-    return 0;
-error:
-    if (local && local->fd)
-        fd_unref(fd);
-    if (local && local->iobref)
-        iobref_unref(iobref);
-    if (local && local->xdata)
-        dict_unref(xdata);
-    if (local && local->xattr)
-        dict_unref(local->xattr);
-    if (local && local->info)
-        free_inode_info(local->info);
-
-    CRYPT_STACK_UNWIND(writev, frame, -1, ret, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-prepare_for_prune(call_frame_t *frame, xlator_t *this, uint64_t offset)
-{
-    set_config_offsets(frame, this,
-			   offset,
-			   0, /* count */
-			   DATA_ATOM,
-			   0 /* since we prune, there is no
-				gap in tail to uptodate */);
-    return 0;
-}
-
-/*
- * Finish the read-prune-modify sequence
- *
- * Can be invoked as
- * 1) ->ftruncate_cbk() for cblock-aligned, or trivial prune
- * 2) ->writev_cbk() for non-cblock-aligned prune
- */
-
-static int32_t
-prune_complete(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-               struct iatt *postbuf, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    update_local_file_params(frame, this, prebuf, postbuf);
-
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-/*
- * This is called as ->ftruncate_cbk()
- *
- * Perform the "write" component of the
- * read-prune-write sequence.
- *
- * submuit the rest of the file
- */
-static int32_t
-prune_submit_file_tail(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                       struct iatt *postbuf, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-    dict_t *dict;
-
-    if (op_ret < 0)
-        goto put_one_call;
-
-    if (local->xdata) {
-        dict_unref(local->xdata);
-        local->xdata = NULL;
-    }
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    dict = dict_new();
-    if (!dict) {
-        op_errno = ENOMEM;
-        goto error;
-    }
-
-    update_local_file_params(frame, this, prebuf, postbuf);
-    local->new_file_size = conf->orig_offset;
-
-    /*
-     * The rest of the file is a partial block and, hence,
-     * should be written via RMW sequence, so the crypt xlator
-     * does STACK_WIND to itself.
-     *
-     * Pass current file size to crypt_writev()
-     */
-    op_errno = dict_set(dict, FSIZE_XATTR_PREFIX,
-                        data_from_uint64(local->cur_file_size));
-    if (op_errno) {
-        gf_log("crypt", GF_LOG_WARNING, "can not set key to update file size");
-        dict_unref(dict);
-        goto error;
-    }
-    gf_log("crypt", GF_LOG_DEBUG,
-           "passing current file size (%llu) to crypt_writev",
-           (unsigned long long)local->cur_file_size);
-    /*
-     * Padding will be filled with
-     * zeros by rmw_partial_block()
-     */
-    STACK_WIND(frame, prune_complete, this,
-               this->fops->writev, /* crypt_writev */
-               local->fd, &local->vec, 1,
-               conf->aligned_offset, /* offset to write from */
-               0, local->iobref, dict);
-
-    dict_unref(dict);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-put_one_call:
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-/*
- * This is called as a callback of ->writev() invoked in behalf
- * of ftruncate(): it can be
- * 1) ordered writes issued by hole conversion in the case of
- *    expanded truncate, or
- * 2) an rmw partial data block issued by non-cblock-aligned
- * prune.
- */
-int32_t
-end_writeback_ftruncate(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    /*
-     * if nothing has been written,
-     * then it must be an error
-     */
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0)
-        goto put_one_call;
-
-    update_local_file_params(frame, this, prebuf, postbuf);
-
-    if (data_write_in_progress(local))
-        /* case (2) */
-        goto put_one_call;
-    /* case (1) */
-    if (should_resume_submit_hole(local))
-        submit_hole(frame, this);
-    /*
-     * case of hole, when we shouldn't resume
-     */
-put_one_call:
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-/*
- * Perform prune and write components of the
- * read-prune-write sequence.
- *
- * Called as ->readv_cbk()
- *
- * Pre-conditions:
- * @vec contains the latest atom of the file
- * (plain text)
- */
-static int32_t
-prune_write(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-            int32_t op_errno, struct iovec *vec, int32_t count,
-            struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    int32_t i;
-    size_t to_copy;
-    size_t copied = 0;
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-    if (op_ret == -1)
-        goto put_one_call;
-
-    /*
-     * At first, uptodate head block
-     */
-    if (iov_length(vec, count) < conf->off_in_head) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "Failed to uptodate head block for prune");
-        local->op_ret = -1;
-        local->op_errno = EIO;
-        goto put_one_call;
-    }
-    local->vec.iov_len = conf->off_in_head;
-    local->vec.iov_base = GF_CALLOC(1, local->vec.iov_len, gf_crypt_mt_data);
-
-    if (local->vec.iov_base == NULL) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "Failed to calloc head block for prune");
-        local->op_ret = -1;
-        local->op_errno = ENOMEM;
-        goto put_one_call;
-    }
-    for (i = 0; i < count; i++) {
-        to_copy = vec[i].iov_len;
-        if (to_copy > local->vec.iov_len - copied)
-            to_copy = local->vec.iov_len - copied;
-
-        memcpy((char *)local->vec.iov_base + copied, vec[i].iov_base, to_copy);
-        copied += to_copy;
-        if (copied == local->vec.iov_len)
-            break;
-    }
-    /*
-     * perform prune with aligned offset
-     * (i.e. at this step we prune a bit
-     * more then it is needed
-     */
-    STACK_WIND(frame, prune_submit_file_tail, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->ftruncate, local->fd,
-               conf->aligned_offset, local->xdata);
-    return 0;
-put_one_call:
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-/*
- * Perform a read-prune-write sequence
- */
-int32_t
-read_prune_write(call_frame_t *frame, xlator_t *this)
-{
-    int32_t ret = 0;
-    dict_t *dict = NULL;
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = &local->data_conf;
-    struct object_cipher_info *object = &local->info->cinfo;
-
-    set_local_io_params_ftruncate(frame, object);
-    get_one_call_nolock(frame);
-
-    if ((conf->orig_offset & (object_alg_blksize(object) - 1)) == 0) {
-        /*
-         * cblock-aligned prune:
-         * we don't need read and write components,
-         * just cut file body
-         */
-        gf_log("crypt", GF_LOG_DEBUG, "prune without RMW (at offset %llu",
-               (unsigned long long)conf->orig_offset);
-
-        STACK_WIND(frame, prune_complete, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->ftruncate, local->fd,
-                   conf->orig_offset, local->xdata);
-        return 0;
-    }
-    gf_log("crypt", GF_LOG_DEBUG, "prune with RMW (at offset %llu",
-           (unsigned long long)conf->orig_offset);
-    /*
-     * We are about to perform the "read" component of the
-     * read-prune-write sequence. It means that we need to
-     * read encrypted data from disk and decrypt it.
-     * So, the crypt translator does STACK_WIND to itself.
-     *
-     * Pass current file size to crypt_readv()
-
-     */
-    dict = dict_new();
-    if (!dict) {
-        gf_log("crypt", GF_LOG_WARNING, "Can not alloc dict");
-        ret = ENOMEM;
-        goto exit;
-    }
-    ret = dict_set(dict, FSIZE_XATTR_PREFIX,
-                   data_from_uint64(local->cur_file_size));
-    if (ret) {
-        gf_log("crypt", GF_LOG_WARNING, "Can not set dict");
-        goto exit;
-    }
-    STACK_WIND(frame, prune_write, this, this->fops->readv, /* crypt_readv */
-               local->fd, get_atom_size(object),            /* bytes to read */
-               conf->aligned_offset, /* offset to read from */
-               0, dict);
-exit:
-    if (dict)
-        dict_unref(dict);
-    return ret;
-}
-
-/*
- * File prune is more complicated than expand.
- * First we need to read the latest atom to not lose info
- * needed for proper update. Also we need to make sure that
- * every component of read-prune-write sequence leaves data
- * consistent
- *
- * Non-cblock aligned prune is performed as read-prune-write
- * sequence:
- *
- * 1) read the latest atom;
- * 2) perform cblock-aligned prune
- * 3) issue a write request for the end-of-file
- */
-int32_t
-prune_file(call_frame_t *frame, xlator_t *this, uint64_t offset)
-{
-    int32_t ret;
-
-    ret = prepare_for_prune(frame, this, offset);
-    if (ret)
-        return ret;
-    return read_prune_write(frame, this);
-}
-
-int32_t
-expand_file(call_frame_t *frame, xlator_t *this, uint64_t offset)
-{
-    int32_t ret;
-    crypt_local_t *local = frame->local;
-
-    ret = prepare_for_submit_hole(frame, this, local->old_file_size,
-                                  offset - local->old_file_size);
-    if (ret)
-        return ret;
-    submit_hole(frame, this);
-    return 0;
-}
-
-static int32_t
-ftruncate_trivial_completion(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                             dict_t *dict)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-    local->prebuf = *buf;
-    local->postbuf = *buf;
-
-    local->prebuf.ia_size = local->cur_file_size;
-    local->postbuf.ia_size = local->cur_file_size;
-
-    get_one_call(frame);
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-static int32_t
-do_ftruncate(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    data_t *data;
-    crypt_local_t *local = frame->local;
-
-    if (op_ret)
-        goto error;
-    /*
-     * extract regular file size
-     */
-    data = dict_get(dict, FSIZE_XATTR_PREFIX);
-    if (!data) {
-        gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-        op_errno = EIO;
-        goto error;
-    }
-    local->old_file_size = local->cur_file_size = data_to_uint64(data);
-
-    if (local->data_conf.orig_offset == local->cur_file_size) {
-#if DEBUG_CRYPT
-        gf_log("crypt", GF_LOG_DEBUG,
-               "trivial ftruncate (current file size %llu)",
-               (unsigned long long)local->cur_file_size);
-#endif
-        goto trivial;
-    } else if (local->data_conf.orig_offset < local->cur_file_size) {
-#if DEBUG_CRYPT
-        gf_log("crypt", GF_LOG_DEBUG, "prune from %llu to %llu",
-               (unsigned long long)local->cur_file_size,
-               (unsigned long long)local->data_conf.orig_offset);
-#endif
-        op_errno = prune_file(frame, this, local->data_conf.orig_offset);
-    } else {
-#if DEBUG_CRYPT
-        gf_log("crypt", GF_LOG_DEBUG, "expand from %llu to %llu",
-               (unsigned long long)local->cur_file_size,
-               (unsigned long long)local->data_conf.orig_offset);
-#endif
-        op_errno = expand_file(frame, this, local->data_conf.orig_offset);
-    }
-    if (op_errno)
-        goto error;
-    return 0;
-trivial:
-    STACK_WIND(frame, ftruncate_trivial_completion, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, local->fd, NULL);
-    return 0;
-error:
-    /*
-     * finish with ftruncate
-     */
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-
-    get_one_call_nolock(frame);
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-static int32_t
-crypt_ftruncate_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0)
-        goto error;
-    /*
-     * An access has been granted,
-     * retrieve file size first
-     */
-    STACK_WIND(frame, do_ftruncate, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, local->fd,
-               FSIZE_XATTR_PREFIX, NULL);
-    return 0;
-error:
-    get_one_call_nolock(frame);
-    put_one_call_ftruncate(frame, this);
-    return 0;
-}
-
-/*
- * ftruncate is performed in 2 steps:
- * . receive file size;
- * . expand or prune file.
- */
-static int32_t
-crypt_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-                dict_t *xdata)
-{
-    int32_t ret;
-    crypt_local_t *local;
-    struct crypt_inode_info *info;
-    struct gf_flock lock = {
-        0,
-    };
-
-    local = crypt_alloc_local(frame, this, GF_FOP_FTRUNCATE);
-    if (!local) {
-        ret = ENOMEM;
-        goto error;
-    }
-    local->xattr = dict_new();
-    if (!local->xattr) {
-        ret = ENOMEM;
-        goto error;
-    }
-    local->fd = fd_ref(fd);
-    info = local_get_inode_info(local, this);
-    if (info == NULL) {
-        ret = EINVAL;
-        goto error;
-    }
-    if (!object_alg_atomic(&info->cinfo)) {
-        ret = EINVAL;
-        goto error;
-    }
-    local->data_conf.orig_offset = offset;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    lock.l_len = 0;
-    lock.l_start = 0;
-    lock.l_type = F_WRLCK;
-    lock.l_whence = SEEK_SET;
-
-    STACK_WIND(frame, crypt_ftruncate_finodelk_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, fd, F_SETLKW,
-               &lock, NULL);
-    return 0;
-error:
-    if (local && local->fd)
-        fd_unref(fd);
-    if (local && local->xdata)
-        dict_unref(xdata);
-    if (local && local->xattr)
-        dict_unref(local->xattr);
-    if (local && local->info)
-        free_inode_info(local->info);
-
-    CRYPT_STACK_UNWIND(ftruncate, frame, -1, ret, NULL, NULL, NULL);
-    return 0;
-}
-
-/* ->flush_cbk() */
-int32_t
-truncate_end(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    CRYPT_STACK_UNWIND(truncate, frame, op_ret, op_errno, &local->prebuf,
-                       &local->postbuf, local->xdata);
-    return 0;
-}
-
-/* ftruncate_cbk() */
-int32_t
-truncate_flush(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-               struct iatt *postbuf, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    fd_t *fd = local->fd;
-    local->prebuf = *prebuf;
-    local->postbuf = *postbuf;
-
-    STACK_WIND(frame, truncate_end, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->flush, fd, NULL);
-    fd_unref(fd);
-    return 0;
-}
-
-/*
- * is called as ->open_cbk()
- */
-static int32_t
-truncate_begin(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0) {
-        fd_unref(fd);
-        CRYPT_STACK_UNWIND(truncate, frame, op_ret, op_errno, NULL, NULL, NULL);
-        return 0;
-    } else {
-        fd_bind(fd);
-    }
-    /*
-     * crypt_truncate() is implemented via crypt_ftruncate(),
-     * so the crypt xlator does STACK_WIND to itself here
-     */
-    STACK_WIND(frame, truncate_flush, this,
-               this->fops->ftruncate, /* crypt_ftruncate */
-               fd, local->offset, NULL);
-    return 0;
-}
-
-/*
- * crypt_truncate() is implemented via crypt_ftruncate() as a
- * sequence crypt_open() - crypt_ftruncate() - truncate_flush()
- */
-int32_t
-crypt_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-               dict_t *xdata)
-{
-    fd_t *fd;
-    crypt_local_t *local;
-
-#if DEBUG_CRYPT
-    gf_log(this->name, GF_LOG_DEBUG, "truncate file %s at offset %llu",
-           loc->path, (unsigned long long)offset);
-#endif
-    local = crypt_alloc_local(frame, this, GF_FOP_TRUNCATE);
-    if (!local)
-        goto error;
-
-    fd = fd_create(loc->inode, frame->root->pid);
-    if (!fd) {
-        gf_log(this->name, GF_LOG_ERROR, "Can not create fd");
-        goto error;
-    }
-    local->fd = fd;
-    local->offset = offset;
-    local->xdata = xdata;
-    STACK_WIND(frame, truncate_begin, this, this->fops->open, /* crypt_open() */
-               loc, O_RDWR, fd, NULL);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(truncate, frame, -1, EINVAL, NULL, NULL, NULL);
-    return 0;
-}
-
-end_writeback_handler_t
-dispatch_end_writeback(glusterfs_fop_t fop)
-{
-    switch (fop) {
-        case GF_FOP_WRITE:
-            return end_writeback_writev;
-        case GF_FOP_FTRUNCATE:
-            return end_writeback_ftruncate;
-        default:
-            gf_log("crypt", GF_LOG_WARNING, "Bad wb operation %d", fop);
-            return NULL;
-    }
-}
-
-/*
- * true, if the caller needs metadata string
- */
-static int32_t
-is_custom_mtd(dict_t *xdata)
-{
-    data_t *data;
-    uint32_t flags;
-
-    if (!xdata)
-        return 0;
-
-    data = dict_get(xdata, MSGFLAGS_PREFIX);
-    if (!data)
-        return 0;
-    if (data->len != sizeof(uint32_t)) {
-        gf_log("crypt", GF_LOG_WARNING, "Bad msgflags size (%d)", data->len);
-        return -1;
-    }
-    flags = *((uint32_t *)data->data);
-    return msgflags_check_mtd_lock(&flags);
-}
-
-static int32_t
-crypt_open_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-    if (op_ret < 0)
-        gf_log(this->name, GF_LOG_WARNING, "mtd unlock failed (%d)", op_errno);
-    put_one_call_open(frame);
-    return 0;
-}
-
-static void
-crypt_open_tail(call_frame_t *frame, xlator_t *this)
-{
-    struct gf_flock lock = {
-        0,
-    };
-    crypt_local_t *local = frame->local;
-
-    lock.l_type = F_UNLCK;
-    lock.l_whence = SEEK_SET;
-    lock.l_start = 0;
-    lock.l_len = 0;
-    lock.l_pid = 0;
-
-    STACK_WIND(frame, crypt_open_done, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-               F_SETLKW, &lock, NULL);
-}
-
-/*
- * load private inode info at open time
- * called as ->fgetxattr_cbk()
- */
-static int
-load_mtd_open(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    int32_t ret;
-    gf_boolean_t upload_info;
-    data_t *mtd;
-    uint64_t value = 0;
-    struct crypt_inode_info *info;
-    crypt_local_t *local = frame->local;
-    crypt_private_t *priv = this->private;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (local->fd->inode->ia_type == IA_IFLNK)
-        goto exit;
-    if (op_ret < 0)
-        goto exit;
-    /*
-     * first, check for cached info
-     */
-    ret = inode_ctx_get(local->fd->inode, this, &value);
-    if (ret != -1) {
-        info = (struct crypt_inode_info *)(long)value;
-        if (info == NULL) {
-            gf_log(this->name, GF_LOG_WARNING,
-                   "Inode info expected, but not found");
-            local->op_ret = -1;
-            local->op_errno = EIO;
-            goto exit;
-        }
-        /*
-         * info has been found in the cache
-         */
-        upload_info = _gf_false;
-    } else {
-        /*
-         * info hasn't been found in the cache.
-         */
-        info = alloc_inode_info(local, local->loc);
-        if (!info) {
-            local->op_ret = -1;
-            local->op_errno = ENOMEM;
-            goto exit;
-        }
-        init_inode_info_head(info, local->fd);
-        upload_info = _gf_true;
-    }
-    /*
-     * extract metadata
-     */
-    mtd = dict_get(dict, CRYPTO_FORMAT_PREFIX);
-    if (!mtd) {
-        local->op_ret = -1;
-        local->op_errno = ENOENT;
-        gf_log(this->name, GF_LOG_WARNING, "Format string wasn't found");
-        goto exit;
-    }
-    /*
-     * authenticate metadata against the path
-     */
-    ret = open_format((unsigned char *)mtd->data, mtd->len, local->loc, info,
-                      get_master_cinfo(priv), local, upload_info);
-    if (ret) {
-        local->op_ret = -1;
-        local->op_errno = ret;
-        goto exit;
-    }
-    if (upload_info) {
-        ret = init_inode_info_tail(info, get_master_cinfo(priv));
-        if (ret) {
-            local->op_ret = -1;
-            local->op_errno = ret;
-            goto exit;
-        }
-        ret = inode_ctx_put(local->fd->inode, this, (uint64_t)(long)info);
-        if (ret == -1) {
-            local->op_ret = -1;
-            local->op_errno = EIO;
-            goto exit;
-        }
-    }
-    if (local->custom_mtd) {
-        /*
-         * pass the metadata string to the customer
-         */
-        ret = dict_set_static_bin(local->xdata, CRYPTO_FORMAT_PREFIX, mtd->data,
-                                  mtd->len);
-        if (ret) {
-            local->op_ret = -1;
-            local->op_errno = ret;
-            goto exit;
-        }
-    }
-exit:
-    if (!local->custom_mtd)
-        crypt_open_tail(frame, this);
-    else
-        put_one_call_open(frame);
-    return 0;
-}
-
-static int32_t
-crypt_open_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "finodelk (LOCK) failed");
-        goto exit;
-    }
-    STACK_WIND(frame, load_mtd_open, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, local->fd,
-               CRYPTO_FORMAT_PREFIX, NULL);
-    return 0;
-exit:
-    put_one_call_open(frame);
-    return 0;
-}
-
-/*
- * verify metadata against the specified pathname
- */
-static int32_t
-crypt_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    struct gf_flock lock = {
-        0,
-    };
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (local->fd->inode->ia_type == IA_IFLNK)
-        goto exit;
-    if (op_ret < 0)
-        goto exit;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    else if (local->custom_mtd) {
-        local->xdata = dict_new();
-        if (!local->xdata) {
-            local->op_ret = -1;
-            local->op_errno = ENOMEM;
-            gf_log("crypt", GF_LOG_ERROR,
-                   "Can not get new dict for mtd string");
-            goto exit;
-        }
-    }
-    lock.l_len = 0;
-    lock.l_start = 0;
-    lock.l_type = local->custom_mtd ? F_WRLCK : F_RDLCK;
-    lock.l_whence = SEEK_SET;
-
-    STACK_WIND(frame, crypt_open_finodelk_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, fd, F_SETLKW,
-               &lock, NULL);
-    return 0;
-exit:
-    put_one_call_open(frame);
-    return 0;
-}
-
-static int32_t
-crypt_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           fd_t *fd, dict_t *xdata)
-{
-    int32_t ret = ENOMEM;
-    crypt_local_t *local;
-
-    local = crypt_alloc_local(frame, this, GF_FOP_OPEN);
-    if (!local)
-        goto error;
-    local->loc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-    if (!local->loc) {
-        ret = ENOMEM;
-        goto error;
-    }
-    ret = loc_copy(local->loc, loc);
-    if (ret) {
-        GF_FREE(local->loc);
-        ret = ENOMEM;
-        goto error;
-    }
-    local->fd = fd_ref(fd);
-
-    ret = is_custom_mtd(xdata);
-    if (ret < 0) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-        ret = EINVAL;
-        goto error;
-    }
-    local->custom_mtd = ret;
-
-    if ((flags & O_ACCMODE) == O_WRONLY)
-        /*
-         * we can't open O_WRONLY, because
-         * we need to do read-modify-write
-         */
-        flags = (flags & ~O_ACCMODE) | O_RDWR;
-    /*
-     * Make sure that out translated offsets
-     * and counts won't be ignored
-     */
-    flags &= ~O_APPEND;
-    get_one_call_nolock(frame);
-    STACK_WIND(frame, crypt_open_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(open, frame, -1, ret, NULL, NULL);
-    return 0;
-}
-
-static int32_t
-init_inode_info_tail(struct crypt_inode_info *info,
-                     struct master_cipher_info *master)
-{
-    int32_t ret;
-    struct object_cipher_info *object = &info->cinfo;
-
-#if DEBUG_CRYPT
-    gf_log("crypt", GF_LOG_DEBUG, "Init inode info for object %s",
-           uuid_utoa(info->oid));
-#endif
-    ret = data_cipher_algs[object->o_alg][object->o_mode].set_private(info,
-                                                                      master);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Set private info failed");
-        return ret;
-    }
-    return 0;
-}
-
-/*
- * Init inode info at ->create() time
- */
-static void
-init_inode_info_create(struct crypt_inode_info *info,
-                       struct master_cipher_info *master, data_t *data)
-{
-    struct object_cipher_info *object;
-
-    info->nr_minor = CRYPT_XLATOR_ID;
-    memcpy(info->oid, data->data, data->len);
-
-    object = &info->cinfo;
-
-    object->o_alg = master->m_alg;
-    object->o_mode = master->m_mode;
-    object->o_block_bits = master->m_block_bits;
-    object->o_dkey_size = master->m_dkey_size;
-}
-
-static void
-init_inode_info_head(struct crypt_inode_info *info, fd_t *fd)
-{
-    memcpy(info->oid, fd->inode->gfid, sizeof(uuid_t));
-}
-
-static int32_t
-crypt_create_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_private_t *priv = this->private;
-    crypt_local_t *local = frame->local;
-    struct crypt_inode_info *info = local->info;
-    fd_t *local_fd = local->fd;
-    dict_t *local_xdata = local->xdata;
-    inode_t *local_inode = local->inode;
-
-    if (op_ret < 0) {
-        free_inode_info(info);
-        goto unwind;
-    }
-    op_errno = init_inode_info_tail(info, get_master_cinfo(priv));
-    if (op_errno) {
-        op_ret = -1;
-        free_inode_info(info);
-        goto unwind;
-    }
-    /*
-     * FIXME: drop major subversion number
-     */
-    op_ret = inode_ctx_put(local->fd->inode, this, (uint64_t)(long)info);
-    if (op_ret == -1) {
-        op_errno = EIO;
-        free_inode_info(info);
-        goto unwind;
-    }
-unwind:
-    free_format(local);
-    CRYPT_STACK_UNWIND(create, frame, op_ret, op_errno, local_fd, local_inode,
-                       &local->buf, &local->prebuf, &local->postbuf,
-                       local_xdata);
-    fd_unref(local_fd);
-    inode_unref(local_inode);
-    if (local_xdata)
-        dict_unref(local_xdata);
-    return 0;
-}
-
-static int
-crypt_create_tail(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    struct gf_flock lock = {
-        0,
-    };
-    crypt_local_t *local = frame->local;
-    fd_t *local_fd = local->fd;
-    dict_t *local_xdata = local->xdata;
-    inode_t *local_inode = local->inode;
-
-    dict_unref(local->xattr);
-
-    if (op_ret < 0)
-        goto error;
-
-    lock.l_type = F_UNLCK;
-    lock.l_whence = SEEK_SET;
-    lock.l_start = 0;
-    lock.l_len = 0;
-    lock.l_pid = 0;
-
-    STACK_WIND(frame, crypt_create_done, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-               F_SETLKW, &lock, NULL);
-    return 0;
-error:
-    free_inode_info(local->info);
-    free_format(local);
-
-    CRYPT_STACK_UNWIND(create, frame, op_ret, op_errno, local_fd, local_inode,
-                       &local->buf, &local->prebuf, &local->postbuf,
-                       local_xdata);
-
-    fd_unref(local_fd);
-    inode_unref(local_inode);
-    if (local_xdata)
-        dict_unref(local_xdata);
-    return 0;
-}
-
-static int32_t
-crypt_create_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    struct crypt_inode_info *info = local->info;
-
-    if (op_ret < 0)
-        goto error;
-
-    STACK_WIND(frame, crypt_create_tail, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetxattr, local->fd,
-               local->xattr, /* CRYPTO_FORMAT_PREFIX */
-               0, NULL);
-    return 0;
-error:
-    free_inode_info(info);
-    free_format(local);
-    fd_unref(local->fd);
-    dict_unref(local->xattr);
-    if (local->xdata)
-        dict_unref(local->xdata);
-
-    CRYPT_STACK_UNWIND(create, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
-                       NULL, NULL);
-    return 0;
-}
-
-/*
- * Create and store crypt-specific format on disk;
- * Populate cache with private inode info
- */
-static int32_t
-crypt_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
-{
-    struct gf_flock lock = {
-        0,
-    };
-    crypt_local_t *local = frame->local;
-    struct crypt_inode_info *info = local->info;
-
-    if (op_ret < 0)
-        goto error;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    local->inode = inode_ref(inode);
-    local->buf = *buf;
-    local->prebuf = *preparent;
-    local->postbuf = *postparent;
-
-    lock.l_len = 0;
-    lock.l_start = 0;
-    lock.l_type = F_WRLCK;
-    lock.l_whence = SEEK_SET;
-
-    STACK_WIND(frame, crypt_create_finodelk_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-               F_SETLKW, &lock, NULL);
-    return 0;
-error:
-    free_inode_info(info);
-    free_format(local);
-    fd_unref(local->fd);
-    dict_unref(local->xattr);
-
-    CRYPT_STACK_UNWIND(create, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
-                       NULL, NULL);
-    return 0;
-}
-
-static int32_t
-crypt_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-             mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
-{
-    int ret;
-    data_t *data;
-    crypt_local_t *local;
-    crypt_private_t *priv;
-    struct master_cipher_info *master;
-    struct crypt_inode_info *info;
-
-    priv = this->private;
-    master = get_master_cinfo(priv);
-
-    if (master_alg_atomic(master)) {
-        /*
-         * We can't open O_WRONLY, because we
-         * need to do read-modify-write.
-         */
-        if ((flags & O_ACCMODE) == O_WRONLY)
-            flags = (flags & ~O_ACCMODE) | O_RDWR;
-        /*
-         * Make sure that out translated offsets
-         * and counts won't be ignored
-         */
-        flags &= ~O_APPEND;
-    }
-    local = crypt_alloc_local(frame, this, GF_FOP_CREATE);
-    if (!local) {
-        ret = ENOMEM;
-        goto error;
-    }
-    data = dict_get(xdata, "gfid-req");
-    if (!data) {
-        ret = EINVAL;
-        gf_log("crypt", GF_LOG_WARNING, "gfid not found");
-        goto error;
-    }
-    if (data->len != sizeof(uuid_t)) {
-        ret = EINVAL;
-        gf_log("crypt", GF_LOG_WARNING, "bad gfid size (%d), should be %d",
-               (int)data->len, (int)sizeof(uuid_t));
-        goto error;
-    }
-    info = alloc_inode_info(local, loc);
-    if (!info) {
-        ret = ENOMEM;
-        goto error;
-    }
-    /*
-     * NOTE:
-     * format has to be created BEFORE
-     * proceeding to the untrusted server
-     */
-    ret = alloc_format_create(local);
-    if (ret) {
-        free_inode_info(info);
-        goto error;
-    }
-    init_inode_info_create(info, master, data);
-
-    ret = create_format(local->format, loc, info, master);
-    if (ret) {
-        free_inode_info(info);
-        goto error;
-    }
-    local->xattr = dict_new();
-    if (!local->xattr) {
-        free_inode_info(info);
-        free_format(local);
-        goto error;
-    }
-    ret = dict_set_static_bin(local->xattr, CRYPTO_FORMAT_PREFIX, local->format,
-                              new_format_size());
-    if (ret) {
-        dict_unref(local->xattr);
-        free_inode_info(info);
-        free_format(local);
-        ret = EINVAL;
-        goto error;
-    }
-    ret = dict_set(local->xattr, FSIZE_XATTR_PREFIX, data_from_uint64(0));
-    if (ret) {
-        dict_unref(local->xattr);
-        free_inode_info(info);
-        free_format(local);
-        ret = ENOMEM;
-        goto error;
-    }
-    local->fd = fd_ref(fd);
-
-    STACK_WIND(frame, crypt_create_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
-               xdata);
-    return 0;
-error:
-    gf_log("crypt", GF_LOG_WARNING, "can not create file");
-    CRYPT_STACK_UNWIND(create, frame, -1, ret, NULL, NULL, NULL, NULL, NULL,
-                       NULL);
-    return 0;
-}
-
-/*
- * FIXME: this should depends on the version of format string
- */
-static int32_t
-filter_crypt_xattr(dict_t *dict, char *key, data_t *value, void *data)
-{
-    dict_del(dict, key);
-    return 0;
-}
-
-static int32_t
-crypt_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                int32_t flags, dict_t *xdata)
-{
-    dict_foreach_fnmatch(dict, "trusted.glusterfs.crypt*", filter_crypt_xattr,
-                         NULL);
-    STACK_WIND(frame, default_fsetxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
-    return 0;
-}
-
-/*
- * TBD: verify file metadata before wind
- */
-static int32_t
-crypt_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-               int32_t flags, dict_t *xdata)
-{
-    dict_foreach_fnmatch(dict, "trusted.glusterfs.crypt*", filter_crypt_xattr,
-                         NULL);
-    STACK_WIND(frame, default_setxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
-    return 0;
-}
-
-/*
- * called as flush_cbk()
- */
-static int32_t
-linkop_end(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-           int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    linkop_unwind_handler_t unwind_fn;
-    unwind_fn = linkop_unwind_dispatch(local->fop);
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0 && op_errno == ENOENT &&
-        local->loc->inode->ia_type == IA_IFLNK) {
-        local->op_ret = 0;
-        local->op_errno = 0;
-    }
-    unwind_fn(frame);
-    return 0;
-}
-
-/*
- * unpin inode on the server
- */
-static int32_t
-link_flush(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-           int32_t op_errno, inode_t *inode, struct iatt *buf,
-           struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto error;
-    if (local->xdata) {
-        dict_unref(local->xdata);
-        local->xdata = NULL;
-    }
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    local->inode = inode_ref(inode);
-    local->buf = *buf;
-    local->prebuf = *preparent;
-    local->postbuf = *postparent;
-
-    STACK_WIND(frame, linkop_end, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->flush, local->fd, NULL);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-    link_unwind(frame);
-    return 0;
-}
-
-void
-link_unwind(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    dict_t *xdata;
-    dict_t *xattr;
-    inode_t *inode;
-
-    if (!local) {
-        CRYPT_STACK_UNWIND(link, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
-                           NULL);
-        return;
-    }
-    xdata = local->xdata;
-    xattr = local->xattr;
-    inode = local->inode;
-
-    if (local->loc) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-    }
-    if (local->newloc) {
-        loc_wipe(local->newloc);
-        GF_FREE(local->newloc);
-    }
-    if (local->fd)
-        fd_unref(local->fd);
-    if (local->format)
-        GF_FREE(local->format);
-
-    CRYPT_STACK_UNWIND(link, frame, local->op_ret, local->op_errno, inode,
-                       &local->buf, &local->prebuf, &local->postbuf, xdata);
-    if (xdata)
-        dict_unref(xdata);
-    if (xattr)
-        dict_unref(xattr);
-    if (inode)
-        inode_unref(inode);
-}
-
-void
-link_wind(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-
-    STACK_WIND(frame, link_flush, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->link, local->loc, local->newloc,
-               local->xdata);
-}
-
-/*
- * unlink()
- */
-static int32_t
-unlink_flush(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, struct iatt *preparent, struct iatt *postparent,
-             dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto error;
-    local->prebuf = *preparent;
-    local->postbuf = *postparent;
-    if (local->xdata) {
-        dict_unref(local->xdata);
-        local->xdata = NULL;
-    }
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    STACK_WIND(frame, linkop_end, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->flush, local->fd, NULL);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-    unlink_unwind(frame);
-    return 0;
-}
-
-void
-unlink_unwind(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    dict_t *xdata;
-    dict_t *xattr;
-
-    if (!local) {
-        CRYPT_STACK_UNWIND(unlink, frame, -1, ENOMEM, NULL, NULL, NULL);
-        return;
-    }
-    xdata = local->xdata;
-    xattr = local->xattr;
-    if (local->loc) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-    }
-    if (local->fd)
-        fd_unref(local->fd);
-    if (local->format)
-        GF_FREE(local->format);
-
-    CRYPT_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
-                       &local->prebuf, &local->postbuf, xdata);
-    if (xdata)
-        dict_unref(xdata);
-    if (xattr)
-        dict_unref(xattr);
-}
-
-void
-unlink_wind(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-
-    STACK_WIND(frame, unlink_flush, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->unlink, local->loc, local->flags,
-               local->xdata);
-}
-
-void
-rename_unwind(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    dict_t *xdata;
-    dict_t *xattr;
-    struct iatt *prenewparent;
-    struct iatt *postnewparent;
-
-    if (!local) {
-        CRYPT_STACK_UNWIND(rename, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
-                           NULL, NULL);
-        return;
-    }
-    xdata = local->xdata;
-    xattr = local->xattr;
-    prenewparent = local->prenewparent;
-    postnewparent = local->postnewparent;
-
-    if (local->loc) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-    }
-    if (local->newloc) {
-        loc_wipe(local->newloc);
-        GF_FREE(local->newloc);
-    }
-    if (local->fd)
-        fd_unref(local->fd);
-    if (local->format)
-        GF_FREE(local->format);
-
-    CRYPT_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
-                       &local->buf, &local->prebuf, &local->postbuf,
-                       prenewparent, postnewparent, xdata);
-    if (xdata)
-        dict_unref(xdata);
-    if (xattr)
-        dict_unref(xattr);
-    if (prenewparent)
-        GF_FREE(prenewparent);
-    if (postnewparent)
-        GF_FREE(postnewparent);
-}
-
-/*
- * called as flush_cbk()
- */
-static int32_t
-rename_end(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-           int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    rename_unwind(frame);
-    return 0;
-}
-
-static int32_t
-rename_flush(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, struct iatt *buf, struct iatt *preoldparent,
-             struct iatt *postoldparent, struct iatt *prenewparent,
-             struct iatt *postnewparent, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto error;
-    dict_unref(local->xdata);
-    local->xdata = NULL;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    local->buf = *buf;
-    local->prebuf = *preoldparent;
-    local->postbuf = *postoldparent;
-    if (prenewparent) {
-        local->prenewparent = GF_CALLOC(1, sizeof(*prenewparent),
-                                        gf_crypt_mt_iatt);
-        if (!local->prenewparent) {
-            op_errno = ENOMEM;
-            goto error;
-        }
-        *local->prenewparent = *prenewparent;
-    }
-    if (postnewparent) {
-        local->postnewparent = GF_CALLOC(1, sizeof(*postnewparent),
-                                         gf_crypt_mt_iatt);
-        if (!local->postnewparent) {
-            op_errno = ENOMEM;
-            goto error;
-        }
-        *local->postnewparent = *postnewparent;
-    }
-    STACK_WIND(frame, rename_end, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->flush, local->fd, NULL);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-    rename_unwind(frame);
-    return 0;
-}
-
-void
-rename_wind(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-
-    STACK_WIND(frame, rename_flush, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->rename, local->loc, local->newloc,
-               local->xdata);
-}
-
-static int32_t
-__do_linkop(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-            int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    linkop_wind_handler_t wind_fn;
-    linkop_unwind_handler_t unwind_fn;
-
-    wind_fn = linkop_wind_dispatch(local->fop);
-    unwind_fn = linkop_unwind_dispatch(local->fop);
-
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret >= 0)
-        wind_fn(frame, this);
-    else {
-        gf_log(this->name, GF_LOG_WARNING, "mtd unlock failed (%d)", op_errno);
-        unwind_fn(frame);
-    }
-    return 0;
-}
-
-static int32_t
-do_linkop(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-          int32_t op_errno, dict_t *xdata)
-{
-    struct gf_flock lock = {
-        0,
-    };
-    crypt_local_t *local = frame->local;
-    linkop_unwind_handler_t unwind_fn;
-
-    unwind_fn = linkop_unwind_dispatch(local->fop);
-    local->op_ret = op_ret;
-    local->op_errno = op_errno;
-
-    if (op_ret < 0)
-        goto error;
-
-    lock.l_type = F_UNLCK;
-    lock.l_whence = SEEK_SET;
-    lock.l_start = 0;
-    lock.l_len = 0;
-    lock.l_pid = 0;
-
-    STACK_WIND(frame, __do_linkop, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-               F_SETLKW, &lock, NULL);
-    return 0;
-error:
-    unwind_fn(frame);
-    return 0;
-}
-
-/*
- * Update the metadata string (against the new pathname);
- * submit the result
- */
-static int32_t
-linkop_begin(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    gf_boolean_t upload_info;
-    crypt_local_t *local = frame->local;
-    crypt_private_t *priv = this->private;
-    struct crypt_inode_info *info;
-    data_t *old_mtd;
-    uint32_t new_mtd_size;
-    uint64_t value = 0;
-    void (*unwind_fn)(call_frame_t * frame);
-    mtd_op_t mop;
-
-    unwind_fn = linkop_unwind_dispatch(local->fop);
-    mop = linkop_mtdop_dispatch(local->fop);
-
-    if (op_ret < 0) {
-        /*
-         * verification failed
-         */
-        goto error;
-    } else {
-        fd_bind(fd);
-    }
-
-    old_mtd = dict_get(xdata, CRYPTO_FORMAT_PREFIX);
-    if (!old_mtd) {
-        op_errno = EIO;
-        gf_log(this->name, GF_LOG_DEBUG, "Metadata string wasn't found");
-        goto error;
-    }
-    new_mtd_size = format_size(mop, old_mtd->len);
-    op_errno = alloc_format(local, new_mtd_size);
-    if (op_errno)
-        goto error;
-    /*
-     * check for cached info
-     */
-    op_ret = inode_ctx_get(fd->inode, this, &value);
-    if (op_ret != -1) {
-        info = (struct crypt_inode_info *)(long)value;
-        if (info == NULL) {
-            gf_log(this->name, GF_LOG_WARNING, "Inode info was not found");
-            op_errno = EINVAL;
-            goto error;
-        }
-        /*
-         * info was found in the cache
-         */
-        local->info = info;
-        upload_info = _gf_false;
-    } else {
-        /*
-         * info wasn't found in the cache;
-         */
-        info = alloc_inode_info(local, local->loc);
-        if (!info)
-            goto error;
-        init_inode_info_head(info, fd);
-        local->info = info;
-        upload_info = _gf_true;
-    }
-    op_errno = open_format((unsigned char *)old_mtd->data, old_mtd->len,
-                           local->loc, info, get_master_cinfo(priv), local,
-                           upload_info);
-    if (op_errno)
-        goto error;
-    if (upload_info == _gf_true) {
-        op_errno = init_inode_info_tail(info, get_master_cinfo(priv));
-        if (op_errno)
-            goto error;
-        op_errno = inode_ctx_put(fd->inode, this, (uint64_t)(long)(info));
-        if (op_errno == -1) {
-            op_errno = EIO;
-            goto error;
-        }
-    }
-    /*
-     * update the format string (append/update/cup a MAC)
-     */
-    op_errno = update_format(local->format, (unsigned char *)old_mtd->data,
-                             old_mtd->len, local->mac_idx, mop, local->newloc,
-                             info, get_master_cinfo(priv), local);
-    if (op_errno)
-        goto error;
-    /*
-     * store the new format string on the server
-     */
-    if (new_mtd_size) {
-        op_errno = dict_set_static_bin(local->xattr, CRYPTO_FORMAT_PREFIX,
-                                       local->format, new_mtd_size);
-        if (op_errno)
-            goto error;
-    }
-    STACK_WIND(frame, do_linkop, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setxattr, local->loc, local->xattr, 0,
-               NULL);
-    return 0;
-error:
-    local->op_ret = -1;
-    local->op_errno = op_errno;
-    unwind_fn(frame);
-    return 0;
-}
-
-static int32_t
-linkop_grab_local(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-                  loc_t *newloc, int flags, dict_t *xdata, glusterfs_fop_t op)
-{
-    int32_t ret = ENOMEM;
-    fd_t *fd;
-    crypt_local_t *local;
-
-    local = crypt_alloc_local(frame, this, op);
-    if (!local)
-        goto error;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    fd = fd_create(oldloc->inode, frame->root->pid);
-    if (!fd) {
-        gf_log(this->name, GF_LOG_ERROR, "Can not create fd");
-        goto error;
-    }
-    local->fd = fd;
-    local->flags = flags;
-    local->loc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-    if (!local->loc)
-        goto error;
-    ret = loc_copy(local->loc, oldloc);
-    if (ret) {
-        GF_FREE(local->loc);
-        local->loc = NULL;
-        goto error;
-    }
-    if (newloc) {
-        local->newloc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-        if (!local->newloc) {
-            loc_wipe(local->loc);
-            GF_FREE(local->loc);
-            goto error;
-        }
-        ret = loc_copy(local->newloc, newloc);
-        if (ret) {
-            loc_wipe(local->loc);
-            GF_FREE(local->loc);
-            GF_FREE(local->newloc);
-            goto error;
-        }
-    }
-    local->xattr = dict_new();
-    if (!local->xattr) {
-        gf_log(this->name, GF_LOG_ERROR, "Can not create dict");
-        ret = ENOMEM;
-        goto error;
-    }
-    return 0;
-
-error:
-    if (local) {
-        if (local->xdata)
-            dict_unref(local->xdata);
-        if (local->fd)
-            fd_unref(local->fd);
-        local->fd = 0;
-        local->loc = NULL;
-        local->newloc = NULL;
-        local->op_ret = -1;
-        local->op_errno = ret;
-    }
-
-    return ret;
-}
-
-/*
- * read and verify locked metadata against the old pathname (via open);
- * update the metadata string in accordance with the new pathname;
- * submit modified metadata;
- * wind;
- */
-static int32_t
-linkop(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-       int flags, dict_t *xdata, glusterfs_fop_t op)
-{
-    int32_t ret;
-    dict_t *dict;
-    crypt_local_t *local;
-    void (*unwind_fn)(call_frame_t * frame);
-    void (*wind_fn)(call_frame_t * frame, xlator_t * this);
-
-    wind_fn = linkop_wind_dispatch(op);
-    unwind_fn = linkop_unwind_dispatch(op);
-
-    ret = linkop_grab_local(frame, this, oldloc, newloc, flags, xdata, op);
-    local = frame->local;
-    if (ret)
-        goto error;
-
-    if (local->fd->inode->ia_type == IA_IFLNK)
-        goto wind;
-
-    dict = dict_new();
-    if (!dict) {
-        gf_log(this->name, GF_LOG_ERROR, "Can not create dict");
-        ret = ENOMEM;
-        goto error;
-    }
-    /*
-     * Set a message to crypt_open() that we need
-     * locked metadata string.
-     * All link operations (link, unlink, rename)
-     * need write lock
-     */
-    msgflags_set_mtd_wlock(&local->msgflags);
-    ret = dict_set_static_bin(dict, MSGFLAGS_PREFIX, &local->msgflags,
-                              sizeof(local->msgflags));
-    if (ret) {
-        gf_log(this->name, GF_LOG_ERROR, "Can not set dict");
-        dict_unref(dict);
-        goto error;
-    }
-    /*
-     * verify metadata against the old pathname
-     * and retrieve locked metadata string
-     */
-    STACK_WIND(frame, linkop_begin, this, this->fops->open, /* crypt_open() */
-               oldloc, O_RDWR, local->fd, dict);
-    dict_unref(dict);
-    return 0;
-
-wind:
-    wind_fn(frame, this);
-    return 0;
-
-error:
-    local->op_ret = -1;
-    local->op_errno = ret;
-    unwind_fn(frame);
-    return 0;
-}
-
-static int32_t
-crypt_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-           dict_t *xdata)
-{
-    return linkop(frame, this, oldloc, newloc, 0, xdata, GF_FOP_LINK);
-}
-
-static int32_t
-crypt_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-             dict_t *xdata)
-{
-    return linkop(frame, this, loc, NULL, flags, xdata, GF_FOP_UNLINK);
-}
-
-static int32_t
-crypt_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-             dict_t *xdata)
-{
-    return linkop(frame, this, oldloc, newloc, 0, xdata, GF_FOP_RENAME);
-}
-
-static void
-put_one_call_open(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    if (put_one_call(local)) {
-        fd_t *fd = local->fd;
-        loc_t *loc = local->loc;
-        dict_t *xdata = local->xdata;
-
-        CRYPT_STACK_UNWIND(open, frame, local->op_ret, local->op_errno, fd,
-                           xdata);
-        fd_unref(fd);
-        if (xdata)
-            dict_unref(xdata);
-        loc_wipe(loc);
-        GF_FREE(loc);
-    }
-}
-
-static int32_t
-__crypt_readv_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    fd_t *local_fd = local->fd;
-    dict_t *local_xdata = local->xdata;
-    /* read deals with data configs only */
-    struct iovec *avec = local->data_conf.avec;
-    char **pool = local->data_conf.pool;
-    int blocks_in_pool = local->data_conf.blocks_in_pool;
-    struct iobref *iobref = local->iobref;
-    struct iobref *iobref_data = local->iobref_data;
-
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "readv unlock failed (%d)",
-               op_errno);
-        if (local->op_ret >= 0) {
-            local->op_ret = op_ret;
-            local->op_errno = op_errno;
-        }
-    }
-    dump_plain_text(local, avec);
-
-    gf_log("crypt", GF_LOG_DEBUG,
-           "readv: ret_to_user: %d, iovec len: %d, ia_size: %llu",
-           (int)(local->rw_count > 0 ? local->rw_count : local->op_ret),
-           (int)(local->rw_count > 0 ? iov_length(avec, local->data_conf.acount)
-                                     : 0),
-           (unsigned long long)local->buf.ia_size);
-
-    CRYPT_STACK_UNWIND(
-        readv, frame, local->rw_count > 0 ? local->rw_count : local->op_ret,
-        local->op_errno, avec, avec ? local->data_conf.acount : 0, &local->buf,
-        local->iobref, local_xdata);
-
-    free_avec(avec, pool, blocks_in_pool);
-    fd_unref(local_fd);
-    if (local_xdata)
-        dict_unref(local_xdata);
-    if (iobref)
-        iobref_unref(iobref);
-    if (iobref_data)
-        iobref_unref(iobref_data);
-    return 0;
-}
-
-static void
-crypt_readv_done(call_frame_t *frame, xlator_t *this)
-{
-    if (parent_is_crypt_xlator(frame, this))
-        /*
-         *  don't unlock (it will be done by the parent)
-         */
-        __crypt_readv_done(frame, NULL, this, 0, 0, NULL);
-    else {
-        crypt_local_t *local = frame->local;
-        struct gf_flock lock = {
-            0,
-        };
-
-        lock.l_type = F_UNLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-        lock.l_pid = 0;
-
-        STACK_WIND(frame, __crypt_readv_done, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-                   F_SETLKW, &lock, NULL);
-    }
-}
-
-static void
-put_one_call_readv(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    if (put_one_call(local))
-        crypt_readv_done(frame, this);
-}
-
-static int32_t
-__crypt_writev_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    fd_t *local_fd = local->fd;
-    dict_t *local_xdata = local->xdata;
-    int32_t ret_to_user;
-
-    if (local->xattr)
-        dict_unref(local->xattr);
-    /*
-     * Calculate amount of butes to be returned
-     * to user. We need to subtract paddings that
-     * have been written as a part of atom.
-     */
-    /*
-     * subtract head padding
-     */
-    if (local->rw_count == 0)
-        /*
-         * Nothing has been written, it must be an error
-         */
-        ret_to_user = local->op_ret;
-    else if (local->rw_count <= local->data_conf.off_in_head) {
-        gf_log("crypt", GF_LOG_WARNING, "Incomplete write");
-        ret_to_user = 0;
-    } else
-        ret_to_user = local->rw_count - local->data_conf.off_in_head;
-    /*
-     * subtract tail padding
-     */
-    if (ret_to_user > local->data_conf.orig_size)
-        ret_to_user = local->data_conf.orig_size;
-
-    if (local->iobref)
-        iobref_unref(local->iobref);
-    if (local->iobref_data)
-        iobref_unref(local->iobref_data);
-    free_avec_data(local);
-    free_avec_hole(local);
-
-    gf_log("crypt", GF_LOG_DEBUG, "writev: ret_to_user: %d", ret_to_user);
-
-    CRYPT_STACK_UNWIND(writev, frame, ret_to_user, local->op_errno,
-                       &local->prebuf, &local->postbuf, local_xdata);
-    fd_unref(local_fd);
-    if (local_xdata)
-        dict_unref(local_xdata);
-    return 0;
-}
-
-static int32_t
-crypt_writev_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        gf_log("crypt", GF_LOG_WARNING, "can not update file size");
-
-    if (parent_is_crypt_xlator(frame, this))
-        /*
-         * don't unlock (it will be done by the parent)
-         */
-        __crypt_writev_done(frame, NULL, this, 0, 0, NULL);
-    else {
-        struct gf_flock lock = {
-            0,
-        };
-
-        lock.l_type = F_UNLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-        lock.l_pid = 0;
-
-        STACK_WIND(frame, __crypt_writev_done, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-                   F_SETLKW, &lock, NULL);
-    }
-    return 0;
-}
-
-static void
-put_one_call_writev(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    if (put_one_call(local)) {
-        if (local->update_disk_file_size) {
-            int32_t ret;
-            /*
-             * update file size, unlock the file and unwind
-             */
-            ret = dict_set(local->xattr, FSIZE_XATTR_PREFIX,
-                           data_from_uint64(local->cur_file_size));
-            if (ret) {
-                gf_log("crypt", GF_LOG_WARNING,
-                       "can not set key to update file size");
-                crypt_writev_done(frame, NULL, this, 0, 0, NULL);
-                return;
-            }
-            gf_log("crypt", GF_LOG_DEBUG, "Updating disk file size to %llu",
-                   (unsigned long long)local->cur_file_size);
-            STACK_WIND(frame, crypt_writev_done, FIRST_CHILD(this),
-                       FIRST_CHILD(this)->fops->fsetxattr, local->fd,
-                       local->xattr, /* CRYPTO_FORMAT_PREFIX */
-                       0, NULL);
-        } else
-            crypt_writev_done(frame, NULL, this, 0, 0, NULL);
-    }
-}
-
-static int32_t
-__crypt_ftruncate_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    fd_t *local_fd = local->fd;
-    dict_t *local_xdata = local->xdata;
-    char *iobase = local->vec.iov_base;
-
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "ftruncate unlock failed (%d)",
-               op_errno);
-        if (local->op_ret >= 0) {
-            local->op_ret = op_ret;
-            local->op_errno = op_errno;
-        }
-    }
-    if (local->iobref_data)
-        iobref_unref(local->iobref_data);
-    free_avec_data(local);
-    free_avec_hole(local);
-
-    gf_log("crypt", GF_LOG_DEBUG,
-           "ftruncate, return to user: presize=%llu, postsize=%llu",
-           (unsigned long long)local->prebuf.ia_size,
-           (unsigned long long)local->postbuf.ia_size);
-
-    CRYPT_STACK_UNWIND(ftruncate, frame, ((local->op_ret < 0) ? -1 : 0),
-                       local->op_errno, &local->prebuf, &local->postbuf,
-                       local_xdata);
-    fd_unref(local_fd);
-    if (local_xdata)
-        dict_unref(local_xdata);
-    if (iobase)
-        GF_FREE(iobase);
-    return 0;
-}
-
-static int32_t
-crypt_ftruncate_done(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-    struct gf_flock lock = {
-        0,
-    };
-
-    dict_unref(local->xattr);
-    if (op_ret < 0)
-        gf_log("crypt", GF_LOG_WARNING, "can not update file size");
-
-    lock.l_type = F_UNLCK;
-    lock.l_whence = SEEK_SET;
-    lock.l_start = 0;
-    lock.l_len = 0;
-    lock.l_pid = 0;
-
-    STACK_WIND(frame, __crypt_ftruncate_done, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->finodelk, this->name, local->fd,
-               F_SETLKW, &lock, NULL);
-    return 0;
-}
-
-static void
-put_one_call_ftruncate(call_frame_t *frame, xlator_t *this)
-{
-    crypt_local_t *local = frame->local;
-    if (put_one_call(local)) {
-        if (local->update_disk_file_size) {
-            int32_t ret;
-            /*
-             * update file size, unlock the file and unwind
-             */
-            ret = dict_set(local->xattr, FSIZE_XATTR_PREFIX,
-                           data_from_uint64(local->cur_file_size));
-            if (ret) {
-                gf_log("crypt", GF_LOG_WARNING,
-                       "can not set key to update file size");
-                crypt_ftruncate_done(frame, NULL, this, 0, 0, NULL);
-                return;
-            }
-            gf_log("crypt", GF_LOG_DEBUG, "Updating disk file size to %llu",
-                   (unsigned long long)local->cur_file_size);
-            STACK_WIND(frame, crypt_ftruncate_done, FIRST_CHILD(this),
-                       FIRST_CHILD(this)->fops->fsetxattr, local->fd,
-                       local->xattr, /* CRYPTO_FORMAT_PREFIX */
-                       0, NULL);
-        } else
-            crypt_ftruncate_done(frame, NULL, this, 0, 0, NULL);
-    }
-}
-
-/*
- * load regular file size for some FOPs
- */
-static int32_t
-load_file_size(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    data_t *data;
-    crypt_local_t *local = frame->local;
-
-    dict_t *local_xdata = local->xdata;
-    inode_t *local_inode = local->inode;
-
-    if (op_ret < 0)
-        goto unwind;
-    /*
-     * load regular file size
-     */
-    data = dict_get(dict, FSIZE_XATTR_PREFIX);
-    if (!data) {
-        if (local->xdata)
-            dict_unref(local->xdata);
-        gf_log("crypt", GF_LOG_WARNING, "Regular file size not found");
-        op_ret = -1;
-        op_errno = EIO;
-        goto unwind;
-    }
-    local->buf.ia_size = data_to_uint64(data);
-
-    gf_log(this->name, GF_LOG_DEBUG, "FOP %d: Translate regular file to %llu",
-           local->fop, (unsigned long long)local->buf.ia_size);
-unwind:
-    if (local->fd)
-        fd_unref(local->fd);
-    if (local->loc) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-    }
-    switch (local->fop) {
-        case GF_FOP_FSTAT:
-            CRYPT_STACK_UNWIND(fstat, frame, op_ret, op_errno,
-                               op_ret >= 0 ? &local->buf : NULL, local->xdata);
-            break;
-        case GF_FOP_STAT:
-            CRYPT_STACK_UNWIND(stat, frame, op_ret, op_errno,
-                               op_ret >= 0 ? &local->buf : NULL, local->xdata);
-            break;
-        case GF_FOP_LOOKUP:
-            CRYPT_STACK_UNWIND(lookup, frame, op_ret, op_errno,
-                               op_ret >= 0 ? local->inode : NULL,
-                               op_ret >= 0 ? &local->buf : NULL, local->xdata,
-                               op_ret >= 0 ? &local->postbuf : NULL);
-            break;
-        case GF_FOP_READ:
-            CRYPT_STACK_UNWIND(readv, frame, op_ret, op_errno, NULL, 0,
-                               op_ret >= 0 ? &local->buf : NULL, NULL, NULL);
-            break;
-        default:
-            gf_log(this->name, GF_LOG_WARNING, "Improper file operation %d",
-                   local->fop);
-    }
-    if (local_xdata)
-        dict_unref(local_xdata);
-    if (local_inode)
-        inode_unref(local_inode);
-    return 0;
-}
-
-static int32_t
-crypt_stat_common_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                      dict_t *xdata)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto unwind;
-    if (!IA_ISREG(buf->ia_type))
-        goto unwind;
-
-    local->buf = *buf;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-
-    switch (local->fop) {
-        case GF_FOP_FSTAT:
-            STACK_WIND(frame, load_file_size, FIRST_CHILD(this),
-                       FIRST_CHILD(this)->fops->fgetxattr, local->fd,
-                       FSIZE_XATTR_PREFIX, NULL);
-            break;
-        case GF_FOP_STAT:
-            STACK_WIND(frame, load_file_size, FIRST_CHILD(this),
-                       FIRST_CHILD(this)->fops->getxattr, local->loc,
-                       FSIZE_XATTR_PREFIX, NULL);
-            break;
-        default:
-            gf_log(this->name, GF_LOG_WARNING, "Improper file operation %d",
-                   local->fop);
-    }
-    return 0;
-unwind:
-    if (local->fd)
-        fd_unref(local->fd);
-    if (local->loc) {
-        loc_wipe(local->loc);
-        GF_FREE(local->loc);
-    }
-    switch (local->fop) {
-        case GF_FOP_FSTAT:
-            CRYPT_STACK_UNWIND(fstat, frame, op_ret, op_errno,
-                               op_ret >= 0 ? buf : NULL,
-                               op_ret >= 0 ? xdata : NULL);
-            break;
-        case GF_FOP_STAT:
-            CRYPT_STACK_UNWIND(stat, frame, op_ret, op_errno,
-                               op_ret >= 0 ? buf : NULL,
-                               op_ret >= 0 ? xdata : NULL);
-            break;
-        default:
-            gf_log(this->name, GF_LOG_WARNING, "Improper file operation %d",
-                   local->fop);
-    }
-    return 0;
-}
-
-static int32_t
-crypt_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    crypt_local_t *local;
-
-    local = crypt_alloc_local(frame, this, GF_FOP_FSTAT);
-    if (!local)
-        goto error;
-    local->fd = fd_ref(fd);
-    STACK_WIND(frame, crypt_stat_common_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, xdata);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(fstat, frame, -1, ENOMEM, NULL, NULL);
-    return 0;
-}
-
-static int32_t
-crypt_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    int32_t ret;
-    crypt_local_t *local;
-
-    local = crypt_alloc_local(frame, this, GF_FOP_STAT);
-    if (!local)
-        goto error;
-    local->loc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-    if (!local->loc)
-        goto error;
-    ret = loc_copy(local->loc, loc);
-    if (ret) {
-        GF_FREE(local->loc);
-        goto error;
-    }
-    STACK_WIND(frame, crypt_stat_common_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->stat, loc, xdata);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(stat, frame, -1, ENOMEM, NULL, NULL);
-    return 0;
-}
-
-static int32_t
-crypt_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, dict_t *xdata, struct iatt *postparent)
-{
-    crypt_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto unwind;
-    if (!IA_ISREG(buf->ia_type))
-        goto unwind;
-
-    local->inode = inode_ref(inode);
-    local->buf = *buf;
-    local->postbuf = *postparent;
-    if (xdata)
-        local->xdata = dict_ref(xdata);
-    gf_uuid_copy(local->loc->gfid, buf->ia_gfid);
-
-    STACK_WIND(frame, load_file_size, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->getxattr, local->loc,
-               FSIZE_XATTR_PREFIX, NULL);
-    return 0;
-unwind:
-    loc_wipe(local->loc);
-    GF_FREE(local->loc);
-    CRYPT_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xdata,
-                       postparent);
-    return 0;
-}
-
-static int32_t
-crypt_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    int32_t ret;
-    crypt_local_t *local;
-
-    local = crypt_alloc_local(frame, this, GF_FOP_LOOKUP);
-    if (!local)
-        goto error;
-    local->loc = GF_CALLOC(1, sizeof(loc_t), gf_crypt_mt_loc);
-    if (!local->loc)
-        goto error;
-    ret = loc_copy(local->loc, loc);
-    if (ret) {
-        GF_FREE(local->loc);
-        goto error;
-    }
-    gf_log(this->name, GF_LOG_DEBUG, "Lookup %s", loc->path);
-    STACK_WIND(frame, crypt_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, xdata);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
-    return 0;
-}
-
-/*
- * for every regular directory entry find its real file size
- * and update stat's buf properly
- */
-static int32_t
-crypt_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                   dict_t *xdata)
-{
-    gf_dirent_t *entry = NULL;
-
-    if (op_ret < 0)
-        goto unwind;
-
-    list_for_each_entry(entry, (&entries->list), list)
-    {
-        data_t *data;
-
-        if (!IA_ISREG(entry->d_stat.ia_type))
-            continue;
-        data = dict_get(entry->dict, FSIZE_XATTR_PREFIX);
-        if (!data) {
-            gf_log("crypt", GF_LOG_WARNING,
-                   "Regular file size of direntry not found");
-            op_errno = EIO;
-            op_ret = -1;
-            break;
-        }
-        entry->d_stat.ia_size = data_to_uint64(data);
-    }
-unwind:
-    CRYPT_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata);
-    return 0;
-}
-
-/*
- * ->readdirp() fills in-core inodes, so we need to set proper
- * file sizes for all directory entries of the parent @fd.
- * Actual updates take place in ->crypt_readdirp_cbk()
- */
-static int32_t
-crypt_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-               off_t offset, dict_t *xdata)
-{
-    int32_t ret = ENOMEM;
-
-    if (!xdata) {
-        xdata = dict_new();
-        if (!xdata)
-            goto error;
-    } else
-        dict_ref(xdata);
-    /*
-     * make sure that we'll have real file sizes at ->readdirp_cbk()
-     */
-    ret = dict_set(xdata, FSIZE_XATTR_PREFIX, data_from_uint64(0));
-    if (ret) {
-        dict_unref(xdata);
-        ret = ENOMEM;
-        goto error;
-    }
-    STACK_WIND(frame, crypt_readdirp_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata);
-    dict_unref(xdata);
-    return 0;
-error:
-    CRYPT_STACK_UNWIND(readdirp, frame, -1, ret, NULL, NULL);
-    return 0;
-}
-
-static int32_t
-crypt_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask,
-             dict_t *xdata)
-{
-    gf_log(this->name, GF_LOG_WARNING,
-           "NFS mounts of encrypted volumes are unsupported");
-    CRYPT_STACK_UNWIND(access, frame, -1, EPERM, NULL);
-    return 0;
-}
-
-int32_t
-master_set_block_size(xlator_t *this, crypt_private_t *priv, dict_t *options)
-{
-    uint64_t block_size = 0;
-    struct master_cipher_info *master = get_master_cinfo(priv);
-
-    if (options != NULL)
-        GF_OPTION_RECONF("block-size", block_size, options, size_uint64, error);
-    else
-        GF_OPTION_INIT("block-size", block_size, size_uint64, error);
-
-    switch (block_size) {
-        case 512:
-            master->m_block_bits = 9;
-            break;
-        case 1024:
-            master->m_block_bits = 10;
-            break;
-        case 2048:
-            master->m_block_bits = 11;
-            break;
-        case 4096:
-            master->m_block_bits = 12;
-            break;
-        default:
-            gf_log("crypt", GF_LOG_ERROR, "FATAL: unsupported block size %llu",
-                   (unsigned long long)block_size);
-            goto error;
-    }
-    return 0;
-error:
-    return -1;
-}
-
-int32_t
-master_set_alg(xlator_t *this, crypt_private_t *priv)
-{
-    struct master_cipher_info *master = get_master_cinfo(priv);
-    master->m_alg = AES_CIPHER_ALG;
-    return 0;
-}
-
-int32_t
-master_set_mode(xlator_t *this, crypt_private_t *priv)
-{
-    struct master_cipher_info *master = get_master_cinfo(priv);
-    master->m_mode = XTS_CIPHER_MODE;
-    return 0;
-}
-
-/*
- * set key size in bits to the master info
- * Pre-conditions: cipher mode in the master info is uptodate.
- */
-static int
-master_set_data_key_size(xlator_t *this, crypt_private_t *priv, dict_t *options)
-{
-    int32_t ret;
-    uint64_t key_size = 0;
-    struct master_cipher_info *master = get_master_cinfo(priv);
-
-    if (options != NULL)
-        GF_OPTION_RECONF("data-key-size", key_size, options, uint64, error);
-    else
-        GF_OPTION_INIT("data-key-size", key_size, uint64, error);
-
-    ret = data_cipher_algs[master->m_alg][master->m_mode].check_key(key_size);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR,
-               "FATAL: wrong bin key size %llu for alg %d mode %d",
-               (unsigned long long)key_size, (int)master->m_alg,
-               (int)master->m_mode);
-        goto error;
-    }
-    master->m_dkey_size = key_size;
-    return 0;
-error:
-    return -1;
-}
-
-static int
-is_hex(char *s)
-{
-    return ('0' <= *s && *s <= '9') || ('a' <= *s && *s <= 'f');
-}
-
-static int
-parse_hex_buf(xlator_t *this, char *src, unsigned char *dst, int hex_size)
-{
-    int i;
-    int hex_byte = 0;
-
-    for (i = 0; i < (hex_size / 2); i++) {
-        if (!is_hex(src + i * 2) || !is_hex(src + i * 2 + 1)) {
-            gf_log("crypt", GF_LOG_ERROR, "FATAL: not hex symbol in key");
-            return -1;
-        }
-        if (sscanf(src + i * 2, "%2x", &hex_byte) != 1) {
-            gf_log("crypt", GF_LOG_ERROR, "FATAL: can not parse hex key");
-            return -1;
-        }
-        dst[i] = hex_byte & 0xff;
-    }
-    return 0;
-}
-
-/*
- * Parse options;
- * install master volume key
- */
-int32_t
-master_set_master_vol_key(xlator_t *this, crypt_private_t *priv)
-{
-    int32_t ret;
-    FILE *file = NULL;
-
-    int32_t key_size;
-    char *opt_key_file_pathname = NULL;
-
-    unsigned char bin_buf[MASTER_VOL_KEY_SIZE];
-    char hex_buf[2 * MASTER_VOL_KEY_SIZE];
-
-    struct master_cipher_info *master = get_master_cinfo(priv);
-    /*
-     * extract master key passed via option
-     */
-    GF_OPTION_INIT("master-key", opt_key_file_pathname, path, bad_key);
-
-    if (!opt_key_file_pathname) {
-        gf_log(this->name, GF_LOG_ERROR, "FATAL: missing master key");
-        return -1;
-    }
-    gf_log(this->name, GF_LOG_DEBUG, "handling file key %s",
-           opt_key_file_pathname);
-
-    file = fopen(opt_key_file_pathname, "r");
-    if (file == NULL) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "FATAL: can not open file with master key");
-        return -1;
-    }
-    /*
-     * extract hex key
-     */
-    key_size = fread(hex_buf, 1, sizeof(hex_buf), file);
-    if (key_size < sizeof(hex_buf)) {
-        gf_log(this->name, GF_LOG_ERROR, "FATAL: master key is too short");
-        goto bad_key;
-    }
-    ret = parse_hex_buf(this, hex_buf, bin_buf, key_size);
-    if (ret)
-        goto bad_key;
-    memcpy(master->m_key, bin_buf, MASTER_VOL_KEY_SIZE);
-    memset(hex_buf, 0, sizeof(hex_buf));
-    fclose(file);
-
-    memset(bin_buf, 0, sizeof(bin_buf));
-    return 0;
-bad_key:
-    gf_log(this->name, GF_LOG_ERROR, "FATAL: bad master key");
-    if (file)
-        fclose(file);
-    memset(bin_buf, 0, sizeof(bin_buf));
-    return -1;
-}
-
-/*
- * Derive volume key for object-id authentication
- */
-int32_t
-master_set_nmtd_vol_key(xlator_t *this, crypt_private_t *priv)
-{
-    return get_nmtd_vol_key(get_master_cinfo(priv));
-}
-
-int32_t
-crypt_init_xlator(xlator_t *this)
-{
-    int32_t ret;
-    crypt_private_t *priv = this->private;
-
-    ret = master_set_alg(this, priv);
-    if (ret)
-        return ret;
-    ret = master_set_mode(this, priv);
-    if (ret)
-        return ret;
-    ret = master_set_block_size(this, priv, NULL);
-    if (ret)
-        return ret;
-    ret = master_set_data_key_size(this, priv, NULL);
-    if (ret)
-        return ret;
-    ret = master_set_master_vol_key(this, priv);
-    if (ret)
-        return ret;
-    return master_set_nmtd_vol_key(this, priv);
-}
-
-static int32_t
-crypt_alloc_private(xlator_t *this)
-{
-    this->private = GF_CALLOC(1, sizeof(crypt_private_t), gf_crypt_mt_priv);
-    if (!this->private) {
-        gf_log("crypt", GF_LOG_ERROR,
-               "Can not allocate memory for private data");
-        return ENOMEM;
-    }
-    return 0;
-}
-
-static void
-crypt_free_private(xlator_t *this)
-{
-    crypt_private_t *priv = this->private;
-    if (priv) {
-        memset(priv, 0, sizeof(*priv));
-        GF_FREE(priv);
-    }
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    if (!this)
-        return ret;
-
-    ret = xlator_mem_acct_init(this, gf_crypt_mt_end);
-
-    if (ret != 0) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Memory accounting init"
-               "failed");
-        return ret;
-    }
-
-    return ret;
-}
-
-int32_t
-reconfigure(xlator_t *this, dict_t *options)
-{
-    int32_t ret = -1;
-    crypt_private_t *priv = NULL;
-
-    GF_VALIDATE_OR_GOTO("crypt", this, error);
-    GF_VALIDATE_OR_GOTO(this->name, this->private, error);
-    GF_VALIDATE_OR_GOTO(this->name, options, error);
-
-    priv = this->private;
-
-    ret = master_set_block_size(this, priv, options);
-    if (ret) {
-        gf_log("this->name", GF_LOG_ERROR, "Failed to reconfure block size");
-        goto error;
-    }
-    ret = master_set_data_key_size(this, priv, options);
-    if (ret) {
-        gf_log("this->name", GF_LOG_ERROR, "Failed to reconfure data key size");
-        goto error;
-    }
-    return 0;
-error:
-    return ret;
-}
-
-int32_t
-init(xlator_t *this)
-{
-    int32_t ret;
-
-    if (!this->children || this->children->next) {
-        gf_log("crypt", GF_LOG_ERROR,
-               "FATAL: crypt should have exactly one child");
-        return EINVAL;
-    }
-    if (!this->parents) {
-        gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile ");
-    }
-    ret = crypt_alloc_private(this);
-    if (ret)
-        return ret;
-    ret = crypt_init_xlator(this);
-    if (ret)
-        goto error;
-    this->local_pool = mem_pool_new(crypt_local_t, 64);
-    if (!this->local_pool) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "failed to create local_t's memory pool");
-        ret = ENOMEM;
-        goto error;
-    }
-    gf_log("crypt", GF_LOG_INFO, "crypt xlator loaded");
-    return 0;
-error:
-    crypt_free_private(this);
-    return ret;
-}
-
-void
-fini(xlator_t *this)
-{
-    crypt_free_private(this);
-}
-
-struct xlator_fops fops = {.readv = crypt_readv,
-                           .writev = crypt_writev,
-                           .truncate = crypt_truncate,
-                           .ftruncate = crypt_ftruncate,
-                           .setxattr = crypt_setxattr,
-                           .fsetxattr = crypt_fsetxattr,
-                           .link = crypt_link,
-                           .unlink = crypt_unlink,
-                           .rename = crypt_rename,
-                           .open = crypt_open,
-                           .create = crypt_create,
-                           .stat = crypt_stat,
-                           .fstat = crypt_fstat,
-                           .lookup = crypt_lookup,
-                           .readdirp = crypt_readdirp,
-                           .access = crypt_access};
-
-struct xlator_cbks cbks = {.forget = crypt_forget};
-
-struct volume_options options[] = {
-    {.key = {"master-key"},
-     .type = GF_OPTION_TYPE_PATH,
-     .description =
-         "Pathname of regular file which contains master volume key"},
-    {
-        .key = {"data-key-size"},
-        .type = GF_OPTION_TYPE_SIZET,
-        .description = "Data key size (bits)",
-        .min = 256,
-        .max = 512,
-        .default_value = "256",
-    },
-    {.key = {"block-size"},
-     .type = GF_OPTION_TYPE_SIZET,
-     .description = "Atom size (bits)",
-     .min = 512,
-     .max = 4096,
-     .default_value = "4096"},
-    {.key = {NULL}},
-};
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/crypt.h b/xlators/encryption/crypt/src/crypt.h
deleted file mode 100644
index c1216a2cdb0..00000000000
--- a/xlators/encryption/crypt/src/crypt.h
+++ /dev/null
@@ -1,931 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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 __CRYPT_H__
-#define __CRYPT_H__
-
-#include <openssl/aes.h>
-#include <openssl/evp.h>
-#include <openssl/sha.h>
-#include <openssl/hmac.h>
-#include <openssl/cmac.h>
-#include <openssl/modes.h>
-#include "crypt-mem-types.h"
-#include <glusterfs/compat.h>
-
-#define CRYPT_XLATOR_ID (0)
-
-#define MAX_IOVEC_BITS (3)
-#define MAX_IOVEC (1 << MAX_IOVEC_BITS)
-#define KEY_FACTOR_BITS (6)
-
-#define DEBUG_CRYPT (0)
-#define TRIVIAL_TFM (0)
-
-#define CRYPT_MIN_BLOCK_BITS (9)
-#define CRYPT_MAX_BLOCK_BITS (12)
-
-#define MASTER_VOL_KEY_SIZE (32)
-#define NMTD_VOL_KEY_SIZE (16)
-
-#if !defined(GF_LINUX_HOST_OS)
-typedef off_t loff_t;
-#endif
-
-struct crypt_key {
-    uint32_t len;
-    const char *label;
-};
-
-/*
- * Add new key types to the end of this
- * enumeration but before LAST_KEY_TYPE
- */
-typedef enum {
-    MASTER_VOL_KEY,
-    NMTD_VOL_KEY,
-    NMTD_LINK_KEY,
-    EMTD_FILE_KEY,
-    DATA_FILE_KEY_256,
-    DATA_FILE_KEY_512,
-    LAST_KEY_TYPE
-} crypt_key_type;
-
-struct kderive_context {
-    const unsigned char *pkey; /* parent key */
-    uint32_t pkey_len;         /* parent key size, bits */
-    uint32_t ckey_len;         /* child key size, bits */
-    unsigned char *fid;        /* fixed input data, NIST 800-108, 5.1 */
-    uint32_t fid_len;          /* fid len, bytes */
-    unsigned char *out;        /* contains child keying material */
-    uint32_t out_len;          /* out len, bytes */
-};
-
-typedef enum { DATA_ATOM, HOLE_ATOM, LAST_DATA_TYPE } atom_data_type;
-
-typedef enum {
-    HEAD_ATOM,
-    TAIL_ATOM,
-    FULL_ATOM,
-    LAST_LOCALITY_TYPE
-} atom_locality_type;
-
-typedef enum {
-    MTD_CREATE,
-    MTD_APPEND,
-    MTD_OVERWRITE,
-    MTD_CUT,
-    MTD_LAST_OP
-} mtd_op_t;
-
-struct xts128_context {
-    void *key1, *key2;
-    block128_f block1, block2;
-};
-
-struct object_cipher_info {
-    cipher_alg_t o_alg;
-    cipher_mode_t o_mode;
-    uint32_t o_block_bits;
-    uint32_t o_dkey_size; /* raw data key size in bits */
-    union {
-        struct {
-            unsigned char ivec[16];
-            AES_KEY dkey[2];
-            AES_KEY tkey; /* key used for tweaking */
-            XTS128_CONTEXT xts;
-        } aes_xts;
-    } u;
-};
-
-struct master_cipher_info {
-    /*
-     * attributes inherited by newly created regular files
-     */
-    cipher_alg_t m_alg;
-    cipher_mode_t m_mode;
-    uint32_t m_block_bits;
-    uint32_t m_dkey_size; /* raw key size in bits */
-    /*
-     * master key
-     */
-    unsigned char m_key[MASTER_VOL_KEY_SIZE];
-    /*
-     * volume key for oid authentication
-     */
-    unsigned char m_nmtd_key[NMTD_VOL_KEY_SIZE];
-};
-
-/*
- * This info is not changed during file's life
- */
-struct crypt_inode_info {
-#if DEBUG_CRYPT
-    loc_t *loc; /* pathname that the file has been
-                   opened, or created with */
-#endif
-    uint16_t nr_minor;
-    uuid_t oid;
-    struct object_cipher_info cinfo;
-};
-
-/*
- * this should locate in secure memory
- */
-typedef struct {
-    struct master_cipher_info master;
-} crypt_private_t;
-
-static inline struct master_cipher_info *
-get_master_cinfo(crypt_private_t *priv)
-{
-    return &priv->master;
-}
-
-static inline struct object_cipher_info *
-get_object_cinfo(struct crypt_inode_info *info)
-{
-    return &info->cinfo;
-}
-
-/*
- * this describes layouts and properties
- * of atoms in an aligned vector
- */
-struct avec_config {
-    uint32_t atom_size;
-    atom_data_type type;
-    size_t orig_size;
-    off_t orig_offset;
-    size_t expanded_size;
-    off_t aligned_offset;
-
-    uint32_t off_in_head;
-    uint32_t off_in_tail;
-    uint32_t gap_in_tail;
-    uint32_t nr_full_blocks;
-
-    struct iovec *avec; /* aligned vector */
-    uint32_t acount;    /* number of avec components. The same
-                         * as number of occupied logical blocks */
-    char **pool;
-    uint32_t blocks_in_pool;
-    uint32_t cursor; /* makes sense only for ordered writes,
-                      * so there is no races on this counter.
-                      *
-                      * Cursor is per-config object, we don't
-                      * reset cursor for atoms of different
-                      * localities (head, tail, full)
-                      */
-};
-
-typedef struct {
-    glusterfs_fop_t fop; /* code of FOP this local info built for */
-    fd_t *fd;
-    inode_t *inode;
-    loc_t *loc;
-    int32_t mac_idx;
-    loc_t *newloc;
-    int32_t flags;
-    int32_t wbflags;
-    struct crypt_inode_info *info;
-    struct iobref *iobref;
-    struct iobref *iobref_data;
-    off_t offset;
-
-    uint64_t old_file_size; /* per FOP, retrieved under lock held */
-    uint64_t cur_file_size; /* per iteration, before issuing IOs */
-    uint64_t new_file_size; /* per iteration, after issuing IOs */
-
-    uint64_t io_offset;        /* offset of IOs issued per iteration */
-    uint64_t io_offset_nopad;  /* offset of user's data in the atom */
-    uint32_t io_size;          /* size of IOs issued per iteration */
-    uint32_t io_size_nopad;    /* size of user's data in the IOs */
-    uint32_t eof_padding_size; /* size od EOF padding in the IOs */
-
-    gf_lock_t call_lock; /* protect nr_calls from many cbks */
-    int32_t nr_calls;
-
-    atom_data_type active_setup; /* which setup (hole or date)
-                                    is currently active */
-    /* data setup */
-    struct avec_config data_conf;
-
-    /* hole setup */
-    int hole_conv_in_proggress;
-    gf_lock_t hole_lock; /* protect hole config from many cbks */
-    int hole_handled;
-    struct avec_config hole_conf;
-    struct iatt buf;
-    struct iatt prebuf;
-    struct iatt postbuf;
-    struct iatt *prenewparent;
-    struct iatt *postnewparent;
-    int32_t op_ret;
-    int32_t op_errno;
-    int32_t rw_count;        /* total read or written */
-    gf_lock_t rw_count_lock; /* protect the counter above */
-    unsigned char *format;   /* for create, update format string */
-    uint32_t format_size;
-    uint32_t msgflags; /* messages for crypt_open() */
-    dict_t *xdata;
-    dict_t *xattr;
-    struct iovec vec; /* contains last file's atom for
-                         read-prune-write sequence */
-    gf_boolean_t custom_mtd;
-    /*
-     * the next 3 fields are used by readdir and friends
-     */
-    gf_dirent_t *de;        /* directory entry */
-    char *de_path;          /* pathname of directory entry */
-    uint32_t de_prefix_len; /* length of the parent's pathname */
-    gf_dirent_t *entries;
-
-    uint32_t update_disk_file_size : 1;
-} crypt_local_t;
-
-/* This represents a (read)modify-write atom */
-struct rmw_atom {
-    atom_locality_type locality;
-    /*
-     * read-modify-write sequence of the atom
-     */
-    int32_t (*rmw)(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iovec *vec,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                   dict_t *xdata);
-    /*
-     * offset of the logical block in a file
-     */
-    loff_t (*offset_at)(call_frame_t *frame, struct object_cipher_info *object);
-    /*
-     * IO offset in an atom
-     */
-    uint32_t (*offset_in)(call_frame_t *frame,
-                          struct object_cipher_info *object);
-    /*
-     * number of bytes of plain text of this atom that user
-     * wants to read/write.
-     * It can be smaller than atom_size in the case of head
-     * or tail atoms.
-     */
-    uint32_t (*io_size_nopad)(call_frame_t *frame,
-                              struct object_cipher_info *object);
-    /*
-     * which iovec represents the atom
-     */
-    struct iovec *(*get_iovec)(call_frame_t *frame, uint32_t count);
-    /*
-     * how many bytes of partial block should be uptodated by
-     * reading from disk.
-     * This is used to perform a read component of RMW (read-modify-write).
-     */
-    uint32_t (*count_to_uptodate)(call_frame_t *frame,
-                                  struct object_cipher_info *object);
-    struct avec_config *(*get_config)(call_frame_t *frame);
-};
-
-struct data_cipher_alg {
-    gf_boolean_t atomic;     /* true means that algorithm requires
-                                to pad data before cipher transform */
-    gf_boolean_t should_pad; /* true means that algorithm requires
-                                to pad the end of file with extra-data */
-    uint32_t blkbits;        /* blksize = 1 << blkbits */
-    /*
-     * any preliminary sanity checks goes here
-     */
-    int32_t (*init)(void);
-    /*
-     * set alg-mode specific inode info
-     */
-    int32_t (*set_private)(struct crypt_inode_info *info,
-                           struct master_cipher_info *master);
-    /*
-     * check alg-mode specific data key
-     */
-    int32_t (*check_key)(uint32_t key_size);
-    void (*set_iv)(off_t offset, struct object_cipher_info *object);
-    int32_t (*encrypt)(const unsigned char *from, unsigned char *to,
-                       size_t length, off_t offset, const int enc,
-                       struct object_cipher_info *object);
-};
-
-/*
- * version-dependent metadata loader
- */
-struct crypt_mtd_loader {
-    /*
-     * return core format size
-     */
-    size_t (*format_size)(mtd_op_t op, size_t old_size);
-    /*
-     * pack version-specific metadata of an object
-     * at ->create()
-     */
-    int32_t (*create_format)(unsigned char *wire, loc_t *loc,
-                             struct crypt_inode_info *info,
-                             struct master_cipher_info *master);
-    /*
-     * extract version-specific metadata of an object
-     * at ->open() time
-     */
-    int32_t (*open_format)(unsigned char *wire, int32_t len, loc_t *loc,
-                           struct crypt_inode_info *info,
-                           struct master_cipher_info *master,
-                           crypt_local_t *local, gf_boolean_t load_info);
-    int32_t (*update_format)(unsigned char *new, unsigned char *old,
-                             size_t old_len, int32_t mac_idx, mtd_op_t op,
-                             loc_t *loc, struct crypt_inode_info *info,
-                             struct master_cipher_info *master,
-                             crypt_local_t *local);
-};
-
-typedef int32_t (*end_writeback_handler_t)(call_frame_t *frame, void *cookie,
-                                           xlator_t *this, int32_t op_ret,
-                                           int32_t op_errno,
-                                           struct iatt *prebuf,
-                                           struct iatt *postbuf, dict_t *xdata);
-typedef void (*linkop_wind_handler_t)(call_frame_t *frame, xlator_t *this);
-typedef void (*linkop_unwind_handler_t)(call_frame_t *frame);
-
-/* Declarations */
-
-/* keys.c */
-extern struct crypt_key crypt_keys[LAST_KEY_TYPE];
-int32_t
-get_nmtd_vol_key(struct master_cipher_info *master);
-int32_t
-get_nmtd_link_key(loc_t *loc, struct master_cipher_info *master,
-                  unsigned char *result);
-int32_t
-get_emtd_file_key(struct crypt_inode_info *info,
-                  struct master_cipher_info *master, unsigned char *result);
-int32_t
-get_data_file_key(struct crypt_inode_info *info,
-                  struct master_cipher_info *master, uint32_t keysize,
-                  unsigned char *key);
-/* data.c */
-extern struct data_cipher_alg data_cipher_algs[LAST_CIPHER_ALG]
-                                              [LAST_CIPHER_MODE];
-void
-encrypt_aligned_iov(struct object_cipher_info *object, struct iovec *vec,
-                    int count, off_t off);
-void
-decrypt_aligned_iov(struct object_cipher_info *object, struct iovec *vec,
-                    int count, off_t off);
-int32_t
-align_iov_by_atoms(xlator_t *this, crypt_local_t *local,
-                   struct object_cipher_info *object,
-                   struct iovec *vec /* input vector */,
-                   int32_t count /* number of vec components */,
-                   struct iovec *avec /* aligned vector */,
-                   char **blocks /* pool of blocks */,
-                   uint32_t *blocks_allocated, struct avec_config *conf);
-int32_t
-set_config_avec_data(xlator_t *this, crypt_local_t *local,
-                     struct avec_config *conf,
-                     struct object_cipher_info *object, struct iovec *vec,
-                     int32_t vec_count);
-int32_t
-set_config_avec_hole(xlator_t *this, crypt_local_t *local,
-                     struct avec_config *conf,
-                     struct object_cipher_info *object, glusterfs_fop_t fop);
-void
-set_gap_at_end(call_frame_t *frame, struct object_cipher_info *object,
-               struct avec_config *conf, atom_data_type dtype);
-void
-set_config_offsets(call_frame_t *frame, xlator_t *this, uint64_t offset,
-                   uint64_t count, atom_data_type dtype,
-                   int32_t setup_gap_in_tail);
-
-/* metadata.c */
-extern struct crypt_mtd_loader mtd_loaders[LAST_MTD_LOADER];
-
-int32_t
-alloc_format(crypt_local_t *local, size_t size);
-int32_t
-alloc_format_create(crypt_local_t *local);
-void
-free_format(crypt_local_t *local);
-size_t
-format_size(mtd_op_t op, size_t old_size);
-size_t
-new_format_size(void);
-int32_t
-open_format(unsigned char *str, int32_t len, loc_t *loc,
-            struct crypt_inode_info *info, struct master_cipher_info *master,
-            crypt_local_t *local, gf_boolean_t load_info);
-int32_t
-update_format(unsigned char *new, unsigned char *old, size_t old_len,
-              int32_t mac_idx, mtd_op_t op, loc_t *loc,
-              struct crypt_inode_info *info, struct master_cipher_info *master,
-              crypt_local_t *local);
-int32_t
-create_format(unsigned char *wire, loc_t *loc, struct crypt_inode_info *info,
-              struct master_cipher_info *master);
-
-/* atom.c */
-struct rmw_atom *
-atom_by_types(atom_data_type data, atom_locality_type locality);
-void
-submit_partial(call_frame_t *frame, xlator_t *this, fd_t *fd,
-               atom_locality_type ltype);
-void
-submit_full(call_frame_t *frame, xlator_t *this);
-
-/* crypt.c */
-
-end_writeback_handler_t
-dispatch_end_writeback(glusterfs_fop_t fop);
-void
-set_local_io_params_writev(call_frame_t *frame,
-                           struct object_cipher_info *object,
-                           struct rmw_atom *atom, off_t io_offset,
-                           uint32_t io_size);
-void
-link_wind(call_frame_t *frame, xlator_t *this);
-void
-unlink_wind(call_frame_t *frame, xlator_t *this);
-void
-link_unwind(call_frame_t *frame);
-void
-unlink_unwind(call_frame_t *frame);
-void
-rename_wind(call_frame_t *frame, xlator_t *this);
-void
-rename_unwind(call_frame_t *frame);
-
-/* Inline functions */
-
-static inline int32_t
-crypt_xlator_id(void)
-{
-    return CRYPT_XLATOR_ID;
-}
-
-static inline mtd_loader_id
-current_mtd_loader(void)
-{
-    return MTD_LOADER_V1;
-}
-
-static inline uint32_t
-master_key_size(void)
-{
-    return crypt_keys[MASTER_VOL_KEY].len >> 3;
-}
-
-static inline uint32_t
-nmtd_vol_key_size(void)
-{
-    return crypt_keys[NMTD_VOL_KEY].len >> 3;
-}
-
-static inline uint32_t
-alg_mode_blkbits(cipher_alg_t alg, cipher_mode_t mode)
-{
-    return data_cipher_algs[alg][mode].blkbits;
-}
-
-static inline uint32_t
-alg_mode_blksize(cipher_alg_t alg, cipher_mode_t mode)
-{
-    return 1 << alg_mode_blkbits(alg, mode);
-}
-
-static inline gf_boolean_t
-alg_mode_atomic(cipher_alg_t alg, cipher_mode_t mode)
-{
-    return data_cipher_algs[alg][mode].atomic;
-}
-
-static inline gf_boolean_t
-alg_mode_should_pad(cipher_alg_t alg, cipher_mode_t mode)
-{
-    return data_cipher_algs[alg][mode].should_pad;
-}
-
-static inline uint32_t
-master_alg_blksize(struct master_cipher_info *mr)
-{
-    return alg_mode_blksize(mr->m_alg, mr->m_mode);
-}
-
-static inline uint32_t
-master_alg_blkbits(struct master_cipher_info *mr)
-{
-    return alg_mode_blkbits(mr->m_alg, mr->m_mode);
-}
-
-static inline gf_boolean_t
-master_alg_atomic(struct master_cipher_info *mr)
-{
-    return alg_mode_atomic(mr->m_alg, mr->m_mode);
-}
-
-static inline gf_boolean_t
-master_alg_should_pad(struct master_cipher_info *mr)
-{
-    return alg_mode_should_pad(mr->m_alg, mr->m_mode);
-}
-
-static inline uint32_t
-object_alg_blksize(struct object_cipher_info *ob)
-{
-    return alg_mode_blksize(ob->o_alg, ob->o_mode);
-}
-
-static inline uint32_t
-object_alg_blkbits(struct object_cipher_info *ob)
-{
-    return alg_mode_blkbits(ob->o_alg, ob->o_mode);
-}
-
-static inline gf_boolean_t
-object_alg_atomic(struct object_cipher_info *ob)
-{
-    return alg_mode_atomic(ob->o_alg, ob->o_mode);
-}
-
-static inline gf_boolean_t
-object_alg_should_pad(struct object_cipher_info *ob)
-{
-    return alg_mode_should_pad(ob->o_alg, ob->o_mode);
-}
-
-static inline uint32_t
-aes_raw_key_size(struct master_cipher_info *master)
-{
-    return master->m_dkey_size >> 3;
-}
-
-static inline struct avec_config *
-get_hole_conf(call_frame_t *frame)
-{
-    return &(((crypt_local_t *)frame->local)->hole_conf);
-}
-
-static inline struct avec_config *
-get_data_conf(call_frame_t *frame)
-{
-    return &(((crypt_local_t *)frame->local)->data_conf);
-}
-
-static inline int32_t
-get_atom_bits(struct object_cipher_info *object)
-{
-    return object->o_block_bits;
-}
-
-static inline int32_t
-get_atom_size(struct object_cipher_info *object)
-{
-    return 1 << get_atom_bits(object);
-}
-
-static inline int32_t
-has_head_block(struct avec_config *conf)
-{
-    return conf->off_in_head || (conf->acount == 1 && conf->off_in_tail);
-}
-
-static inline int32_t
-has_tail_block(struct avec_config *conf)
-{
-    return conf->off_in_tail && conf->acount > 1;
-}
-
-static inline int32_t
-has_full_blocks(struct avec_config *conf)
-{
-    return conf->nr_full_blocks;
-}
-
-static inline int32_t
-should_submit_head_block(struct avec_config *conf)
-{
-    return has_head_block(conf) && (conf->cursor == 0);
-}
-
-static inline int32_t
-should_submit_tail_block(struct avec_config *conf)
-{
-    return has_tail_block(conf) && (conf->cursor == conf->acount - 1);
-}
-
-static inline int32_t
-should_submit_full_block(struct avec_config *conf)
-{
-    uint32_t start = has_head_block(conf) ? 1 : 0;
-
-    return has_full_blocks(conf) && conf->cursor >= start &&
-           conf->cursor < start + conf->nr_full_blocks;
-}
-
-#if DEBUG_CRYPT
-static inline void
-crypt_check_input_len(size_t len, struct object_cipher_info *object)
-{
-    if (object_alg_should_pad(object) &&
-        (len & (object_alg_blksize(object) - 1)))
-        gf_log("crypt", GF_LOG_DEBUG, "bad input len: %d", (int)len);
-}
-
-static inline void
-check_head_block(struct avec_config *conf)
-{
-    if (!has_head_block(conf))
-        gf_log("crypt", GF_LOG_DEBUG, "not a head atom");
-}
-
-static inline void
-check_tail_block(struct avec_config *conf)
-{
-    if (!has_tail_block(conf))
-        gf_log("crypt", GF_LOG_DEBUG, "not a tail atom");
-}
-
-static inline void
-check_full_block(struct avec_config *conf)
-{
-    if (!has_full_blocks(conf))
-        gf_log("crypt", GF_LOG_DEBUG, "not a full atom");
-}
-
-static inline void
-check_cursor_head(struct avec_config *conf)
-{
-    if (!has_head_block(conf))
-        gf_log("crypt", GF_LOG_DEBUG, "Illegal call of head atom method");
-    else if (conf->cursor != 0)
-        gf_log("crypt", GF_LOG_DEBUG, "Cursor (%d) is not at head atom",
-               conf->cursor);
-}
-
-static inline void
-check_cursor_full(struct avec_config *conf)
-{
-    if (!has_full_blocks(conf))
-        gf_log("crypt", GF_LOG_DEBUG, "Illegal call of full atom method");
-    if (has_head_block(conf) && (conf->cursor == 0))
-        gf_log("crypt", GF_LOG_DEBUG, "Cursor is not at full atom");
-}
-
-/*
- * FIXME: use avec->iov_len to check setup
- */
-static inline int
-data_local_invariant(crypt_local_t *local)
-{
-    return 0;
-}
-
-#else
-#define crypt_check_input_len(len, object) noop
-#define check_head_block(conf) noop
-#define check_tail_block(conf) noop
-#define check_full_block(conf) noop
-#define check_cursor_head(conf) noop
-#define check_cursor_full(conf) noop
-
-#endif /* DEBUG_CRYPT */
-
-static inline struct avec_config *
-conf_by_type(call_frame_t *frame, atom_data_type dtype)
-{
-    struct avec_config *conf = NULL;
-
-    switch (dtype) {
-        case HOLE_ATOM:
-            conf = get_hole_conf(frame);
-            break;
-        case DATA_ATOM:
-            conf = get_data_conf(frame);
-            break;
-        default:
-            gf_log("crypt", GF_LOG_DEBUG, "bad atom type");
-    }
-    return conf;
-}
-
-static inline uint32_t
-nr_calls_head(struct avec_config *conf)
-{
-    return has_head_block(conf) ? 1 : 0;
-}
-
-static inline uint32_t
-nr_calls_tail(struct avec_config *conf)
-{
-    return has_tail_block(conf) ? 1 : 0;
-}
-
-static inline uint32_t
-nr_calls_full(struct avec_config *conf)
-{
-    switch (conf->type) {
-        case HOLE_ATOM:
-            return has_full_blocks(conf);
-        case DATA_ATOM:
-            return has_full_blocks(conf)
-                       ? logical_blocks_occupied(0, conf->nr_full_blocks,
-                                                 MAX_IOVEC_BITS)
-                       : 0;
-        default:
-            gf_log("crypt", GF_LOG_DEBUG, "bad atom data type");
-            return 0;
-    }
-}
-
-static inline uint32_t
-nr_calls(struct avec_config *conf)
-{
-    return nr_calls_head(conf) + nr_calls_tail(conf) + nr_calls_full(conf);
-}
-
-static inline uint32_t
-nr_calls_data(call_frame_t *frame)
-{
-    return nr_calls(get_data_conf(frame));
-}
-
-static inline uint32_t
-nr_calls_hole(call_frame_t *frame)
-{
-    return nr_calls(get_hole_conf(frame));
-}
-
-static inline void
-get_one_call_nolock(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-
-    ++local->nr_calls;
-
-    // gf_log("crypt", GF_LOG_DEBUG, "get %d calls", 1);
-}
-
-static inline void
-get_one_call(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-
-    LOCK(&local->call_lock);
-    get_one_call_nolock(frame);
-    UNLOCK(&local->call_lock);
-}
-
-static inline void
-get_nr_calls_nolock(call_frame_t *frame, int32_t nr)
-{
-    crypt_local_t *local = frame->local;
-
-    local->nr_calls += nr;
-
-    // gf_log("crypt", GF_LOG_DEBUG, "get %d calls", nr);
-}
-
-static inline void
-get_nr_calls(call_frame_t *frame, int32_t nr)
-{
-    crypt_local_t *local = frame->local;
-
-    LOCK(&local->call_lock);
-    get_nr_calls_nolock(frame, nr);
-    UNLOCK(&local->call_lock);
-}
-
-static inline int
-put_one_call(crypt_local_t *local)
-{
-    uint32_t last = 0;
-
-    LOCK(&local->call_lock);
-    if (--local->nr_calls == 0)
-        last = 1;
-
-    // gf_log("crypt", GF_LOG_DEBUG, "put %d calls", 1);
-
-    UNLOCK(&local->call_lock);
-    return last;
-}
-
-static inline int
-is_appended_write(call_frame_t *frame)
-{
-    crypt_local_t *local = frame->local;
-    struct avec_config *conf = get_data_conf(frame);
-
-    return conf->orig_offset + conf->orig_size > local->old_file_size;
-}
-
-static inline int
-is_ordered_mode(call_frame_t *frame)
-{
-#if 0
-	crypt_local_t *local = frame->local;
-	return local->fop == GF_FOP_FTRUNCATE ||
-		(local->fop == GF_FOP_WRITE && is_appended_write(frame));
-#endif
-    return 1;
-}
-
-static inline int32_t
-hole_conv_completed(crypt_local_t *local)
-{
-    struct avec_config *conf = &local->hole_conf;
-    return conf->cursor == conf->acount;
-}
-
-static inline int32_t
-data_write_in_progress(crypt_local_t *local)
-{
-    return local->active_setup == DATA_ATOM;
-}
-
-static inline int32_t
-parent_is_crypt_xlator(call_frame_t *frame, xlator_t *this)
-{
-    return frame->parent->this == this;
-}
-
-static inline linkop_wind_handler_t
-linkop_wind_dispatch(glusterfs_fop_t fop)
-{
-    switch (fop) {
-        case GF_FOP_LINK:
-            return link_wind;
-        case GF_FOP_UNLINK:
-            return unlink_wind;
-        case GF_FOP_RENAME:
-            return rename_wind;
-        default:
-            gf_log("crypt", GF_LOG_ERROR, "Bad link operation %d", fop);
-            return NULL;
-    }
-}
-
-static inline linkop_unwind_handler_t
-linkop_unwind_dispatch(glusterfs_fop_t fop)
-{
-    switch (fop) {
-        case GF_FOP_LINK:
-            return link_unwind;
-        case GF_FOP_UNLINK:
-            return unlink_unwind;
-        case GF_FOP_RENAME:
-            return rename_unwind;
-        default:
-            gf_log("crypt", GF_LOG_ERROR, "Bad link operation %d", fop);
-            return NULL;
-    }
-}
-
-static inline mtd_op_t
-linkop_mtdop_dispatch(glusterfs_fop_t fop)
-{
-    switch (fop) {
-        case GF_FOP_LINK:
-            return MTD_APPEND;
-        case GF_FOP_UNLINK:
-            return MTD_CUT;
-        case GF_FOP_RENAME:
-            return MTD_OVERWRITE;
-        default:
-            gf_log("crypt", GF_LOG_WARNING, "Bad link operation %d", fop);
-            return MTD_LAST_OP;
-    }
-}
-
-#define CRYPT_STACK_UNWIND(fop, frame, params...)                              \
-    do {                                                                       \
-        crypt_local_t *__local = NULL;                                         \
-        if (frame) {                                                           \
-            __local = frame->local;                                            \
-            frame->local = NULL;                                               \
-        }                                                                      \
-        STACK_UNWIND_STRICT(fop, frame, params);                               \
-        if (__local) {                                                         \
-            GF_FREE(__local);                                                  \
-        }                                                                      \
-    } while (0)
-
-#endif /* __CRYPT_H__ */
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/data.c b/xlators/encryption/crypt/src/data.c
deleted file mode 100644
index 93288b1a414..00000000000
--- a/xlators/encryption/crypt/src/data.c
+++ /dev/null
@@ -1,715 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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.
-*/
-
-#include <glusterfs/defaults.h>
-#include "crypt-common.h"
-#include "crypt.h"
-
-static void
-set_iv_aes_xts(off_t offset, struct object_cipher_info *object)
-{
-    unsigned char *ivec;
-
-    ivec = object->u.aes_xts.ivec;
-
-    /* convert the tweak into a little-endian byte
-     * array (IEEE P1619/D16, May 2007, section 5.1)
-     */
-
-    *((uint64_t *)ivec) = htole64(offset);
-
-    /* ivec is padded with zeroes */
-}
-
-static int32_t
-aes_set_keys_common(unsigned char *raw_key, uint32_t key_size, AES_KEY *keys)
-{
-    int32_t ret;
-
-    ret = AES_set_encrypt_key(raw_key, key_size, &keys[AES_ENCRYPT]);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Set encrypt key failed");
-        return ret;
-    }
-    ret = AES_set_decrypt_key(raw_key, key_size, &keys[AES_DECRYPT]);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Set decrypt key failed");
-        return ret;
-    }
-    return 0;
-}
-
-/*
- * set private cipher info for xts mode
- */
-static int32_t
-set_private_aes_xts(struct crypt_inode_info *info,
-                    struct master_cipher_info *master)
-{
-    int ret;
-    struct object_cipher_info *object = get_object_cinfo(info);
-    unsigned char *data_key;
-    uint32_t subkey_size;
-
-    /* init tweak value */
-    memset(object->u.aes_xts.ivec, 0, 16);
-
-    data_key = GF_CALLOC(1, object->o_dkey_size, gf_crypt_mt_key);
-    if (!data_key)
-        return ENOMEM;
-
-    /*
-     * retrieve data keying material
-     */
-    ret = get_data_file_key(info, master, object->o_dkey_size, data_key);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Failed to retrieve data key");
-        GF_FREE(data_key);
-        return ret;
-    }
-    /*
-     * parse compound xts key
-     */
-    subkey_size = object->o_dkey_size >> 4; /* (xts-key-size-in-bytes / 2) */
-    /*
-     * install key for data encryption
-     */
-    ret = aes_set_keys_common(data_key, subkey_size << 3,
-                              object->u.aes_xts.dkey);
-    if (ret) {
-        GF_FREE(data_key);
-        return ret;
-    }
-    /*
-     * set up key used to encrypt tweaks
-     */
-    ret = AES_set_encrypt_key(data_key + subkey_size, object->o_dkey_size / 2,
-                              &object->u.aes_xts.tkey);
-    if (ret < 0)
-        gf_log("crypt", GF_LOG_ERROR, "Set tweak key failed");
-
-    GF_FREE(data_key);
-    return ret;
-}
-
-static int32_t
-aes_xts_init(void)
-{
-    cassert(AES_BLOCK_SIZE == (1 << AES_BLOCK_BITS));
-    return 0;
-}
-
-static int32_t
-check_key_aes_xts(uint32_t keysize)
-{
-    switch (keysize) {
-        case 256:
-        case 512:
-            return 0;
-        default:
-            break;
-    }
-    return -1;
-}
-
-static int32_t
-encrypt_aes_xts(const unsigned char *from, unsigned char *to, size_t length,
-                off_t offset, const int enc, struct object_cipher_info *object)
-{
-    XTS128_CONTEXT ctx;
-    if (enc) {
-        ctx.key1 = &object->u.aes_xts.dkey[AES_ENCRYPT];
-        ctx.block1 = (block128_f)AES_encrypt;
-    } else {
-        ctx.key1 = &object->u.aes_xts.dkey[AES_DECRYPT];
-        ctx.block1 = (block128_f)AES_decrypt;
-    }
-    ctx.key2 = &object->u.aes_xts.tkey;
-    ctx.block2 = (block128_f)AES_encrypt;
-
-    return CRYPTO_xts128_encrypt(&ctx, object->u.aes_xts.ivec, from, to, length,
-                                 enc);
-}
-
-/*
- * Cipher input chunk @from of length @len;
- * @to: result of cipher transform;
- * @off: offset in a file (must be cblock-aligned);
- */
-static void
-cipher_data(struct object_cipher_info *object, char *from, char *to, off_t off,
-            size_t len, const int enc)
-{
-    crypt_check_input_len(len, object);
-
-#if TRIVIAL_TFM && DEBUG_CRYPT
-    return;
-#endif
-    data_cipher_algs[object->o_alg][object->o_mode].set_iv(off, object);
-    data_cipher_algs[object->o_alg][object->o_mode].encrypt(
-        (const unsigned char *)from, (unsigned char *)to, len, off, enc,
-        object);
-}
-
-#define MAX_CIPHER_CHUNK (1 << 30)
-
-/*
- * Do cipher (encryption/decryption) transform of a
- * continuous region of memory.
- *
- * @len: a number of bytes to transform;
- * @buf: data to transform;
- * @off: offset in a file, should be block-aligned
- *       for atomic cipher modes and ksize-aligned
- *       for other modes).
- * @dir: direction of transform (encrypt/decrypt).
- */
-static void
-cipher_region(struct object_cipher_info *object, char *from, char *to,
-              off_t off, size_t len, int dir)
-{
-    while (len > 0) {
-        size_t to_cipher;
-
-        to_cipher = len;
-        if (to_cipher > MAX_CIPHER_CHUNK)
-            to_cipher = MAX_CIPHER_CHUNK;
-
-        /* this will reset IV */
-        cipher_data(object, from, to, off, to_cipher, dir);
-        from += to_cipher;
-        to += to_cipher;
-        off += to_cipher;
-        len -= to_cipher;
-    }
-}
-
-/*
- * Do cipher transform (encryption/decryption) of
- * plaintext/ciphertext represented by @vec.
- *
- * Pre-conditions: @vec represents a continuous piece
- * of data in a file at offset @off to be ciphered
- * (encrypted/decrypted).
- * @count is the number of vec's components. All the
- * components must be block-aligned, the caller is
- * responsible for this. @dir is "direction" of
- * transform (encrypt/decrypt).
- */
-static void
-cipher_aligned_iov(struct object_cipher_info *object, struct iovec *vec,
-                   int count, off_t off, int32_t dir)
-{
-    int i;
-    int len = 0;
-
-    for (i = 0; i < count; i++) {
-        cipher_region(object, vec[i].iov_base, vec[i].iov_base, off + len,
-                      vec[i].iov_len, dir);
-        len += vec[i].iov_len;
-    }
-}
-
-void
-encrypt_aligned_iov(struct object_cipher_info *object, struct iovec *vec,
-                    int count, off_t off)
-{
-    cipher_aligned_iov(object, vec, count, off, 1);
-}
-
-void
-decrypt_aligned_iov(struct object_cipher_info *object, struct iovec *vec,
-                    int count, off_t off)
-{
-    cipher_aligned_iov(object, vec, count, off, 0);
-}
-
-#if DEBUG_CRYPT
-static void
-compound_stream(struct iovec *vec, int count, char *buf, off_t skip)
-{
-    int i;
-    int off = 0;
-    for (i = 0; i < count; i++) {
-        memcpy(buf + off, vec[i].iov_base + skip, vec[i].iov_len - skip);
-
-        off += (vec[i].iov_len - skip);
-        skip = 0;
-    }
-}
-
-static void
-check_iovecs(struct iovec *vec, int cnt, struct iovec *avec, int acnt,
-             uint32_t off_in_head)
-{
-    char *s1, *s2;
-    uint32_t size, asize;
-
-    size = iov_length(vec, cnt);
-    asize = iov_length(avec, acnt) - off_in_head;
-    if (size != asize) {
-        gf_log("crypt", GF_LOG_DEBUG, "size %d is not eq asize %d", size,
-               asize);
-        return;
-    }
-    s1 = GF_CALLOC(1, size, gf_crypt_mt_data);
-    if (!s1) {
-        gf_log("crypt", GF_LOG_DEBUG, "Can not allocate stream ");
-        return;
-    }
-    s2 = GF_CALLOC(1, asize, gf_crypt_mt_data);
-    if (!s2) {
-        GF_FREE(s1);
-        gf_log("crypt", GF_LOG_DEBUG, "Can not allocate stream ");
-        return;
-    }
-    compound_stream(vec, cnt, s1, 0);
-    compound_stream(avec, acnt, s2, off_in_head);
-    if (memcmp(s1, s2, size))
-        gf_log("crypt", GF_LOG_DEBUG, "chunks of different data");
-    GF_FREE(s1);
-    GF_FREE(s2);
-}
-
-#else
-#define check_iovecs(vec, count, avec, avecn, off) noop
-#endif /* DEBUG_CRYPT */
-
-static char *
-data_alloc_block(xlator_t *this, crypt_local_t *local, int32_t block_size)
-{
-    struct iobuf *iobuf = NULL;
-
-    iobuf = iobuf_get2(this->ctx->iobuf_pool, block_size);
-    if (!iobuf) {
-        gf_log("crypt", GF_LOG_ERROR, "Failed to get iobuf");
-        return NULL;
-    }
-    if (!local->iobref_data) {
-        local->iobref_data = iobref_new();
-        if (!local->iobref_data) {
-            gf_log("crypt", GF_LOG_ERROR, "Failed to get iobref");
-            iobuf_unref(iobuf);
-            return NULL;
-        }
-    }
-    iobref_add(local->iobref_data, iobuf);
-    return iobuf->ptr;
-}
-
-/*
- * Compound @avec, which represent the same data
- * chunk as @vec, but has aligned components of
- * specified block size. Alloc blocks, if needed.
- * In particular, incomplete head and tail blocks
- * must be allocated.
- * Put number of allocated blocks to @num_blocks.
- *
- * Example:
- *
- * input: data chunk represented by 4 components
- * [AB],[BC],[CD],[DE];
- * output: 5 logical blocks (0, 1, 2, 3, 4).
- *
- *   A     B       C     D               E
- *   *-----*+------*-+---*----+--------+-*
- *   |     ||      | |   |    |        | |
- * *-+-----+*------+-*---+----*--------*-+------*
- * 0        1        2        3        4
- *
- * 0 - incomplete compound (head);
- * 1, 2 - full compound;
- * 3 - full non-compound (the case of reuse);
- * 4 - incomplete non-compound (tail).
- */
-int32_t
-align_iov_by_atoms(xlator_t *this, crypt_local_t *local,
-                   struct object_cipher_info *object,
-                   struct iovec *vec /* input vector */,
-                   int32_t count /* number of vec components */,
-                   struct iovec *avec /* aligned vector */,
-                   char **blocks /* pool of blocks */,
-                   uint32_t *blocks_allocated, struct avec_config *conf)
-{
-    int vecn = 0;      /* number of the current component in vec */
-    int avecn = 0;     /* number of the current component in avec */
-    off_t vec_off = 0; /* offset in the current vec component,
-                        * i.e. the number of bytes have already
-                        * been copied */
-    int32_t block_size = get_atom_size(object);
-    size_t to_process; /* number of vec's bytes to copy and(or) re-use */
-    int32_t off_in_head = conf->off_in_head;
-
-    to_process = iov_length(vec, count);
-
-    while (to_process > 0) {
-        if (off_in_head || vec[vecn].iov_len - vec_off < block_size) {
-            /*
-             * less than block_size:
-             * the case of incomplete (head or tail),
-             * or compound block
-             */
-            size_t copied = 0;
-            /*
-             * populate the pool with a new block
-             */
-            blocks[*blocks_allocated] = data_alloc_block(this, local,
-                                                         block_size);
-            if (!blocks[*blocks_allocated])
-                return -ENOMEM;
-            memset(blocks[*blocks_allocated], 0, off_in_head);
-            /*
-             * fill the block with vec components
-             */
-            do {
-                size_t to_copy;
-
-                to_copy = vec[vecn].iov_len - vec_off;
-                if (to_copy > block_size - off_in_head)
-                    to_copy = block_size - off_in_head;
-
-                memcpy(blocks[*blocks_allocated] + off_in_head + copied,
-                       vec[vecn].iov_base + vec_off, to_copy);
-
-                copied += to_copy;
-                to_process -= to_copy;
-
-                vec_off += to_copy;
-                if (vec_off == vec[vecn].iov_len) {
-                    /* finished with this vecn */
-                    vec_off = 0;
-                    vecn++;
-                }
-            } while (copied < (block_size - off_in_head) && to_process > 0);
-            /*
-             * update avec
-             */
-            avec[avecn].iov_len = off_in_head + copied;
-            avec[avecn].iov_base = blocks[*blocks_allocated];
-
-            (*blocks_allocated)++;
-            off_in_head = 0;
-        } else {
-            /*
-             * the rest of the current vec component
-             * is not less than block_size, so reuse
-             * the memory buffer of the component.
-             */
-            size_t to_reuse;
-            to_reuse = (to_process > block_size ? block_size : to_process);
-            avec[avecn].iov_len = to_reuse;
-            avec[avecn].iov_base = vec[vecn].iov_base + vec_off;
-
-            vec_off += to_reuse;
-            if (vec_off == vec[vecn].iov_len) {
-                /* finished with this vecn */
-                vec_off = 0;
-                vecn++;
-            }
-            to_process -= to_reuse;
-        }
-        avecn++;
-    }
-    check_iovecs(vec, count, avec, avecn, conf->off_in_head);
-    return 0;
-}
-
-/*
- * allocate and setup aligned vector for data submission
- * Pre-condition: @conf is set.
- */
-int32_t
-set_config_avec_data(xlator_t *this, crypt_local_t *local,
-                     struct avec_config *conf,
-                     struct object_cipher_info *object, struct iovec *vec,
-                     int32_t vec_count)
-{
-    int32_t ret = ENOMEM;
-    struct iovec *avec;
-    char **pool;
-    uint32_t blocks_in_pool = 0;
-
-    conf->type = DATA_ATOM;
-
-    avec = GF_CALLOC(conf->acount, sizeof(*avec), gf_crypt_mt_iovec);
-    if (!avec)
-        return ret;
-    pool = GF_CALLOC(conf->acount, sizeof(*pool), gf_crypt_mt_char);
-    if (!pool) {
-        GF_FREE(avec);
-        return ret;
-    }
-    if (!vec) {
-        /*
-         * degenerated case: no data
-         */
-        pool[0] = data_alloc_block(this, local, get_atom_size(object));
-        if (!pool[0])
-            goto free;
-        blocks_in_pool = 1;
-        avec->iov_base = pool[0];
-        avec->iov_len = conf->off_in_tail;
-    } else {
-        ret = align_iov_by_atoms(this, local, object, vec, vec_count, avec,
-                                 pool, &blocks_in_pool, conf);
-        if (ret)
-            goto free;
-    }
-    conf->avec = avec;
-    conf->pool = pool;
-    conf->blocks_in_pool = blocks_in_pool;
-    return 0;
-free:
-    GF_FREE(avec);
-    GF_FREE(pool);
-    return ret;
-}
-
-/*
- * allocate and setup aligned vector for hole submission
- */
-int32_t
-set_config_avec_hole(xlator_t *this, crypt_local_t *local,
-                     struct avec_config *conf,
-                     struct object_cipher_info *object, glusterfs_fop_t fop)
-{
-    uint32_t i, idx;
-    struct iovec *avec;
-    char **pool;
-    uint32_t num_blocks;
-    uint32_t blocks_in_pool = 0;
-
-    conf->type = HOLE_ATOM;
-
-    num_blocks = conf->acount -
-                 (conf->nr_full_blocks ? conf->nr_full_blocks - 1 : 0);
-
-    switch (fop) {
-        case GF_FOP_WRITE:
-            /*
-             * hole goes before data
-             */
-            if (num_blocks == 1 && conf->off_in_tail != 0)
-                /*
-                 * we won't submit a hole which fits into
-                 * a data atom: this part of hole will be
-                 * submitted with data write
-                 */
-                return 0;
-            break;
-        case GF_FOP_FTRUNCATE:
-            /*
-             * expanding truncate, hole goes after data,
-             * and will be submitted in any case.
-             */
-            break;
-        default:
-            gf_log("crypt", GF_LOG_WARNING, "bad file operation %d", fop);
-            return 0;
-    }
-    avec = GF_CALLOC(num_blocks, sizeof(*avec), gf_crypt_mt_iovec);
-    if (!avec)
-        return ENOMEM;
-    pool = GF_CALLOC(num_blocks, sizeof(*pool), gf_crypt_mt_char);
-    if (!pool) {
-        GF_FREE(avec);
-        return ENOMEM;
-    }
-    for (i = 0; i < num_blocks; i++) {
-        pool[i] = data_alloc_block(this, local, get_atom_size(object));
-        if (pool[i] == NULL)
-            goto free;
-        blocks_in_pool++;
-    }
-    if (has_head_block(conf)) {
-        /* set head block */
-        idx = 0;
-        avec[idx].iov_base = pool[idx];
-        avec[idx].iov_len = get_atom_size(object);
-        memset(avec[idx].iov_base + conf->off_in_head, 0,
-               get_atom_size(object) - conf->off_in_head);
-    }
-    if (has_tail_block(conf)) {
-        /* set tail block */
-        idx = num_blocks - 1;
-        avec[idx].iov_base = pool[idx];
-        avec[idx].iov_len = get_atom_size(object);
-        memset(avec[idx].iov_base, 0, conf->off_in_tail);
-    }
-    if (has_full_blocks(conf)) {
-        /* set full block */
-        idx = conf->off_in_head ? 1 : 0;
-        avec[idx].iov_base = pool[idx];
-        avec[idx].iov_len = get_atom_size(object);
-        /*
-         * since we re-use the buffer,
-         * zeroes will be set every time
-         * before encryption, see submit_full()
-         */
-    }
-    conf->avec = avec;
-    conf->pool = pool;
-    conf->blocks_in_pool = blocks_in_pool;
-    return 0;
-free:
-    GF_FREE(avec);
-    GF_FREE(pool);
-    return ENOMEM;
-}
-
-/* A helper for setting up config of partial atoms (which
- * participate in read-modify-write sequence).
- *
- * Calculate and setup precise amount of "extra-bytes"
- * that should be uptodated at the end of partial (not
- * necessarily tail!) block.
- *
- * Pre-condition: local->old_file_size is valid!
- * @conf contains setup, which is enough for correct calculation
- * of has_tail_block(), ->get_offset().
- */
-void
-set_gap_at_end(call_frame_t *frame, struct object_cipher_info *object,
-               struct avec_config *conf, atom_data_type dtype)
-{
-    uint32_t to_block;
-    crypt_local_t *local = frame->local;
-    uint64_t old_file_size = local->old_file_size;
-    struct rmw_atom *partial = atom_by_types(
-        dtype, has_tail_block(conf) ? TAIL_ATOM : HEAD_ATOM);
-
-    if (old_file_size <= partial->offset_at(frame, object))
-        to_block = 0;
-    else {
-        to_block = old_file_size - partial->offset_at(frame, object);
-        if (to_block > get_atom_size(object))
-            to_block = get_atom_size(object);
-    }
-    if (to_block > conf->off_in_tail)
-        conf->gap_in_tail = to_block - conf->off_in_tail;
-    else
-        /*
-         * nothing to uptodate
-         */
-        conf->gap_in_tail = 0;
-}
-
-/*
- * fill struct avec_config with offsets layouts
- */
-void
-set_config_offsets(call_frame_t *frame, xlator_t *this, uint64_t offset,
-                   uint64_t count, atom_data_type dtype, int32_t set_gap)
-{
-    crypt_local_t *local;
-    struct object_cipher_info *object;
-    struct avec_config *conf;
-    uint32_t resid;
-
-    uint32_t atom_size;
-    uint32_t atom_bits;
-
-    size_t orig_size;
-    off_t orig_offset;
-    size_t expanded_size;
-    off_t aligned_offset;
-
-    uint32_t off_in_head = 0;
-    uint32_t off_in_tail = 0;
-    uint32_t nr_full_blocks;
-    int32_t size_full_blocks;
-
-    uint32_t acount; /* number of aligned components to write.
-                      * The same as number of occupied logical
-                      * blocks (atoms)
-                      */
-    local = frame->local;
-    object = &local->info->cinfo;
-    conf = (dtype == DATA_ATOM ? get_data_conf(frame) : get_hole_conf(frame));
-
-    orig_offset = offset;
-    orig_size = count;
-
-    atom_size = get_atom_size(object);
-    atom_bits = get_atom_bits(object);
-
-    /*
-     * Round-down the start,
-     * round-up the end.
-     */
-    resid = offset & (uint64_t)(atom_size - 1);
-
-    if (resid)
-        off_in_head = resid;
-    aligned_offset = offset - off_in_head;
-    expanded_size = orig_size + off_in_head;
-
-    /* calculate tail,
-       expand size forward  */
-    resid = (offset + orig_size) & (uint64_t)(atom_size - 1);
-
-    if (resid) {
-        off_in_tail = resid;
-        expanded_size += (atom_size - off_in_tail);
-    }
-    /*
-     * calculate number of occupied blocks
-     */
-    acount = expanded_size >> atom_bits;
-    /*
-     * calculate number of full blocks
-     */
-    size_full_blocks = expanded_size;
-    if (off_in_head)
-        size_full_blocks -= atom_size;
-    if (off_in_tail && size_full_blocks > 0)
-        size_full_blocks -= atom_size;
-    nr_full_blocks = size_full_blocks >> atom_bits;
-
-    conf->atom_size = atom_size;
-    conf->orig_size = orig_size;
-    conf->orig_offset = orig_offset;
-    conf->expanded_size = expanded_size;
-    conf->aligned_offset = aligned_offset;
-
-    conf->off_in_head = off_in_head;
-    conf->off_in_tail = off_in_tail;
-    conf->nr_full_blocks = nr_full_blocks;
-    conf->acount = acount;
-    /*
-     * Finally, calculate precise amount of
-     * "extra-bytes" that should be uptodated
-     * at the end.
-     * Only if RMW is expected.
-     */
-    if (off_in_tail && set_gap)
-        set_gap_at_end(frame, object, conf, dtype);
-}
-
-struct data_cipher_alg data_cipher_algs[LAST_CIPHER_ALG][LAST_CIPHER_MODE] = {
-    [AES_CIPHER_ALG][XTS_CIPHER_MODE] = {.atomic = _gf_true,
-                                         .should_pad = _gf_true,
-                                         .blkbits = AES_BLOCK_BITS,
-                                         .init = aes_xts_init,
-                                         .set_private = set_private_aes_xts,
-                                         .check_key = check_key_aes_xts,
-                                         .set_iv = set_iv_aes_xts,
-                                         .encrypt = encrypt_aes_xts}};
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/keys.c b/xlators/encryption/crypt/src/keys.c
deleted file mode 100644
index 92a4d471f58..00000000000
--- a/xlators/encryption/crypt/src/keys.c
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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.
-*/
-
-#include <glusterfs/defaults.h>
-#include "crypt-common.h"
-#include "crypt.h"
-
-/* Key hierarchy
-
-                   +----------------+
-                   | MASTER_VOL_KEY |
-                   +-------+--------+
-                           |
-                           |
-          +----------------+----------------+
-          |                |                |
-          |                |                |
-  +-------+------+ +-------+-------+ +------+--------+
-  | NMTD_VOL_KEY | | EMTD_FILE_KEY | | DATA_FILE_KEY |
-  +-------+------+ +---------------+ +---------------+
-          |
-          |
-  +-------+-------+
-  | NMTD_LINK_KEY |
-  +---------------+
-
- */
-
-#if DEBUG_CRYPT
-static void
-check_prf_iters(uint32_t num_iters)
-{
-    if (num_iters == 0)
-        gf_log("crypt", GF_LOG_DEBUG, "bad number of prf iterations : %d",
-               num_iters);
-}
-#else
-#define check_prf_iters(num_iters) noop
-#endif /* DEBUG_CRYPT */
-
-unsigned char crypt_fake_oid[16] = {0, 0, 0, 0, 0, 0, 0, 0,
-                                    0, 0, 0, 0, 0, 0, 0, 0};
-
-/*
- * derive key in the counter mode using
- * sha256-based HMAC as PRF, see
- * NIST Special Publication 800-108, 5.1)
- */
-
-#define PRF_OUTPUT_SIZE SHA256_DIGEST_LENGTH
-
-static int32_t
-kderive_init(struct kderive_context *ctx,
-             const unsigned char *pkey,  /* parent key */
-             uint32_t pkey_size,         /* parent key size */
-             const unsigned char *idctx, /* id-context */
-             uint32_t idctx_size, crypt_key_type type /* type of child key */)
-{
-    unsigned char *pos;
-    uint32_t llen = strlen(crypt_keys[type].label);
-    /*
-     * Compoud the fixed input data for KDF:
-     * [i]_2 || Label || 0x00 || Id-Context || [L]_2),
-     * NIST SP 800-108, 5.1
-     */
-    ctx->fid_len = sizeof(uint32_t) + llen + 1 + idctx_size + sizeof(uint32_t);
-
-    ctx->fid = GF_CALLOC(ctx->fid_len, 1, gf_crypt_mt_key);
-    if (!ctx->fid)
-        return ENOMEM;
-    ctx->out_len = round_up(crypt_keys[type].len >> 3, PRF_OUTPUT_SIZE);
-    ctx->out = GF_CALLOC(ctx->out_len, 1, gf_crypt_mt_key);
-    if (!ctx->out) {
-        GF_FREE(ctx->fid);
-        return ENOMEM;
-    }
-    ctx->pkey = pkey;
-    ctx->pkey_len = pkey_size;
-    ctx->ckey_len = crypt_keys[type].len;
-
-    pos = ctx->fid;
-
-    /* counter will be set up in kderive_rfn() */
-    pos += sizeof(uint32_t);
-
-    memcpy(pos, crypt_keys[type].label, llen);
-    pos += llen;
-
-    /* set up zero octet */
-    *pos = 0;
-    pos += 1;
-
-    memcpy(pos, idctx, idctx_size);
-    pos += idctx_size;
-
-    *((uint32_t *)pos) = htobe32(ctx->ckey_len);
-
-    return 0;
-}
-
-static void
-kderive_update(struct kderive_context *ctx)
-{
-    uint32_t i;
-#if (OPENSSL_VERSION_NUMBER < 0x1010002f)
-    HMAC_CTX hctx;
-#endif
-    HMAC_CTX *phctx = NULL;
-    unsigned char *pos = ctx->out;
-    uint32_t *p_iter = (uint32_t *)ctx->fid;
-    uint32_t num_iters = ctx->out_len / PRF_OUTPUT_SIZE;
-
-    check_prf_iters(num_iters);
-
-#if (OPENSSL_VERSION_NUMBER < 0x1010002f)
-    HMAC_CTX_init(&hctx);
-    phctx = &hctx;
-#else
-    phctx = HMAC_CTX_new();
-    /* I guess we presume it was successful? */
-#endif
-    for (i = 0; i < num_iters; i++) {
-        /*
-         * update the iteration number in the fid
-         */
-        *p_iter = htobe32(i);
-        HMAC_Init_ex(phctx, ctx->pkey, ctx->pkey_len >> 3, EVP_sha256(), NULL);
-        HMAC_Update(phctx, ctx->fid, ctx->fid_len);
-        HMAC_Final(phctx, pos, NULL);
-
-        pos += PRF_OUTPUT_SIZE;
-    }
-#if (OPENSSL_VERSION_NUMBER < 0x1010002f)
-    HMAC_CTX_cleanup(phctx);
-#else
-    HMAC_CTX_free(phctx);
-#endif
-}
-
-static void
-kderive_final(struct kderive_context *ctx, unsigned char *child)
-{
-    memcpy(child, ctx->out, ctx->ckey_len >> 3);
-    GF_FREE(ctx->fid);
-    GF_FREE(ctx->out);
-    memset(ctx, 0, sizeof(*ctx));
-}
-
-/*
- * derive per-volume key for object ids aithentication
- */
-int32_t
-get_nmtd_vol_key(struct master_cipher_info *master)
-{
-    int32_t ret;
-    struct kderive_context ctx;
-
-    ret = kderive_init(&ctx, master->m_key, master_key_size(), crypt_fake_oid,
-                       sizeof(uuid_t), NMTD_VOL_KEY);
-    if (ret)
-        return ret;
-    kderive_update(&ctx);
-    kderive_final(&ctx, master->m_nmtd_key);
-    return 0;
-}
-
-/*
- * derive per-link key for aithentication of non-encrypted
- * meta-data (nmtd)
- */
-int32_t
-get_nmtd_link_key(loc_t *loc, struct master_cipher_info *master,
-                  unsigned char *result)
-{
-    int32_t ret;
-    struct kderive_context ctx;
-
-    ret = kderive_init(&ctx, master->m_nmtd_key, nmtd_vol_key_size(),
-                       (const unsigned char *)loc->path, strlen(loc->path),
-                       NMTD_LINK_KEY);
-    if (ret)
-        return ret;
-    kderive_update(&ctx);
-    kderive_final(&ctx, result);
-    return 0;
-}
-
-/*
- * derive per-file key for encryption and authentication
- * of encrypted part of metadata (emtd)
- */
-int32_t
-get_emtd_file_key(struct crypt_inode_info *info,
-                  struct master_cipher_info *master, unsigned char *result)
-{
-    int32_t ret;
-    struct kderive_context ctx;
-
-    ret = kderive_init(&ctx, master->m_key, master_key_size(), info->oid,
-                       sizeof(uuid_t), EMTD_FILE_KEY);
-    if (ret)
-        return ret;
-    kderive_update(&ctx);
-    kderive_final(&ctx, result);
-    return 0;
-}
-
-static int32_t
-data_key_type_by_size(uint32_t keysize, crypt_key_type *type)
-{
-    int32_t ret = 0;
-    switch (keysize) {
-        case 256:
-            *type = DATA_FILE_KEY_256;
-            break;
-        case 512:
-            *type = DATA_FILE_KEY_512;
-            break;
-        default:
-            gf_log("crypt", GF_LOG_ERROR, "Unsupported data key size %d",
-                   keysize);
-            ret = ENOTSUP;
-            break;
-    }
-    return ret;
-}
-
-/*
- * derive per-file key for data encryption
- */
-int32_t
-get_data_file_key(struct crypt_inode_info *info,
-                  struct master_cipher_info *master, uint32_t keysize,
-                  unsigned char *key)
-{
-    int32_t ret;
-    struct kderive_context ctx;
-    crypt_key_type type;
-
-    ret = data_key_type_by_size(keysize, &type);
-    if (ret)
-        return ret;
-    ret = kderive_init(&ctx, master->m_key, master_key_size(), info->oid,
-                       sizeof(uuid_t), type);
-    if (ret)
-        return ret;
-    kderive_update(&ctx);
-    kderive_final(&ctx, key);
-    return 0;
-}
-
-/*
- * NOTE: Don't change existing keys: it will break compatibility;
- */
-struct crypt_key crypt_keys[LAST_KEY_TYPE] = {
-    [MASTER_VOL_KEY] =
-        {
-            .len = MASTER_VOL_KEY_SIZE << 3,
-            .label = "volume-master",
-        },
-    [NMTD_VOL_KEY] = {.len = NMTD_VOL_KEY_SIZE << 3,
-                      .label = "volume-nmtd-key-generation"},
-    [NMTD_LINK_KEY] = {.len = 128, .label = "link-nmtd-authentication"},
-    [EMTD_FILE_KEY] = {.len = 128, .label = "file-emtd-encryption-and-auth"},
-    [DATA_FILE_KEY_256] = {.len = 256, .label = "file-data-encryption-256"},
-    [DATA_FILE_KEY_512] = {.len = 512, .label = "file-data-encryption-512"}};
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/metadata.c b/xlators/encryption/crypt/src/metadata.c
deleted file mode 100644
index 120ae62f777..00000000000
--- a/xlators/encryption/crypt/src/metadata.c
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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.
-*/
-
-#include <glusterfs/defaults.h>
-#include "crypt-common.h"
-#include "crypt.h"
-#include "metadata.h"
-
-int32_t
-alloc_format(crypt_local_t *local, size_t size)
-{
-    if (size > 0) {
-        local->format = GF_CALLOC(1, size, gf_crypt_mt_mtd);
-        if (!local->format)
-            return ENOMEM;
-    }
-    local->format_size = size;
-    return 0;
-}
-
-int32_t
-alloc_format_create(crypt_local_t *local)
-{
-    return alloc_format(local, new_format_size());
-}
-
-void
-free_format(crypt_local_t *local)
-{
-    GF_FREE(local->format);
-}
-
-/*
- * Check compatibility with extracted metadata
- */
-static int32_t
-check_file_metadata(struct crypt_inode_info *info)
-{
-    struct object_cipher_info *object = &info->cinfo;
-
-    if (info->nr_minor != CRYPT_XLATOR_ID) {
-        gf_log("crypt", GF_LOG_WARNING, "unsupported minor subversion %d",
-               info->nr_minor);
-        return EINVAL;
-    }
-    if (object->o_alg > LAST_CIPHER_ALG) {
-        gf_log("crypt", GF_LOG_WARNING, "unsupported cipher algorithm %d",
-               object->o_alg);
-        return EINVAL;
-    }
-    if (object->o_mode > LAST_CIPHER_MODE) {
-        gf_log("crypt", GF_LOG_WARNING, "unsupported cipher mode %d",
-               object->o_mode);
-        return EINVAL;
-    }
-    if (object->o_block_bits < CRYPT_MIN_BLOCK_BITS ||
-        object->o_block_bits > CRYPT_MAX_BLOCK_BITS) {
-        gf_log("crypt", GF_LOG_WARNING, "unsupported block bits %d",
-               object->o_block_bits);
-        return EINVAL;
-    }
-    /* TBD: check data key size */
-    return 0;
-}
-
-static size_t
-format_size_v1(mtd_op_t op, size_t old_size)
-{
-    switch (op) {
-        case MTD_CREATE:
-            return sizeof(struct mtd_format_v1);
-        case MTD_OVERWRITE:
-            return old_size;
-        case MTD_APPEND:
-            return old_size + NMTD_8_MAC_SIZE;
-        case MTD_CUT:
-            if (old_size > sizeof(struct mtd_format_v1))
-                return old_size - NMTD_8_MAC_SIZE;
-            else
-                return 0;
-        default:
-            gf_log("crypt", GF_LOG_WARNING, "Bad mtd operation");
-            return 0;
-    }
-}
-
-/*
- * Calculate size of the updated format string.
- * Returned zero means that we don't need to update the format string.
- */
-size_t
-format_size(mtd_op_t op, size_t old_size)
-{
-    size_t versioned;
-
-    versioned = mtd_loaders[current_mtd_loader()].format_size(
-        op, old_size - sizeof(struct crypt_format));
-    if (versioned != 0)
-        return versioned + sizeof(struct crypt_format);
-    return 0;
-}
-
-/*
- * size of the format string of newly created file (nr_links = 1)
- */
-size_t
-new_format_size(void)
-{
-    return format_size(MTD_CREATE, 0);
-}
-
-/*
- * Calculate per-link MAC by pathname
- */
-static int32_t
-calc_link_mac_v1(struct mtd_format_v1 *fmt, loc_t *loc, unsigned char *result,
-                 struct crypt_inode_info *info,
-                 struct master_cipher_info *master)
-{
-    int32_t ret;
-    unsigned char nmtd_link_key[16];
-    CMAC_CTX *cctx;
-    size_t len;
-
-    ret = get_nmtd_link_key(loc, master, nmtd_link_key);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Can not get nmtd link key");
-        return -1;
-    }
-    cctx = CMAC_CTX_new();
-    if (!cctx) {
-        gf_log("crypt", GF_LOG_ERROR, "CMAC_CTX_new failed");
-        return -1;
-    }
-    ret = CMAC_Init(cctx, nmtd_link_key, sizeof(nmtd_link_key),
-                    EVP_aes_128_cbc(), 0);
-    if (!ret) {
-        gf_log("crypt", GF_LOG_ERROR, "CMAC_Init failed");
-        CMAC_CTX_free(cctx);
-        return -1;
-    }
-    ret = CMAC_Update(cctx, get_NMTD_V1(info), SIZE_OF_NMTD_V1);
-    if (!ret) {
-        gf_log("crypt", GF_LOG_ERROR, "CMAC_Update failed");
-        CMAC_CTX_free(cctx);
-        return -1;
-    }
-    ret = CMAC_Final(cctx, result, &len);
-    CMAC_CTX_free(cctx);
-    if (!ret) {
-        gf_log("crypt", GF_LOG_ERROR, "CMAC_Final failed");
-        return -1;
-    }
-    return 0;
-}
-
-/*
- * Create per-link MAC of index @idx by pathname
- */
-static int32_t
-create_link_mac_v1(struct mtd_format_v1 *fmt, uint32_t idx, loc_t *loc,
-                   struct crypt_inode_info *info,
-                   struct master_cipher_info *master)
-{
-    int32_t ret;
-    unsigned char *mac;
-    unsigned char cmac[16];
-
-    mac = get_NMTD_V1_MAC(fmt) + idx * SIZE_OF_NMTD_V1_MAC;
-
-    ret = calc_link_mac_v1(fmt, loc, cmac, info, master);
-    if (ret)
-        return -1;
-    memcpy(mac, cmac, SIZE_OF_NMTD_V1_MAC);
-    return 0;
-}
-
-static int32_t
-create_format_v1(unsigned char *wire, loc_t *loc, struct crypt_inode_info *info,
-                 struct master_cipher_info *master)
-{
-    int32_t ret;
-    struct mtd_format_v1 *fmt;
-    unsigned char mtd_key[16];
-    AES_KEY EMTD_KEY;
-    unsigned char nmtd_link_key[16];
-    uint32_t ad;
-    GCM128_CONTEXT *gctx;
-
-    fmt = (struct mtd_format_v1 *)wire;
-
-    fmt->minor_id = info->nr_minor;
-    fmt->alg_id = AES_CIPHER_ALG;
-    fmt->dkey_factor = master->m_dkey_size >> KEY_FACTOR_BITS;
-    fmt->block_bits = master->m_block_bits;
-    fmt->mode_id = master->m_mode;
-    /*
-     * retrieve keys for the parts of metadata
-     */
-    ret = get_emtd_file_key(info, master, mtd_key);
-    if (ret)
-        return ret;
-    ret = get_nmtd_link_key(loc, master, nmtd_link_key);
-    if (ret)
-        return ret;
-
-    AES_set_encrypt_key(mtd_key, sizeof(mtd_key) * 8, &EMTD_KEY);
-
-    gctx = CRYPTO_gcm128_new(&EMTD_KEY, (block128_f)AES_encrypt);
-
-    /* TBD: Check return values */
-
-    CRYPTO_gcm128_setiv(gctx, info->oid, sizeof(uuid_t));
-
-    ad = htole32(MTD_LOADER_V1);
-    ret = CRYPTO_gcm128_aad(gctx, (const unsigned char *)&ad, sizeof(ad));
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_aad failed");
-        CRYPTO_gcm128_release(gctx);
-        return ret;
-    }
-    ret = CRYPTO_gcm128_encrypt(gctx, get_EMTD_V1(fmt), get_EMTD_V1(fmt),
-                                SIZE_OF_EMTD_V1);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_encrypt failed");
-        CRYPTO_gcm128_release(gctx);
-        return ret;
-    }
-    /*
-     * set MAC of encrypted part of metadata
-     */
-    CRYPTO_gcm128_tag(gctx, get_EMTD_V1_MAC(fmt), SIZE_OF_EMTD_V1_MAC);
-    CRYPTO_gcm128_release(gctx);
-    /*
-     * set the first MAC of non-encrypted part of metadata
-     */
-    return create_link_mac_v1(fmt, 0, loc, info, master);
-}
-
-/*
- * Called by fops:
- * ->create();
- * ->link();
- *
- * Pack common and version-specific parts of file's metadata
- * Pre-conditions: @info contains valid object-id.
- */
-int32_t
-create_format(unsigned char *wire, loc_t *loc, struct crypt_inode_info *info,
-              struct master_cipher_info *master)
-{
-    struct crypt_format *fmt = (struct crypt_format *)wire;
-
-    fmt->loader_id = current_mtd_loader();
-
-    wire += sizeof(struct crypt_format);
-    return mtd_loaders[current_mtd_loader()].create_format(wire, loc, info,
-                                                           master);
-}
-
-/*
- * Append or overwrite per-link mac of @mac_idx index
- * in accordance with the new pathname
- */
-int32_t
-appov_link_mac_v1(unsigned char *new, unsigned char *old, uint32_t old_size,
-                  int32_t mac_idx, loc_t *loc, struct crypt_inode_info *info,
-                  struct master_cipher_info *master, crypt_local_t *local)
-{
-    memcpy(new, old, old_size);
-    return create_link_mac_v1((struct mtd_format_v1 *)new, mac_idx, loc, info,
-                              master);
-}
-
-/*
- * Cut per-link mac of @mac_idx index
- */
-static int32_t
-cut_link_mac_v1(unsigned char *new, unsigned char *old, uint32_t old_size,
-                int32_t mac_idx, loc_t *loc, struct crypt_inode_info *info,
-                struct master_cipher_info *master, crypt_local_t *local)
-{
-    memcpy(new, old,
-           sizeof(struct mtd_format_v1) + NMTD_8_MAC_SIZE * (mac_idx - 1));
-
-    memcpy(
-        new + sizeof(struct mtd_format_v1) + NMTD_8_MAC_SIZE *(mac_idx - 1),
-        old + sizeof(struct mtd_format_v1) + NMTD_8_MAC_SIZE * mac_idx,
-        old_size - (sizeof(struct mtd_format_v1) + NMTD_8_MAC_SIZE * mac_idx));
-    return 0;
-}
-
-int32_t
-update_format_v1(unsigned char *new, unsigned char *old, size_t old_len,
-                 int32_t mac_idx, /* of old name */
-                 mtd_op_t op, loc_t *loc, struct crypt_inode_info *info,
-                 struct master_cipher_info *master, crypt_local_t *local)
-{
-    switch (op) {
-        case MTD_APPEND:
-            mac_idx = 1 + (old_len - sizeof(struct mtd_format_v1)) / 8;
-        case MTD_OVERWRITE:
-            return appov_link_mac_v1(new, old, old_len, mac_idx, loc, info,
-                                     master, local);
-        case MTD_CUT:
-            return cut_link_mac_v1(new, old, old_len, mac_idx, loc, info,
-                                   master, local);
-        default:
-            gf_log("crypt", GF_LOG_ERROR, "Bad  mtd operation %d", op);
-            return -1;
-    }
-}
-
-/*
- * Called by fops:
- *
- * ->link()
- * ->unlink()
- * ->rename()
- *
- */
-int32_t
-update_format(unsigned char *new, unsigned char *old, size_t old_len,
-              int32_t mac_idx, mtd_op_t op, loc_t *loc,
-              struct crypt_inode_info *info, struct master_cipher_info *master,
-              crypt_local_t *local)
-{
-    if (!new)
-        return 0;
-    memcpy(new, old, sizeof(struct crypt_format));
-
-    old += sizeof(struct crypt_format);
-    new += sizeof(struct crypt_format);
-    old_len -= sizeof(struct crypt_format);
-
-    return mtd_loaders[current_mtd_loader()].update_format(
-        new, old, old_len, mac_idx, op, loc, info, master, local);
-}
-
-/*
- * Perform preliminary checks of found metadata
- * Return < 0 on errors;
- * Return number of object-id MACs (>= 1) on success
- */
-int32_t
-check_format_v1(uint32_t len, unsigned char *wire)
-{
-    uint32_t nr_links;
-
-    if (len < sizeof(struct mtd_format_v1)) {
-        gf_log("crypt", GF_LOG_ERROR, "v1-loader: bad metadata size %d", len);
-        goto error;
-    }
-    len -= sizeof(struct mtd_format_v1);
-    if (len % sizeof(nmtd_8_mac_t)) {
-        gf_log("crypt", GF_LOG_ERROR, "v1-loader: bad metadata format");
-        goto error;
-    }
-    nr_links = 1 + len / sizeof(nmtd_8_mac_t);
-    if (nr_links > _POSIX_LINK_MAX)
-        goto error;
-    return nr_links;
-error:
-    return EIO;
-}
-
-/*
- * Verify per-link MAC specified by index @idx
- *
- * return:
- * -1 on errors;
- *  0 on failed verification;
- *  1 on successful verification
- */
-static int32_t
-verify_link_mac_v1(struct mtd_format_v1 *fmt,
-                   uint32_t idx /* index of the mac to verify */, loc_t *loc,
-                   struct crypt_inode_info *info,
-                   struct master_cipher_info *master)
-{
-    int32_t ret;
-    unsigned char *mac;
-    unsigned char cmac[16];
-
-    mac = get_NMTD_V1_MAC(fmt) + idx * SIZE_OF_NMTD_V1_MAC;
-
-    ret = calc_link_mac_v1(fmt, loc, cmac, info, master);
-    if (ret)
-        return -1;
-    if (memcmp(cmac, mac, SIZE_OF_NMTD_V1_MAC))
-        return 0;
-    return 1;
-}
-
-/*
- * Lookup per-link MAC by pathname.
- *
- * return index of the MAC, if it was found;
- * return < 0 on errors, or if the MAC wasn't found
- */
-static int32_t
-lookup_link_mac_v1(struct mtd_format_v1 *fmt, uint32_t nr_macs, loc_t *loc,
-                   struct crypt_inode_info *info,
-                   struct master_cipher_info *master)
-{
-    int32_t ret;
-    uint32_t idx;
-
-    for (idx = 0; idx < nr_macs; idx++) {
-        ret = verify_link_mac_v1(fmt, idx, loc, info, master);
-        if (ret < 0)
-            return ret;
-        if (ret > 0)
-            return idx;
-    }
-    return -ENOENT;
-}
-
-/*
- * Extract version-specific part of metadata
- */
-static int32_t
-open_format_v1(unsigned char *wire, int32_t len, loc_t *loc,
-               struct crypt_inode_info *info, struct master_cipher_info *master,
-               crypt_local_t *local, gf_boolean_t load_info)
-{
-    int32_t ret;
-    int32_t num_nmtd_macs;
-    struct mtd_format_v1 *fmt;
-    unsigned char mtd_key[16];
-    AES_KEY EMTD_KEY;
-    GCM128_CONTEXT *gctx;
-    uint32_t ad;
-    emtd_8_mac_t gmac;
-    struct object_cipher_info *object;
-
-    num_nmtd_macs = check_format_v1(len, wire);
-    if (num_nmtd_macs <= 0)
-        return EIO;
-
-    ret = lookup_link_mac_v1((struct mtd_format_v1 *)wire, num_nmtd_macs, loc,
-                             info, master);
-    if (ret < 0) {
-        gf_log("crypt", GF_LOG_ERROR, "NMTD verification failed");
-        return EINVAL;
-    }
-
-    local->mac_idx = ret;
-    if (load_info == _gf_false)
-        /* the case of partial open */
-        return 0;
-
-    fmt = GF_MALLOC(len, gf_crypt_mt_mtd);
-    if (!fmt)
-        return ENOMEM;
-    memcpy(fmt, wire, len);
-
-    object = &info->cinfo;
-
-    ret = get_emtd_file_key(info, master, mtd_key);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, "Can not retrieve metadata key");
-        goto out;
-    }
-    /*
-     * decrypt encrypted meta-data
-     */
-    ret = AES_set_encrypt_key(mtd_key, sizeof(mtd_key) * 8, &EMTD_KEY);
-    if (ret < 0) {
-        gf_log("crypt", GF_LOG_ERROR, "Can not set encrypt key");
-        ret = EIO;
-        goto out;
-    }
-    gctx = CRYPTO_gcm128_new(&EMTD_KEY, (block128_f)AES_encrypt);
-    if (!gctx) {
-        gf_log("crypt", GF_LOG_ERROR, "Can not alloc gcm context");
-        ret = ENOMEM;
-        goto out;
-    }
-    CRYPTO_gcm128_setiv(gctx, info->oid, sizeof(uuid_t));
-
-    ad = htole32(MTD_LOADER_V1);
-    ret = CRYPTO_gcm128_aad(gctx, (const unsigned char *)&ad, sizeof(ad));
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_aad failed");
-        CRYPTO_gcm128_release(gctx);
-        ret = EIO;
-        goto out;
-    }
-    ret = CRYPTO_gcm128_decrypt(gctx, get_EMTD_V1(fmt), get_EMTD_V1(fmt),
-                                SIZE_OF_EMTD_V1);
-    if (ret) {
-        gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_decrypt failed");
-        CRYPTO_gcm128_release(gctx);
-        ret = EIO;
-        goto out;
-    }
-    /*
-     * verify metadata
-     */
-    CRYPTO_gcm128_tag(gctx, gmac, sizeof(gmac));
-    CRYPTO_gcm128_release(gctx);
-    if (memcmp(gmac, get_EMTD_V1_MAC(fmt), SIZE_OF_EMTD_V1_MAC)) {
-        gf_log("crypt", GF_LOG_ERROR, "EMTD verification failed");
-        ret = EINVAL;
-        goto out;
-    }
-    /*
-     * load verified metadata to the private part of inode
-     */
-    info->nr_minor = fmt->minor_id;
-
-    object->o_alg = fmt->alg_id;
-    object->o_dkey_size = fmt->dkey_factor << KEY_FACTOR_BITS;
-    object->o_block_bits = fmt->block_bits;
-    object->o_mode = fmt->mode_id;
-
-    ret = check_file_metadata(info);
-out:
-    GF_FREE(fmt);
-    return ret;
-}
-
-/*
- * perform metadata authentication against @loc->path;
- * extract crypt-specific attribute and populate @info
- * with them (optional)
- */
-int32_t
-open_format(unsigned char *str, int32_t len, loc_t *loc,
-            struct crypt_inode_info *info, struct master_cipher_info *master,
-            crypt_local_t *local, gf_boolean_t load_info)
-{
-    struct crypt_format *fmt;
-    if (len < sizeof(*fmt)) {
-        gf_log("crypt", GF_LOG_ERROR, "Bad core format");
-        return EIO;
-    }
-    fmt = (struct crypt_format *)str;
-
-    if (fmt->loader_id >= LAST_MTD_LOADER) {
-        gf_log("crypt", GF_LOG_ERROR, "Unsupported loader id %d",
-               fmt->loader_id);
-        return EINVAL;
-    }
-    str += sizeof(*fmt);
-    len -= sizeof(*fmt);
-
-    return mtd_loaders[fmt->loader_id].open_format(str, len, loc, info, master,
-                                                   local, load_info);
-}
-
-struct crypt_mtd_loader mtd_loaders[LAST_MTD_LOADER] = {
-    [MTD_LOADER_V1] = {.format_size = format_size_v1,
-                       .create_format = create_format_v1,
-                       .open_format = open_format_v1,
-                       .update_format = update_format_v1}};
-
-/*
-  Local variables:
-  c-indentation-style: "K&R"
-  mode-name: "LC"
-  c-basic-offset: 8
-  tab-width: 8
-  fill-column: 80
-  scroll-step: 1
-  End:
-*/
diff --git a/xlators/encryption/crypt/src/metadata.h b/xlators/encryption/crypt/src/metadata.h
deleted file mode 100644
index 0bcee1b18c8..00000000000
--- a/xlators/encryption/crypt/src/metadata.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (c) 2008-2013 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 __METADATA_H__
-#define __METADATA_H__
-
-#define NMTD_8_MAC_SIZE (8)
-#define EMTD_8_MAC_SIZE (8)
-
-typedef uint8_t nmtd_8_mac_t[NMTD_8_MAC_SIZE];
-typedef uint8_t emtd_8_mac_t[EMTD_8_MAC_SIZE];
-
-/*
- * Version "v1" of file's metadata.
- * Metadata of this version has 4 components:
- *
- * 1) EMTD (Encrypted part of MeTaData);
- * 2) NMTD (Non-encrypted part of MeTaData);
- * 3) EMTD_MAC; (EMTD Message Authentication Code);
- * 4) Array of per-link NMTD MACs (for every (hard)link it includes
- *    exactly one MAC)
- */
-struct mtd_format_v1 {
-    /* EMTD, encrypted part of meta-data */
-    uint8_t alg_id;      /* cipher algorithm id (only AES for now) */
-    uint8_t mode_id;     /* cipher mode id; (only XTS for now) */
-    uint8_t block_bits;  /* encoded block size */
-    uint8_t minor_id;    /* client translator id */
-    uint8_t dkey_factor; /* encoded size of the data key */
-    /* MACs */
-    emtd_8_mac_t gmac; /* MAC of the encrypted meta-data, 8 bytes */
-    nmtd_8_mac_t omac; /* per-link MACs of the non-encrypted
-                        * meta-data: at least one such MAC is always
-                        * present */
-} __attribute__((packed));
-
-/*
- * NMTD, the non-encrypted part of metadata of version "v1"
- * is file's gfid, which is generated on trusted machines.
- */
-#define SIZE_OF_NMTD_V1 (sizeof(uuid_t))
-#define SIZE_OF_EMTD_V1                                                        \
-    (offsetof(struct mtd_format_v1, gmac) -                                    \
-     offsetof(struct mtd_format_v1, alg_id))
-#define SIZE_OF_NMTD_V1_MAC (NMTD_8_MAC_SIZE)
-#define SIZE_OF_EMTD_V1_MAC (EMTD_8_MAC_SIZE)
-
-static inline unsigned char *
-get_EMTD_V1(struct mtd_format_v1 *format)
-{
-    return &format->alg_id;
-}
-
-static inline unsigned char *
-get_NMTD_V1(struct crypt_inode_info *info)
-{
-    return info->oid;
-}
-
-static inline unsigned char *
-get_EMTD_V1_MAC(struct mtd_format_v1 *format)
-{
-    return format->gmac;
-}
-
-static inline unsigned char *
-get_NMTD_V1_MAC(struct mtd_format_v1 *format)
-{
-    return format->omac;
-}
-
-#endif /* __METADATA_H__ */
diff --git a/xlators/encryption/rot-13/Makefile.am b/xlators/encryption/rot-13/Makefile.am
deleted file mode 100644
index d471a3f9243..00000000000
--- a/xlators/encryption/rot-13/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES = 
diff --git a/xlators/experimental/Makefile.am b/xlators/experimental/Makefile.am
deleted file mode 100644
index a530845c4c0..00000000000
--- a/xlators/experimental/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = jbr-client jbr-server fdl dht2 posix2
-
-CLEANFILES =
diff --git a/xlators/experimental/README.md b/xlators/experimental/README.md
deleted file mode 100644
index b00f24e114b..00000000000
--- a/xlators/experimental/README.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# Purpose of this directory
-
-This directory is created to host experimental gluster translators. A new
-translator that is *experimental* in nature, would need to create its own
-subdirectory under this directory, to host/publish its work.
-
-Example:
-  The first commit should include the following changes
-    1. xlators/experimental/Makefile.am
-      NOTE: Add foobar to the list of SUBDIRS here
-    2. xlators/experimental/foobar
-    3. xlators/experimental/foobar/Makefle.am
-      NOTE: Can be empty initially in the first commit
-    4. configure.ac
-      NOTE: Include your experimental Makefile under AC_CONFIG_FILES
-    5. xlators/experimental/foobar/README.md
-      NOTE: The readme should cover details as required for the translator to be
-      accepted as experimental, primarily including a link to the specification
-      under the gluster-specs repository [1]. Later the readme should suffice
-      as an entry point for developers and users alike, who wish to experiment
-      with the xlator under development
-    6. xlators/experimental/foobar/TODO.md
-      NOTE: This is a list of TODO's identified during the development process
-      that needs addressing over time. These include exceptions granted during
-      the review process, for things not addressed when commits are merged into
-      the repository
-
-# Why is it provided
-
-Quite often translator development that happens out of tree, does not get
-enough eyeballs early in its development phase, has not undergone CI
-(regression/continuous integration testing), and at times is not well integrated
-with the rest of gluster stack.
-
-Also, when such out of tree translators are submitted for acceptance, it is a
-bulk commit that makes review difficult and inefficient. Such submissions also
-have to be merged forward, and depending on the time spent in developing the
-translator the master branch could have moved far ahead, making this a painful
-activity.
-
-Experimental is born out of such needs, to provide xlator developers,
-  - Early access to CI
-  - Ability to adapt to ongoing changes in other parts of gluster
-  - More eye balls on the code and design aspects of the translator
-  - TBD: What else?
-
-and for maintainers,
-  - Ability to look at smaller change sets in the review process
-  - Ability to verify/check implementation against the specification provided
-
-# General rules
-
-1. If a new translator is added under here it should, at the very least, pass
-compilation.
-
-2. All translators under the experimental directory are shipped as a part of
-gluster-experimental RPMs.
-TBD: Spec file and other artifacts for the gluster-experimental RPM needs to be
-fleshed out.
-
-3. Experimental translators can leverage the CI framework as needed. Tests need
-to be hosted under xlators/experimental/tests initially, and later moved to the
-appropriate tests/ directory as the xlator matures. It is encouraged to provide
-tests for each commit or series of commits, so that code and tests can be
-inspected together.
-
-4. If any experimental translator breaks CI, it is quarantined till demonstrable
-proof towards the contrary is provided. This is applicable as tests are moved
-out of experimental tests directory to the CI framework directory, as otherwise
-experimental tests are not a part of regular CI regression runs.
-
-5. An experimental translator need not function at all, as a result commits can
-be merged pretty much at will as long as other rules as stated are not violated.
-
-6. Experimental submissions will be assigned a existing maintainer, to aid
-merging commits and ensure aspects of gluster code submissions are respected.
-When an experimental xlator is proposed and the first commit posted
-a mail to gluster-devel@gluster.org requesting attention, will assign the
-maintainer buddy for the submission.
-NOTE: As we scale, this may change.
-
-6. More?
-
-# Getting out of the experimental jail
-
-So you now think your xlator is ready to leave experimental and become part of
-mainline!
-- TBD: guidelines pending.
-
-# FAQs
-
-1. How do I submit/commit experimental framework changes outside of my
-experimental xlator?
-  - Provide such framework changes as a separate commit
-  - Conditionally ensure these are built or activated only when the experimental
-  feature is activated, so as to prevent normal gluster workflow to function as
-  before
-  - TBD: guidelines and/or examples pending.
-
-2. Ask your question either on gluster-devel@gluster.org or as a change request
-to this file in gluster gerrit [2] for an answer that will be assimilated into
-this readme.
-
-# Links
-[1] http://review.gluster.org/#/q/project:glusterfs-specs
-
-[2] http://review.gluster.org/#/q/project:glusterfs
diff --git a/xlators/experimental/dht2/Makefile.am b/xlators/experimental/dht2/Makefile.am
deleted file mode 100644
index 9d910a66056..00000000000
--- a/xlators/experimental/dht2/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = dht2-client dht2-server
-
-CLEANFILES =
diff --git a/xlators/experimental/dht2/README.md b/xlators/experimental/dht2/README.md
deleted file mode 100644
index 8f249a83673..00000000000
--- a/xlators/experimental/dht2/README.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# DHT2 Experimental README
-
-DHT2 is the new distribution scheme being developed for Gluster, that
-aims to remove the subdirectory spread across all DHT subvolumes.
-
-As a result of this work, the Gluster backend file layouts and on disk
-representation of directories and files are modified, thus making DHT2
-volumes incompatible to existing DHT based Gluster deployments.
-
-This document presents interested users with relevant data to play around
-with DHT2 volumes and provide feedback towards the same.
-
-REMOVEME: Design details currently under review here,
-	- http://review.gluster.org/#/c/13395/
-
-TODO: Add more information as relevant code is pulled in
-
-# Directory strucutre elaborated
-
-## dht2-server
-This directory contains code for the server side DHT2 xlator. This xlator is
-intended to run on the brick graph, and is responsible for FOP synchronization,
-redirection, transactions, and journal replays.
-
-NOTE: The server side code also handles changes to volume/cluster map and
-also any rebalance activities.
-
-## dht2-client
-This directory contains code for the client side DHT2 xlator. This xlator is
-intended to run on the client/access protocol/mount graph, and is responsible
-for FOP routing to the right DHT2 subvolume. It uses a volume/cluster wide map
-of the routing (layout), to achieve the same.
-
-## dht2-common
-This directory contains code that is used in common across other parts of DHT2.
-For example, FOP routing store/consult abstractions that are common across the
-client and server side of DHT2.
-
-## Issue: How to build dht2-common?
-  1. Build a shared object
-    - We cannot ship this as a part of both the client xlator RPM
-  2. Build an archive
-    - Symbol clashes? when both the client and server xlators are loaded as a
-    part of the same graph
-  3. Compile with other parts of the code that needs it 
-    - Not a very different from (2) above
-    - This is what is chosen at present, and maybe would be revised later
diff --git a/xlators/experimental/dht2/TODO.md b/xlators/experimental/dht2/TODO.md
deleted file mode 100644
index 1e2c53c5b36..00000000000
--- a/xlators/experimental/dht2/TODO.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# DHT2 TODO list
-
-<Items will be added as code is pulled into the repository>
diff --git a/xlators/experimental/dht2/dht2-client/Makefile.am b/xlators/experimental/dht2/dht2-client/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/dht2/dht2-client/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/dht2/dht2-client/src/Makefile.am b/xlators/experimental/dht2/dht2-client/src/Makefile.am
deleted file mode 100644
index 3a13a2a3986..00000000000
--- a/xlators/experimental/dht2/dht2-client/src/Makefile.am
+++ /dev/null
@@ -1,21 +0,0 @@
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-xlator_LTLIBRARIES = dht2c.la
-
-dht2c_sources = dht2-client-main.c
-
-dht2common_sources = $(top_srcdir)/xlators/experimental/dht2/dht2-common/src/dht2-common-map.c
-
-dht2c_la_SOURCES = $(dht2c_sources) $(dht2common_sources)
-dht2c_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-dht2c_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-AM_CPPFLAGS = $(GF_CPPFLAGS)
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/experimental/dht2/dht2-common/src/
-AM_CPPFLAGS += -I$(top_srcdir)/libglusterfs/src
-AM_CPPFLAGS += -I$(top_srcdir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_builddir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/lib/src
-
-CLEANFILES =
diff --git a/xlators/experimental/dht2/dht2-client/src/dht2-client-main.c b/xlators/experimental/dht2/dht2-client/src/dht2-client-main.c
deleted file mode 100644
index 14a4c0e04fe..00000000000
--- a/xlators/experimental/dht2/dht2-client/src/dht2-client-main.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  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.
-*/
-
-/* File: dht2-client-main.c
- * This file contains the xlator loading functions, FOP entry points
- * and options.
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
-
-int32_t
-dht2_client_init(xlator_t *this)
-{
-    if (!this->children) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Missing children in volume graph, this (%s) is"
-               " not a leaf translator",
-               this->name);
-        return -1;
-    }
-
-    return 0;
-}
-
-void
-dht2_client_fini(xlator_t *this)
-{
-    return;
-}
-
-class_methods_t class_methods = {
-    .init = dht2_client_init,
-    .fini = dht2_client_fini,
-};
-
-struct xlator_fops fops = {};
-
-struct xlator_cbks cbks = {};
-
-/*
-struct xlator_dumpops dumpops = {
-};
-*/
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/experimental/dht2/dht2-common/src/dht2-common-map.c b/xlators/experimental/dht2/dht2-common/src/dht2-common-map.c
deleted file mode 100644
index 84ff27241d3..00000000000
--- a/xlators/experimental/dht2/dht2-common/src/dht2-common-map.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
-  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.
-*/
-
-/* File: dht2-common-map.c
- * This file contains helper routines to store, consult, the volume map
- * for subvolume to GFID relations.
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
diff --git a/xlators/experimental/dht2/dht2-server/Makefile.am b/xlators/experimental/dht2/dht2-server/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/dht2/dht2-server/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/dht2/dht2-server/src/Makefile.am b/xlators/experimental/dht2/dht2-server/src/Makefile.am
deleted file mode 100644
index c76fab0ca74..00000000000
--- a/xlators/experimental/dht2/dht2-server/src/Makefile.am
+++ /dev/null
@@ -1,23 +0,0 @@
-if WITH_SERVER
-xlator_LTLIBRARIES = dht2s.la
-endif
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-
-dht2s_sources = dht2-server-main.c
-
-dht2common_sources = $(top_srcdir)/xlators/experimental/dht2/dht2-common/src/dht2-common-map.c
-
-dht2s_la_SOURCES = $(dht2s_sources) $(dht2common_sources)
-dht2s_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-dht2s_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-AM_CPPFLAGS = $(GF_CPPFLAGS)
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/experimental/dht2/dht2-common/src/
-AM_CPPFLAGS += -I$(top_srcdir)/libglusterfs/src
-AM_CPPFLAGS += -I$(top_srcdir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_builddir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/lib/src
-
-CLEANFILES =
diff --git a/xlators/experimental/dht2/dht2-server/src/dht2-server-main.c b/xlators/experimental/dht2/dht2-server/src/dht2-server-main.c
deleted file mode 100644
index 6f67e07ffdf..00000000000
--- a/xlators/experimental/dht2/dht2-server/src/dht2-server-main.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  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.
-*/
-
-/* File: dht2-server-main.c
- * This file contains the xlator loading functions, FOP entry points
- * and options.
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
-
-int32_t
-dht2_server_init(xlator_t *this)
-{
-    if (!this->children) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Missing children in volume graph, this (%s) is"
-               " not a leaf translator",
-               this->name);
-        return -1;
-    }
-
-    return 0;
-}
-
-void
-dht2_server_fini(xlator_t *this)
-{
-    return;
-}
-
-class_methods_t class_methods = {
-    .init = dht2_server_init,
-    .fini = dht2_server_fini,
-};
-
-struct xlator_fops fops = {};
-
-struct xlator_cbks cbks = {};
-
-/*
-struct xlator_dumpops dumpops = {
-};
-*/
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/experimental/fdl/Makefile.am b/xlators/experimental/fdl/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/fdl/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/fdl/src/Makefile.am b/xlators/experimental/fdl/src/Makefile.am
deleted file mode 100644
index bdcaaf6c38d..00000000000
--- a/xlators/experimental/fdl/src/Makefile.am
+++ /dev/null
@@ -1,48 +0,0 @@
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-if WITH_SERVER
-xlator_LTLIBRARIES = fdl.la
-endif
-
-noinst_HEADERS = fdl.h
-
-nodist_fdl_la_SOURCES = fdl.c
-fdl_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-fdl_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-if WITH_SERVER
-sbin_PROGRAMS = gf_logdump gf_recon
-endif
-gf_logdump_SOURCES = logdump.c
-nodist_gf_logdump_SOURCES = libfdl.c
-gf_logdump_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	$(top_builddir)/api/src/libgfapi.la $(GFAPI_LIBS) $(UUID_LIBS)
-
-# Eventually recon(ciliation) code will move elsewhere, but for now it's
-# easier to have it next to the similar logdump code.
-gf_recon_SOURCES = recon.c
-nodist_gf_recon_SOURCES = librecon.c
-gf_recon_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	$(top_builddir)/api/src/libgfapi.la $(GFAPI_LIBS) $(UUID_LIBS)
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
-	-I$(top_srcdir)/api/src -fPIC \
-	-D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS) \
-	-DDATADIR=\"$(localstatedir)\"
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-noinst_PYTHON = gen_fdl.py gen_dumper.py gen_recon.py
-EXTRA_DIST = fdl-tmpl.c.in dump-tmpl.c.in recon-tmpl.c.in
-
-CLEANFILES = $(nodist_fdl_la_SOURCES) $(nodist_gf_logdump_SOURCES) \
-	$(nodist_gf_recon_SOURCES)
-
-fdl.c: fdl-tmpl.c.in gen_fdl.py
-	$(PYTHON) $(srcdir)/gen_fdl.py $(srcdir)/fdl-tmpl.c.in > $@
-
-libfdl.c: dump-tmpl.c.in gen_dumper.py
-	$(PYTHON) $(srcdir)/gen_dumper.py $(srcdir)/dump-tmpl.c.in > $@
-
-librecon.c: recon-tmpl.c.in gen_recon.py
-	$(PYTHON) $(srcdir)/gen_recon.py $(srcdir)/recon-tmpl.c.in > $@
diff --git a/xlators/experimental/fdl/src/dump-tmpl.c.in b/xlators/experimental/fdl/src/dump-tmpl.c.in
deleted file mode 100644
index 97249ac3e71..00000000000
--- a/xlators/experimental/fdl/src/dump-tmpl.c.in
+++ /dev/null
@@ -1,177 +0,0 @@
-#pragma fragment PROLOG
-#ifndef _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#include <ctype.h>
-#endif
-
-#include "glfs.h"
-#include "iatt.h"
-#include "xlator.h"
-#include "fdl.h"
-
-/*
- * Returns 0 if the string is ASCII printable *
- * and -1 if it's not ASCII printable         *
- */
-int
-str_isprint(char *s)
-{
-    int ret = -1;
-
-    if (!s)
-        goto out;
-
-    while (s[0] != '\0') {
-        if (!isprint(s[0]))
-            goto out;
-        else
-            s++;
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-#pragma fragment DICT
-{
-    int key_len, data_len;
-    char *key_ptr;
-    char *key_val;
-    printf("@ARGNAME@ = dict {\n");
-    for (;;) {
-        key_len = *((int *)new_meta);
-        new_meta += sizeof(int);
-        if (!key_len) {
-            break;
-        }
-        key_ptr = new_meta;
-        new_meta += key_len;
-        data_len = *((int *)new_meta);
-        key_val = new_meta + sizeof(int);
-        new_meta += sizeof(int) + data_len;
-        if (str_isprint(key_val))
-            printf(" %s = <%d bytes>\n", key_ptr, data_len);
-        else
-            printf(" %s = %s <%d bytes>\n", key_ptr, key_val, data_len);
-    }
-    printf("}\n");
-}
-
-#pragma fragment DOUBLE
-printf("@ARGNAME@ = @FORMAT@\n", *((uint64_t *)new_meta),
-       *((uint64_t *)new_meta));
-new_meta += sizeof(uint64_t);
-
-#pragma fragment GFID
-printf("@ARGNAME@ = <gfid %s>\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
-
-#pragma fragment INTEGER
-printf("@ARGNAME@ = @FORMAT@\n", *((uint32_t *)new_meta),
-       *((uint32_t *)new_meta));
-new_meta += sizeof(uint32_t);
-
-#pragma fragment LOC
-printf("@ARGNAME@ = loc {\n");
-printf("  gfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
-printf("  pargfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
-new_meta += 16;
-if (*(new_meta++)) {
-    printf("  name = %s\n", new_meta);
-    new_meta += (strlen(new_meta) + 1);
-}
-printf("}\n");
-
-#pragma fragment STRING
-if (*(new_meta++)) {
-    printf("@ARGNAME@ = %s\n", new_meta);
-    new_meta += (strlen(new_meta) + 1);
-}
-
-#pragma fragment VECTOR
-{
-    size_t len = *((size_t *)new_meta);
-    new_meta += sizeof(len);
-    printf("@ARGNAME@ = <%zu bytes>\n", len);
-    new_data += len;
-}
-
-#pragma fragment IATT
-{
-    ia_prot_t *myprot = ((ia_prot_t *)new_meta);
-    printf("@ARGNAME@ = iatt {\n");
-    printf("  ia_prot = %c%c%c", myprot->suid ? 'S' : '-',
-           myprot->sgid ? 'S' : '-', myprot->sticky ? 'T' : '-');
-    printf("%c%c%c", myprot->owner.read ? 'r' : '-',
-           myprot->owner.write ? 'w' : '-', myprot->owner.exec ? 'x' : '-');
-    printf("%c%c%c", myprot->group.read ? 'r' : '-',
-           myprot->group.write ? 'w' : '-', myprot->group.exec ? 'x' : '-');
-    printf("%c%c%c\n", myprot->other.read ? 'r' : '-',
-           myprot->other.write ? 'w' : '-', myprot->other.exec ? 'x' : '-');
-    new_meta += sizeof(ia_prot_t);
-    uint32_t *myints = (uint32_t *)new_meta;
-    printf("  ia_uid = %u\n", myints[0]);
-    printf("  ia_gid = %u\n", myints[1]);
-    printf("  ia_atime = %u.%09u\n", myints[2], myints[3]);
-    printf("  ia_mtime = %u.%09u\n", myints[4], myints[5]);
-    new_meta += sizeof(*myints) * 6;
-}
-
-#pragma fragment FOP
-void fdl_dump_@NAME@(char **old_meta, char **old_data)
-{
-    char *new_meta = *old_meta;
-    char *new_data = *old_data;
-
-    /* TBD: word size/endianness */
-    @FUNCTION_BODY@
-
-    *old_meta = new_meta;
-    *old_data = new_data;
-}
-
-#pragma fragment CASE
-case GF_FOP_@UPNAME@:
-    printf("=== GF_FOP_@UPNAME@\n");
-    fdl_dump_@NAME@(&new_meta, &new_data);
-    break;
-
-#pragma fragment EPILOG
-    int
-    fdl_dump(char **old_meta, char **old_data)
-    {
-        char *new_meta = *old_meta;
-        char *new_data = *old_data;
-        static glfs_t *fs = NULL;
-        int recognized = 1;
-        event_header_t *eh;
-
-        /*
-         * We don't really call anything else in GFAPI, but this is the most
-         * convenient way to satisfy all of the spurious dependencies on how it
-         * or glusterfsd initialize (e.g. setting up THIS).
-         */
-        if (!fs) {
-            fs = glfs_new("dummy");
-        }
-
-        eh = (event_header_t *)new_meta;
-        new_meta += sizeof(*eh);
-
-        /* TBD: check event_type instead of assuming NEW_REQUEST */
-
-        switch (eh->fop_type) {
-            @SWITCH_BODY@
-
-            default :
-                printf("unknown fop %u\n", eh->fop_type);
-                recognized = 0;
-        }
-
-        *old_meta = new_meta;
-        *old_data = new_data;
-        return recognized;
-    }
diff --git a/xlators/experimental/fdl/src/fdl-tmpl.c.in b/xlators/experimental/fdl/src/fdl-tmpl.c.in
deleted file mode 100644
index c99157be957..00000000000
--- a/xlators/experimental/fdl/src/fdl-tmpl.c.in
+++ /dev/null
@@ -1,513 +0,0 @@
-/*
-  Copyright (c) 2015 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 _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include "call-stub.h"
-#include "iatt.h"
-#include "defaults.h"
-#include "syscall.h"
-#include "xlator.h"
-#include "fdl.h"
-
-/* TBD: make tunable */
-#define META_FILE_SIZE (1 << 20)
-#define DATA_FILE_SIZE (1 << 24)
-
-enum gf_fdl { gf_fdl_mt_fdl_private_t = gf_common_mt_end + 1, gf_fdl_mt_end };
-
-typedef struct {
-    char *type;
-    off_t size;
-    char *path;
-    int fd;
-    void *ptr;
-    off_t max_offset;
-} log_obj_t;
-
-typedef struct {
-    struct list_head reqs;
-    pthread_mutex_t req_lock;
-    pthread_cond_t req_cond;
-    char *log_dir;
-    pthread_t worker;
-    gf_boolean_t should_stop;
-    gf_boolean_t change_term;
-    log_obj_t meta_log;
-    log_obj_t data_log;
-    int term;
-    int first_term;
-} fdl_private_t;
-
-int32_t
-fdl_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata);
-
-void
-fdl_enqueue(xlator_t *this, call_stub_t *stub)
-{
-    fdl_private_t *priv = this->private;
-
-    pthread_mutex_lock(&priv->req_lock);
-    list_add_tail(&stub->list, &priv->reqs);
-    pthread_mutex_unlock(&priv->req_lock);
-
-    pthread_cond_signal(&priv->req_cond);
-}
-
-#pragma generate
-
-char *
-fdl_open_term_log(xlator_t *this, log_obj_t *obj, int term)
-{
-    fdl_private_t *priv = this->private;
-    int ret;
-    char *ptr = NULL;
-
-    /*
-     * Use .jnl instead of .log so that we don't get test info (mistakenly)
-     * appended to our journal files.
-     */
-    if (this->ctx->cmd_args.log_ident) {
-        ret = gf_asprintf(&obj->path, "%s/%s-%s-%d.jnl", priv->log_dir,
-                          this->ctx->cmd_args.log_ident, obj->type, term);
-    } else {
-        ret = gf_asprintf(&obj->path, "%s/fubar-%s-%d.jnl", priv->log_dir,
-                          obj->type, term);
-    }
-    if ((ret <= 0) || !obj->path) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to construct log-file path");
-        goto err;
-    }
-
-    gf_log(this->name, GF_LOG_INFO, "opening %s (size %" PRId64 ")", obj->path,
-           obj->size);
-
-    obj->fd = open(obj->path, O_RDWR | O_CREAT | O_TRUNC, 0666);
-    if (obj->fd < 0) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to open log file (%s)",
-               strerror(errno));
-        goto err;
-    }
-
-#if !defined(GF_BSD_HOST_OS)
-    /*
-     * NetBSD can just go die in a fire.  Even though it claims to support
-     * fallocate/posix_fallocate they don't actually *do* anything so the
-     * file size remains zero.  Then mmap succeeds anyway, but any access
-     * to the mmap'ed region will segfault.  It would be acceptable for
-     * fallocate to do what it says, for mmap to fail, or for access to
-     * extend the file.  NetBSD managed to hit the trifecta of Getting
-     * Everything Wrong, and debugging in that environment to get this far
-     * has already been painful enough (systems I worked on in 1990 were
-     * better that way).  We'll fall through to the lseek/write method, and
-     * performance will be worse, and TOO BAD.
-     */
-    if (sys_fallocate(obj->fd, 0, 0, obj->size) < 0)
-#endif
-    {
-        gf_log(this->name, GF_LOG_WARNING,
-               "failed to fallocate space for log file");
-        /* Have to do this the ugly page-faulty way. */
-        (void)sys_lseek(obj->fd, obj->size - 1, SEEK_SET);
-        (void)sys_write(obj->fd, "", 1);
-    }
-
-    ptr = mmap(NULL, obj->size, PROT_WRITE, MAP_SHARED, obj->fd, 0);
-    if (ptr == MAP_FAILED) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to mmap log (%s)",
-               strerror(errno));
-        goto err;
-    }
-
-    obj->ptr = ptr;
-    obj->max_offset = 0;
-    return ptr;
-
-err:
-    if (obj->fd >= 0) {
-        sys_close(obj->fd);
-        obj->fd = (-1);
-    }
-    if (obj->path) {
-        GF_FREE(obj->path);
-        obj->path = NULL;
-    }
-    return ptr;
-}
-
-void
-fdl_close_term_log(xlator_t *this, log_obj_t *obj)
-{
-    fdl_private_t *priv = this->private;
-
-    if (obj->ptr) {
-        (void)munmap(obj->ptr, obj->size);
-        obj->ptr = NULL;
-    }
-
-    if (obj->fd >= 0) {
-        gf_log(this->name, GF_LOG_INFO,
-               "truncating term %d %s journal to %" PRId64,
-               priv->term, obj->type, obj->max_offset);
-        if (sys_ftruncate(obj->fd, obj->max_offset) < 0) {
-            gf_log(this->name, GF_LOG_WARNING,
-                   "failed to truncate journal (%s)", strerror(errno));
-        }
-        sys_close(obj->fd);
-        obj->fd = (-1);
-    }
-
-    if (obj->path) {
-        GF_FREE(obj->path);
-        obj->path = NULL;
-    }
-}
-
-gf_boolean_t
-fdl_change_term(xlator_t *this, char **meta_ptr, char **data_ptr)
-{
-    fdl_private_t *priv = this->private;
-
-    fdl_close_term_log(this, &priv->meta_log);
-    fdl_close_term_log(this, &priv->data_log);
-
-    ++(priv->term);
-
-    *meta_ptr = fdl_open_term_log(this, &priv->meta_log, priv->term);
-    if (!*meta_ptr) {
-        return _gf_false;
-    }
-
-    *data_ptr = fdl_open_term_log(this, &priv->data_log, priv->term);
-    if (!*data_ptr) {
-        return _gf_false;
-    }
-
-    return _gf_true;
-}
-
-void *
-fdl_worker(void *arg)
-{
-    xlator_t *this = arg;
-    fdl_private_t *priv = this->private;
-    call_stub_t *stub;
-    char *meta_ptr = NULL;
-    off_t *meta_offset = &priv->meta_log.max_offset;
-    char *data_ptr = NULL;
-    off_t *data_offset = &priv->data_log.max_offset;
-    unsigned long base_as_ul;
-    void *msync_ptr;
-    size_t msync_len;
-    gf_boolean_t recycle;
-    void *err_label = &&err_unlocked;
-
-    priv->meta_log.type = "meta";
-    priv->meta_log.size = META_FILE_SIZE;
-    priv->meta_log.path = NULL;
-    priv->meta_log.fd = (-1);
-    priv->meta_log.ptr = NULL;
-
-    priv->data_log.type = "data";
-    priv->data_log.size = DATA_FILE_SIZE;
-    priv->data_log.path = NULL;
-    priv->data_log.fd = (-1);
-    priv->data_log.ptr = NULL;
-
-    /* TBD: initial term should come from persistent storage (e.g. etcd) */
-    priv->first_term = ++(priv->term);
-    meta_ptr = fdl_open_term_log(this, &priv->meta_log, priv->term);
-    if (!meta_ptr) {
-        goto *err_label;
-    }
-    data_ptr = fdl_open_term_log(this, &priv->data_log, priv->term);
-    if (!data_ptr) {
-        fdl_close_term_log(this, &priv->meta_log);
-        goto *err_label;
-    }
-
-    for (;;) {
-        pthread_mutex_lock(&priv->req_lock);
-        err_label = &&err_locked;
-        while (list_empty(&priv->reqs)) {
-            pthread_cond_wait(&priv->req_cond, &priv->req_lock);
-            if (priv->should_stop) {
-                goto *err_label;
-            }
-            if (priv->change_term) {
-                if (!fdl_change_term(this, &meta_ptr, &data_ptr)) {
-                    goto *err_label;
-                }
-                priv->change_term = _gf_false;
-                continue;
-            }
-        }
-        stub = list_entry(priv->reqs.next, call_stub_t, list);
-        list_del_init(&stub->list);
-        pthread_mutex_unlock(&priv->req_lock);
-        err_label = &&err_unlocked;
-        /*
-         * TBD: batch requests
-         *
-         * What we should do here is gather up *all* of the requests
-         * that have accumulated since we were last at this point,
-         * blast them all out in one big writev, and then dispatch them
-         * all before coming back for more.  That maximizes throughput,
-         * at some cost to latency (due to queuing effects at the log
-         * stage).  Note that we're likely to be above io-threads, so
-         * the dispatch itself will be parallelized (at further cost to
-         * latency).  For now, we just do the simplest thing and handle
-         * one request all the way through before fetching the next.
-         *
-         * So, why mmap/msync instead of writev/fdatasync?  Because it's
-         * faster.  Much faster.  So much faster that I half-suspect
-         * cheating, but it's more convenient for now than having to
-         * ensure that everything's page-aligned for O_DIRECT (the only
-         * alternative that still might avoid ridiculous levels of
-         * local-FS overhead).
-         *
-         * TBD: check that msync really does get our data to disk.
-         */
-        gf_log(this->name, GF_LOG_DEBUG, "logging %u+%u bytes for op %d",
-               stub->jnl_meta_len, stub->jnl_data_len, stub->fop);
-        recycle = _gf_false;
-        if ((*meta_offset + stub->jnl_meta_len) > priv->meta_log.size) {
-            recycle = _gf_true;
-        }
-        if ((*data_offset + stub->jnl_data_len) > priv->data_log.size) {
-            recycle = _gf_true;
-        }
-        if (recycle && !fdl_change_term(this, &meta_ptr, &data_ptr)) {
-            goto *err_label;
-        }
-        meta_ptr = priv->meta_log.ptr;
-        data_ptr = priv->data_log.ptr;
-        gf_log(this->name, GF_LOG_DEBUG, "serializing to %p/%p",
-               meta_ptr + *meta_offset, data_ptr + *data_offset);
-        stub->serialize(stub, meta_ptr + *meta_offset, data_ptr + *data_offset);
-        if (stub->jnl_meta_len > 0) {
-            base_as_ul = (unsigned long)(meta_ptr + *meta_offset);
-            msync_ptr = (void *)(base_as_ul & ~0x0fff);
-            msync_len = (size_t)(base_as_ul & 0x0fff);
-            if (msync(msync_ptr, msync_len + stub->jnl_meta_len, MS_SYNC) < 0) {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "failed to log request meta (%s)", strerror(errno));
-            }
-            *meta_offset += stub->jnl_meta_len;
-        }
-        if (stub->jnl_data_len > 0) {
-            base_as_ul = (unsigned long)(data_ptr + *data_offset);
-            msync_ptr = (void *)(base_as_ul & ~0x0fff);
-            msync_len = (size_t)(base_as_ul & 0x0fff);
-            if (msync(msync_ptr, msync_len + stub->jnl_data_len, MS_SYNC) < 0) {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "failed to log request data (%s)", strerror(errno));
-            }
-            *data_offset += stub->jnl_data_len;
-        }
-        call_resume(stub);
-    }
-
-err_locked:
-    pthread_mutex_unlock(&priv->req_lock);
-err_unlocked:
-    fdl_close_term_log(this, &priv->meta_log);
-    fdl_close_term_log(this, &priv->data_log);
-    return NULL;
-}
-
-int32_t
-fdl_ipc_continue(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
-{
-    /*
-     * Nothing to be done here. Just Unwind. *
-     */
-    STACK_UNWIND_STRICT(ipc, frame, 0, 0, xdata);
-
-    return 0;
-}
-
-int32_t
-fdl_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
-{
-    call_stub_t *stub;
-    fdl_private_t *priv = this->private;
-    dict_t *tdict;
-    int32_t gt_err = EIO;
-
-    switch (op) {
-        case FDL_IPC_CHANGE_TERM:
-            gf_log(this->name, GF_LOG_INFO, "got CHANGE_TERM op");
-            priv->change_term = _gf_true;
-            pthread_cond_signal(&priv->req_cond);
-            STACK_UNWIND_STRICT(ipc, frame, 0, 0, NULL);
-            break;
-
-        case FDL_IPC_GET_TERMS:
-            gf_log(this->name, GF_LOG_INFO, "got GET_TERMS op");
-            tdict = dict_new();
-            if (!tdict) {
-                gt_err = ENOMEM;
-                goto gt_done;
-            }
-            if (dict_set_int32(tdict, "first", priv->first_term) != 0) {
-                goto gt_done;
-            }
-            if (dict_set_int32(tdict, "last", priv->term) != 0) {
-                goto gt_done;
-            }
-            gt_err = 0;
-        gt_done:
-            if (gt_err) {
-                STACK_UNWIND_STRICT(ipc, frame, -1, gt_err, NULL);
-            } else {
-                STACK_UNWIND_STRICT(ipc, frame, 0, 0, tdict);
-            }
-            if (tdict) {
-                dict_unref(tdict);
-            }
-            break;
-
-        case FDL_IPC_JBR_SERVER_ROLLBACK:
-            /*
-             * In case of a rollback from jbr-server, dump  *
-             * the term and index number in the journal,    *
-             * which will later be used to rollback the fop *
-             */
-            stub = fop_ipc_stub(frame, fdl_ipc_continue, op, xdata);
-            fdl_len_ipc(stub);
-            stub->serialize = fdl_serialize_ipc;
-            fdl_enqueue(this, stub);
-
-            break;
-
-        default:
-            STACK_WIND_TAIL(frame, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->ipc, op, xdata);
-    }
-
-    return 0;
-}
-
-int
-fdl_init(xlator_t *this)
-{
-    fdl_private_t *priv = NULL;
-
-    priv = GF_CALLOC(1, sizeof(*priv), gf_fdl_mt_fdl_private_t);
-    if (!priv) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to allocate fdl_private");
-        goto err;
-    }
-
-    INIT_LIST_HEAD(&priv->reqs);
-    if (pthread_mutex_init(&priv->req_lock, NULL) != 0) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to initialize req_lock");
-        goto err;
-    }
-    if (pthread_cond_init(&priv->req_cond, NULL) != 0) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to initialize req_cond");
-        goto err;
-    }
-
-    GF_OPTION_INIT("log-path", priv->log_dir, path, err);
-
-    this->private = priv;
-    /*
-     * The rest of the fop table is automatically generated, so this is a
-     * bit cleaner than messing with the generation to add a hand-written
-     * exception.
-     */
-
-    if (gf_thread_create(&priv->worker, NULL, fdl_worker, this, "fdlwrker") !=
-        0) {
-        gf_log(this->name, GF_LOG_ERROR, "failed to start fdl_worker");
-        goto err;
-    }
-
-    return 0;
-
-err:
-    if (priv) {
-        GF_FREE(priv);
-    }
-    return -1;
-}
-
-void
-fdl_fini(xlator_t *this)
-{
-    fdl_private_t *priv = this->private;
-
-    if (priv) {
-        priv->should_stop = _gf_true;
-        pthread_cond_signal(&priv->req_cond);
-        pthread_join(priv->worker, NULL);
-        GF_FREE(priv);
-    }
-}
-
-int
-fdl_reconfigure(xlator_t *this, dict_t *options)
-{
-    fdl_private_t *priv = this->private;
-
-    GF_OPTION_RECONF("log_dir", priv->log_dir, options, path, out);
-    /* TBD: react if it changed */
-
-out:
-    return 0;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("fdl", this, out);
-
-    ret = xlator_mem_acct_init(this, gf_fdl_mt_end + 1);
-
-    if (ret != 0) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Memory accounting init"
-               "failed");
-        return ret;
-    }
-out:
-    return ret;
-}
-
-class_methods_t class_methods = {
-    .init = fdl_init,
-    .fini = fdl_fini,
-    .reconfigure = fdl_reconfigure,
-    .notify = default_notify,
-};
-
-struct volume_options options[] = {
-    {.key = {"log-path"},
-     .type = GF_OPTION_TYPE_PATH,
-     .default_value = DEFAULT_LOG_FILE_DIRECTORY,
-     .description = "Directory for FDL files."},
-    {.key = {NULL}},
-};
-
-struct xlator_cbks cbks = {
-    .release = default_release,
-    .releasedir = default_releasedir,
-    .forget = default_forget,
-};
diff --git a/xlators/experimental/fdl/src/fdl.h b/xlators/experimental/fdl/src/fdl.h
deleted file mode 100644
index 827db9f1246..00000000000
--- a/xlators/experimental/fdl/src/fdl.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-   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 _FDL_H_
-#define _FDL_H_
-
-#define NEW_REQUEST (uint8_t)'N'
-
-typedef struct {
-    uint8_t event_type; /* e.g. NEW_REQUEST */
-    uint8_t fop_type;   /* e.g. GF_FOP_SETATTR */
-    uint16_t request_id;
-    uint32_t ext_length;
-} event_header_t;
-
-enum {
-    FDL_IPC_BASE = 0xfeedbee5, /* ... and they make honey */
-    FDL_IPC_CHANGE_TERM,
-    FDL_IPC_GET_TERMS,
-    FDL_IPC_JBR_SERVER_ROLLBACK
-};
-
-#endif /* _FDL_H_ */
diff --git a/xlators/experimental/fdl/src/gen_dumper.py b/xlators/experimental/fdl/src/gen_dumper.py
deleted file mode 100755
index 630b54492f7..00000000000
--- a/xlators/experimental/fdl/src/gen_dumper.py
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/usr/bin/python3
-
-from __future__ import print_function
-import os
-import re
-import sys
-
-curdir = os.path.dirname (sys.argv[0])
-gendir = os.path.join (curdir, '../../../../libglusterfs/src')
-sys.path.append (gendir)
-from generator import ops, fop_subs, cbk_subs, generate
-
-# See the big header comment at the start of gen_fdl.py to see how the stages
-# fit together.  The big difference here is that *all* of the C code is in the
-# template file as labelled fragments, instead of as Python strings.  That
-# makes it much easier to edit in one place, with proper syntax highlighting
-# and indentation.
-#
-#   Stage 1 uses type-specific fragments to generate FUNCTION_BODY, instead of
-#   LEN_*_TEMPLATE and SERLZ_*_TEMPLATE to generate LEN_CODE and SER_CODE.
-#
-#   Stage 2 uses the FOP and CASE fragments instead of RECON_TEMPLATE and
-#   FOP_TEMPLATE.  The expanded FOP code (including FUNCTION_BODY substitution
-#   in the middle of each function) is emitted immediately; the expanded CASE
-#   code is saved for the next stage.
-#
-#   Stage 3 uses the PROLOG and EPILOG fragments, with the expanded CASE code
-#   in the middle of EPILOG, to generate the whole output file.
-#
-# Another way of looking at it is to consider how the fragments appear in
-# the final output:
-#
-#   PROLOG
-#   FOP (expanded for CREATE)
-#       FOP before FUNCTION_BODY
-#       LOC, INTEGER, GFID, etc. (one per arg, by type)
-#       FOP after FUNCTION_BODY
-#   FOP (expanded for WRITEV)
-#       FOP before FUNCTION_BODY
-#       GFID, VECTOR, etc. (on per arg, by type)
-#       FOP after FUNCTION_BODY
-#   (more FOPs)
-#   EPILOG
-#       EPILOG before CASE
-#       CASE statements (one per fop)
-#       EPILOG after CASE
-
-typemap = {
-	'dict_t *':				( "DICT",		""),
-	'fd_t *':				( "GFID",		""),
-	'dev_t':				( "DOUBLE",		"%\"PRId64\" (0x%\"PRIx64\")"),
-	'gf_xattrop_flags_t':	( "INTEGER",	"%d (0x%x)"),
-	'int32_t':				( "INTEGER",	"%d (0x%x)"),
-	'mode_t':				( "INTEGER",	"%d (0x%x)"),
-	'off_t':				( "DOUBLE",		"%\"PRId64\" (0x%\"PRIx64\")"),
-	'size_t':				( "DOUBLE",		"%\"PRId64\" (0x%\"PRIx64\")"),
-	'uint32_t':				( "INTEGER",	"%d (0x%x)"),
-	'loc_t *':				( "LOC",		""),
-	'const char *':			( "STRING",		""),
-	'struct iovec *':		( "VECTOR",		""),
-	'struct iatt *':		( "IATT",		""),
-}
-
-def get_special_subs (args):
-	code = ""
-	for arg in args:
-		if (arg[0] != 'fop-arg') or (len(arg) < 4):
-			continue
-		recon_type, recon_fmt = typemap[arg[2]]
-		code += fragments[recon_type].replace("@ARGNAME@", arg[3])		\
-									 .replace("@FORMAT@", recon_fmt)
-	return code
-
-def gen_functions ():
-	code = ""
-	for name, value in ops.items():
-		if "journal" not in [ x[0] for x in value ]:
-			continue
-		fop_subs[name]["@FUNCTION_BODY@"] = get_special_subs(value)
-		# Print the FOP fragment with @FUNCTION_BODY@ in the middle.
-		code += generate(fragments["FOP"], name, fop_subs)
-	return code
-
-def gen_cases ():
-	code = ""
-	for name, value in ops.items():
-		if "journal" not in [ x[0] for x in value ]:
-			continue
-		# Add the CASE fragment for this fop.
-		code += generate(fragments["CASE"], name, fop_subs)
-	return code
-
-def load_fragments (path="recon-tmpl.c"):
-	pragma_re = re.compile('pragma fragment (.*)')
-	cur_symbol = None
-	cur_value = ""
-	result = {}
-	for line in open(path, "r").readlines():
-		m = pragma_re.search(line)
-		if m:
-			if cur_symbol:
-				result[cur_symbol] = cur_value
-			cur_symbol = m.group(1)
-			cur_value = ""
-		else:
-			cur_value += line
-	if cur_symbol:
-		result[cur_symbol] = cur_value
-	return result
-
-if __name__ == "__main__":
-	fragments = load_fragments(sys.argv[1])
-	print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
-	print(fragments["PROLOG"])
-	print(gen_functions())
-	print(fragments["EPILOG"].replace("@SWITCH_BODY@", gen_cases()))
-	print("/* END GENERATED CODE */")
diff --git a/xlators/experimental/fdl/src/gen_fdl.py b/xlators/experimental/fdl/src/gen_fdl.py
deleted file mode 100755
index 467ec8927b7..00000000000
--- a/xlators/experimental/fdl/src/gen_fdl.py
+++ /dev/null
@@ -1,354 +0,0 @@
-#!/usr/bin/python3
-
-from __future__ import print_function
-import os
-import sys
-
-curdir = os.path.dirname (sys.argv[0])
-gendir = os.path.join (curdir, '../../../../libglusterfs/src')
-sys.path.append (gendir)
-from generator import ops, fop_subs, cbk_subs, generate
-
-# Generation occurs in three stages.  In this case, it actually makes more
-# sense to discuss them in the *opposite* order of that in which they
-# actually happen.
-#
-#   Stage 3 is to insert all of the generated code into a file, replacing the
-#   "#pragma generate" that's already there.  The file can thus contain all
-#   sorts of stuff that's not specific to one fop, either before or after the
-#   generated code as appropriate.
-#
-#   Stage 2 is to generate all of the code *for a particular fop*, using a
-#   string-valued template plus a table of substitution values.  Most of these
-#   are built in to the generator itself.  However, we also add a couple that
-#   are specific to this particular translator - LEN_CODE and SER_CODE.  These
-#   are per-fop functions to get the length or the contents (respectively) of
-#   what we'll put in the log.  As with stage 3 allowing per-file boilerplate
-#   before and after generated code, this allows per-fop boilerplate before and
-#   after generated code.
-#
-#   Stage 1, therefore, is to create the LEN_CODE and SER_CODE substitutions for
-#   each fop, and put them in the same table where e.g. NAME and SHORT_ARGS
-#   already are.  We do this by looking at the fop-description table in the
-#   generator module, then doing out own template substitution to plug each
-#   specific argument name into another string-valued template.
-#
-# So, what does this leave us with in terms of variables and files?
-#
-#   For stage 1, we have a series of LEN_*_TEMPLATE and SERLZ_*_TEMPLATE
-#   strings, which are used to generate the length and serialization code for
-#   each argument type.
-#
-#   For stage 2, we have a bunch of *_TEMPLATE strings (no LEN_ or SERLZ_
-#   prefix), which are used (along with the output from stage 1) to generate
-#   whole functions.
-#
-#   For stage 3, we have a whole separate file (fdl_tmpl.c) into which we insert
-#   the collection of all functions defined in stage 2.
-
-
-LEN_TEMPLATE = """
-void
-fdl_len_@NAME@ (call_stub_t *stub)
-{
-        uint32_t    meta_len    = sizeof (event_header_t);
-		uint32_t	data_len	= 0;
-
-        /* TBD: global stuff, e.g. uid/gid */
-@LEN_CODE@
-
-		/* TBD: pad extension length */
-		stub->jnl_meta_len = meta_len;
-		stub->jnl_data_len = data_len;
-}
-"""
-
-SER_TEMPLATE = """
-void
-fdl_serialize_@NAME@ (call_stub_t *stub, char *meta_buf, char *data_buf)
-{
-		event_header_t	*eh;
-		unsigned long	offset = 0;
-
-        /* TBD: word size/endianness */
-		eh = (event_header_t *)meta_buf;
-		eh->event_type = NEW_REQUEST;
-		eh->fop_type = GF_FOP_@UPNAME@;
-		eh->request_id = 0;	// TBD
-		meta_buf += sizeof (*eh);
-@SER_CODE@
-		/* TBD: pad extension length */
-		eh->ext_length = offset;
-}
-"""
-
-CBK_TEMPLATE = """
-int32_t
-fdl_@NAME@_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno,
-                @LONG_ARGS@)
-{
-        STACK_UNWIND_STRICT (@NAME@, frame, op_ret, op_errno,
-                             @SHORT_ARGS@);
-        return 0;
-}
-"""
-
-CONTINUE_TEMPLATE = """
-int32_t
-fdl_@NAME@_continue (call_frame_t *frame, xlator_t *this,
-                     @LONG_ARGS@)
-{
-        STACK_WIND (frame, fdl_@NAME@_cbk,
-                    FIRST_CHILD(this), FIRST_CHILD(this)->fops->@NAME@,
-                    @SHORT_ARGS@);
-        return 0;
-}
-
-"""
-
-FOP_TEMPLATE = """
-int32_t
-fdl_@NAME@ (call_frame_t *frame, xlator_t *this,
-            @LONG_ARGS@)
-{
-        call_stub_t     *stub;
-
-        stub = fop_@NAME@_stub (frame, default_@NAME@,
-                                @SHORT_ARGS@);
-		fdl_len_@NAME@ (stub);
-        stub->serialize = fdl_serialize_@NAME@;
-        fdl_enqueue (this, stub);
-
-        return 0;
-}
-"""
-
-LEN_DICT_TEMPLATE = """
-		if (@SRC@) {
-			data_pair_t *memb;
-			for (memb = @SRC@->members_list; memb; memb = memb->next) {
-				meta_len += sizeof(int);
-				meta_len += strlen(memb->key) + 1;
-				meta_len += sizeof(int);
-				meta_len += memb->value->len;
-			}
-		}
-		meta_len += sizeof(int);
-"""
-
-LEN_GFID_TEMPLATE = """
-        meta_len += 16;
-"""
-
-LEN_INTEGER_TEMPLATE = """
-        meta_len += sizeof (@SRC@);
-"""
-
-# 16 for gfid, 16 for pargfid, 1 for flag, 0/1 for terminating NUL
-LEN_LOC_TEMPLATE = """
-        if (@SRC@.name) {
-                meta_len += (strlen (@SRC@.name) + 34);
-        } else {
-                meta_len += 33;
-        }
-"""
-
-LEN_STRING_TEMPLATE = """
-        if (@SRC@) {
-                meta_len += (strlen (@SRC@) + 1);
-        } else {
-                meta_len += 1;
-        }
-"""
-
-LEN_VECTOR_TEMPLATE = """
-        meta_len += sizeof(size_t);
-        data_len += iov_length (@VEC@, @CNT@);
-"""
-
-LEN_IATT_TEMPLATE = """
-		meta_len += sizeof(@SRC@.ia_prot);
-		meta_len += sizeof(@SRC@.ia_uid);
-		meta_len += sizeof(@SRC@.ia_gid);
-		meta_len += sizeof(@SRC@.ia_atime);
-		meta_len += sizeof(@SRC@.ia_atime_nsec);
-		meta_len += sizeof(@SRC@.ia_mtime);
-		meta_len += sizeof(@SRC@.ia_mtime_nsec);
-"""
-
-SERLZ_DICT_TEMPLATE = """
-        if (@SRC@) {
-			data_pair_t *memb;
-			for (memb = @SRC@->members_list; memb; memb = memb->next) {
-				*((int *)(meta_buf+offset)) = strlen(memb->key) + 1;
-				offset += sizeof(int);
-				strcpy (meta_buf+offset, memb->key);
-				offset += strlen(memb->key) + 1;
-				*((int *)(meta_buf+offset)) = memb->value->len;
-				offset += sizeof(int);
-				memcpy (meta_buf+offset, memb->value->data, memb->value->len);
-				offset += memb->value->len;
-			}
-        }
-		*((int *)(meta_buf+offset)) = 0;
-		offset += sizeof(int);
-"""
-
-SERLZ_GFID_TEMPLATE = """
-        memcpy (meta_buf+offset, @SRC@->inode->gfid, 16);
-        offset += 16;
-"""
-
-SERLZ_INTEGER_TEMPLATE = """
-        memcpy (meta_buf+offset, &@SRC@, sizeof(@SRC@));
-        offset += sizeof(@SRC@);
-"""
-
-SERLZ_LOC_TEMPLATE = """
-        memcpy (meta_buf+offset, @SRC@.gfid, 16);
-        offset += 16;
-        memcpy (meta_buf+offset, @SRC@.pargfid, 16);
-        offset += 16;
-        if (@SRC@.name) {
-                *(meta_buf+offset) = 1;
-				++offset;
-                strcpy (meta_buf+offset, @SRC@.name);
-                offset += (strlen (@SRC@.name) + 1);
-        } else {
-                *(meta_buf+offset) = 0;
-				++offset;
-        }
-"""
-
-SERLZ_STRING_TEMPLATE = """
-        if (@SRC@) {
-                *(meta_buf+offset) = 1;
-				++offset;
-                strcpy (meta_buf+offset, @SRC@);
-                offset += strlen(@SRC@);
-        } else {
-                *(meta_buf+offset) = 0;
-				++offset;
-        }
-"""
-
-SERLZ_VECTOR_TEMPLATE = """
-        *((size_t *)(meta_buf+offset)) = iov_length (@VEC@, @CNT@);
-        offset += sizeof(size_t);
-        int32_t i;
-        for (i = 0; i < @CNT@; ++i) {
-                memcpy (data_buf, @VEC@[i].iov_base, @VEC@[i].iov_len);
-                data_buf += @VEC@[i].iov_len;
-        }
-"""
-
-# We don't need to save all of the fields - only those affected by chown,
-# chgrp, chmod, and utime.
-SERLZ_IATT_TEMPLATE = """
-		*((ia_prot_t *)(meta_buf+offset)) = @SRC@.ia_prot;
-		offset += sizeof(@SRC@.ia_prot);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_uid;
-		offset += sizeof(@SRC@.ia_uid);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_gid;
-		offset += sizeof(@SRC@.ia_gid);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_atime;
-		offset += sizeof(@SRC@.ia_atime);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_atime_nsec;
-		offset += sizeof(@SRC@.ia_atime_nsec);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_mtime;
-		offset += sizeof(@SRC@.ia_mtime);
-		*((uint32_t *)(meta_buf+offset)) = @SRC@.ia_mtime_nsec;
-		offset += sizeof(@SRC@.ia_mtime_nsec);
-"""
-
-typemap = {
-	'dict_t *':				( LEN_DICT_TEMPLATE,	SERLZ_DICT_TEMPLATE),
-	'fd_t *':				( LEN_GFID_TEMPLATE,	SERLZ_GFID_TEMPLATE),
-	'dev_t':				( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'gf_xattrop_flags_t':	( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'int32_t':				( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'mode_t':				( LEN_INTEGER_TEMPLATE, SERLZ_INTEGER_TEMPLATE),
-	'off_t':				( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'size_t':				( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'uint32_t':				( LEN_INTEGER_TEMPLATE,	SERLZ_INTEGER_TEMPLATE),
-	'loc_t *':				( LEN_LOC_TEMPLATE,		SERLZ_LOC_TEMPLATE),
-	'const char *':			( LEN_STRING_TEMPLATE,	SERLZ_STRING_TEMPLATE),
-	'struct iatt *':		( LEN_IATT_TEMPLATE,	SERLZ_IATT_TEMPLATE),
-}
-
-def get_special_subs (args):
-	len_code = ""
-	ser_code = ""
-	for arg in args:
-		if (arg[0] != 'fop-arg') or (len(arg) < 4):
-			continue
-		# Let this throw an exception if we get an unknown field name.  The
-		# broken build will remind whoever messed with the stub code that a
-		# corresponding update is needed here.
-		if arg[3] == "vector":
-			# Make it as obvious as possible that this is a special case.
-			len_code += LEN_VECTOR_TEMPLATE \
-				.replace("@VEC@", "stub->args.vector") \
-				.replace("@CNT@", "stub->args.count")
-			ser_code += SERLZ_VECTOR_TEMPLATE \
-				.replace("@VEC@", "stub->args.vector") \
-				.replace("@CNT@", "stub->args.count")
-		else:
-			len_tmpl, ser_tmpl = typemap[arg[2]]
-			src = "stub->args.%s" % arg[3]
-			len_code += len_tmpl.replace("@SRC@", src)
-			ser_code += ser_tmpl.replace("@SRC@", src)
-	return len_code, ser_code
-
-# Mention those fops in the selective_generate table, for which
-# only a few common functions will be generated, and mention those
-# functions. Rest of the functions can be customized
-selective_generate = {
-		"ipc":			"len,serialize",
-	}
-
-def gen_fdl ():
-	entrypoints = []
-	for name, value in ops.items():
-		if "journal" not in [ x[0] for x in value ]:
-			continue
-
-		# generate all functions for all the fops
-		# except for the ones in selective_generate for which
-		# generate only the functions mentioned in the
-		# selective_generate table
-		gen_funcs = "len,serialize,callback,continue,fop"
-		if name in selective_generate:
-			gen_funcs = selective_generate[name].split(",")
-
-		len_code, ser_code = get_special_subs(value)
-		fop_subs[name]["@LEN_CODE@"] = len_code[:-1]
-		fop_subs[name]["@SER_CODE@"] = ser_code[:-1]
-		if 'len' in gen_funcs:
-			print(generate(LEN_TEMPLATE, name, fop_subs))
-		if 'serialize' in gen_funcs:
-			print(generate(SER_TEMPLATE, name, fop_subs))
-		if name == 'writev':
-			print("#define DESTAGE_ASYNC")
-		if 'callback' in gen_funcs:
-			print(generate(CBK_TEMPLATE, name, cbk_subs))
-		if 'continue' in gen_funcs:
-			print(generate(CONTINUE_TEMPLATE, name, fop_subs))
-		if 'fop' in gen_funcs:
-			print(generate(FOP_TEMPLATE, name, fop_subs))
-		if name == 'writev':
-			print("#undef DESTAGE_ASYNC")
-		entrypoints.append(name)
-	print("struct xlator_fops fops = {")
-	for ep in entrypoints:
-		print("\t.%s = fdl_%s," % (ep, ep))
-	print("};")
-
-for l in open(sys.argv[1], 'r').readlines():
-	if l.find('#pragma generate') != -1:
-		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
-		gen_fdl()
-		print("/* END GENERATED CODE */")
-	else:
-		print(l[:-1])
diff --git a/xlators/experimental/fdl/src/gen_recon.py b/xlators/experimental/fdl/src/gen_recon.py
deleted file mode 100755
index 0766f61320a..00000000000
--- a/xlators/experimental/fdl/src/gen_recon.py
+++ /dev/null
@@ -1,218 +0,0 @@
-#!/usr/bin/python3
-
-from __future__ import print_function
-import os
-import re
-import string
-import sys
-
-curdir = os.path.dirname (sys.argv[0])
-gendir = os.path.join (curdir, '../../../../libglusterfs/src')
-sys.path.append (gendir)
-from generator import ops, fop_subs, cbk_subs, generate
-
-# See the big header comment at the start of gen_fdl.py to see how the stages
-# fit together.  The big difference here is that *all* of the C code is in the
-# template file as labelled fragments, instead of as Python strings.  That
-# makes it much easier to edit in one place, with proper syntax highlighting
-# and indentation.
-#
-#   Stage 1 uses type-specific fragments to generate FUNCTION_BODY, instead of
-#   LEN_*_TEMPLATE and SERLZ_*_TEMPLATE to generate LEN_CODE and SER_CODE.
-#
-#   Stage 2 uses the FOP and CASE fragments instead of RECON_TEMPLATE and
-#   FOP_TEMPLATE.  The expanded FOP code (including FUNCTION_BODY substitution
-#   in the middle of each function) is emitted immediately; the expanded CASE
-#   code is saved for the next stage.
-#
-#   Stage 3 uses the PROLOG and EPILOG fragments, with the expanded CASE code
-#   in the middle of EPILOG, to generate the whole output file.
-#
-# Another way of looking at it is to consider how the fragments appear in
-# the final output:
-#
-#   PROLOG
-#   FOP (expanded for CREATE)
-#       FOP before FUNCTION_BODY
-#       LOC, INTEGER, GFID, etc. (one per arg, by type)
-#       FOP after FUNCTION_BODY
-#   FOP (expanded for WRITEV)
-#       FOP before FUNCTION_BODY
-#       GFID, VECTOR, etc. (one per arg, by type)
-#       FOP after FUNCTION_BODY
-#   (more FOPs)
-#   EPILOG
-#       EPILOG before CASE
-#       CASE statements (one per fop)
-#       EPILOG after CASE
-
-typemap = {
-	'dict_t *':				"DICT",
-	'fd_t *':				"FD",
-	'dev_t':				"DOUBLE",
-	'gf_xattrop_flags_t':	"INTEGER",
-	'int32_t':				"INTEGER",
-	'mode_t':				"INTEGER",
-	'off_t':				"DOUBLE",
-	'size_t':				"DOUBLE",
-	'uint32_t':				"INTEGER",
-	'loc_t *':				"LOC",
-	'const char *':			"STRING",
-	'struct iovec *':		"VECTOR",
-	'struct iatt *':		"IATT",
-	'struct iobref *':		"IOBREF",
-}
-
-def get_special_subs (name, args, fop_type):
-	code = ""
-	cleanups = ""
-	links = ""
-	s_args = []
-	for arg in args:
-		if arg[0] == 'extra':
-			code += "\t%s %s;\n\n" % (arg[2], arg[1])
-			s_args.append(arg[3])
-			continue
-		if arg[0] == 'link':
-			links += fragments["LINK"].replace("@INODE_ARG@", arg[1])	\
-									  .replace("@IATT_ARG@", arg[2])
-			continue
-		if arg[0] != 'fop-arg':
-			continue
-		if (name, arg[1]) == ('writev', 'count'):
-			# Special case: just skip this.  We can't mark it as 'nosync'
-			# because of the way the translator and dumper generators look for
-			# that after 'stub-name' which we don't define.  Instead of adding a
-			# bunch of generic infrastructure for this one case, just pound it
-			# here.
-			continue
-		recon_type = typemap[arg[2]]
-		# print "/* %s.%s => %s (%s)*/" % (name, arg[1], recon_type, fop_type)
-		if (name == "create") and (arg[1] == "fd"):
-			# Special case: fd for create is new, not looked up.
-			# print "/* change to NEW_FD */"
-			recon_type = "NEW_FD"
-		elif (recon_type == "LOC") and (fop_type == "entry-op"):
-			# Need to treat this differently for inode vs. entry ops.
-			# Special case: link source is treated like inode-op.
-			if (name != "link") or (arg[1] != "oldloc"):
-				# print "/* change to PARENT_LOC */"
-				recon_type = "PARENT_LOC"
-		code += fragments[recon_type].replace("@ARGNAME@", arg[1])		\
-									 .replace("@ARGTYPE@", arg[2])
-		cleanup_key = recon_type + "_CLEANUP"
-		if cleanup_key in fragments:
-			new_frag = fragments[cleanup_key].replace("@ARGNAME@", arg[1])
-			# Make sure these get added in *reverse* order.  Otherwise, a
-			# failure for an earlier argument might goto a label that falls
-			# through to the cleanup code for a variable associated with a
-			# later argument, but that variable might not even have been
-			# *declared* (let alone initialized) yet.  Consider the following
-			# case.
-			#
-			#         process argument A (on failure goto cleanup_A)
-			#         set error label to cleanup_A
-			#
-			#         declare pointer variable for argument B
-			#         process argument B (on failure goto cleanup_B)
-			#
-			#     cleanup_A:
-			#         /* whatever */
-			#     cleanup_B:
-			#         free pointer variable <= "USED BUT NOT SET" error here
-			#
-			# By adding these in reverse order, we ensure that cleanup_B is
-			# actually *before* cleanup_A, and nothing will try to do the free
-			# until we've actually attempted processing of B.
-			cleanups = new_frag + cleanups
-		if 'nosync' in arg[4:]:
-			code += "\t(void)%s;\n" % arg[1];
-			continue
-		if arg[2] in ("loc_t *", "struct iatt *"):
-			# These are passed as pointers to the syncop, but they're actual
-			# structures in the generated code.
-			s_args.append("&"+arg[1]);
-		else:
-			s_args.append(arg[1])
-	# We have to handle a couple of special cases here, because some n00b
-	# defined the syncops with a different argument order than the fops they're
-	# based on.
-	if name == 'writev':
-		# Swap 'flags' and 'iobref'.  Also, we need to add the iov count, which
-		# is not stored in or read from the journal.  There are other ways to
-		# do that, but this is the only place we need anything similar and we
-		# already have to treat it as a special case so this is simplest.
-	       s_args_str = 'fd, &vector, 1, off, iobref, flags, &preop, &postop, xdata'
-	elif name == 'symlink':
-		# Swap 'linkpath' and 'loc'.
-		s_args_str = '&loc, linkpath, &iatt, xdata'
-	elif name == 'xattrop':
-	        s_args_str = '&loc, flags, dict, xdata, NULL'
-	elif name == 'fxattrop':
-	        s_args_str = 'fd, flags, dict, xdata, NULL'
-	else:
-		s_args_str = ', '.join(s_args)
-	return code, links, s_args_str, cleanups
-
-# TBD: probably need to generate type-specific cleanup code as well - e.g.
-# fd_unref for an fd_t, loc_wipe for a loc_t, and so on.  All of these
-# generated CLEANUP fragments will go at the end of the function, with goto
-# labels.  Meanwhile, the error-checking part of each type-specific fragment
-# (e.g. LOC or FD) will need to update the indirect label that we jump to when
-# an error is detected.  This will probably get messy.
-def gen_functions ():
-	code = ""
-	for name, value in ops.items():
-		fop_type = [ x[1] for x in value if x[0] == "journal" ]
-		if not fop_type:
-			continue
-		body, links, syncop_args, cleanups = get_special_subs (name, value,
-															   fop_type[0])
-		fop_subs[name]["@FUNCTION_BODY@"] = body
-		fop_subs[name]["@LINKS@"] = links
-		fop_subs[name]["@SYNCOP_ARGS@"] = syncop_args
-		fop_subs[name]["@CLEANUPS@"] = cleanups
-		if name == "writev":
-			# Take advantage of the fact that, *during reconciliation*, the
-			# vector is always a single element.  In normal I/O it's not.
-			fop_subs[name]["@SUCCESS_VALUE@"] = "vector.iov_len"
-		else:
-			fop_subs[name]["@SUCCESS_VALUE@"] = "GFAPI_SUCCESS"
-		# Print the FOP fragment with @FUNCTION_BODY@ in the middle.
-		code += generate(fragments["FOP"], name, fop_subs)
-	return code
-
-def gen_cases ():
-	code = ""
-	for name, value in ops.items():
-		if "journal" not in [ x[0] for x in value ]:
-			continue
-		# Add the CASE fragment for this fop.
-		code += generate(fragments["CASE"], name, fop_subs)
-	return code
-
-def load_fragments (path="recon-tmpl.c"):
-	pragma_re = re.compile('pragma fragment (.*)')
-	cur_symbol = None
-	cur_value = ""
-	result = {}
-	for line in open(path, "r").readlines():
-		m = pragma_re.search(line)
-		if m:
-			if cur_symbol:
-				result[cur_symbol] = cur_value
-			cur_symbol = m.group(1)
-			cur_value = ""
-		else:
-			cur_value += line
-	if cur_symbol:
-		result[cur_symbol] = cur_value
-	return result
-
-if __name__ == "__main__":
-	fragments = load_fragments(sys.argv[1])
-	print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
-	print(fragments["PROLOG"])
-	print(gen_functions())
-	print(fragments["EPILOG"].replace("@SWITCH_BODY@", gen_cases()))
-	print("/* END GENERATED CODE */")
diff --git a/xlators/experimental/fdl/src/logdump.c b/xlators/experimental/fdl/src/logdump.c
deleted file mode 100644
index 6fbc5218d47..00000000000
--- a/xlators/experimental/fdl/src/logdump.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-extern int
-fdl_dump(char **, char **);
-
-int
-main(int argc, char **argv)
-{
-    int meta_fd = (-1);
-    char *meta_buf = NULL;
-    int data_fd = (-1);
-    char *data_buf = NULL;
-
-    meta_fd = open(argv[1], O_RDONLY);
-    if (meta_fd < 0) {
-        perror("open");
-        return EXIT_FAILURE;
-    }
-
-    /* TBD: get proper length */
-    meta_buf = mmap(NULL, 1048576, PROT_READ, MAP_PRIVATE, meta_fd, 0);
-    if (meta_buf == MAP_FAILED) {
-        perror("mmap");
-        return EXIT_FAILURE;
-    }
-
-    data_fd = open(argv[2], O_RDONLY);
-    if (data_fd < 0) {
-        perror("open");
-        return EXIT_FAILURE;
-    }
-
-    /* TBD: get proper length */
-    data_buf = mmap(NULL, 1048576, PROT_READ, MAP_PRIVATE, data_fd, 0);
-    if (data_buf == MAP_FAILED) {
-        perror("mmap");
-        return EXIT_FAILURE;
-    }
-
-    for (;;) {
-        if (!fdl_dump(&meta_buf, &data_buf)) {
-            break;
-        }
-    }
-
-    return EXIT_SUCCESS;
-}
diff --git a/xlators/experimental/fdl/src/recon-tmpl.c.in b/xlators/experimental/fdl/src/recon-tmpl.c.in
deleted file mode 100644
index 5115dfd5c75..00000000000
--- a/xlators/experimental/fdl/src/recon-tmpl.c.in
+++ /dev/null
@@ -1,297 +0,0 @@
-#pragma fragment PROLOG
-#ifndef _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif
-
-#include "glusterfs.h"
-#include "iatt.h"
-#include "syncop.h"
-#include "xlator.h"
-#include "glfs-internal.h"
-
-#include "fdl.h"
-
-#define GFAPI_SUCCESS 0
-
-inode_t *
-recon_get_inode(glfs_t *fs, uuid_t gfid)
-{
-    inode_t *inode;
-    loc_t loc = {
-        NULL,
-    };
-    struct iatt iatt;
-    int ret;
-    inode_t *newinode;
-
-    inode = inode_find(fs->active_subvol->itable, gfid);
-    if (inode) {
-        printf("=== FOUND %s IN TABLE\n", uuid_utoa(gfid));
-        return inode;
-    }
-
-    loc.inode = inode_new(fs->active_subvol->itable);
-    if (!loc.inode) {
-        return NULL;
-    }
-    gf_uuid_copy(loc.inode->gfid, gfid);
-    gf_uuid_copy(loc.gfid, gfid);
-
-    printf("=== DOING LOOKUP FOR %s\n", uuid_utoa(gfid));
-
-    ret = syncop_lookup(fs->active_subvol, &loc, &iatt, NULL, NULL, NULL);
-    if (ret != GFAPI_SUCCESS) {
-        fprintf(stderr, "syncop_lookup failed (%d)\n", ret);
-        return NULL;
-    }
-
-    newinode = inode_link(loc.inode, NULL, NULL, &iatt);
-    if (newinode) {
-        inode_lookup(newinode);
-    }
-
-    return newinode;
-}
-
-#pragma fragment DICT
-dict_t *@ARGNAME@;
-
-@ARGNAME@ = dict_new();
-if (!@ARGNAME@) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-
-{
-    int key_len, data_len;
-    char *key_ptr;
-    int garbage;
-    for (;;) {
-        key_len = *((int *)new_meta);
-        new_meta += sizeof(int);
-        if (!key_len) {
-            break;
-        }
-        key_ptr = new_meta;
-        new_meta += key_len;
-        data_len = *((int *)new_meta);
-        new_meta += sizeof(int);
-        garbage = dict_set_static_bin(@ARGNAME@, key_ptr, new_meta, data_len);
-        /* TBD: check error from dict_set_static_bin */
-        (void)garbage;
-        new_meta += data_len;
-    }
-}
-
-#pragma fragment DICT_CLEANUP
-cleanup_@ARGNAME@ : dict_unref(@ARGNAME@);
-
-#pragma fragment DOUBLE
-@ARGTYPE@ @ARGNAME@ = *((@ARGTYPE@ *)new_meta);
-new_meta += sizeof(uint64_t);
-
-#pragma fragment FD
-inode_t *@ARGNAME@_ino;
-fd_t *@ARGNAME@;
-
-@ARGNAME@_ino = recon_get_inode(fs, *((uuid_t *)new_meta));
-new_meta += 16;
-if (!@ARGNAME@_ino) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@_ino;
-
-@ARGNAME@ = fd_anonymous(@ARGNAME@_ino);
-if (!@ARGNAME@) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-
-#pragma fragment FD_CLEANUP
-cleanup_@ARGNAME@ : fd_unref(@ARGNAME@);
-cleanup_@ARGNAME@_ino : inode_unref(@ARGNAME@_ino);
-
-#pragma fragment NEW_FD
-/*
- * This pseudo-type is only used for create, and in that case we know
- * we'll be using loc.inode, so it's not worth generalizing to take an
- * extra argument.
- */
-fd_t *@ARGNAME@ = fd_anonymous(loc.inode);
-
-if (!fd) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-new_meta += 16;
-
-#pragma fragment NEW_FD_CLEANUP
-cleanup_@ARGNAME@ : fd_unref(@ARGNAME@);
-
-#pragma fragment INTEGER
-@ARGTYPE@ @ARGNAME@ = *((@ARGTYPE@ *)new_meta);
-
-new_meta += sizeof(@ARGTYPE@);
-
-#pragma fragment LOC
-loc_t @ARGNAME@ = {
-    NULL,
-};
-
-@ARGNAME@.inode = recon_get_inode(fs, *((uuid_t *)new_meta));
-if (!@ARGNAME@.inode) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-gf_uuid_copy(@ARGNAME@.gfid, @ARGNAME@.inode->gfid);
-new_meta += 16;
-new_meta += 16; /* skip over pargfid */
-if (*(new_meta++)) {
-    @ARGNAME@.name = new_meta;
-    new_meta += strlen(new_meta) + 1;
-}
-
-#pragma fragment LOC_CLEANUP
-cleanup_@ARGNAME@ : loc_wipe(&@ARGNAME@);
-
-#pragma fragment PARENT_LOC
-loc_t @ARGNAME@ = {
-    NULL,
-};
-
-new_meta += 16; /* skip over gfid */
-@ARGNAME@.parent = recon_get_inode(fs, *((uuid_t *)new_meta));
-if (!@ARGNAME@.parent) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-gf_uuid_copy(@ARGNAME@.pargfid, @ARGNAME@.parent->gfid);
-new_meta += 16;
-if (!*(new_meta++)) {
-    goto *err_label;
-}
-@ARGNAME@.name = new_meta;
-new_meta += strlen(new_meta) + 1;
-
-@ARGNAME@.inode = inode_new(fs->active_subvol->itable);
-if (!@ARGNAME@.inode) {
-    goto *err_label;
-}
-
-#pragma fragment PARENT_LOC_CLEANUP
-cleanup_@ARGNAME@ : loc_wipe(&@ARGNAME@);
-
-#pragma fragment STRING
-char *@ARGNAME@;
-if (*(new_meta++)) {
-    @ARGNAME@ = new_meta;
-    new_meta += (strlen(new_meta) + 1);
-} else {
-    goto *err_label;
-}
-
-#pragma fragment VECTOR
-struct iovec @ARGNAME@;
-
-@ARGNAME@.iov_len = *((size_t *)new_meta);
-new_meta += sizeof(@ARGNAME@.iov_len);
-@ARGNAME@.iov_base = new_data;
-new_data += @ARGNAME@.iov_len;
-
-#pragma fragment IATT
-struct iatt @ARGNAME@;
-{
-    @ARGNAME@.ia_prot = *((ia_prot_t *)new_meta);
-    new_meta += sizeof(ia_prot_t);
-    uint32_t *myints = (uint32_t *)new_meta;
-    @ARGNAME@.ia_uid = myints[0];
-    @ARGNAME@.ia_gid = myints[1];
-    @ARGNAME@.ia_atime = myints[2];
-    @ARGNAME@.ia_atime_nsec = myints[3];
-    @ARGNAME@.ia_mtime = myints[4];
-    @ARGNAME@.ia_mtime_nsec = myints[5];
-    new_meta += sizeof(*myints) * 6;
-}
-
-#pragma fragment IOBREF
-struct iobref *@ARGNAME@;
-
-@ARGNAME@ = iobref_new();
-if (!@ARGNAME@) {
-    goto *err_label;
-}
-err_label = &&cleanup_@ARGNAME@;
-
-#pragma fragment IOBREF_CLEANUP
-cleanup_@ARGNAME@ : iobref_unref(@ARGNAME@);
-
-#pragma fragment LINK
-/* TBD: check error */
-inode_t *new_inode = inode_link(@INODE_ARG@, NULL, NULL, @IATT_ARG@);
-if (new_inode) {
-    inode_lookup(new_inode);
-}
-
-#pragma fragment FOP
-int fdl_replay_@NAME@(glfs_t *fs, char **old_meta, char **old_data)
-{
-    char *new_meta = *old_meta;
-    char *new_data = *old_data;
-    int ret;
-    int status = 0xbad;
-    void *err_label = &&done;
-
-    @FUNCTION_BODY@
-
-    ret = syncop_@NAME@(fs->active_subvol, @SYNCOP_ARGS@, NULL);
-    if (ret !=@SUCCESS_VALUE@) {
-        fprintf(stderr, "syncop_@NAME@ returned %d", ret);
-        goto *err_label;
-    }
-
-    @LINKS@
-
-    status = 0;
-
-    @CLEANUPS@
-
-     done : *old_meta = new_meta;
-    *old_data = new_data;
-    return status;
-}
-
-#pragma fragment CASE
-case GF_FOP_@UPNAME@:
-    printf("=== GF_FOP_@UPNAME@\n");
-    if (fdl_replay_@NAME@(fs, &new_meta, &new_data) != 0) {
-        goto done;
-    }
-    recognized = 1;
-    break;
-
-#pragma fragment EPILOG
-    int
-    recon_execute(glfs_t *fs, char **old_meta, char **old_data)
-    {
-        char *new_meta = *old_meta;
-        char *new_data = *old_data;
-        int recognized = 0;
-        event_header_t *eh;
-
-        eh = (event_header_t *)new_meta;
-        new_meta += sizeof(*eh);
-
-        /* TBD: check event_type instead of assuming NEW_REQUEST */
-
-        switch (eh->fop_type) {
-            @SWITCH_BODY@
-
-            default : printf("unknown fop %u\n", eh->fop_type);
-        }
-
-    done:
-        *old_meta = new_meta;
-        *old_data = new_data;
-        return recognized;
-    }
diff --git a/xlators/experimental/fdl/src/recon.c b/xlators/experimental/fdl/src/recon.c
deleted file mode 100644
index 51c57d4ac22..00000000000
--- a/xlators/experimental/fdl/src/recon.c
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/fd.h>
-#include <glusterfs/syncop.h>
-#include "glfs-internal.h"
-
-#define GFAPI_SUCCESS 0
-
-extern int
-recon_execute(glfs_t *, char **, char **);
-
-int
-main(int argc, char **argv)
-{
-    glfs_t *fs;
-    int ret;
-    int meta_fd = (-1);
-    char *meta_buf = NULL;
-    int data_fd = (-1);
-    char *data_buf = NULL;
-
-    fs = glfs_new("whocares");
-    if (!fs) {
-        fprintf(stderr, "glfs_new failed\n");
-        return EXIT_FAILURE;
-    }
-
-    if (getenv("RECON_DEBUG")) {
-        ret = glfs_set_logging(fs, "/dev/stderr", 7);
-    } else {
-        ret = glfs_set_logging(fs, "/dev/null", 0);
-    }
-
-    if (ret != GFAPI_SUCCESS) {
-        fprintf(stderr, "glfs_set_logging failed (%d)\n", errno);
-        return EXIT_FAILURE;
-    }
-
-    ret = glfs_set_volfile(fs, argv[1]);
-    if (ret != GFAPI_SUCCESS) {
-        fprintf(stderr, "glfs_set_volfile failed (%d)\n", errno);
-        return EXIT_FAILURE;
-    }
-
-    ret = glfs_init(fs);
-    if (ret != GFAPI_SUCCESS) {
-        fprintf(stderr, "glfs_init failed (%d)\n", errno);
-        return EXIT_FAILURE;
-    }
-
-    meta_fd = open(argv[2], O_RDONLY);
-    if (meta_fd < 0) {
-        perror("open");
-        return EXIT_FAILURE;
-    }
-
-    /* TBD: get proper length */
-    meta_buf = mmap(NULL, 1048576, PROT_READ, MAP_PRIVATE, meta_fd, 0);
-    if (meta_buf == MAP_FAILED) {
-        perror("mmap");
-        return EXIT_FAILURE;
-    }
-
-    data_fd = open(argv[3], O_RDONLY);
-    if (data_fd < 0) {
-        perror("open");
-        return EXIT_FAILURE;
-    }
-
-    /* TBD: get proper length */
-    data_buf = mmap(NULL, 1048576, PROT_READ, MAP_PRIVATE, data_fd, 0);
-    if (data_buf == MAP_FAILED) {
-        perror("mmap");
-        return EXIT_FAILURE;
-    }
-
-    for (;;) {
-        if (!recon_execute(fs, &meta_buf, &data_buf)) {
-            break;
-        }
-    }
-
-    return EXIT_SUCCESS;
-}
diff --git a/xlators/experimental/jbr-client/Makefile.am b/xlators/experimental/jbr-client/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/jbr-client/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/jbr-client/src/Makefile.am b/xlators/experimental/jbr-client/src/Makefile.am
deleted file mode 100644
index c71f5ff1e83..00000000000
--- a/xlators/experimental/jbr-client/src/Makefile.am
+++ /dev/null
@@ -1,34 +0,0 @@
-if WITH_SERVER
-xlator_LTLIBRARIES = jbrc.la
-endif
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-
-nodist_jbrc_la_SOURCES = jbrc-cg.c
-CLEANFILES = $(nodist_jbrc_la_SOURCES)
-
-jbrc_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-jbrc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-noinst_HEADERS = $(top_srcdir)/xlators/lib/src/libxlator.h \
-	$(top_srcdir)/glusterfsd/src/glusterfsd.h \
-	jbrc.h jbr-messages.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/xlators/lib/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
-	-I$(top_srcdir)/rpc/rpc-lib/src
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-JBRC_PREFIX	= $(top_srcdir)/xlators/experimental/jbr-client/src
-JBRC_GEN_FOPS	= $(JBRC_PREFIX)/gen-fops.py
-JBRC_TEMPLATES	= $(JBRC_PREFIX)/fop-template.c.in
-JBRC_WRAPPER	= $(JBRC_PREFIX)/jbrc.c
-noinst_PYTHON	= $(JBRC_GEN_FOPS)
-EXTRA_DIST	= $(JBRC_TEMPLATES) $(JBRC_WRAPPER)
-
-jbrc-cg.c: $(JBRC_GEN_FOPS) $(JBRC_TEMPLATES) $(JBRC_WRAPPER)
-	$(PYTHON) $(JBRC_GEN_FOPS) $(JBRC_TEMPLATES) $(JBRC_WRAPPER) > $@
-
-uninstall-local:
-	rm -f $(DESTDIR)$(xlatordir)/jbr.so
diff --git a/xlators/experimental/jbr-client/src/fop-template.c.in b/xlators/experimental/jbr-client/src/fop-template.c.in
deleted file mode 100644
index 9732badc794..00000000000
--- a/xlators/experimental/jbr-client/src/fop-template.c.in
+++ /dev/null
@@ -1,102 +0,0 @@
-/* template-name fop */
-int32_t jbrc_@NAME@(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    jbrc_local_t *local = NULL;
-    xlator_t *target_xl = ACTIVE_CHILD(this);
-
-    local = mem_get(this->local_pool);
-    if (!local) {
-        goto err;
-    }
-
-    local->stub = fop_@NAME@_stub(frame, jbrc_@NAME@_continue, @SHORT_ARGS@);
-    if (!local->stub) {
-        goto err;
-    }
-    local->curr_xl = target_xl;
-    local->scars = 0;
-
-    frame->local = local;
-    STACK_WIND_COOKIE(frame, jbrc_@NAME@_cbk, target_xl, target_xl,
-                      target_xl->fops->@NAME@, @SHORT_ARGS@);
-    return 0;
-
-err:
-    if (local) {
-        mem_put(local);
-    }
-    STACK_UNWIND_STRICT(@NAME@, frame, -1, ENOMEM, @ERROR_ARGS@);
-    return 0;
-}
-
-/* template-name cbk */
-int32_t jbrc_@NAME@_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                          int32_t op_ret, int32_t op_errno, @LONG_ARGS@)
-{
-    jbrc_local_t *local = frame->local;
-    xlator_t *last_xl = cookie;
-    xlator_t *next_xl;
-    jbrc_private_t *priv = this->private;
-    struct timespec spec;
-
-    if (op_ret != (-1)) {
-        if (local->scars) {
-            gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_RETRY_MSG,
-                   HILITE("retried %p OK"), frame->local);
-        }
-        priv->active = last_xl;
-        goto unwind;
-    }
-    if ((op_errno != EREMOTE) && (op_errno != ENOTCONN)) {
-        goto unwind;
-    }
-
-    /* TBD: get leader ID from xdata? */
-    next_xl = next_xlator(this, last_xl);
-    /*
-     * We can't just give up after we've tried all bricks, because it's
-     * quite likely that a new leader election just hasn't finished yet.
-     * We also shouldn't retry endlessly, and especially not at a high
-     * rate, but that's good enough while we work on other things.
-     *
-     * TBD: implement slow/finite retry via a worker thread
-     */
-    if (!next_xl || (local->scars >= SCAR_LIMIT)) {
-        gf_msg(this->name, GF_LOG_DEBUG, 0, J_MSG_RETRY_MSG,
-               HILITE("ran out of retries for %p"), frame->local);
-        goto unwind;
-    }
-
-    local->curr_xl = next_xl;
-    local->scars += 1;
-    spec.tv_sec = 1;
-    spec.tv_nsec = 0;
-    /*
-     * WARNING
-     *
-     * Just calling gf_timer_call_after like this leaves open the
-     * possibility that writes will get reordered, if a first write is
-     * rescheduled and then a second comes along to find an updated
-     * priv->active before the first actually executes.  We might need to
-     * implement a stricter (and more complicated) queuing mechanism to
-     * ensure absolute consistency in this case.
-     */
-    if (gf_timer_call_after(this->ctx, spec, jbrc_retry_cb, local)) {
-        return 0;
-    }
-
-unwind:
-    call_stub_destroy(local->stub);
-    STACK_UNWIND_STRICT(@NAME@, frame, op_ret, op_errno, @SHORT_ARGS@);
-    return 0;
-}
-
-/* template-name cont-func */
-int32_t jbrc_@NAME@_continue(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    jbrc_local_t *local = frame->local;
-
-    STACK_WIND_COOKIE(frame, jbrc_@NAME@_cbk, local->curr_xl, local->curr_xl,
-                      local->curr_xl->fops->@NAME@, @SHORT_ARGS@);
-    return 0;
-}
diff --git a/xlators/experimental/jbr-client/src/gen-fops.py b/xlators/experimental/jbr-client/src/gen-fops.py
deleted file mode 100755
index a5ddf577fbe..00000000000
--- a/xlators/experimental/jbr-client/src/gen-fops.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/python3
-
-from __future__ import print_function
-import os
-import re
-import string
-import sys
-
-curdir = os.path.dirname(sys.argv[0])
-gendir = os.path.join(curdir, '../../../../libglusterfs/src')
-sys.path.append(gendir)
-from generator import ops, fop_subs, cbk_subs, generate
-
-# We really want the callback argument list, even when we're generating fop
-# code, so we propagate here.
-# TBD: this should probably be right in generate.py
-for k, v in cbk_subs.items():
-	fop_subs[k]['@ERROR_ARGS@'] = v['@ERROR_ARGS@']
-
-# Stolen from old codegen.py
-def load_templates (path):
-	templates = {}
-	tmpl_re = re.compile("/\* template-name (.*) \*/")
-	templates = {}
-	t_name = None
-	for line in open(path, "r").readlines():
-		if not line:
-			break
-		m = tmpl_re.match(line)
-		if m:
-			if t_name:
-				templates[t_name] = ''.join(t_contents)
-			t_name = m.group(1).strip()
-			t_contents = []
-		elif t_name:
-			t_contents.append(line)
-	if t_name:
-		templates[t_name] = ''.join(t_contents)
-	return templates
-
-# Stolen from gen_fdl.py
-def gen_client (templates):
-	for name, value in ops.items():
-		if name == 'getspec':
-			# It's not real if it doesn't have a stub function.
-			continue
-		print(generate(templates['cbk'], name, cbk_subs))
-		print(generate(templates['cont-func'], name, fop_subs))
-		print(generate(templates['fop'], name, fop_subs))
-
-tmpl = load_templates(sys.argv[1])
-for l in open(sys.argv[2], 'r').readlines():
-	if l.find('#pragma generate') != -1:
-		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
-		gen_client(tmpl)
-		print("/* END GENERATED CODE */")
-	else:
-		print(l[:-1])
diff --git a/xlators/experimental/jbr-client/src/jbr-messages.h b/xlators/experimental/jbr-client/src/jbr-messages.h
deleted file mode 100644
index 608e024f920..00000000000
--- a/xlators/experimental/jbr-client/src/jbr-messages.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-  Copyright (c) 2015 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 _JBR_MESSAGES_H_
-#define _JBR_MESSAGES_H_
-
-#include <glusterfs/glfs-message-id.h>
-
-/* To add new message IDs, append new identifiers at the end of the list.
- *
- * Never remove a message ID. If it's not used anymore, you can rename it or
- * leave it as it is, but not delete it. This is to prevent reutilization of
- * IDs by other messages.
- *
- * The component name must match one of the entries defined in
- * glfs-message-id.h.
- */
-
-GLFS_MSGID(JBR, J_MSG_INIT_FAIL, J_MSG_RETRY_MSG, J_MSG_MEM_ERR, J_MSG_DICT_FLR,
-           J_MSG_GENERIC, J_MSG_INVALID, J_MSG_NO_DATA, J_MSG_SYS_CALL_FAILURE,
-           J_MSG_QUORUM_NOT_MET, J_MSG_LOCK_FAILURE);
-
-#endif /* _JBR_MESSAGES_H_ */
diff --git a/xlators/experimental/jbr-client/src/jbrc.c b/xlators/experimental/jbr-client/src/jbrc.c
deleted file mode 100644
index 5c58a1efa99..00000000000
--- a/xlators/experimental/jbr-client/src/jbrc.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
-  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
-
-  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 _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif
-
-#include <glusterfs/call-stub.h>
-#include <glusterfs/defaults.h>
-#include <glusterfs/timer.h>
-#include <glusterfs/xlator.h>
-#include "jbr-messages.h"
-#include "jbrc.h"
-#include <glusterfs/statedump.h>
-
-#define SCAR_LIMIT 20
-#define HILITE(x) ("" x "")
-
-/*
- * The fops are actually generated by gen-fops.py; the rest was mostly copied
- * from defaults.c (commit cd253754 on 27 August 2013).
- */
-
-enum gf_dht_mem_types_ {
-    gf_mt_jbrc_private_t = gf_common_mt_end + 1,
-    gf_mt_jbrc_end
-};
-
-char *JBRC_XATTR = "user.jbr.active";
-
-static inline xlator_t *
-ACTIVE_CHILD(xlator_t *parent)
-{
-    jbrc_private_t *priv = parent->private;
-
-    return priv ? priv->active : FIRST_CHILD(parent);
-}
-
-xlator_t *
-next_xlator(xlator_t *this, xlator_t *prev)
-{
-    xlator_list_t *trav;
-
-    for (trav = this->children; trav; trav = trav->next) {
-        if (trav->xlator == prev) {
-            return trav->next ? trav->next->xlator : this->children->xlator;
-        }
-    }
-
-    return NULL;
-}
-
-void
-jbrc_retry_cb(void *cb_arg)
-{
-    jbrc_local_t *local = cb_arg;
-
-    gf_msg(__func__, GF_LOG_INFO, 0, J_MSG_RETRY_MSG, HILITE("retrying %p"),
-           local);
-    call_resume_wind(local->stub);
-}
-
-#pragma generate
-
-int32_t
-jbrc_forget(xlator_t *this, inode_t *inode)
-{
-    gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, J_MSG_INIT_FAIL,
-                     "xlator does not implement forget_cbk");
-    return 0;
-}
-
-int32_t
-jbrc_releasedir(xlator_t *this, fd_t *fd)
-{
-    gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, J_MSG_INIT_FAIL,
-                     "xlator does not implement releasedir_cbk");
-    return 0;
-}
-
-int32_t
-jbrc_release(xlator_t *this, fd_t *fd)
-{
-    gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, J_MSG_INIT_FAIL,
-                     "xlator does not implement release_cbk");
-    return 0;
-}
-
-struct xlator_fops fops = {
-    .lookup = jbrc_lookup,
-    .stat = jbrc_stat,
-    .fstat = jbrc_fstat,
-    .truncate = jbrc_truncate,
-    .ftruncate = jbrc_ftruncate,
-    .access = jbrc_access,
-    .readlink = jbrc_readlink,
-    .mknod = jbrc_mknod,
-    .mkdir = jbrc_mkdir,
-    .unlink = jbrc_unlink,
-    .rmdir = jbrc_rmdir,
-    .symlink = jbrc_symlink,
-    .rename = jbrc_rename,
-    .link = jbrc_link,
-    .create = jbrc_create,
-    .open = jbrc_open,
-    .readv = jbrc_readv,
-    .writev = jbrc_writev,
-    .flush = jbrc_flush,
-    .fsync = jbrc_fsync,
-    .opendir = jbrc_opendir,
-    .readdir = jbrc_readdir,
-    .readdirp = jbrc_readdirp,
-    .fsyncdir = jbrc_fsyncdir,
-    .statfs = jbrc_statfs,
-    .setxattr = jbrc_setxattr,
-    .getxattr = jbrc_getxattr,
-    .fsetxattr = jbrc_fsetxattr,
-    .fgetxattr = jbrc_fgetxattr,
-    .removexattr = jbrc_removexattr,
-    .fremovexattr = jbrc_fremovexattr,
-    .lk = jbrc_lk,
-    .inodelk = jbrc_inodelk,
-    .finodelk = jbrc_finodelk,
-    .entrylk = jbrc_entrylk,
-    .fentrylk = jbrc_fentrylk,
-    .rchecksum = jbrc_rchecksum,
-    .xattrop = jbrc_xattrop,
-    .fxattrop = jbrc_fxattrop,
-    .setattr = jbrc_setattr,
-    .fsetattr = jbrc_fsetattr,
-    .fallocate = jbrc_fallocate,
-    .discard = jbrc_discard,
-};
-
-struct xlator_cbks cbks = {};
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("jbrc", this, out);
-
-    ret = xlator_mem_acct_init(this, gf_mt_jbrc_end + 1);
-
-    if (ret != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, J_MSG_MEM_ERR,
-               "Memory accounting init failed");
-        return ret;
-    }
-out:
-    return ret;
-}
-
-int32_t
-jbrc_init(xlator_t *this)
-{
-    jbrc_private_t *priv = NULL;
-    xlator_list_t *trav = NULL;
-
-    this->local_pool = mem_pool_new(jbrc_local_t, 128);
-    if (!this->local_pool) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, J_MSG_MEM_ERR,
-               "failed to create jbrc_local_t pool");
-        goto err;
-    }
-
-    priv = GF_CALLOC(1, sizeof(*priv), gf_mt_jbrc_private_t);
-    if (!priv) {
-        goto err;
-    }
-
-    for (trav = this->children; trav; trav = trav->next) {
-        ++(priv->n_children);
-    }
-
-    priv->active = FIRST_CHILD(this);
-    this->private = priv;
-    return 0;
-
-err:
-    if (priv) {
-        GF_FREE(priv);
-    }
-    return -1;
-}
-
-void
-jbrc_fini(xlator_t *this)
-{
-    GF_FREE(this->private);
-}
-
-int
-jbrc_get_child_index(xlator_t *this, xlator_t *kid)
-{
-    xlator_list_t *trav;
-    int retval = -1;
-
-    for (trav = this->children; trav; trav = trav->next) {
-        ++retval;
-        if (trav->xlator == kid) {
-            return retval;
-        }
-    }
-
-    return -1;
-}
-
-uint8_t
-jbrc_count_up_kids(jbrc_private_t *priv)
-{
-    uint8_t retval = 0;
-    uint8_t i;
-
-    for (i = 0; i < priv->n_children; ++i) {
-        if (priv->kid_state & (1 << i)) {
-            ++retval;
-        }
-    }
-
-    return retval;
-}
-
-int32_t
-jbrc_notify(xlator_t *this, int32_t event, void *data, ...)
-{
-    int32_t ret = 0;
-    int32_t index = 0;
-    jbrc_private_t *priv = NULL;
-
-    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-
-    switch (event) {
-        case GF_EVENT_CHILD_UP:
-            index = jbrc_get_child_index(this, data);
-            if (index >= 0) {
-                priv->kid_state |= (1 << index);
-                priv->up_children = jbrc_count_up_kids(priv);
-                gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                       "got CHILD_UP for %s, now %u kids",
-                       ((xlator_t *)data)->name, priv->up_children);
-            }
-            ret = default_notify(this, event, data);
-            break;
-        case GF_EVENT_CHILD_DOWN:
-            index = jbrc_get_child_index(this, data);
-            if (index >= 0) {
-                priv->kid_state &= ~(1 << index);
-                priv->up_children = jbrc_count_up_kids(priv);
-                gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                       "got CHILD_DOWN for %s, now %u kids",
-                       ((xlator_t *)data)->name, priv->up_children);
-            }
-            break;
-        default:
-            ret = default_notify(this, event, data);
-    }
-
-out:
-    return ret;
-}
-
-int
-jbrc_priv_dump(xlator_t *this)
-{
-    jbrc_private_t *priv = NULL;
-    char key_prefix[GF_DUMP_MAX_BUF_LEN];
-    xlator_list_t *trav = NULL;
-    int32_t i = -1;
-
-    GF_VALIDATE_OR_GOTO(THIS->name, this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-
-    snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
-    gf_proc_dump_add_section("%s", key_prefix);
-
-    gf_proc_dump_write("up_children", "%u", priv->up_children);
-
-    for (trav = this->children, i = 0; trav; trav = trav->next, i++) {
-        snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "child_%d", i);
-        gf_proc_dump_write(key_prefix, "%s", trav->xlator->name);
-    }
-
-out:
-    return 0;
-}
-
-struct xlator_dumpops dumpops = {
-    .priv = jbrc_priv_dump,
-};
-
-class_methods_t class_methods = {
-    .init = jbrc_init,
-    .fini = jbrc_fini,
-    .notify = jbrc_notify,
-};
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/experimental/jbr-client/src/jbrc.h b/xlators/experimental/jbr-client/src/jbrc.h
deleted file mode 100644
index f99178402b3..00000000000
--- a/xlators/experimental/jbr-client/src/jbrc.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-  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 _JBRC_H_
-#define _JBRC_H_
-
-typedef struct {
-    xlator_t *active;
-    uint8_t up_children;
-    uint8_t n_children;
-    uint32_t kid_state;
-} jbrc_private_t;
-
-typedef struct {
-    call_stub_t *stub;
-    xlator_t *curr_xl;
-    uint16_t scars;
-} jbrc_local_t;
-
-#endif /* _JBRC_H_ */
diff --git a/xlators/experimental/jbr-server/Makefile.am b/xlators/experimental/jbr-server/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/jbr-server/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/jbr-server/src/Makefile.am b/xlators/experimental/jbr-server/src/Makefile.am
deleted file mode 100644
index 42d3c8a6c36..00000000000
--- a/xlators/experimental/jbr-server/src/Makefile.am
+++ /dev/null
@@ -1,39 +0,0 @@
-if WITH_SERVER
-xlator_LTLIBRARIES = jbr.la
-endif
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-
-nodist_jbr_la_SOURCES = jbr-cg.c
-CLEANFILES = $(nodist_jbr_la_SOURCES)
-
-jbr_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-jbr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-		$(top_builddir)/api/src/libgfapi.la
-
-noinst_HEADERS = jbr-internal.h \
-	$(top_srcdir)/xlators/lib/src/libxlator.h \
-	$(top_srcdir)/xlators/experimental/fdl/src/fdl.h \
-	$(top_srcdir)/glusterfsd/src/glusterfsd.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
-	-I$(top_srcdir)/xlators/lib/src -I$(top_srcdir)/rpc/rpc-lib/src \
-	-I$(top_srcdir)/xlators/experimental/fdl/src/ \
-	-DSBIN_DIR=\"$(sbindir)\" -I$(top_srcdir)/api/src \
-	-DJBR_SCRIPT_PREFIX=\"$(jbrdir)\" \
-	-I$(top_srcdir)/xlators/experimental/jbr-client/src/
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-JBR_PREFIX	= $(top_srcdir)/xlators/experimental/jbr-server/src
-JBR_GEN_FOPS	= $(JBR_PREFIX)/gen-fops.py
-JBR_TEMPLATES	= $(JBR_PREFIX)/all-templates.c.in
-JBR_WRAPPER	= $(JBR_PREFIX)/jbr.c
-noinst_PYTHON	= $(JBR_GEN_FOPS)
-EXTRA_DIST	= $(JBR_TEMPLATES) $(JBR_WRAPPER)
-
-jbr-cg.c: $(JBR_GEN_FOPS) $(JBR_TEMPLATES) $(JBR_WRAPPER)
-	$(PYTHON) $(JBR_GEN_FOPS) $(JBR_TEMPLATES) $(JBR_WRAPPER) > $@
-
-uninstall-local:
-	rm -f $(DESTDIR)$(xlatordir)/jbr.so
diff --git a/xlators/experimental/jbr-server/src/all-templates.c.in b/xlators/experimental/jbr-server/src/all-templates.c.in
deleted file mode 100644
index a9d57fc646f..00000000000
--- a/xlators/experimental/jbr-server/src/all-templates.c.in
+++ /dev/null
@@ -1,501 +0,0 @@
-/*
- * You can put anything here - it doesn't even have to be a comment - and it
- * will be ignored until we reach the first template-name comment.
- */
-
-/* template-name read-fop */
-int32_t jbr_@NAME@(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    jbr_private_t *priv = NULL;
-    gf_boolean_t in_recon = _gf_false;
-    int32_t op_errno = 0;
-    int32_t recon_term, recon_index;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, err);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, err);
-    GF_VALIDATE_OR_GOTO(this->name, frame, err);
-
-    op_errno = EREMOTE;
-
-    /* allow reads during reconciliation       *
-     * TBD: allow "dirty" reads on non-leaders *
-     */
-    if (xdata && (dict_get_int32(xdata, RECON_TERM_XATTR, &recon_term) == 0) &&
-        (dict_get_int32(xdata, RECON_INDEX_XATTR, &recon_index) == 0)) {
-        in_recon = _gf_true;
-    }
-
-    if ((!priv->leader) && (in_recon == _gf_false)) {
-        goto err;
-    }
-
-    STACK_WIND(frame, default_@NAME@_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->@NAME@, @SHORT_ARGS@);
-    return 0;
-
-err:
-    STACK_UNWIND_STRICT(@NAME@, frame, -1, op_errno, @ERROR_ARGS@);
-    return 0;
-}
-
-/* template-name read-perform_local_op */
-/* No "perform_local_op" function needed for @NAME@ */
-
-/* template-name read-dispatch */
-/* No "dispatch" function needed for @NAME@ */
-
-/* template-name read-call_dispatch */
-/* No "call_dispatch" function needed for @NAME@ */
-
-/* template-name read-fan-in */
-/* No "fan-in" function needed for @NAME@ */
-
-/* template-name read-continue */
-/* No "continue" function needed for @NAME@ */
-
-/* template-name read-complete */
-/* No "complete" function needed for @NAME@ */
-
-/* template-name write-fop */
-int32_t jbr_@NAME@(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-    int32_t ret = -1;
-    int op_errno = ENOMEM;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, err);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, err);
-    GF_VALIDATE_OR_GOTO(this->name, frame, err);
-
-#if defined(JBR_CG_NEED_FD)
-    ret = jbr_leader_checks_and_init(frame, this, &op_errno, xdata, fd);
-#else
-    ret = jbr_leader_checks_and_init(frame, this, &op_errno, xdata, NULL);
-#endif
-    if (ret)
-        goto err;
-
-    local = frame->local;
-
-    /*
-     * If we let it through despite not being the leader, then we just want
-     * to pass it on down without all of the additional xattrs, queuing, and
-     * so on.  However, jbr_*_complete does depend on the initialization
-     * immediately above this.
-     */
-    if (!priv->leader) {
-        STACK_WIND(frame, jbr_@NAME@_complete, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->@NAME@, @SHORT_ARGS@);
-        return 0;
-    }
-
-    ret = jbr_initialize_xdata_set_attrs(this, &xdata);
-    if (ret)
-        goto err;
-
-    local->xdata = dict_ref(xdata);
-    local->stub = fop_@NAME@_stub(frame, jbr_@NAME@_continue, @SHORT_ARGS@);
-    if (!local->stub) {
-        goto err;
-    }
-
-    /*
-     * Can be used to just call_dispatch or be customised per fop to *
-     * perform ops specific to that particular fop.                  *
-     */
-    ret = jbr_@NAME@_perform_local_op(frame, this, &op_errno, @SHORT_ARGS@);
-    if (ret)
-        goto err;
-
-    return ret;
-err:
-    if (local) {
-        if (local->stub) {
-            call_stub_destroy(local->stub);
-        }
-        if (local->qstub) {
-            call_stub_destroy(local->qstub);
-        }
-        if (local->fd) {
-            fd_unref(local->fd);
-        }
-        mem_put(local);
-    }
-    STACK_UNWIND_STRICT(@NAME@, frame, -1, op_errno, @ERROR_ARGS@);
-    return 0;
-}
-
-/* template-name write-perform_local_op */
-int32_t jbr_@NAME@_perform_local_op(call_frame_t *frame, xlator_t *this,
-                                    int *op_errno, @LONG_ARGS@)
-{
-    int32_t ret = -1;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    GF_VALIDATE_OR_GOTO(this->name, op_errno, out);
-
-    ret = jbr_@NAME@_call_dispatch(frame, this, op_errno, @SHORT_ARGS@);
-
-out:
-    return ret;
-}
-
-/* template-name write-call_dispatch */
-int32_t jbr_@NAME@_call_dispatch(call_frame_t *frame, xlator_t *this,
-                                 int *op_errno, @LONG_ARGS@)
-{
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-    int32_t ret = -1;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-    GF_VALIDATE_OR_GOTO(this->name, op_errno, out);
-
-#if defined(JBR_CG_QUEUE)
-    jbr_inode_ctx_t *ictx = jbr_get_inode_ctx(this, fd->inode);
-    if (!ictx) {
-        *op_errno = EIO;
-        goto out;
-    }
-
-    LOCK(&ictx->lock);
-    if (ictx->active) {
-        gf_msg_debug(this->name, 0, "queuing request due to conflict");
-        /*
-         * TBD: enqueue only for real conflict
-         *
-         * Currently we just act like all writes are in
-         * conflict with one another.  What we should really do
-         * is check the active/pending queues and defer only if
-         * there's a conflict there.
-         *
-         * It's important to check the pending queue because we
-         * might have an active request X which conflicts with
-         * a pending request Y, and this request Z might
-         * conflict with Y but not X.  If we checked only the
-         * active queue then Z could jump ahead of Y, which
-         * would be incorrect.
-         */
-        local->qstub = fop_@NAME@_stub(frame, jbr_@NAME@_dispatch,
-                                       @SHORT_ARGS@);
-        if (!local->qstub) {
-            UNLOCK(&ictx->lock);
-            goto out;
-        }
-        list_add_tail(&local->qlinks, &ictx->pqueue);
-        ++(ictx->pending);
-        UNLOCK(&ictx->lock);
-        ret = 0;
-        goto out;
-    } else {
-        list_add_tail(&local->qlinks, &ictx->aqueue);
-        ++(ictx->active);
-    }
-    UNLOCK(&ictx->lock);
-#endif
-    ret = jbr_@NAME@_dispatch(frame, this, @SHORT_ARGS@);
-
-out:
-    return ret;
-}
-
-/* template-name write-dispatch */
-int32_t jbr_@NAME@_dispatch(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-    int32_t ret = -1;
-    xlator_list_t *trav;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    /*
-     * TBD: unblock pending request(s) if we fail after this point but
-     * before we get to jbr_@NAME@_complete (where that code currently
-     * resides).
-     */
-
-    local->call_count = priv->n_children - 1;
-    for (trav = this->children->next; trav; trav = trav->next) {
-        STACK_WIND(frame, jbr_@NAME@_fan_in, trav->xlator,
-                   trav->xlator->fops->@NAME@, @SHORT_ARGS@);
-    }
-
-    /* TBD: variable Issue count */
-    ret = 0;
-out:
-    return ret;
-}
-
-/* template-name write-fan-in */
-int32_t jbr_@NAME@_fan_in(call_frame_t *frame, void *cookie, xlator_t *this,
-                            int32_t op_ret, int32_t op_errno, @LONG_ARGS@)
-{
-    jbr_local_t *local = NULL;
-    int32_t ret = -1;
-    uint8_t call_count;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    gf_msg_trace(this->name, 0, "op_ret = %d, op_errno = %d\n", op_ret,
-                 op_errno);
-
-    LOCK(&frame->lock);
-    call_count = --(local->call_count);
-    if (op_ret != -1) {
-        /* Increment the number of successful acks *
-         * received for the operation.             *
-         */
-        (local->successful_acks)++;
-        local->successful_op_ret = op_ret;
-    }
-    gf_msg_debug(this->name, 0, "succ_acks = %d, op_ret = %d, op_errno = %d\n",
-                 op_ret, op_errno, local->successful_acks);
-    UNLOCK(&frame->lock);
-
-    /* TBD: variable Completion count */
-    if (call_count == 0) {
-        call_resume(local->stub);
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/* template-name write-continue */
-int32_t jbr_@NAME@_continue(call_frame_t *frame, xlator_t *this, @LONG_ARGS@)
-{
-    int32_t ret = -1;
-    gf_boolean_t result = _gf_false;
-    jbr_local_t *local = NULL;
-    jbr_local_t *new_local = NULL;
-    jbr_private_t *priv = NULL;
-    int32_t op_errno = 0;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    priv = this->private;
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    /* Perform quorum check to see if the leader needs     *
-     * to perform the operation. If the operation will not *
-     * meet quorum irrespective of the leader's result     *
-     * there is no point in the leader performing the fop  *
-     */
-    result = fop_quorum_check(this, (double)priv->n_children,
-                              (double)local->successful_acks + 1);
-    if (result == _gf_false) {
-        gf_msg(this->name, GF_LOG_ERROR, EROFS, J_MSG_QUORUM_NOT_MET,
-               "Didn't receive enough acks "
-               "to meet quorum. Failing the operation without trying "
-               "it on the leader.");
-
-#if defined(JBR_CG_QUEUE)
-        /*
-         * In case of a fop failure, before unwinding need to *
-         * remove it from queue                               *
-         */
-        ret = jbr_remove_from_queue(frame, this);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_GENERIC,
-                   "Failed to remove from queue.");
-        }
-#endif
-
-        /*
-         * In this case, the quorum is not met on the followers  *
-         * So the operation will not be performed on the leader  *
-         * and a rollback will be sent via GF_FOP_IPC to all the *
-         * followers, where this particular fop's term and index *
-         * numbers will be journaled, and later used to rollback *
-         */
-        call_frame_t *new_frame;
-
-        new_frame = copy_frame(frame);
-
-        if (new_frame) {
-            new_local = mem_get0(this->local_pool);
-            if (new_local) {
-                INIT_LIST_HEAD(&new_local->qlinks);
-                ret = dict_set_int32(local->xdata, "rollback-fop",
-                                     GF_FOP_@UPNAME@);
-                if (ret) {
-                    gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-                           "failed to set rollback-fop");
-                } else {
-                    new_local->xdata = dict_ref(local->xdata);
-                    new_frame->local = new_local;
-                    jbr_ipc_call_dispatch(new_frame, this, &op_errno,
-                                          FDL_IPC_JBR_SERVER_ROLLBACK,
-                                          new_local->xdata);
-                }
-            } else {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "Could not create local for new_frame");
-            }
-        } else {
-            gf_log(this->name, GF_LOG_WARNING, "Could not send rollback ipc");
-        }
-
-        STACK_UNWIND_STRICT(@NAME@, frame, -1, EROFS, @ERROR_ARGS@);
-    } else {
-        STACK_WIND(frame, jbr_@NAME@_complete, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->@NAME@, @SHORT_ARGS@);
-    }
-
-out:
-    return 0;
-}
-
-/* template-name write-complete */
-int32_t jbr_@NAME@_complete(call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno, @LONG_ARGS@)
-{
-    int32_t ret = -1;
-    gf_boolean_t result = _gf_false;
-    jbr_private_t *priv = NULL;
-    jbr_local_t *local = NULL;
-    jbr_local_t *new_local = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, err);
-    GF_VALIDATE_OR_GOTO(this->name, frame, err);
-    priv = this->private;
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, priv, err);
-    GF_VALIDATE_OR_GOTO(this->name, local, err);
-
-    /* If the fop failed on the leader, then reduce one successful ack
-     * before calculating the fop quorum
-     */
-    LOCK(&frame->lock);
-    if (op_ret == -1)
-        (local->successful_acks)--;
-    UNLOCK(&frame->lock);
-
-#if defined(JBR_CG_QUEUE)
-    ret = jbr_remove_from_queue(frame, this);
-    if (ret)
-        goto err;
-#endif
-
-#if defined(JBR_CG_FSYNC)
-    jbr_mark_fd_dirty(this, local);
-#endif
-
-#if defined(JBR_CG_NEED_FD)
-    fd_unref(local->fd);
-#endif
-
-    /* After the leader completes the fop, a quorum check is      *
-     * performed, taking into account the outcome of the fop      *
-     * on the leader. Irrespective of the fop being successful    *
-     * or failing on the leader, the result of the quorum will    *
-     * determine if the overall fop is successful or not. For     *
-     * example, a fop might have succeeded on every node except   *
-     * the leader, in which case as quorum is being met, the fop  *
-     * will be treated as a successful fop, even though it failed *
-     * on the leader. On follower nodes, no quorum check should   *
-     * be done, and the result is returned to the leader as is.   *
-     */
-    if (priv->leader) {
-        result = fop_quorum_check(this, (double)priv->n_children,
-                                  (double)local->successful_acks + 1);
-        if (result == _gf_false) {
-            op_ret = -1;
-            op_errno = EROFS;
-            gf_msg(this->name, GF_LOG_ERROR, EROFS, J_MSG_QUORUM_NOT_MET,
-                   "Quorum is not met. "
-                   "The operation has failed.");
-            /*
-             * In this case, the quorum is not met after the      *
-             * operation is performed on the leader. Hence a      *
-             * rollback will be sent via GF_FOP_IPC to the leader *
-             * where this particular fop's term and index numbers *
-             * will be journaled, and later used to rollback.     *
-             * The same will be done on all the followers         *
-             */
-            call_frame_t *new_frame;
-
-            new_frame = copy_frame(frame);
-            if (new_frame) {
-                new_local = mem_get0(this->local_pool);
-                if (new_local) {
-                    INIT_LIST_HEAD(&new_local->qlinks);
-                    gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-                           "op = %d", new_frame->op);
-                    ret = dict_set_int32(local->xdata, "rollback-fop",
-                                         GF_FOP_@UPNAME@);
-                    if (ret) {
-                        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-                               "failed to set "
-                               "rollback-fop");
-                    } else {
-                        new_local->xdata = dict_ref(local->xdata);
-                        new_frame->local = new_local;
-                        /*
-                         * Calling STACK_WIND instead *
-                         * of jbr_ipc as it will not  *
-                         * unwind to the previous     *
-                         * translators like it will   *
-                         * in case of jbr_ipc.        *
-                         */
-                        STACK_WIND(
-                            new_frame, jbr_ipc_complete, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->ipc,
-                            FDL_IPC_JBR_SERVER_ROLLBACK, new_local->xdata);
-                    }
-                } else {
-                    gf_log(this->name, GF_LOG_WARNING,
-                           "Could not create local "
-                           "for new_frame");
-                }
-            } else {
-                gf_log(this->name, GF_LOG_WARNING,
-                       "Could not send rollback ipc");
-            }
-        } else {
-#if defined(JBR_CG_NEED_FD)
-            op_ret = local->successful_op_ret;
-#else
-            op_ret = 0;
-#endif
-            op_errno = 0;
-            gf_msg_debug(this->name, 0,
-                         "Quorum has met. The operation has succeeded.");
-        }
-    }
-
-    /*
-     * Unrefing the reference taken in jbr_@NAME@ () *
-     */
-    dict_unref(local->xdata);
-
-    STACK_UNWIND_STRICT(@NAME@, frame, op_ret, op_errno, @SHORT_ARGS@);
-
-    return 0;
-
-err:
-    STACK_UNWIND_STRICT(@NAME@, frame, -1, 0, @SHORT_ARGS@);
-
-    return 0;
-}
diff --git a/xlators/experimental/jbr-server/src/gen-fops.py b/xlators/experimental/jbr-server/src/gen-fops.py
deleted file mode 100755
index 616782bba45..00000000000
--- a/xlators/experimental/jbr-server/src/gen-fops.py
+++ /dev/null
@@ -1,181 +0,0 @@
-#!/usr/bin/python3
-
-# This script generates the boilerplate versions of most fops and cbks in the
-# server.  This allows the details of leadership-status checking, sequencing
-# between leader and followers (including fan-out), and basic error checking
-# to be centralized one place, with per-operation code kept to a minimum.
-
-from __future__ import print_function
-import os
-import re
-import string
-import sys
-
-curdir = os.path.dirname(sys.argv[0])
-gendir = os.path.join(curdir, '../../../../libglusterfs/src')
-sys.path.append(gendir)
-from generator import ops, fop_subs, cbk_subs, generate
-
-# We really want the callback argument list, even when we're generating fop
-# code, so we propagate here.
-# TBD: this should probably be right in generate.py
-for k, v in cbk_subs.items():
-	fop_subs[k]['@ERROR_ARGS@'] = v['@ERROR_ARGS@']
-
-# Stolen from old codegen.py
-def load_templates (path):
-	templates = {}
-	tmpl_re = re.compile("/\* template-name (.*) \*/")
-	templates = {}
-	t_name = None
-	for line in open(path, "r").readlines():
-		if not line:
-			break
-		m = tmpl_re.match(line)
-		if m:
-			if t_name:
-				templates[t_name] = ''.join(t_contents)
-			t_name = m.group(1).strip()
-			t_contents = []
-		elif t_name:
-			t_contents.append(line)
-	if t_name:
-		templates[t_name] = ''.join(t_contents)
-	return templates
-
-# We need two types of templates.  The first, for pure read operations, just
-# needs to do a simple am-i-leader check (augmented to allow dirty reads).
-# The second, for pure writes, needs to do fan-out to followers between those
-# initial checks and local execution.  There are other operations that don't
-# fit neatly into either category - e.g. lock ops or fsync - so we'll just have
-# to handle those manually.  The table thus includes entries only for those we
-# can categorize.  The special cases, plus any new operations we've never even
-# heard of, aren't in there.
-#
-# Various keywords can be used to define/undefine preprocessor symbols used
-# in the templates, on a per-function basis.  For example, if the keyword here
-# is "fsync" (lowercase word or abbreviation) that will cause JBR_CG_FSYNC
-# (prefix plus uppercase version) to be defined above all of the generated code
-# for that fop.
-
-fop_table = {
-	"access":		"read",
-	"create":		"write",
-	"discard":		"write",
-#	"entrylk":		"read",
-	"fallocate":	"write",
-#	"fentrylk":		"read",
-	"fgetxattr":	"read",
-#	"finodelk":		"read",
-#	"flush":		"read",
-	"fremovexattr":	"write",
-	"fsetattr":		"write",
-	"fsetxattr":	"write",
-	"fstat":		"read",
-#	"fsync":		"read",
-#	"fsyncdir":		"read",
-	"ftruncate":	"write",
-	"fxattrop":		"write",
-	"getxattr":		"read",
-#	"inodelk":		"read",
-	"link":			"write",
-	"lk":			"write,queue",
-#	"lookup":		"read",
-	"mkdir":		"write",
-	"mknod":		"write",
-	"open":			"write",
-	"opendir":		"read",
-	"rchecksum":	"read",
-	"readdir":		"read",
-	"readdirp":		"read",
-	"readlink":		"read",
-	"readv":		"read",
-	"removexattr":	"write",
-	"rename":		"write",
-	"rmdir":		"write",
-	"setattr":		"write",
-	"setxattr":		"write",
-	"stat":			"read",
-	"statfs":		"read",
-	"symlink":		"write",
-	"truncate":		"write",
-	"unlink":		"write",
-	"writev":		"write,fsync,queue",
-	"xattrop":		"write",
-	"ipc":			"write",
-}
-
-# Mention those fops in the selective_generate table, for which
-# only a few common functions will be generated, and mention those
-# functions. Rest of the functions can be customized
-selective_generate = {
-	"lk":			"fop,dispatch,call_dispatch",
-	"ipc":			"dispatch,call_dispatch",
-}
-
-# Stolen from gen_fdl.py
-def gen_server (templates):
-	fops_done = []
-	for name in fop_table.keys():
-		info = fop_table[name].split(",")
-		kind = info[0]
-		flags = info[1:]
-
-		# generate all functions for the fops in fop_table
-		# except for the ones in selective_generate for which
-		# generate only the functions mentioned in the
-		# selective_generate table
-		gen_funcs = "fop,complete,continue,fan-in,dispatch, \
-			call_dispatch,perform_local_op"
-		if name in selective_generate:
-			gen_funcs = selective_generate[name].split(",")
-
-		if ("fsync" in flags) or ("queue" in flags):
-			flags.append("need_fd")
-		for fname in flags:
-			print("#define JBR_CG_%s" % fname.upper())
-
-		if 'complete' in gen_funcs:
-			print(generate(templates[kind+"-complete"],
-					name, cbk_subs))
-
-		if 'continue' in gen_funcs:
-			print(generate(templates[kind+"-continue"],
-					name, fop_subs))
-
-		if 'fan-in' in gen_funcs:
-			print(generate(templates[kind+"-fan-in"],
-					name, cbk_subs))
-
-		if 'dispatch' in gen_funcs:
-			print(generate(templates[kind+"-dispatch"],
-					name, fop_subs))
-
-		if 'call_dispatch' in gen_funcs:
-			print(generate(templates[kind+"-call_dispatch"],
-					name, fop_subs))
-
-		if 'perform_local_op' in gen_funcs:
-			print(generate(templates[kind+"-perform_local_op"],
-					name, fop_subs))
-
-		if 'fop' in gen_funcs:
-			print(generate(templates[kind+"-fop"], name, fop_subs))
-
-		for fname in flags:
-			print("#undef JBR_CG_%s" % fname.upper())
-		fops_done.append(name)
-	# Just for fun, emit the fops table too.
-	print("struct xlator_fops fops = {")
-	for x in fops_done:
-		print(("	.%s = jbr_%s,"%(x, x)))
-	print("};")
-
-tmpl = load_templates(sys.argv[1])
-for l in open(sys.argv[2], 'r').readlines():
-	if l.find('#pragma generate') != -1:
-		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
-		gen_server(tmpl)
-		print("/* END GENERATED CODE */")
-	else:
-		print(l[:-1])
diff --git a/xlators/experimental/jbr-server/src/jbr-internal.h b/xlators/experimental/jbr-server/src/jbr-internal.h
deleted file mode 100644
index f225e988a5f..00000000000
--- a/xlators/experimental/jbr-server/src/jbr-internal.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-   Copyright (c) 2013 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.
-*/
-
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#define LEADER_XATTR "user.jbr.leader"
-#define SECOND_CHILD(xl) (xl->children->next->xlator)
-#define RECONCILER_PATH JBR_SCRIPT_PREFIX "/reconciler.py"
-#define CHANGELOG_ENTRY_SIZE 128
-
-enum {
-    gf_mt_jbr_private_t = gf_common_mt_end + 1,
-    gf_mt_jbr_fd_ctx_t,
-    gf_mt_jbr_inode_ctx_t,
-    gf_mt_jbr_dirty_t,
-    gf_mt_jbr_end
-};
-
-typedef enum jbr_recon_notify_ev_id_t {
-    JBR_RECON_SET_LEADER = 1,
-    JBR_RECON_ADD_CHILD = 2
-} jbr_recon_notify_ev_id_t;
-
-typedef struct _jbr_recon_notify_ev_s {
-    jbr_recon_notify_ev_id_t id;
-    uint32_t index; /* in case of add */
-    struct list_head list;
-} jbr_recon_notify_ev_t;
-
-typedef struct {
-    /*
-     * This is a hack to allow a non-leader to accept requests while the
-     * leader is down, and it only works for n=2.  The way it works is that
-     * "config_leader" indicates the state from our options (via init or
-     * reconfigure) but "leader" is what the fop code actually looks at.  If
-     * config_leader is true, then leader will *always* be true as well,
-     * giving that brick precedence.  If config_leader is false, then
-     * leader will only be true if there is no connection to the other
-     * brick (tracked in jbr_notify).
-     *
-     * TBD: implement real leader election
-     */
-    gf_boolean_t config_leader;
-    gf_boolean_t leader;
-    uint8_t up_children;
-    uint8_t n_children;
-    char *vol_file;
-    uint32_t current_term;
-    uint32_t kid_state;
-    gf_lock_t dirty_lock;
-    struct list_head dirty_fds;
-    uint32_t index;
-    gf_lock_t index_lock;
-    double quorum_pct;
-    int term_fd;
-    long term_total;
-    long term_read;
-    /*
-     * This is a super-duper hack, but it will do for now.  The reason it's
-     * a hack is that we pass this to dict_set_static_bin, so we don't have
-     * to mess around with allocating and freeing it on every single IPC
-     * request, but it's totally not thread-safe.  On the other hand, there
-     * should only be one reconciliation thread running and calling these
-     * functions at a time, so maybe that doesn't matter.
-     *
-     * TBD: re-evaluate how to manage this
-     */
-    char term_buf[CHANGELOG_ENTRY_SIZE];
-    gf_boolean_t child_up; /* To maintain the state of *
-                            * the translator */
-} jbr_private_t;
-
-typedef struct {
-    call_stub_t *stub;
-    call_stub_t *qstub;
-    uint32_t call_count;
-    uint32_t successful_acks;
-    uint32_t successful_op_ret;
-    fd_t *fd;
-    struct list_head qlinks;
-    dict_t *xdata;
-} jbr_local_t;
-
-/*
- * This should match whatever changelog returns on the pre-op for us to pass
- * when we're ready for our post-op.
- */
-typedef uint32_t log_id_t;
-
-typedef struct {
-    struct list_head links;
-    log_id_t id;
-} jbr_dirty_list_t;
-
-typedef struct {
-    fd_t *fd;
-    struct list_head dirty_list;
-    struct list_head fd_list;
-} jbr_fd_ctx_t;
-
-typedef struct {
-    gf_lock_t lock;
-    uint32_t active;
-    struct list_head aqueue;
-    uint32_t pending;
-    struct list_head pqueue;
-} jbr_inode_ctx_t;
-
-void
-jbr_start_reconciler(xlator_t *this);
diff --git a/xlators/experimental/jbr-server/src/jbr.c b/xlators/experimental/jbr-server/src/jbr.c
deleted file mode 100644
index f5fb55fee18..00000000000
--- a/xlators/experimental/jbr-server/src/jbr.c
+++ /dev/null
@@ -1,1676 +0,0 @@
-/*
-   Copyright (c) 2013 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 _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif
-
-#include <fnmatch.h>
-#include <glusterfs/call-stub.h>
-#include <glusterfs/defaults.h>
-#include <glusterfs/xlator.h>
-#include "glfs.h"
-#include "glfs-internal.h"
-#include <glusterfs/run.h>
-#include <glusterfs/common-utils.h>
-#include <glusterfs/syncop.h>
-#include <glusterfs/syscall.h>
-#include <glusterfs/compat-errno.h>
-#include "fdl.h"
-
-#include "jbr-internal.h"
-#include "jbr-messages.h"
-
-#define JBR_FLUSH_INTERVAL 5
-
-enum {
-    /* echo "cluster/jbr-server" | md5sum | cut -c 1-8 */
-    JBR_SERVER_IPC_BASE = 0x0e2d66a5,
-    JBR_SERVER_TERM_RANGE,
-    JBR_SERVER_OPEN_TERM,
-    JBR_SERVER_NEXT_ENTRY
-};
-
-/*
- * Need to declare jbr_lk_call_dispatch as jbr_lk_continue and *
- * jbr_lk_perform_local_op call it, before code is generated.  *
- */
-int32_t
-jbr_lk_call_dispatch(call_frame_t *frame, xlator_t *this, int *op_errno,
-                     fd_t *fd, int32_t cmd, struct gf_flock *lock,
-                     dict_t *xdata);
-
-int32_t
-jbr_lk_dispatch(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-                struct gf_flock *lock, dict_t *xdata);
-
-int32_t
-jbr_ipc_call_dispatch(call_frame_t *frame, xlator_t *this, int *op_errno,
-                      int32_t op, dict_t *xdata);
-
-int32_t
-jbr_ipc_complete(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata);
-
-/* Used to check the quorum of acks received after the fop
- * confirming the status of the fop on all the brick processes
- * for this particular subvolume
- */
-gf_boolean_t
-fop_quorum_check(xlator_t *this, double n_children, double current_state)
-{
-    jbr_private_t *priv = NULL;
-    gf_boolean_t result = _gf_false;
-    double required = 0;
-    double current = 0;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-
-    required = n_children * priv->quorum_pct;
-
-    /*
-     * Before performing the fop on the leader, we need to check,
-     * if there is any merit in performing the fop on the leader.
-     * In a case, where even a successful write on the leader, will
-     * not meet quorum, there is no point in trying the fop on the
-     * leader.
-     * When this function is called after the leader has tried
-     * performing the fop, this check will calculate quorum taking into
-     * account the status of the fop on the leader. If the leader's
-     * op_ret was -1, the complete function would account that by
-     * decrementing successful_acks by 1
-     */
-
-    current = current_state * 100.0;
-
-    if (current < required) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_QUORUM_NOT_MET,
-               "Quorum not met. quorum_pct = %f "
-               "Current State = %f, Required State = %f",
-               priv->quorum_pct, current, required);
-    } else
-        result = _gf_true;
-
-out:
-    return result;
-}
-
-jbr_inode_ctx_t *
-jbr_get_inode_ctx(xlator_t *this, inode_t *inode)
-{
-    uint64_t ctx_int = 0LL;
-    jbr_inode_ctx_t *ctx_ptr;
-
-    if (__inode_ctx_get(inode, this, &ctx_int) == 0) {
-        ctx_ptr = (jbr_inode_ctx_t *)(long)ctx_int;
-    } else {
-        ctx_ptr = GF_CALLOC(1, sizeof(*ctx_ptr), gf_mt_jbr_inode_ctx_t);
-        if (ctx_ptr) {
-            ctx_int = (uint64_t)(long)ctx_ptr;
-            if (__inode_ctx_set(inode, this, &ctx_int) == 0) {
-                LOCK_INIT(&ctx_ptr->lock);
-                INIT_LIST_HEAD(&ctx_ptr->aqueue);
-                INIT_LIST_HEAD(&ctx_ptr->pqueue);
-            } else {
-                GF_FREE(ctx_ptr);
-                ctx_ptr = NULL;
-            }
-        }
-    }
-
-    return ctx_ptr;
-}
-
-jbr_fd_ctx_t *
-jbr_get_fd_ctx(xlator_t *this, fd_t *fd)
-{
-    uint64_t ctx_int = 0LL;
-    jbr_fd_ctx_t *ctx_ptr;
-
-    if (__fd_ctx_get(fd, this, &ctx_int) == 0) {
-        ctx_ptr = (jbr_fd_ctx_t *)(long)ctx_int;
-    } else {
-        ctx_ptr = GF_CALLOC(1, sizeof(*ctx_ptr), gf_mt_jbr_fd_ctx_t);
-        if (ctx_ptr) {
-            if (__fd_ctx_set(fd, this, (uint64_t)(uintptr_t)ctx_ptr) == 0) {
-                INIT_LIST_HEAD(&ctx_ptr->dirty_list);
-                INIT_LIST_HEAD(&ctx_ptr->fd_list);
-            } else {
-                GF_FREE(ctx_ptr);
-                ctx_ptr = NULL;
-            }
-        }
-    }
-
-    return ctx_ptr;
-}
-
-void
-jbr_mark_fd_dirty(xlator_t *this, jbr_local_t *local)
-{
-    fd_t *fd = local->fd;
-    jbr_fd_ctx_t *ctx_ptr;
-    jbr_dirty_list_t *dirty;
-    jbr_private_t *priv = this->private;
-
-    /*
-     * TBD: don't do any of this for O_SYNC/O_DIRECT writes.
-     * Unfortunately, that optimization requires that we distinguish
-     * between writev and other "write" calls, saving the original flags
-     * and checking them in the callback.  Too much work for too little
-     * gain right now.
-     */
-
-    LOCK(&fd->lock);
-    ctx_ptr = jbr_get_fd_ctx(this, fd);
-    dirty = GF_CALLOC(1, sizeof(*dirty), gf_mt_jbr_dirty_t);
-    if (ctx_ptr && dirty) {
-        gf_msg_trace(this->name, 0, "marking fd %p as dirty (%p)", fd, dirty);
-        /* TBD: fill dirty->id from what changelog gave us */
-        list_add_tail(&dirty->links, &ctx_ptr->dirty_list);
-        if (list_empty(&ctx_ptr->fd_list)) {
-            /* Add a ref so _release doesn't get called. */
-            ctx_ptr->fd = fd_ref(fd);
-            LOCK(&priv->dirty_lock);
-            list_add_tail(&ctx_ptr->fd_list, &priv->dirty_fds);
-            UNLOCK(&priv->dirty_lock);
-        }
-    } else {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, J_MSG_MEM_ERR,
-               "could not mark %p dirty", fd);
-        if (ctx_ptr) {
-            GF_FREE(ctx_ptr);
-        }
-        if (dirty) {
-            GF_FREE(dirty);
-        }
-    }
-    UNLOCK(&fd->lock);
-}
-
-#define JBR_TERM_XATTR "trusted.jbr.term"
-#define JBR_INDEX_XATTR "trusted.jbr.index"
-#define JBR_REP_COUNT_XATTR "trusted.jbr.rep-count"
-#define RECON_TERM_XATTR "trusted.jbr.recon-term"
-#define RECON_INDEX_XATTR "trusted.jbr.recon-index"
-
-int32_t
-jbr_leader_checks_and_init(call_frame_t *frame, xlator_t *this, int *op_errno,
-                           dict_t *xdata, fd_t *fd)
-{
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-    int32_t ret = -1;
-    gf_boolean_t result = _gf_false;
-    int from_leader = _gf_false;
-    int from_recon = _gf_false;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, op_errno, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-
-    /*
-     * Our first goal here is to avoid "split brain surprise" for users who
-     * specify exactly 50% with two- or three-way replication.  That means
-     * either a more-than check against half the total replicas or an
-     * at-least check against half of our peers (one less).  Of the two,
-     * only an at-least check supports the intuitive use of 100% to mean
-     * all replicas must be present, because "more than 100%" will never
-     * succeed regardless of which count we use.  This leaves us with a
-     * slightly non-traditional definition of quorum ("at least X% of peers
-     * not including ourselves") but one that's useful enough to be worth
-     * it.
-     *
-     * Note that n_children and up_children *do* include the local
-     * subvolume, so we need to subtract one in each case.
-     */
-    if (priv->leader) {
-        result = fop_quorum_check(this, (double)(priv->n_children - 1),
-                                  (double)(priv->up_children - 1));
-
-        if (result == _gf_false) {
-            /* Emulate the AFR client-side-quorum behavior. */
-            gf_msg(this->name, GF_LOG_ERROR, EROFS, J_MSG_QUORUM_NOT_MET,
-                   "Sufficient number of "
-                   "subvolumes are not up to meet quorum.");
-            *op_errno = EROFS;
-            goto out;
-        }
-    } else {
-        if (xdata) {
-            from_leader = !!dict_get(xdata, JBR_TERM_XATTR);
-            from_recon = !!dict_get(xdata, RECON_TERM_XATTR) &&
-                         !!dict_get(xdata, RECON_INDEX_XATTR);
-        } else {
-            from_leader = from_recon = _gf_false;
-        }
-
-        /* follower/recon path        *
-         * just send it to local node *
-         */
-        if (!from_leader && !from_recon) {
-            *op_errno = EREMOTE;
-            goto out;
-        }
-    }
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        goto out;
-    }
-
-    if (fd)
-        local->fd = fd_ref(fd);
-    else
-        local->fd = NULL;
-
-    INIT_LIST_HEAD(&local->qlinks);
-    local->successful_acks = 0;
-    frame->local = local;
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-jbr_initialize_xdata_set_attrs(xlator_t *this, dict_t **xdata)
-{
-    jbr_private_t *priv = NULL;
-    int32_t ret = -1;
-    uint32_t ti = 0;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, xdata, out);
-
-    if (!*xdata) {
-        *xdata = dict_new();
-        if (!*xdata) {
-            gf_msg(this->name, GF_LOG_ERROR, ENOMEM, J_MSG_MEM_ERR,
-                   "failed to allocate xdata");
-            goto out;
-        }
-    }
-
-    if (dict_set_int32(*xdata, JBR_TERM_XATTR, priv->current_term) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to set jbr-term");
-        goto out;
-    }
-
-    LOCK(&priv->index_lock);
-    ti = ++(priv->index);
-    UNLOCK(&priv->index_lock);
-    if (dict_set_int32(*xdata, JBR_INDEX_XATTR, ti) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to set index");
-        goto out;
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-jbr_remove_from_queue(call_frame_t *frame, xlator_t *this)
-{
-    int32_t ret = -1;
-    jbr_inode_ctx_t *ictx = NULL;
-    jbr_local_t *local = NULL;
-    jbr_local_t *next = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    if (local->qlinks.next != &local->qlinks) {
-        list_del(&local->qlinks);
-        ictx = jbr_get_inode_ctx(this, local->fd->inode);
-        if (ictx) {
-            LOCK(&ictx->lock);
-            if (ictx->pending) {
-                /*
-                 * TBD: dequeue *all* non-conflicting
-                 * reqs
-                 *
-                 * With the stub implementation there
-                 * can only be one request active at a
-                 * time (zero here) so it's not an
-                 * issue.  In a real implementation
-                 * there might still be other active
-                 * requests to check against, and
-                 * multiple pending requests that could
-                 * continue.
-                 */
-                gf_msg_debug(this->name, 0, "unblocking next request");
-                --(ictx->pending);
-                next = list_entry(ictx->pqueue.next, jbr_local_t, qlinks);
-                list_del(&next->qlinks);
-                list_add_tail(&next->qlinks, &ictx->aqueue);
-                call_resume(next->qstub);
-            } else {
-                --(ictx->active);
-            }
-            UNLOCK(&ictx->lock);
-        }
-    }
-
-    ret = 0;
-
-out:
-    return ret;
-}
-
-int32_t
-jbr_lk_complete(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *flock,
-                dict_t *xdata)
-{
-    int32_t ret = -1;
-    jbr_private_t *priv = NULL;
-    jbr_local_t *local = NULL;
-    gf_boolean_t result = _gf_false;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, err);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv, err);
-    GF_VALIDATE_OR_GOTO(this->name, frame, err);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, err);
-    GF_VALIDATE_OR_GOTO(this->name, flock, err);
-    GF_VALIDATE_OR_GOTO(this->name, xdata, err);
-
-    /*
-     * Remove from queue for unlock operation only   *
-     * For lock operation, it will be done in fan-in *
-     */
-    if (flock->l_type == F_UNLCK) {
-        ret = jbr_remove_from_queue(frame, this);
-        if (ret)
-            goto err;
-    }
-
-    /*
-     * On a follower, unwind with the op_ret and op_errno. On a *
-     * leader, if the fop is a locking fop, and its a failure,  *
-     * send fail, else call stub which will dispatch the fop to *
-     * the followers.                                           *
-     *                                                          *
-     * If the fop is a unlocking fop, check quorum. If quorum   *
-     * is met, then send success. Else Rollback on leader,      *
-     * followed by followers, and then send -ve ack to client.  *
-     */
-    if (priv->leader) {
-        /* Increase the successful acks if it's a success. */
-        LOCK(&frame->lock);
-        if (op_ret != -1)
-            (local->successful_acks)++;
-        UNLOCK(&frame->lock);
-
-        if (flock->l_type == F_UNLCK) {
-            result = fop_quorum_check(this, (double)priv->n_children,
-                                      (double)local->successful_acks);
-            if (result == _gf_false) {
-                op_ret = -1;
-                op_errno = EROFS;
-                gf_msg(this->name, GF_LOG_ERROR, EROFS, J_MSG_QUORUM_NOT_MET,
-                       "Quorum is not met. "
-                       "The operation has failed.");
-
-                /* TODO: PERFORM UNLOCK ROLLBACK ON LEADER *
-                 * FOLLOWED BY FOLLOWERS. */
-            } else {
-                op_ret = 0;
-                op_errno = 0;
-            }
-
-            fd_unref(local->fd);
-            STACK_UNWIND_STRICT(lk, frame, op_ret, op_errno, flock, xdata);
-        } else {
-            if (op_ret == -1) {
-                gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_LOCK_FAILURE,
-                       "The lock operation failed on "
-                       "the leader.");
-
-                fd_unref(local->fd);
-                STACK_UNWIND_STRICT(lk, frame, op_ret, op_errno, flock, xdata);
-            } else {
-                if (!local->stub) {
-                    goto err;
-                }
-
-                call_resume(local->stub);
-            }
-        }
-    } else {
-        fd_unref(local->fd);
-        STACK_UNWIND_STRICT(lk, frame, op_ret, op_errno, flock, xdata);
-    }
-
-    return 0;
-
-err:
-    if (local) {
-        if (local->stub) {
-            call_stub_destroy(local->stub);
-        }
-        if (local->qstub) {
-            call_stub_destroy(local->qstub);
-        }
-        if (local->fd) {
-            fd_unref(local->fd);
-        }
-        mem_put(local);
-    }
-    STACK_UNWIND_STRICT(lk, frame, -1, op_errno, flock, xdata);
-    return 0;
-}
-
-int32_t
-jbr_lk_fan_in(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct gf_flock *flock, dict_t *xdata)
-{
-    uint8_t call_count = -1;
-    int32_t ret = -1;
-    gf_boolean_t result = _gf_false;
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    priv = this->private;
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    gf_msg_trace(this->name, 0, "op_ret = %d, op_errno = %d\n", op_ret,
-                 op_errno);
-
-    LOCK(&frame->lock);
-    call_count = --(local->call_count);
-    if (op_ret != -1) {
-        /* Increment the number of successful acks *
-         * received for the operation.             *
-         */
-        (local->successful_acks)++;
-        local->successful_op_ret = op_ret;
-    }
-    gf_msg_debug(this->name, 0, "succ_acks = %d, op_ret = %d, op_errno = %d\n",
-                 op_ret, op_errno, local->successful_acks);
-    UNLOCK(&frame->lock);
-
-    if (call_count == 0) {
-        /*
-         * If the fop is a locking fop, then check quorum. If quorum *
-         * is met, send successful ack to the client. If quorum is   *
-         * not met, then rollback locking on followers, followed by  *
-         * rollback of locking on leader, and then sending -ve ack   *
-         * to the client.                                            *
-         *                                                           *
-         * If the fop is a unlocking fop, then call stub.            *
-         */
-        if (flock->l_type == F_UNLCK) {
-            call_resume(local->stub);
-        } else {
-            /*
-             * Remove from queue for locking fops, for unlocking *
-             * fops, it is taken care of in jbr_lk_complete      *
-             */
-            ret = jbr_remove_from_queue(frame, this);
-            if (ret)
-                goto out;
-
-            fd_unref(local->fd);
-
-            result = fop_quorum_check(this, (double)priv->n_children,
-                                      (double)local->successful_acks);
-            if (result == _gf_false) {
-                gf_msg(this->name, GF_LOG_ERROR, EROFS, J_MSG_QUORUM_NOT_MET,
-                       "Didn't receive enough acks to meet "
-                       "quorum. Failing the locking "
-                       "operation and initiating rollback on "
-                       "followers and the leader "
-                       "respectively.");
-
-                /* TODO: PERFORM ROLLBACK OF LOCKING ON
-                 * FOLLOWERS, FOLLOWED BY ROLLBACK ON
-                 * LEADER.
-                 */
-
-                STACK_UNWIND_STRICT(lk, frame, -1, EROFS, flock, xdata);
-            } else {
-                STACK_UNWIND_STRICT(lk, frame, 0, 0, flock, xdata);
-            }
-        }
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/*
- * Called from leader for locking fop, being written as a separate
- * function so as to support queues.
- */
-int32_t
-jbr_perform_lk_on_leader(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                         int32_t cmd, struct gf_flock *flock, dict_t *xdata)
-{
-    int32_t ret = -1;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    GF_VALIDATE_OR_GOTO(this->name, flock, out);
-    GF_VALIDATE_OR_GOTO(this->name, fd, out);
-
-    STACK_WIND(frame, jbr_lk_complete, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lk, fd, cmd, flock, xdata);
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-jbr_lk_perform_local_op(call_frame_t *frame, xlator_t *this, int *op_errno,
-                        fd_t *fd, int32_t cmd, struct gf_flock *flock,
-                        dict_t *xdata)
-{
-    int32_t ret = -1;
-    jbr_local_t *local = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-    GF_VALIDATE_OR_GOTO(this->name, fd, out);
-    GF_VALIDATE_OR_GOTO(this->name, op_errno, out);
-    GF_VALIDATE_OR_GOTO(this->name, flock, out);
-
-    /*
-     * Check if the fop is a locking fop or unlocking fop, and
-     * handle it accordingly. If it is a locking fop, take the
-     * lock on leader first, and then send it to the followers.
-     * If it is a unlocking fop, unlock the followers first,
-     * and then on meeting quorum perform the unlock on the leader.
-     */
-    if (flock->l_type == F_UNLCK) {
-        ret = jbr_lk_call_dispatch(frame, this, op_errno, fd, cmd, flock,
-                                   xdata);
-        if (ret)
-            goto out;
-    } else {
-        jbr_inode_ctx_t *ictx = jbr_get_inode_ctx(this, fd->inode);
-
-        if (!ictx) {
-            *op_errno = EIO;
-            goto out;
-        }
-
-        LOCK(&ictx->lock);
-        if (ictx->active) {
-            gf_msg_debug(this->name, 0, "queuing request due to conflict");
-
-            local->qstub = fop_lk_stub(frame, jbr_perform_lk_on_leader, fd, cmd,
-                                       flock, xdata);
-            if (!local->qstub) {
-                UNLOCK(&ictx->lock);
-                goto out;
-            }
-            list_add_tail(&local->qlinks, &ictx->pqueue);
-            ++(ictx->pending);
-            UNLOCK(&ictx->lock);
-            ret = 0;
-            goto out;
-        } else {
-            list_add_tail(&local->qlinks, &ictx->aqueue);
-            ++(ictx->active);
-        }
-        UNLOCK(&ictx->lock);
-        ret = jbr_perform_lk_on_leader(frame, this, fd, cmd, flock, xdata);
-        if (ret == -1)
-            goto out;
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-jbr_lk_continue(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
-                struct gf_flock *flock, dict_t *xdata)
-{
-    int32_t ret = -1;
-    jbr_local_t *local = NULL;
-    jbr_private_t *priv = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    priv = this->private;
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-    GF_VALIDATE_OR_GOTO(this->name, flock, out);
-    GF_VALIDATE_OR_GOTO(this->name, fd, out);
-    GF_VALIDATE_OR_GOTO(this->name, xdata, out);
-
-    /*
-     * If it's a locking fop, then call dispatch to followers  *
-     * If it's a unlock fop, then perform the unlock operation *
-     */
-    if (flock->l_type == F_UNLCK) {
-        STACK_WIND(frame, jbr_lk_complete, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->lk, fd, cmd, flock, xdata);
-    } else {
-        /*
-         * Directly call jbr_lk_dispatch instead of appending *
-         * in queue, which is done at jbr_lk_perform_local_op *
-         * for locking fops                                   *
-         */
-        ret = jbr_lk_dispatch(frame, this, fd, cmd, flock, xdata);
-        if (ret) {
-            STACK_UNWIND_STRICT(lk, frame, -1, 0, flock, xdata);
-            goto out;
-        }
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-uint8_t
-jbr_count_up_kids(jbr_private_t *priv)
-{
-    uint8_t retval = 0;
-    uint8_t i;
-
-    for (i = 0; i < priv->n_children; ++i) {
-        if (priv->kid_state & (1 << i)) {
-            ++retval;
-        }
-    }
-
-    return retval;
-}
-
-/*
- * The fsync machinery looks a lot like that for any write call, but there are
- * some important differences that are easy to miss.  First, we don't care
- * about the xdata that shows whether the call came from a leader or
- * reconciliation process.  If we're the leader we fan out; if we're not we
- * don't.  Second, we don't wait for followers before we issue the local call.
- * The code generation system could be updated to handle this, and still might
- * if we need to implement other "almost identical" paths (e.g. for open), but
- * a copy is more readable as long as it's just one.
- */
-
-int32_t
-jbr_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
-              dict_t *xdata)
-{
-    jbr_local_t *local = frame->local;
-    gf_boolean_t unwind;
-
-    LOCK(&frame->lock);
-    unwind = !--(local->call_count);
-    UNLOCK(&frame->lock);
-
-    if (unwind) {
-        STACK_UNWIND_STRICT(fsync, frame, op_ret, op_errno, prebuf, postbuf,
-                            xdata);
-    }
-    return 0;
-}
-
-int32_t
-jbr_fsync_local_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf, dict_t *xdata)
-{
-    jbr_dirty_list_t *dirty;
-    jbr_dirty_list_t *dtmp;
-    jbr_local_t *local = frame->local;
-
-    list_for_each_entry_safe(dirty, dtmp, &local->qlinks, links)
-    {
-        gf_msg_trace(this->name, 0, "sending post-op on %p (%p)", local->fd,
-                     dirty);
-        GF_FREE(dirty);
-    }
-
-    return jbr_fsync_cbk(frame, cookie, this, op_ret, op_errno, prebuf, postbuf,
-                         xdata);
-}
-
-int32_t
-jbr_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-          dict_t *xdata)
-{
-    jbr_private_t *priv = this->private;
-    jbr_local_t *local;
-    uint64_t ctx_int = 0LL;
-    jbr_fd_ctx_t *ctx_ptr;
-    xlator_list_t *trav;
-
-    local = mem_get0(this->local_pool);
-    if (!local) {
-        STACK_UNWIND_STRICT(fsync, frame, -1, ENOMEM, NULL, NULL, xdata);
-        return 0;
-    }
-    INIT_LIST_HEAD(&local->qlinks);
-    frame->local = local;
-
-    /* Move the dirty list from the fd to the fsync request. */
-    LOCK(&fd->lock);
-    if (__fd_ctx_get(fd, this, &ctx_int) == 0) {
-        ctx_ptr = (jbr_fd_ctx_t *)(long)ctx_int;
-        list_splice_init(&ctx_ptr->dirty_list, &local->qlinks);
-    }
-    UNLOCK(&fd->lock);
-
-    /* Issue the local call. */
-    local->call_count = priv->leader ? priv->n_children : 1;
-    STACK_WIND(frame, jbr_fsync_local_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsync, fd, flags, xdata);
-
-    /* Issue remote calls if we're the leader. */
-    if (priv->leader) {
-        for (trav = this->children->next; trav; trav = trav->next) {
-            STACK_WIND(frame, jbr_fsync_cbk, FIRST_CHILD(this),
-                       FIRST_CHILD(this)->fops->fsync, fd, flags, xdata);
-        }
-    }
-
-    return 0;
-}
-
-int32_t
-jbr_getxattr_special(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                     const char *name, dict_t *xdata)
-{
-    dict_t *result;
-    jbr_private_t *priv = this->private;
-
-    if (!priv->leader) {
-        STACK_UNWIND_STRICT(getxattr, frame, -1, EREMOTE, NULL, NULL);
-        return 0;
-    }
-
-    if (!name || (strcmp(name, JBR_REP_COUNT_XATTR) != 0)) {
-        STACK_WIND_TAIL(frame, FIRST_CHILD(this),
-                        FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
-        return 0;
-    }
-
-    result = dict_new();
-    if (!result) {
-        goto dn_failed;
-    }
-
-    priv->up_children = jbr_count_up_kids(this->private);
-    if (dict_set_uint32(result, JBR_REP_COUNT_XATTR, priv->up_children) != 0) {
-        goto dsu_failed;
-    }
-
-    STACK_UNWIND_STRICT(getxattr, frame, 0, 0, result, NULL);
-    dict_unref(result);
-    return 0;
-
-dsu_failed:
-    dict_unref(result);
-dn_failed:
-    STACK_UNWIND_STRICT(getxattr, frame, -1, ENOMEM, NULL, NULL);
-    return 0;
-}
-
-void
-jbr_flush_fd(xlator_t *this, jbr_fd_ctx_t *fd_ctx)
-{
-    jbr_dirty_list_t *dirty;
-    jbr_dirty_list_t *dtmp;
-
-    list_for_each_entry_safe(dirty, dtmp, &fd_ctx->dirty_list, links)
-    {
-        gf_msg_trace(this->name, 0, "sending post-op on %p (%p)", fd_ctx->fd,
-                     dirty);
-        GF_FREE(dirty);
-    }
-
-    INIT_LIST_HEAD(&fd_ctx->dirty_list);
-}
-
-void *
-jbr_flush_thread(void *ctx)
-{
-    xlator_t *this = ctx;
-    jbr_private_t *priv = this->private;
-    struct list_head dirty_fds;
-    jbr_fd_ctx_t *fd_ctx;
-    jbr_fd_ctx_t *fd_tmp;
-    int ret;
-
-    for (;;) {
-        /*
-         * We have to be very careful to avoid lock inversions here, so
-         * we can't just hold priv->dirty_lock while we take and
-         * release locks for each fd.  Instead, we only hold dirty_lock
-         * at the beginning of each iteration, as we (effectively) make
-         * a copy of the current list head and then clear the original.
-         * This leads to four scenarios for adding the first entry to
-         * an fd and potentially putting it on the global list.
-         *
-         * (1) While we're asleep.  No lock contention, it just gets
-         *     added and will be processed on the next iteration.
-         *
-         * (2) After we've made a local copy, but before we've started
-         *     processing that fd.  The new entry will be added to the
-         *     fd (under its lock), and we'll process it on the current
-         *     iteration.
-         *
-         * (3) While we're processing the fd.  They'll block on the fd
-         *     lock, then see that the list is empty and put it on the
-         *     global list.  We'll process it here on the next
-         *     iteration.
-         *
-         * (4) While we're working, but after we've processed that fd.
-         *     Same as (1) as far as that fd is concerned.
-         */
-        INIT_LIST_HEAD(&dirty_fds);
-        LOCK(&priv->dirty_lock);
-        list_splice_init(&priv->dirty_fds, &dirty_fds);
-        UNLOCK(&priv->dirty_lock);
-
-        list_for_each_entry_safe(fd_ctx, fd_tmp, &dirty_fds, fd_list)
-        {
-            ret = syncop_fsync(FIRST_CHILD(this), fd_ctx->fd, 0, NULL, NULL,
-                               NULL, NULL);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_WARNING, 0, J_MSG_SYS_CALL_FAILURE,
-                       "failed to fsync %p (%d)", fd_ctx->fd, -ret);
-            }
-
-            LOCK(&fd_ctx->fd->lock);
-            jbr_flush_fd(this, fd_ctx);
-            list_del_init(&fd_ctx->fd_list);
-            UNLOCK(&fd_ctx->fd->lock);
-            fd_unref(fd_ctx->fd);
-        }
-
-        sleep(JBR_FLUSH_INTERVAL);
-    }
-
-    return NULL;
-}
-
-int32_t
-jbr_get_changelog_dir(xlator_t *this, char **cl_dir_p)
-{
-    xlator_t *cl_xl;
-
-    /* Find our changelog translator. */
-    cl_xl = this;
-    while (cl_xl) {
-        if (strcmp(cl_xl->type, "features/changelog") == 0) {
-            break;
-        }
-        cl_xl = cl_xl->children->xlator;
-    }
-    if (!cl_xl) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_INIT_FAIL,
-               "failed to find changelog translator");
-        return ENOENT;
-    }
-
-    /* Find the actual changelog directory. */
-    if (dict_get_str(cl_xl->options, "changelog-dir", cl_dir_p) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_INIT_FAIL,
-               "failed to find changelog-dir for %s", cl_xl->name);
-        return ENODATA;
-    }
-
-    return 0;
-}
-
-void
-jbr_get_terms(call_frame_t *frame, xlator_t *this)
-{
-    int32_t op_errno = 0;
-    char *cl_dir = NULL;
-    int32_t term_first = -1;
-    int32_t term_contig = -1;
-    int32_t term_last = -1;
-    int term_num = 0;
-    char *probe_str = NULL;
-    dict_t *my_xdata = NULL;
-    DIR *fp = NULL;
-    struct dirent *entry = NULL;
-    struct dirent scratch[2] = {
-        {
-            0,
-        },
-    };
-
-    op_errno = jbr_get_changelog_dir(this, &cl_dir);
-    if (op_errno) {
-        goto err; /* Error was already logged. */
-    }
-    op_errno = ENODATA; /* Most common error after this. */
-
-    fp = sys_opendir(cl_dir);
-    if (!fp) {
-        op_errno = errno;
-        goto err;
-    }
-
-    /* Find first and last terms. */
-    for (;;) {
-        errno = 0;
-        entry = sys_readdir(fp, scratch);
-        if (!entry || errno != 0) {
-            if (errno != 0) {
-                op_errno = errno;
-                goto err;
-            }
-            break;
-        }
-
-        if (fnmatch("TERM.*", entry->d_name, FNM_PATHNAME) != 0) {
-            continue;
-        }
-        /* +5 points to the character after the period */
-        term_num = atoi(entry->d_name + 5);
-        gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC, "%s => %d",
-               entry->d_name, term_num);
-        if (term_num < 0) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_INVALID,
-                   "invalid term file name %s", entry->d_name);
-            op_errno = EINVAL;
-            goto err;
-        }
-        if ((term_first < 0) || (term_first > term_num)) {
-            term_first = term_num;
-        }
-        if ((term_last < 0) || (term_last < term_num)) {
-            term_last = term_num;
-        }
-    }
-    if ((term_first < 0) || (term_last < 0)) {
-        /* TBD: are we *sure* there should always be at least one? */
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_NO_DATA, "no terms found");
-        op_errno = EINVAL;
-        goto err;
-    }
-
-    (void)sys_closedir(fp);
-    fp = NULL;
-
-    /*
-     * Find term_contig, which is the earliest term for which there are
-     * no gaps between it and term_last.
-     */
-    for (term_contig = term_last; term_contig > 0; --term_contig) {
-        if (gf_asprintf(&probe_str, "%s/TERM.%d", cl_dir, term_contig - 1) <=
-            0) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-                   "failed to format term %d", term_contig - 1);
-            goto err;
-        }
-        if (sys_access(probe_str, F_OK) != 0) {
-            GF_FREE(probe_str);
-            probe_str = NULL;
-            break;
-        }
-        GF_FREE(probe_str);
-        probe_str = NULL;
-    }
-
-    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC, "found terms %d-%d (%d)",
-           term_first, term_last, term_contig);
-
-    /* Return what we've found */
-    my_xdata = dict_new();
-    if (!my_xdata) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "failed to allocate reply dictionary");
-        goto err;
-    }
-    if (dict_set_int32(my_xdata, "term-first", term_first) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to set term-first");
-        goto err;
-    }
-    if (dict_set_int32(my_xdata, "term-contig", term_contig) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to set term-contig");
-        goto err;
-    }
-    if (dict_set_int32(my_xdata, "term-last", term_last) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to set term-last");
-        goto err;
-    }
-
-    /* Finally! */
-    STACK_UNWIND_STRICT(ipc, frame, 0, 0, my_xdata);
-    dict_unref(my_xdata);
-    return;
-
-err:
-    if (fp) {
-        (void)sys_closedir(fp);
-    }
-    if (my_xdata) {
-        dict_unref(my_xdata);
-    }
-
-    if (probe_str)
-        GF_FREE(probe_str);
-
-    STACK_UNWIND_STRICT(ipc, frame, -1, op_errno, NULL);
-}
-
-long
-get_entry_count(xlator_t *this, int fd)
-{
-    struct stat buf;
-    long min; /* last entry not known to be empty */
-    long max; /* first entry known to be empty */
-    long curr;
-    char entry[CHANGELOG_ENTRY_SIZE];
-
-    if (sys_fstat(fd, &buf) < 0) {
-        return -1;
-    }
-
-    min = 0;
-    max = buf.st_size / CHANGELOG_ENTRY_SIZE;
-
-    while ((min + 1) < max) {
-        curr = (min + max) / 2;
-        if (sys_lseek(fd, curr * CHANGELOG_ENTRY_SIZE, SEEK_SET) < 0) {
-            return -1;
-        }
-        if (sys_read(fd, entry, sizeof(entry)) != sizeof(entry)) {
-            return -1;
-        }
-        if ((entry[0] == '_') && (entry[1] == 'P')) {
-            min = curr;
-        } else {
-            max = curr;
-        }
-    }
-
-    if (sys_lseek(fd, 0, SEEK_SET) < 0) {
-        gf_msg(this->name, GF_LOG_WARNING, 0, J_MSG_SYS_CALL_FAILURE,
-               "failed to reset offset");
-    }
-    return max;
-}
-
-void
-jbr_open_term(call_frame_t *frame, xlator_t *this, dict_t *xdata)
-{
-    int32_t op_errno;
-    char *cl_dir;
-    char *term;
-    char *path = NULL;
-    jbr_private_t *priv = this->private;
-
-    op_errno = jbr_get_changelog_dir(this, &cl_dir);
-    if (op_errno) {
-        goto err;
-    }
-
-    if (dict_get_str(xdata, "term", &term) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_NO_DATA, "missing term");
-        op_errno = ENODATA;
-        goto err;
-    }
-
-    if (gf_asprintf(&path, "%s/TERM.%s", cl_dir, term) < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "failed to construct path");
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    if (priv->term_fd >= 0) {
-        sys_close(priv->term_fd);
-    }
-    priv->term_fd = open(path, O_RDONLY);
-    if (priv->term_fd < 0) {
-        op_errno = errno;
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_SYS_CALL_FAILURE,
-               "failed to open term file");
-        goto err;
-    }
-
-    priv->term_total = get_entry_count(this, priv->term_fd);
-    if (priv->term_total < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_NO_DATA,
-               "failed to get entry count");
-        sys_close(priv->term_fd);
-        priv->term_fd = -1;
-        op_errno = EIO;
-        goto err;
-    }
-    priv->term_read = 0;
-
-    /* Success! */
-    STACK_UNWIND_STRICT(ipc, frame, 0, 0, NULL);
-    GF_FREE(path);
-    return;
-
-err:
-    STACK_UNWIND_STRICT(ipc, frame, -1, op_errno, NULL);
-    GF_FREE(path);
-}
-
-void
-jbr_next_entry(call_frame_t *frame, xlator_t *this)
-{
-    int32_t op_errno = ENOMEM;
-    jbr_private_t *priv = this->private;
-    ssize_t nbytes;
-    dict_t *my_xdata;
-
-    if (priv->term_fd < 0) {
-        op_errno = EBADFD;
-        goto err;
-    }
-
-    if (priv->term_read >= priv->term_total) {
-        op_errno = ENODATA;
-        goto err;
-    }
-
-    nbytes = sys_read(priv->term_fd, priv->term_buf, CHANGELOG_ENTRY_SIZE);
-    if (nbytes < CHANGELOG_ENTRY_SIZE) {
-        if (nbytes < 0) {
-            op_errno = errno;
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_SYS_CALL_FAILURE,
-                   "error reading next entry: %s", strerror(errno));
-        } else {
-            op_errno = EIO;
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_SYS_CALL_FAILURE,
-                   "got %zd/%d bytes for next entry", nbytes,
-                   CHANGELOG_ENTRY_SIZE);
-        }
-        goto err;
-    }
-    ++(priv->term_read);
-
-    my_xdata = dict_new();
-    if (!my_xdata) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "failed to allocate reply xdata");
-        goto err;
-    }
-
-    if (dict_set_static_bin(my_xdata, "data", priv->term_buf,
-                            CHANGELOG_ENTRY_SIZE) != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_DICT_FLR,
-               "failed to assign reply xdata");
-        goto err;
-    }
-
-    STACK_UNWIND_STRICT(ipc, frame, 0, 0, my_xdata);
-    dict_unref(my_xdata);
-    return;
-
-err:
-    STACK_UNWIND_STRICT(ipc, frame, -1, op_errno, NULL);
-}
-
-int32_t
-jbr_ipc_fan_in(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    jbr_local_t *local = NULL;
-    int32_t ret = -1;
-    uint8_t call_count;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    gf_msg_trace(this->name, 0, "op_ret = %d, op_errno = %d\n", op_ret,
-                 op_errno);
-
-    LOCK(&frame->lock);
-    call_count = --(local->call_count);
-    UNLOCK(&frame->lock);
-
-    if (call_count == 0) {
-#if defined(JBR_CG_QUEUE)
-        ret = jbr_remove_from_queue(frame, this);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_GENERIC,
-                   "Failed to remove from queue.");
-        }
-#endif
-        /*
-         * Unrefing the reference taken in continue() or complete() *
-         */
-        dict_unref(local->xdata);
-        STACK_DESTROY(frame->root);
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-int32_t
-jbr_ipc_complete(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    jbr_local_t *local = NULL;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, frame, out);
-    local = frame->local;
-    GF_VALIDATE_OR_GOTO(this->name, local, out);
-
-    jbr_ipc_call_dispatch(frame, this, &op_errno, FDL_IPC_JBR_SERVER_ROLLBACK,
-                          local->xdata);
-out:
-    return 0;
-}
-
-int32_t
-jbr_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata)
-{
-    switch (op) {
-        case JBR_SERVER_TERM_RANGE:
-            jbr_get_terms(frame, this);
-            break;
-        case JBR_SERVER_OPEN_TERM:
-            jbr_open_term(frame, this, xdata);
-            break;
-        case JBR_SERVER_NEXT_ENTRY:
-            jbr_next_entry(frame, this);
-            break;
-        case FDL_IPC_JBR_SERVER_ROLLBACK:
-            /*
-             * Just send the fop down to fdl. Need not *
-             * dispatch it to other bricks in the sub- *
-             * volume, as it will be done where the op *
-             * has failed.                             *
-             */
-        default:
-            STACK_WIND_TAIL(frame, FIRST_CHILD(this),
-                            FIRST_CHILD(this)->fops->ipc, op, xdata);
-    }
-
-    return 0;
-}
-
-#pragma generate
-
-int32_t
-jbr_forget(xlator_t *this, inode_t *inode)
-{
-    uint64_t ctx = 0LL;
-
-    if ((inode_ctx_del(inode, this, &ctx) == 0) && ctx) {
-        GF_FREE((void *)(long)ctx);
-    }
-
-    return 0;
-}
-
-int32_t
-jbr_release(xlator_t *this, fd_t *fd)
-{
-    uint64_t ctx = 0LL;
-
-    if ((fd_ctx_del(fd, this, &ctx) == 0) && ctx) {
-        GF_FREE((void *)(long)ctx);
-    }
-
-    return 0;
-}
-
-struct xlator_cbks cbks = {
-    .forget = jbr_forget,
-    .release = jbr_release,
-};
-
-int
-jbr_reconfigure(xlator_t *this, dict_t *options)
-{
-    jbr_private_t *priv = this->private;
-
-    GF_OPTION_RECONF("leader", priv->config_leader, options, bool, err);
-    GF_OPTION_RECONF("quorum-percent", priv->quorum_pct, options, percent, err);
-    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-           "reconfigure called, config_leader = %d, quorum_pct = %.1f\n",
-           priv->leader, priv->quorum_pct);
-
-    priv->leader = priv->config_leader;
-
-    return 0;
-
-err:
-    return -1;
-}
-
-int
-jbr_get_child_index(xlator_t *this, xlator_t *kid)
-{
-    xlator_list_t *trav;
-    int retval = -1;
-
-    for (trav = this->children; trav; trav = trav->next) {
-        ++retval;
-        if (trav->xlator == kid) {
-            return retval;
-        }
-    }
-
-    return -1;
-}
-
-/*
- * Child notify handling is unreasonably FUBAR.  Sometimes we'll get a
- * CHILD_DOWN for a protocol/client child before we ever got a CHILD_UP for it.
- * Other times we won't.  Because it's effectively random (probably racy), we
- * can't just maintain a count.  We actually have to keep track of the state
- * for each child separately, to filter out the bogus CHILD_DOWN events, and
- * then generate counts on demand.
- */
-int
-jbr_notify(xlator_t *this, int event, void *data, ...)
-{
-    jbr_private_t *priv = this->private;
-    int index = -1;
-    int ret = -1;
-    gf_boolean_t result = _gf_false;
-    gf_boolean_t relevant = _gf_false;
-
-    switch (event) {
-        case GF_EVENT_CHILD_UP:
-            index = jbr_get_child_index(this, data);
-            if (index >= 0) {
-                /* Check if the child was previously down
-                 * and it's not a false CHILD_UP
-                 */
-                if (!(priv->kid_state & (1 << index))) {
-                    relevant = _gf_true;
-                }
-
-                priv->kid_state |= (1 << index);
-                priv->up_children = jbr_count_up_kids(priv);
-                gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                       "got CHILD_UP for %s, now %u kids",
-                       ((xlator_t *)data)->name, priv->up_children);
-                if (!priv->config_leader && (priv->up_children > 1)) {
-                    priv->leader = _gf_false;
-                }
-
-                /* If it's not relevant, or we have already *
-                 * sent CHILD_UP just break */
-                if (!relevant || priv->child_up)
-                    break;
-
-                /* If it's not a leader, just send the notify up */
-                if (!priv->leader) {
-                    ret = default_notify(this, event, data);
-                    if (!ret)
-                        priv->child_up = _gf_true;
-                    break;
-                }
-
-                result = fop_quorum_check(this, (double)(priv->n_children - 1),
-                                          (double)(priv->up_children - 1));
-                if (result == _gf_false) {
-                    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                           "Not enough children "
-                           "are up to meet quorum. Waiting to "
-                           "send CHILD_UP from leader");
-                } else {
-                    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                           "Enough children are up "
-                           "to meet quorum. Sending CHILD_UP "
-                           "from leader");
-                    ret = default_notify(this, event, data);
-                    if (!ret)
-                        priv->child_up = _gf_true;
-                }
-            }
-            break;
-        case GF_EVENT_CHILD_DOWN:
-            index = jbr_get_child_index(this, data);
-            if (index >= 0) {
-                /* Check if the child was previously up
-                 * and it's not a false CHILD_DOWN
-                 */
-                if (priv->kid_state & (1 << index)) {
-                    relevant = _gf_true;
-                }
-                priv->kid_state &= ~(1 << index);
-                priv->up_children = jbr_count_up_kids(priv);
-                gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                       "got CHILD_DOWN for %s, now %u kids",
-                       ((xlator_t *)data)->name, priv->up_children);
-                if (!priv->config_leader && (priv->up_children < 2) &&
-                    relevant) {
-                    priv->leader = _gf_true;
-                }
-
-                /* If it's not relevant, or we have already *
-                 * sent CHILD_DOWN just break */
-                if (!relevant || !priv->child_up)
-                    break;
-
-                /* If it's not a leader, just break coz we shouldn't  *
-                 * propagate the failure from the failure till it     *
-                 * itself goes down                                   *
-                 */
-                if (!priv->leader) {
-                    break;
-                }
-
-                result = fop_quorum_check(this, (double)(priv->n_children - 1),
-                                          (double)(priv->up_children - 1));
-                if (result == _gf_false) {
-                    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                           "Enough children are "
-                           "to down to fail quorum. "
-                           "Sending CHILD_DOWN from leader");
-                    ret = default_notify(this, event, data);
-                    if (!ret)
-                        priv->child_up = _gf_false;
-                } else {
-                    gf_msg(this->name, GF_LOG_INFO, 0, J_MSG_GENERIC,
-                           "Not enough children "
-                           "are down to fail quorum. Waiting to "
-                           "send CHILD_DOWN from leader");
-                }
-            }
-            break;
-        default:
-            ret = default_notify(this, event, data);
-    }
-
-    return ret;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("jbr", this, out);
-
-    ret = xlator_mem_acct_init(this, gf_mt_jbr_end + 1);
-
-    if (ret != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "Memory accounting init"
-               "failed");
-        return ret;
-    }
-out:
-    return ret;
-}
-
-void
-jbr_deallocate_priv(jbr_private_t *priv)
-{
-    if (!priv) {
-        return;
-    }
-
-    GF_FREE(priv);
-}
-
-int32_t
-jbr_init(xlator_t *this)
-{
-    xlator_list_t *remote;
-    xlator_list_t *local;
-    jbr_private_t *priv = NULL;
-    xlator_list_t *trav;
-    pthread_t kid;
-    extern xlator_t global_xlator;
-    glusterfs_ctx_t *oldctx = global_xlator.ctx;
-
-    /*
-     * Any fop that gets special treatment has to be patched in here,
-     * because the compiled-in table is produced by the code generator and
-     * only contains generated functions.  Note that we have to go through
-     * this->fops because of some dynamic-linking strangeness; modifying
-     * the static table doesn't work.
-     */
-    this->fops->getxattr = jbr_getxattr_special;
-    this->fops->fsync = jbr_fsync;
-
-    local = this->children;
-    if (!local) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_NO_DATA,
-               "no local subvolume");
-        goto err;
-    }
-
-    remote = local->next;
-    if (!remote) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_NO_DATA,
-               "no remote subvolumes");
-        goto err;
-    }
-
-    this->local_pool = mem_pool_new(jbr_local_t, 128);
-    if (!this->local_pool) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "failed to create jbr_local_t pool");
-        goto err;
-    }
-
-    priv = GF_CALLOC(1, sizeof(*priv), gf_mt_jbr_private_t);
-    if (!priv) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_MEM_ERR,
-               "could not allocate priv");
-        goto err;
-    }
-
-    for (trav = this->children; trav; trav = trav->next) {
-        ++(priv->n_children);
-    }
-
-    LOCK_INIT(&priv->dirty_lock);
-    LOCK_INIT(&priv->index_lock);
-    INIT_LIST_HEAD(&priv->dirty_fds);
-    priv->term_fd = -1;
-
-    this->private = priv;
-
-    GF_OPTION_INIT("leader", priv->config_leader, bool, err);
-    GF_OPTION_INIT("quorum-percent", priv->quorum_pct, percent, err);
-
-    priv->leader = priv->config_leader;
-    priv->child_up = _gf_false;
-
-    if (gf_thread_create(&kid, NULL, jbr_flush_thread, this, "jbrflush") != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, J_MSG_SYS_CALL_FAILURE,
-               "could not start flush thread");
-        /* TBD: treat this as a fatal error? */
-    }
-
-    /*
-     * Calling glfs_new changes old->ctx, even if THIS still points
-     * to global_xlator.  That causes problems later in the main
-     * thread, when gf_log_dump_graph tries to use the FILE after
-     * we've mucked with it and gets a segfault in __fprintf_chk.
-     * We can avoid all that by undoing the damage before we
-     * continue.
-     */
-    global_xlator.ctx = oldctx;
-
-    return 0;
-
-err:
-    jbr_deallocate_priv(priv);
-    return -1;
-}
-
-void
-jbr_fini(xlator_t *this)
-{
-    jbr_deallocate_priv(this->private);
-}
-
-class_methods_t class_methods = {
-    .init = jbr_init,
-    .fini = jbr_fini,
-    .reconfigure = jbr_reconfigure,
-    .notify = jbr_notify,
-};
-
-struct volume_options options[] = {
-    {.key = {"leader"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .default_value = "false",
-     .description = "Start in the leader role.  This is only for "
-                    "bootstrapping the code, and should go away when we "
-                    "have real leader election."},
-    {.key = {"vol-name"},
-     .type = GF_OPTION_TYPE_STR,
-     .description = "volume name"},
-    {.key = {"my-name"},
-     .type = GF_OPTION_TYPE_STR,
-     .description = "brick name in form of host:/path"},
-    {.key = {"etcd-servers"},
-     .type = GF_OPTION_TYPE_STR,
-     .description = "list of comma separated etc servers"},
-    {.key = {"subvol-uuid"},
-     .type = GF_OPTION_TYPE_STR,
-     .description = "UUID for this JBR (sub)volume"},
-    {.key = {"quorum-percent"},
-     .type = GF_OPTION_TYPE_PERCENT,
-     .default_value = "50.0",
-     .description = "percentage of rep_count-1 that must be up"},
-    {.key = {NULL}},
-};
diff --git a/xlators/experimental/posix2/Makefile.am b/xlators/experimental/posix2/Makefile.am
deleted file mode 100644
index 74e5ab0f5bc..00000000000
--- a/xlators/experimental/posix2/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = common mds ds
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/README.md b/xlators/experimental/posix2/README.md
deleted file mode 100644
index 955a98d061e..00000000000
--- a/xlators/experimental/posix2/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# POSIX2 Experimental README
-
-POSIX2 is an implementation of modified storage translator to cater to DHT2
-on disk needs.
-
-For further understanding, refer to xlators/experimental/dht2/README.md for
-details regarding POSIX2
diff --git a/xlators/experimental/posix2/TODO.md b/xlators/experimental/posix2/TODO.md
deleted file mode 100644
index 20cd1e89c1d..00000000000
--- a/xlators/experimental/posix2/TODO.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# POSIX2 TODO List
-
-<Items will be added as code is pulled into the repository>
\ No newline at end of file
diff --git a/xlators/experimental/posix2/common/Makefile.am b/xlators/experimental/posix2/common/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/posix2/common/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/common/src/Makefile.am b/xlators/experimental/posix2/common/src/Makefile.am
deleted file mode 100644
index 07533d2bf37..00000000000
--- a/xlators/experimental/posix2/common/src/Makefile.am
+++ /dev/null
@@ -1,16 +0,0 @@
-lib_LTLIBRARIES = libposix2common.la
-
-posix2_common_sources = posix2-common.c
-
-libposix2common_la_SOURCES = $(posix2_common_sources)
-libposix2common_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-libposix2common_la_CFLAGS = -Wall $(GF_CFLAGS)
-
-libposix2common_la_CPPFLAGS = $(GF_CPPFLAGS)
-libposix2common_la_CPPFLAGS += -I$(top_srcdir)/libglusterfs/src
-libposix2common_la_CPPFLAGS += -I$(top_srcdir)/rpc/xdr/src
-libposix2common_la_CPPFLAGS += -I$(top_builddir)/rpc/xdr/src
-
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/common/src/posix2-common.c b/xlators/experimental/posix2/common/src/posix2-common.c
deleted file mode 100644
index 06702528bec..00000000000
--- a/xlators/experimental/posix2/common/src/posix2-common.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-  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.
-*/
-
-/* File: posix2-common.c
- * This file contains common routines across ds and mds posix xlators
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
diff --git a/xlators/experimental/posix2/ds/Makefile.am b/xlators/experimental/posix2/ds/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/posix2/ds/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/ds/src/Makefile.am b/xlators/experimental/posix2/ds/src/Makefile.am
deleted file mode 100644
index 7a792a8d07b..00000000000
--- a/xlators/experimental/posix2/ds/src/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-if WITH_SERVER
-xlator_LTLIBRARIES = posix2-ds.la
-endif
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-
-posix2_ds_sources = posix2-ds-main.c
-
-posix2_ds_la_SOURCES = $(posix2_ds_sources)
-posix2_ds_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-posix2_ds_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-posix2_ds_la_LIBADD += $(top_builddir)/xlators/experimental/posix2/common/src/libposix2common.la
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-AM_CPPFLAGS = $(GF_CPPFLAGS)
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/storage/posix2/common/src
-AM_CPPFLAGS += -I$(top_srcdir)/libglusterfs/src
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/lib/src
-AM_CPPFLAGS += -I$(top_srcdir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_builddir)/rpc/xdr/src
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/ds/src/posix2-ds-main.c b/xlators/experimental/posix2/ds/src/posix2-ds-main.c
deleted file mode 100644
index 0d3a026611e..00000000000
--- a/xlators/experimental/posix2/ds/src/posix2-ds-main.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  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.
-*/
-
-/* File: posix2-ds-main.c
- * This file contains the xlator loading functions, FOP entry points
- * and options.
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
-
-int32_t
-posix2_ds_init(xlator_t *this)
-{
-    if (this->children) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "This (%s) is a leaf xlator, but found children", this->name);
-        return -1;
-    }
-
-    return 0;
-}
-
-void
-posix2_ds_fini(xlator_t *this)
-{
-    return;
-}
-
-class_methods_t class_methods = {
-    .init = posix2_ds_init,
-    .fini = posix2_ds_fini,
-};
-
-struct xlator_fops fops = {};
-
-struct xlator_cbks cbks = {};
-
-/*
-struct xlator_dumpops dumpops = {
-};
-*/
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/experimental/posix2/mds/Makefile.am b/xlators/experimental/posix2/mds/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/experimental/posix2/mds/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/mds/src/Makefile.am b/xlators/experimental/posix2/mds/src/Makefile.am
deleted file mode 100644
index 0681cb73c45..00000000000
--- a/xlators/experimental/posix2/mds/src/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-if WITH_SERVER
-xlator_LTLIBRARIES = posix2-mds.la
-endif
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/experimental
-
-posix2_mds_sources = posix2-mds-main.c
-
-posix2_mds_la_SOURCES = $(posix2_mds_sources)
-posix2_mds_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-posix2_mds_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-posix2_mds_la_LIBADD += $(top_builddir)/xlators/experimental/posix2/common/src/libposix2common.la
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-AM_CPPFLAGS = $(GF_CPPFLAGS)
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/storage/posix2/common/src
-AM_CPPFLAGS += -I$(top_srcdir)/libglusterfs/src
-AM_CPPFLAGS += -I$(top_srcdir)/xlators/lib/src
-AM_CPPFLAGS += -I$(top_srcdir)/rpc/xdr/src
-AM_CPPFLAGS += -I$(top_builddir)/rpc/xdr/src
-
-CLEANFILES =
diff --git a/xlators/experimental/posix2/mds/src/posix2-mds-main.c b/xlators/experimental/posix2/mds/src/posix2-mds-main.c
deleted file mode 100644
index f2ec570917d..00000000000
--- a/xlators/experimental/posix2/mds/src/posix2-mds-main.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  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.
-*/
-
-/* File: posix2-mds-main.c
- * This file contains the xlator loading functions, FOP entry points
- * and options.
- * The entire functionality including comments is TODO.
- */
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/statedump.h>
-
-int32_t
-posix2_mds_init(xlator_t *this)
-{
-    if (this->children) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "This (%s) is a leaf xlator, but found children", this->name);
-        return -1;
-    }
-
-    return 0;
-}
-
-void
-posix2_mds_fini(xlator_t *this)
-{
-    return;
-}
-
-class_methods_t class_methods = {
-    .init = posix2_mds_init,
-    .fini = posix2_mds_fini,
-};
-
-struct xlator_fops fops = {};
-
-struct xlator_cbks cbks = {};
-
-/*
-struct xlator_dumpops dumpops = {
-};
-*/
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/features/changetimerecorder/Makefile.am b/xlators/features/changetimerecorder/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/features/changetimerecorder/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/features/changetimerecorder/src/Makefile.am b/xlators/features/changetimerecorder/src/Makefile.am
deleted file mode 100644
index 620017e3309..00000000000
--- a/xlators/features/changetimerecorder/src/Makefile.am
+++ /dev/null
@@ -1,26 +0,0 @@
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features
-
-# changetimerecorder can only get build when libgfdb is enabled
-if BUILD_GFDB
-   xlator_LTLIBRARIES = changetimerecorder.la
-endif
-
-changetimerecorder_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-
-changetimerecorder_la_SOURCES = changetimerecorder.c \
-	ctr-helper.c ctr-xlator-ctx.c
-
-changetimerecorder_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la\
-	$(top_builddir)/libglusterfs/src/gfdb/libgfdb.la
-
-noinst_HEADERS = ctr-messages.h changetimerecorder.h ctr_mem_types.h \
-		ctr-helper.h ctr-xlator-ctx.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/libglusterfs/src/gfdb \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
-	-DDATADIR=\"$(localstatedir)\"
-
-AM_CFLAGS = -Wall $(GF_CFLAGS) $(SQLITE_CFLAGS)
-
-CLEANFILES =
diff --git a/xlators/features/changetimerecorder/src/changetimerecorder.c b/xlators/features/changetimerecorder/src/changetimerecorder.c
deleted file mode 100644
index 1d8068c4f4e..00000000000
--- a/xlators/features/changetimerecorder/src/changetimerecorder.c
+++ /dev/null
@@ -1,2357 +0,0 @@
-/*
-   Copyright (c) 2015 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.
-*/
-#include <ctype.h>
-#include <sys/uio.h>
-
-#include "gfdb_sqlite3.h"
-#include "ctr-helper.h"
-#include "ctr-messages.h"
-#include <glusterfs/syscall.h>
-
-#include "changetimerecorder.h"
-#include "tier-ctr-interface.h"
-
-/*******************************inode forget***********************************/
-int
-ctr_forget(xlator_t *this, inode_t *inode)
-{
-    fini_ctr_xlator_ctx(this, inode);
-    return 0;
-}
-
-/************************** Look up heal **************************************/
-/*
-Problem: The CTR xlator records file meta (heat/hardlinks)
-into the data. This works fine for files which are created
-after ctr xlator is switched ON. But for files which were
-created before CTR xlator is ON, CTR xlator is not able to
-record either of the meta i.e heat or hardlinks. Thus making
-those files immune to promotions/demotions.
-
-Solution: The solution that is implemented in this patch is
-do ctr-db heal of all those pre-existent files, using named lookup.
-For this purpose we use the inode-xlator context variable option
-in gluster.
-The inode-xlator context variable for ctr xlator will have the
-following,
-    a. A Lock for the context variable
-    b. A hardlink list: This list represents the successful looked
-       up hardlinks.
-These are the scenarios when the hardlink list is updated:
-1) Named-Lookup: Whenever a named lookup happens on a file, in the
-   wind path we copy all required hardlink and inode information to
-   ctr_db_record structure, which resides in the frame->local variable.
-   We don't update the database in wind. During the unwind, we read the
-   information from the ctr_db_record and ,
-   Check if the inode context variable is created, if not we create it.
-   Check if the hard link is there in the hardlink list.
-      If its not there we add it to the list and send a update to the
-      database using libgfdb.
-      Please note: The database transaction can fail(and we ignore) as there
-      already might be a record in the db. This update to the db is to heal
-      if its not there.
-      If its there in the list we ignore it.
-2) Inode Forget: Whenever an inode forget hits we clear the hardlink list in
-   the inode context variable and delete the inode context variable.
-   Please note: An inode forget may happen for two reason,
-   a. when the inode is delete.
-   b. the in-memory inode is evicted from the inode table due to cache limits.
-3) create: whenever a create happens we create the inode context variable and
-   add the hardlink. The database updation is done as usual by ctr.
-4) link: whenever a hardlink is created for the inode, we create the inode
- context variable, if not present, and add the hardlink to the list.
-5) unlink: whenever a unlink happens we delete the hardlink from the list.
-6) mknod: same as create.
-7) rename: whenever a rename happens we update the hardlink in list. if the
-   hardlink was not present for updation, we add the hardlink to the list.
-
-What is pending:
-1) This solution will only work for named lookups.
-2) We don't track afr-self-heal/dht-rebalancer traffic for healing.
-
-*/
-
-/* This function does not write anything to the db,
- * just created the local variable
- * for the frame and sets values for the ctr_db_record */
-static int
-ctr_lookup_wind(call_frame_t *frame, xlator_t *this,
-                gf_ctr_inode_context_t *ctr_inode_cx)
-{
-    int ret = -1;
-    gf_ctr_private_t *_priv = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-    GF_ASSERT(this);
-    IS_CTR_INODE_CX_SANE(ctr_inode_cx);
-
-    _priv = this->private;
-    GF_ASSERT(_priv);
-
-    if (_priv->ctr_record_wind && ctr_inode_cx->ia_type != IA_IFDIR) {
-        frame->local = init_ctr_local_t(this);
-        if (!frame->local) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_CREATE_CTR_LOCAL_ERROR_WIND,
-                   "WIND: Error while creating ctr local");
-            goto out;
-        };
-        ctr_local = frame->local;
-        /*Definitely no internal fops will reach here*/
-        ctr_local->is_internal_fop = _gf_false;
-        /*Don't record counters*/
-        CTR_DB_REC(ctr_local).do_record_counters = _gf_false;
-        /*Don't record time at all*/
-        CTR_DB_REC(ctr_local).do_record_times = _gf_false;
-
-        /* Copy gfid into db record*/
-        gf_uuid_copy(CTR_DB_REC(ctr_local).gfid, *(ctr_inode_cx->gfid));
-
-        /* Set fop_path and fop_type, required by libgfdb to make
-         * decision while inserting the record */
-        CTR_DB_REC(ctr_local).gfdb_fop_path = ctr_inode_cx->fop_path;
-        CTR_DB_REC(ctr_local).gfdb_fop_type = ctr_inode_cx->fop_type;
-
-        /* Copy hard link info*/
-        gf_uuid_copy(CTR_DB_REC(ctr_local).pargfid,
-                     *((NEW_LINK_CX(ctr_inode_cx))->pargfid));
-        if (snprintf(CTR_DB_REC(ctr_local).file_name,
-                     sizeof(CTR_DB_REC(ctr_local).file_name), "%s",
-                     NEW_LINK_CX(ctr_inode_cx)->basename) >=
-            sizeof(CTR_DB_REC(ctr_local).file_name)) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_CREATE_CTR_LOCAL_ERROR_WIND,
-                   "WIND: Error copying filename of ctr local");
-            goto out;
-        }
-        /* Since we are in lookup we can ignore errors while
-         * Inserting in the DB, because there may be many
-         * to write to the DB attempts for healing.
-         * We don't want to log all failed attempts and
-         * bloat the log*/
-        ctr_local->gfdb_db_record.ignore_errors = _gf_true;
-    }
-
-    ret = 0;
-
-out:
-
-    if (ret) {
-        free_ctr_local(ctr_local);
-        frame->local = NULL;
-    }
-
-    return ret;
-}
-
-/* This function inserts the ctr_db_record populated by ctr_lookup_wind
- * in to the db. It also destroys the frame->local created by ctr_lookup_wind */
-static int
-ctr_lookup_unwind(call_frame_t *frame, xlator_t *this)
-{
-    int ret = -1;
-    gf_ctr_private_t *_priv = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-
-    _priv = this->private;
-    GF_ASSERT(_priv);
-
-    GF_ASSERT(_priv->_db_conn);
-
-    ctr_local = frame->local;
-
-    if (ctr_local && (ctr_local->ia_inode_type != IA_IFDIR)) {
-        ret = insert_record(_priv->_db_conn, &ctr_local->gfdb_db_record);
-        if (ret == -1) {
-            gf_msg(this->name,
-                   _gfdb_log_level(GF_LOG_ERROR,
-                                   ctr_local->gfdb_db_record.ignore_errors),
-                   0, CTR_MSG_FILL_CTR_LOCAL_ERROR_UNWIND,
-                   "UNWIND: Error filling ctr local");
-            goto out;
-        }
-    }
-    ret = 0;
-out:
-    free_ctr_local(ctr_local);
-    frame->local = NULL;
-    return ret;
-}
-
-/******************************************************************************
- *
- *                        FOPS HANDLING BELOW
- *
- * ***************************************************************************/
-
-/****************************LOOKUP********************************************/
-
-int32_t
-ctr_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, inode_t *inode,
-               struct iatt *buf, dict_t *dict, struct iatt *postparent)
-{
-    int ret = -1;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-    ctr_heal_ret_val_t ret_val = CTR_CTX_ERROR;
-    gf_boolean_t _is_heal_needed = _gf_false;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-
-    /* if the lookup failed lookup don't do anything*/
-    if (op_ret == -1) {
-        gf_msg_trace(this->name, 0, "lookup failed with %s",
-                     strerror(op_errno));
-        goto out;
-    }
-
-    /* Ignore directory lookups */
-    if (inode->ia_type == IA_IFDIR) {
-        goto out;
-    }
-
-    /* if frame local was not set by the ctr_lookup()
-     * so don't so anything*/
-    if (!frame->local) {
-        goto out;
-    }
-
-    /* if the lookup is for dht link donot record*/
-    if (dht_is_linkfile(buf, dict)) {
-        gf_msg_trace(this->name, 0,
-                     "Ignoring Lookup "
-                     "for dht link file");
-        goto out;
-    }
-
-    ctr_local = frame->local;
-    /*Assign the proper inode type*/
-    ctr_local->ia_inode_type = inode->ia_type;
-
-    /* Copy gfid directly from inode */
-    gf_uuid_copy(CTR_DB_REC(ctr_local).gfid, inode->gfid);
-
-    /* Checking if gfid and parent gfid is valid */
-    if (gf_uuid_is_null(CTR_DB_REC(ctr_local).gfid) ||
-        gf_uuid_is_null(CTR_DB_REC(ctr_local).pargfid)) {
-        gf_msg_trace(this->name, 0, "Invalid GFID");
-        goto out;
-    }
-
-    /* if its a first entry
-     * then mark the ctr_record for create
-     * A create will attempt a file and a hard link created in the db*/
-    ctr_xlator_ctx = get_ctr_xlator_ctx(this, inode);
-    if (!ctr_xlator_ctx) {
-        /* This marks inode heal */
-        CTR_DB_REC(ctr_local).gfdb_fop_type = GFDB_FOP_CREATE_WRITE;
-        _is_heal_needed = _gf_true;
-    }
-
-    /* Copy the correct gfid from resolved inode */
-    gf_uuid_copy(CTR_DB_REC(ctr_local).gfid, inode->gfid);
-
-    /* Add hard link to the list */
-    ret_val = add_hard_link_ctx(frame, this, inode);
-    if (ret_val == CTR_CTX_ERROR) {
-        gf_msg_trace(this->name, 0, "Failed adding hardlink to list");
-        goto out;
-    }
-    /* If inode needs healing then heal the hardlink also */
-    else if (ret_val & CTR_TRY_INODE_HEAL) {
-        /* This marks inode heal */
-        CTR_DB_REC(ctr_local).gfdb_fop_type = GFDB_FOP_CREATE_WRITE;
-        _is_heal_needed = _gf_true;
-    }
-    /* If hardlink needs healing */
-    else if (ret_val & CTR_TRY_HARDLINK_HEAL) {
-        _is_heal_needed = _gf_true;
-    }
-
-    /* If lookup heal needed */
-    if (!_is_heal_needed)
-        goto out;
-
-    /* FINALLY HEAL : Inserts the ctr_db_record populated by ctr_lookup_wind
-     * in to the db. It also destroys the frame->local
-     * created by ctr_lookup_wind */
-    ret = ctr_lookup_unwind(frame, this);
-    if (ret) {
-        gf_msg_trace(this->name, 0, "Failed healing/inserting link");
-    }
-
-out:
-    free_ctr_local((gf_ctr_local_t *)frame->local);
-    frame->local = NULL;
-
-    STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, dict,
-                        postparent);
-
-    return 0;
-}
-
-int32_t
-ctr_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t ctr_link_cx;
-    gf_ctr_link_context_t *_link_cx = &ctr_link_cx;
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-
-    /* Don't handle nameless lookups*/
-    if (!loc->parent || !loc->name)
-        goto out;
-
-    /*fill ctr link context*/
-    FILL_CTR_LINK_CX(_link_cx, loc->parent->gfid, loc->name, out);
-
-    /* Fill ctr inode context*/
-    /* IA_IFREG : We assume its a file in the wind
-     * but in the unwind we are sure what the inode is a file
-     * or directory
-     * gfid: we are just filling loc->gfid which is not correct.
-     * In unwind we fill the correct gfid for successful lookup*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, IA_IFREG, loc->gfid, _link_cx, NULL,
-                           GFDB_FOP_DENTRY_WRITE, GFDB_FOP_WIND);
-
-    /* Create the frame->local and populate ctr_db_record
-     * No writing to the db yet */
-    ret = ctr_lookup_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_LINK_WIND_FAILED,
-               "Failed to insert link wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, xdata);
-    return 0;
-}
-
-/****************************WRITEV********************************************/
-int32_t
-ctr_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-               struct iatt *postbuf, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_WRITEV_UNWIND_FAILED,
-               "Failed to insert writev unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf,
-                        xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-           int32_t count, off_t off, uint32_t flags, struct iobref *iobref,
-           dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_WRITEV_WIND_FAILED,
-               "Failed to insert writev wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_writev_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->writev, fd, vector, count, off, flags,
-               iobref, xdata);
-
-    return 0;
-}
-
-/******************************setattr*****************************************/
-
-int32_t
-ctr_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *preop_stbuf,
-                struct iatt *postop_stbuf, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_SETATTR_UNWIND_FAILED,
-               "Failed to insert setattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(setattr, frame, op_ret, op_errno, preop_stbuf,
-                        postop_stbuf, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
-            int32_t valid, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, loc->inode->gfid,
-                           NULL, NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_SETATTR_WIND_FAILED,
-               "Failed to insert setattr wind");
-    }
-out:
-
-    STACK_WIND(frame, ctr_setattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
-
-    return 0;
-}
-
-/*************************** fsetattr ***************************************/
-int32_t
-ctr_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *preop_stbuf,
-                 struct iatt *postop_stbuf, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_SETATTR_UNWIND_FAILED,
-               "Failed to insert fsetattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(fsetattr, frame, op_ret, op_errno, preop_stbuf,
-                        postop_stbuf, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf,
-             int32_t valid, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_SETATTR_WIND_FAILED,
-               "Failed to insert fsetattr wind");
-    }
-out:
-    STACK_WIND(frame, ctr_fsetattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
-
-    return 0;
-}
-/****************************fremovexattr************************************/
-
-int32_t
-ctr_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_FREMOVEXATTR_UNWIND_FAILED,
-               "Failed to insert fremovexattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_FREMOVEXATTR_WIND_FAILED,
-               "Failed to insert fremovexattr wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_fremovexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
-    return 0;
-}
-
-/****************************removexattr*************************************/
-
-int32_t
-ctr_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_REMOVEXATTR_UNWIND_FAILED,
-               "Failed to insert removexattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, loc->inode->gfid,
-                           NULL, NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_REMOVEXATTR_WIND_FAILED,
-               "Failed to insert removexattr wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_removexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
-    return 0;
-}
-
-/****************************truncate****************************************/
-
-int32_t
-ctr_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                 struct iatt *postbuf, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_TRUNCATE_UNWIND_FAILED,
-               "Failed to insert truncate unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(truncate, frame, op_ret, op_errno, prebuf, postbuf,
-                        xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-             dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, loc->inode->gfid,
-                           NULL, NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_TRUNCATE_WIND_FAILED,
-               "Failed to insert truncate wind");
-    }
-out:
-    STACK_WIND(frame, ctr_truncate_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
-    return 0;
-}
-
-/****************************ftruncate***************************************/
-
-int32_t
-ctr_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_FTRUNCATE_UNWIND_FAILED,
-               "Failed to insert ftruncate unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(ftruncate, frame, op_ret, op_errno, prebuf, postbuf,
-                        xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-              dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_INSERT_FTRUNCATE_WIND_FAILED,
-               "Failed to insert ftruncate wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_ftruncate_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
-    return 0;
-}
-
-/****************************rename******************************************/
-int32_t
-ctr_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *buf,
-               struct iatt *preoldparent, struct iatt *postoldparent,
-               struct iatt *prenewparent, struct iatt *postnewparent,
-               dict_t *xdata)
-{
-    int ret = -1;
-    uint32_t remaining_links = -1;
-    gf_ctr_local_t *ctr_local = NULL;
-    gfdb_fop_type_t fop_type = GFDB_FOP_INVALID_OP;
-    gfdb_fop_path_t fop_path = GFDB_FOP_INVALID;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_DENTRY_WRITE,
-                            GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_RENAME_UNWIND_FAILED,
-               "Failed to insert rename unwind");
-        goto out;
-    }
-
-    if (!xdata)
-        goto out;
-    /*
-     *
-     * Extracting GF_RESPONSE_LINK_COUNT_XDATA from POSIX Xlator
-     * This is only set when we are overwriting hardlinks.
-     *
-     * */
-    ret = dict_get_uint32(xdata, GF_RESPONSE_LINK_COUNT_XDATA,
-                          &remaining_links);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_GET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-               "Failed to getting GF_RESPONSE_LINK_COUNT_XDATA");
-        remaining_links = -1;
-        goto out;
-    }
-
-    ctr_local = frame->local;
-    if (!ctr_local) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_NULL_LOCAL,
-               "ctr_local is NULL.");
-        goto out;
-    }
-
-    /* This is not the only link */
-    if (remaining_links > 1) {
-        fop_type = GFDB_FOP_DENTRY_WRITE;
-        fop_path = GFDB_FOP_UNDEL;
-    }
-    /* Last link that was deleted */
-    else if (remaining_links == 1) {
-        fop_type = GFDB_FOP_DENTRY_WRITE;
-        fop_path = GFDB_FOP_UNDEL_ALL;
-    } else {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_RENAME_UNWIND_FAILED,
-               "Invalid link count from posix");
-        goto out;
-    }
-
-    ret = ctr_delete_hard_link_from_db(
-        this, CTR_DB_REC(ctr_local).old_gfid, CTR_DB_REC(ctr_local).pargfid,
-        CTR_DB_REC(ctr_local).file_name, fop_type, fop_path);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_UNLINK_UNWIND_FAILED,
-               "Failed to delete records of %s",
-               CTR_DB_REC(ctr_local).old_file_name);
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(rename, frame, op_ret, op_errno, buf, preoldparent,
-                        postoldparent, prenewparent, postnewparent, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-           dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t new_link_cx, old_link_cx;
-    gf_ctr_link_context_t *_nlink_cx = &new_link_cx;
-    gf_ctr_link_context_t *_olink_cx = &old_link_cx;
-    int is_dict_created = 0;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill old link context*/
-    FILL_CTR_LINK_CX(_olink_cx, oldloc->pargfid, oldloc->name, out);
-
-    /*Fill new link context*/
-    FILL_CTR_LINK_CX(_nlink_cx, newloc->pargfid, newloc->name, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, oldloc->inode->ia_type,
-                           oldloc->inode->gfid, _nlink_cx, _olink_cx,
-                           GFDB_FOP_DENTRY_WRITE, GFDB_FOP_WIND);
-
-    /* If the rename is a overwrite of hardlink
-     * rename ("file1", "file2")
-     * file1 is hardlink for gfid say 00000000-0000-0000-0000-00000000000A
-     * file2 is hardlink for gfid say 00000000-0000-0000-0000-00000000000B
-     * so we are saving file2 gfid in old_gfid so that we delete entries
-     * from the db during rename callback if the fop is successful
-     * */
-    if (newloc->inode) {
-        /* This is the GFID from where the newloc hardlink will be
-         * unlinked */
-        _inode_cx->old_gfid = &newloc->inode->gfid;
-    }
-
-    /* Is a metatdata fop */
-    _inode_cx->is_metadata_fop = _gf_true;
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_RENAME_WIND_FAILED,
-               "Failed to insert rename wind");
-    } else {
-        /* We are doing updation of hard link in inode context in wind
-         * As we don't get the "inode" in the call back for rename */
-        ret = update_hard_link_ctx(frame, this, oldloc->inode);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_UPDATE_HARDLINK_FAILED,
-                   "Failed "
-                   "updating hard link in ctr inode context");
-            goto out;
-        }
-
-        /* If the newloc has an inode. i.e acquiring hardlink of an
-         * exisitng file i.e overwritting a file.
-         * */
-        if (newloc->inode) {
-            /* Getting the ctr inode context variable for
-             * inode whose hardlink will be acquired during
-             * the rename
-             * */
-            ctr_xlator_ctx = get_ctr_xlator_ctx(this, newloc->inode);
-            if (!ctr_xlator_ctx) {
-                /* Since there is no ctr inode context
-                 * so nothing more to do */
-                ret = 0;
-                goto out;
-            }
-
-            /* Deleting hardlink from context variable */
-            ret = ctr_delete_hard_link(this, ctr_xlator_ctx, newloc->pargfid,
-                                       newloc->name);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       CTR_MSG_DELETE_HARDLINK_FAILED,
-                       "Failed to delete hard link");
-                goto out;
-            }
-
-            /* Requesting for number of hardlinks on the newloc
-             * inode from POSIX.
-             * */
-            is_dict_created = set_posix_link_request(this, &xdata);
-            if (is_dict_created == -1) {
-                ret = -1;
-                goto out;
-            }
-        }
-    }
-
-out:
-    STACK_WIND(frame, ctr_rename_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
-
-    if (is_dict_created == 1) {
-        dict_unref(xdata);
-    }
-
-    return 0;
-}
-
-/****************************unlink******************************************/
-int32_t
-ctr_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-               struct iatt *postparent, dict_t *xdata)
-{
-    int ret = -1;
-    uint32_t remaining_links = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    if (!xdata)
-        goto out;
-
-    /*
-     *
-     * Extracting GF_RESPONSE_LINK_COUNT_XDATA from POSIX Xlator
-     *
-     * */
-    ret = dict_get_uint32(xdata, GF_RESPONSE_LINK_COUNT_XDATA,
-                          &remaining_links);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_GET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-               "Failed to getting GF_RESPONSE_LINK_COUNT_XDATA");
-        remaining_links = -1;
-    }
-
-    /*This is not the only link*/
-    if (remaining_links != 1) {
-        ret = ctr_insert_unwind(frame, this, GFDB_FOP_DENTRY_WRITE,
-                                GFDB_FOP_UNDEL);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_INSERT_UNLINK_UNWIND_FAILED,
-                   "Failed to insert unlink unwind");
-        }
-    }
-    /*Last link that was deleted*/
-    else if (remaining_links == 1) {
-        ret = ctr_insert_unwind(frame, this, GFDB_FOP_DENTRY_WRITE,
-                                GFDB_FOP_UNDEL_ALL);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_INSERT_UNLINK_UNWIND_FAILED,
-                   "Failed to insert unlink unwind");
-        }
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent,
-                        xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-           dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t ctr_link_cx;
-    gf_ctr_link_context_t *_link_cx = &ctr_link_cx;
-    gf_boolean_t is_xdata_created = _gf_false;
-    struct iatt dummy_stat = {0};
-
-    GF_ASSERT(frame);
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill link context*/
-    FILL_CTR_LINK_CX(_link_cx, loc->pargfid, loc->name, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, loc->inode->gfid,
-                           _link_cx, NULL, GFDB_FOP_DENTRY_WRITE,
-                           GFDB_FOP_WDEL);
-
-    /*Internal FOP*/
-    _inode_cx->is_internal_fop = is_internal_fop(frame, xdata);
-
-    /* Is a metadata FOP */
-    _inode_cx->is_metadata_fop = _gf_true;
-
-    /* If its a internal FOP and dht link file donot record*/
-    if (_inode_cx->is_internal_fop && dht_is_linkfile(&dummy_stat, xdata)) {
-        goto out;
-    }
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_UNLINK_UNWIND_FAILED,
-               "Failed to insert unlink wind");
-    } else {
-        /* We are doing delete of hard link in inode context in wind
-         * As we don't get the "inode" in the call back for rename */
-        ret = delete_hard_link_ctx(frame, this, loc->inode);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_DELETE_HARDLINK_FAILED,
-                   "Failed "
-                   "deleting hard link from ctr inode context");
-        }
-    }
-
-    /*
-     *
-     * Sending GF_REQUEST_LINK_COUNT_XDATA
-     * to POSIX Xlator to send link count in unwind path
-     *
-     * */
-    /*create xdata if NULL*/
-    if (!xdata) {
-        xdata = dict_new();
-        is_xdata_created = (xdata) ? _gf_true : _gf_false;
-    }
-    if (!xdata) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_XDATA_NULL,
-               "xdata is NULL :Cannot send "
-               "GF_REQUEST_LINK_COUNT_XDATA to posix");
-        goto out;
-    }
-
-    ret = dict_set_int32(xdata, GF_REQUEST_LINK_COUNT_XDATA, 1);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_SET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-               "Failed setting GF_REQUEST_LINK_COUNT_XDATA");
-        if (is_xdata_created) {
-            dict_unref(xdata);
-        }
-        goto out;
-    }
-
-out:
-    STACK_WIND(frame, ctr_unlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
-
-    if (is_xdata_created)
-        dict_unref(xdata);
-
-    return 0;
-}
-
-/****************************fsync******************************************/
-int32_t
-ctr_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
-              dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_FSYNC_UNWIND_FAILED,
-               "Failed to insert fsync unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
-          dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_FSYNC_WIND_FAILED,
-               "Failed to insert fsync wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_fsync_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsync, fd, flags, xdata);
-    return 0;
-}
-
-/****************************setxattr****************************************/
-
-int
-ctr_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_FSYNC_UNWIND_FAILED,
-               "Failed to insert setxattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata);
-
-    return 0;
-}
-
-int
-ctr_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr,
-             int flags, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, loc->inode->gfid,
-                           NULL, NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_SETATTR_WIND_FAILED,
-               "Failed to insert setxattr wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_setxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setxattr, loc, xattr, flags, xdata);
-    return 0;
-}
-/**************************** fsetxattr *************************************/
-int32_t
-ctr_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_WRITE, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_FSYNC_UNWIND_FAILED,
-               "Failed to insert fsetxattr unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata);
-
-    return 0;
-}
-
-int32_t
-ctr_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int32_t flags, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-    CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_SETATTR_WIND_FAILED,
-               "Failed to insert fsetxattr wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_fsetxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
-    return 0;
-}
-/****************************mknod*******************************************/
-
-int32_t
-ctr_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, inode_t *inode, struct iatt *buf,
-              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    int ret = -1;
-    ctr_heal_ret_val_t ret_val = CTR_CTX_ERROR;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    /* Add hard link to the list */
-    ret_val = add_hard_link_ctx(frame, this, inode);
-    if (ret_val == CTR_CTX_ERROR) {
-        gf_msg_trace(this->name, 0, "Failed adding hard link");
-    }
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_CREATE_WRITE,
-                            GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_MKNOD_UNWIND_FAILED,
-               "Failed to insert mknod unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(mknod, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-
-    return 0;
-}
-
-int
-ctr_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dev_t rdev, mode_t umask, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t ctr_link_cx;
-    gf_ctr_link_context_t *_link_cx = &ctr_link_cx;
-    uuid_t gfid = {
-        0,
-    };
-    uuid_t *ptr_gfid = &gfid;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-
-    /*get gfid from xdata dict*/
-    ret = dict_get_gfuuid(xdata, "gfid-req", &gfid);
-    if (ret) {
-        gf_msg_debug(this->name, 0, "failed to get gfid from dict");
-        goto out;
-    }
-
-    /*fill ctr link context*/
-    FILL_CTR_LINK_CX(_link_cx, loc->pargfid, loc->name, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, *ptr_gfid, _link_cx,
-                           NULL, GFDB_FOP_CREATE_WRITE, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_MKNOD_WIND_FAILED,
-               "Failed to insert mknod wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_mknod_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata);
-    return 0;
-}
-
-/****************************create******************************************/
-int
-ctr_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf,
-               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = add_hard_link_ctx(frame, this, inode);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_ADD_HARDLINK_FAILED,
-               "Failed adding hard link");
-    }
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_CREATE_WRITE,
-                            GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_CREATE_UNWIND_FAILED,
-               "Failed to insert create unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, stbuf,
-                        preparent, postparent, xdata);
-
-    return 0;
-}
-
-int
-ctr_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t ctr_link_cx;
-    gf_ctr_link_context_t *_link_cx = &ctr_link_cx;
-    uuid_t gfid = {
-        0,
-    };
-    uuid_t *ptr_gfid = &gfid;
-    struct iatt dummy_stat = {0};
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-
-    /*Get GFID from Xdata dict*/
-    ret = dict_get_gfuuid(xdata, "gfid-req", &gfid);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_GET_GFID_FROM_DICT_FAILED,
-               "failed to get gfid from dict");
-        goto out;
-    }
-
-    /*fill ctr link context*/
-    FILL_CTR_LINK_CX(_link_cx, loc->pargfid, loc->name, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, loc->inode->ia_type, *ptr_gfid, _link_cx,
-                           NULL, GFDB_FOP_CREATE_WRITE, GFDB_FOP_WIND);
-
-    /*Internal FOP*/
-    _inode_cx->is_internal_fop = is_internal_fop(frame, xdata);
-
-    /* If its a internal FOP and dht link file donot record*/
-    if (_inode_cx->is_internal_fop && dht_is_linkfile(&dummy_stat, xdata)) {
-        goto out;
-    }
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, &ctr_inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_CREATE_WIND_FAILED,
-               "Failed to insert create wind");
-    }
-out:
-    STACK_WIND(frame, ctr_create_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
-               xdata);
-    return 0;
-}
-
-/****************************link********************************************/
-
-int
-ctr_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-             int op_errno, inode_t *inode, struct iatt *stbuf,
-             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    /* Add hard link to the list */
-    ret = add_hard_link_ctx(frame, this, inode);
-    if (ret) {
-        gf_msg_trace(this->name, 0, "Failed adding hard link");
-    }
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_DENTRY_WRITE,
-                            GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_CREATE_UNWIND_FAILED,
-               "Failed to insert create unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, stbuf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int
-ctr_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-         dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-    gf_ctr_link_context_t ctr_link_cx;
-    gf_ctr_link_context_t *_link_cx = &ctr_link_cx;
-    struct iatt dummy_stat = {0};
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-
-    /*fill ctr link context*/
-    FILL_CTR_LINK_CX(_link_cx, newloc->pargfid, newloc->name, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, oldloc->inode->ia_type,
-                           oldloc->inode->gfid, _link_cx, NULL,
-                           GFDB_FOP_DENTRY_WRITE, GFDB_FOP_WIND);
-
-    /*Internal FOP*/
-    _inode_cx->is_internal_fop = is_internal_fop(frame, xdata);
-
-    /* Is a metadata fop */
-    _inode_cx->is_metadata_fop = _gf_true;
-
-    /* If its a internal FOP and dht link file donot record*/
-    if (_inode_cx->is_internal_fop && dht_is_linkfile(&dummy_stat, xdata)) {
-        goto out;
-    }
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_LINK_WIND_FAILED,
-               "Failed to insert link wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_link_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
-    return 0;
-}
-
-/******************************readv*****************************************/
-int
-ctr_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, struct iovec *vector, int count, struct iatt *stbuf,
-              struct iobref *iobref, dict_t *xdata)
-{
-    int ret = -1;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, out);
-
-    ret = ctr_insert_unwind(frame, this, GFDB_FOP_INODE_READ, GFDB_FOP_UNWIND);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_CREATE_UNWIND_FAILED,
-               "Failed to insert create unwind");
-    }
-
-out:
-    ctr_free_frame_local(frame);
-
-    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf,
-                        iobref, xdata);
-    return 0;
-}
-
-int
-ctr_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t off,
-          uint32_t flags, dict_t *xdata)
-{
-    int ret = -1;
-    gf_ctr_inode_context_t ctr_inode_cx;
-    gf_ctr_inode_context_t *_inode_cx = &ctr_inode_cx;
-
-    CTR_IS_DISABLED_THEN_GOTO(this, out);
-    CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, xdata, out);
-
-    /*Fill ctr inode context*/
-    FILL_CTR_INODE_CONTEXT(_inode_cx, fd->inode->ia_type, fd->inode->gfid, NULL,
-                           NULL, GFDB_FOP_INODE_READ, GFDB_FOP_WIND);
-
-    /*record into the database*/
-    ret = ctr_insert_wind(frame, this, _inode_cx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_READV_WIND_FAILED,
-               "Failed to insert readv wind");
-    }
-
-out:
-    STACK_WIND(frame, ctr_readv_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readv, fd, size, off, flags, xdata);
-    return 0;
-}
-
-/*******************************ctr_ipc****************************************/
-
-/*This is the call back function per record/file from data base*/
-static int
-ctr_db_query_callback(gfdb_query_record_t *gfdb_query_record, void *args)
-{
-    int ret = -1;
-    ctr_query_cbk_args_t *query_cbk_args = args;
-
-    GF_VALIDATE_OR_GOTO("ctr", query_cbk_args, out);
-
-    ret = gfdb_write_query_record(query_cbk_args->query_fd, gfdb_query_record);
-    if (ret) {
-        gf_msg("ctr", GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "Failed to write to query file");
-        goto out;
-    }
-
-    query_cbk_args->count++;
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/* This function does all the db queries related to tiering and
- * generates/populates new/existing query file
- * inputs:
- * xlator_t *this : CTR Translator
- * void *conn_node : Database connection
- * char *query_file: the query file that needs to be updated
- * gfdb_ipc_ctr_params_t *ipc_ctr_params: the query parameters
- * Return:
- * On success 0
- * On failure -1
- * */
-int
-ctr_db_query(xlator_t *this, void *conn_node, char *query_file,
-             gfdb_ipc_ctr_params_t *ipc_ctr_params)
-{
-    int ret = -1;
-    ctr_query_cbk_args_t query_cbk_args = {0};
-
-    GF_VALIDATE_OR_GOTO("ctr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, conn_node, out);
-    GF_VALIDATE_OR_GOTO(this->name, query_file, out);
-    GF_VALIDATE_OR_GOTO(this->name, ipc_ctr_params, out);
-
-    /*Query for eligible files from db*/
-    query_cbk_args.query_fd = open(query_file, O_WRONLY | O_CREAT | O_APPEND,
-                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-    if (query_cbk_args.query_fd < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, errno, CTR_MSG_FATAL_ERROR,
-               "Failed to open query file %s", query_file);
-        goto out;
-    }
-    if (!ipc_ctr_params->is_promote) {
-        if (ipc_ctr_params->emergency_demote) {
-            /* emergency demotion mode */
-            ret = find_all(conn_node, ctr_db_query_callback,
-                           (void *)&query_cbk_args,
-                           ipc_ctr_params->query_limit);
-        } else {
-            if (ipc_ctr_params->write_freq_threshold == 0 &&
-                ipc_ctr_params->read_freq_threshold == 0) {
-                ret = find_unchanged_for_time(conn_node, ctr_db_query_callback,
-                                              (void *)&query_cbk_args,
-                                              &ipc_ctr_params->time_stamp);
-            } else {
-                ret = find_unchanged_for_time_freq(
-                    conn_node, ctr_db_query_callback, (void *)&query_cbk_args,
-                    &ipc_ctr_params->time_stamp,
-                    ipc_ctr_params->write_freq_threshold,
-                    ipc_ctr_params->read_freq_threshold, _gf_false);
-            }
-        }
-    } else {
-        if (ipc_ctr_params->write_freq_threshold == 0 &&
-            ipc_ctr_params->read_freq_threshold == 0) {
-            ret = find_recently_changed_files(conn_node, ctr_db_query_callback,
-                                              (void *)&query_cbk_args,
-                                              &ipc_ctr_params->time_stamp);
-        } else {
-            ret = find_recently_changed_files_freq(
-                conn_node, ctr_db_query_callback, (void *)&query_cbk_args,
-                &ipc_ctr_params->time_stamp,
-                ipc_ctr_params->write_freq_threshold,
-                ipc_ctr_params->read_freq_threshold, _gf_false);
-        }
-    }
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: query from db failed");
-        goto out;
-    }
-
-    ret = clear_files_heat(conn_node);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: Failed to clear db entries");
-        goto out;
-    }
-
-    ret = 0;
-out:
-
-    if (!ret)
-        ret = query_cbk_args.count;
-
-    if (query_cbk_args.query_fd >= 0) {
-        sys_close(query_cbk_args.query_fd);
-        query_cbk_args.query_fd = -1;
-    }
-
-    return ret;
-}
-
-void *
-ctr_compact_thread(void *args)
-{
-    int ret = -1;
-    void *db_conn = NULL;
-
-    xlator_t *this = NULL;
-    gf_ctr_private_t *priv = NULL;
-    gf_boolean_t compact_active = _gf_false;
-    gf_boolean_t compact_mode_switched = _gf_false;
-
-    this = (xlator_t *)args;
-
-    GF_VALIDATE_OR_GOTO("ctr", this, out);
-
-    priv = this->private;
-
-    db_conn = priv->_db_conn;
-    compact_active = priv->compact_active;
-    compact_mode_switched = priv->compact_mode_switched;
-
-    gf_msg("ctr-compact", GF_LOG_INFO, 0, CTR_MSG_SET, "Starting compaction");
-
-    ret = compact_db(db_conn, compact_active, compact_mode_switched);
-
-    if (ret) {
-        gf_msg("ctr-compact", GF_LOG_ERROR, 0, CTR_MSG_SET,
-               "Failed to perform the compaction");
-    }
-
-    ret = pthread_mutex_lock(&priv->compact_lock);
-
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-               "Failed to acquire lock");
-        goto out;
-    }
-
-    /* We are done compaction on this brick. Set all flags to false */
-    priv->compact_active = _gf_false;
-    priv->compact_mode_switched = _gf_false;
-
-    ret = pthread_mutex_unlock(&priv->compact_lock);
-
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-               "Failed to release lock");
-        goto out;
-    }
-
-out:
-    return NULL;
-}
-
-int
-ctr_ipc_helper(xlator_t *this, dict_t *in_dict, dict_t *out_dict)
-{
-    int ret = -1;
-    char *ctr_ipc_ops = NULL;
-    gf_ctr_private_t *priv = NULL;
-    char *db_version = NULL;
-    char *db_param_key = NULL;
-    char *db_param = NULL;
-    char *query_file = NULL;
-    gfdb_ipc_ctr_params_t *ipc_ctr_params = NULL;
-    int result = 0;
-    pthread_t compact_thread;
-
-    GF_VALIDATE_OR_GOTO("ctr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, this->private, out);
-    priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, priv->_db_conn, out);
-    GF_VALIDATE_OR_GOTO(this->name, in_dict, out);
-    GF_VALIDATE_OR_GOTO(this->name, out_dict, out);
-
-    GET_DB_PARAM_FROM_DICT(this->name, in_dict, GFDB_IPC_CTR_KEY, ctr_ipc_ops,
-                           out);
-
-    /*if its a db clear operation */
-    if (strncmp(ctr_ipc_ops, GFDB_IPC_CTR_CLEAR_OPS,
-                SLEN(GFDB_IPC_CTR_CLEAR_OPS)) == 0) {
-        ret = clear_files_heat(priv->_db_conn);
-        if (ret)
-            goto out;
-
-    } /* if its a query operation, in  which case its query + clear db*/
-    else if (strncmp(ctr_ipc_ops, GFDB_IPC_CTR_QUERY_OPS,
-                     SLEN(GFDB_IPC_CTR_QUERY_OPS)) == 0) {
-        ret = dict_get_str(in_dict, GFDB_IPC_CTR_GET_QFILE_PATH, &query_file);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed extracting query file path");
-            goto out;
-        }
-
-        ret = dict_get_bin(in_dict, GFDB_IPC_CTR_GET_QUERY_PARAMS,
-                           (void *)&ipc_ctr_params);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed extracting query parameters");
-            goto out;
-        }
-
-        ret = ctr_db_query(this, priv->_db_conn, query_file, ipc_ctr_params);
-
-        ret = dict_set_int32(out_dict, GFDB_IPC_CTR_RET_QUERY_COUNT, ret);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed setting query reply");
-            goto out;
-        }
-
-    } /* if its a query for db version */
-    else if (strncmp(ctr_ipc_ops, GFDB_IPC_CTR_GET_DB_VERSION_OPS,
-                     SLEN(GFDB_IPC_CTR_GET_DB_VERSION_OPS)) == 0) {
-        ret = get_db_version(priv->_db_conn, &db_version);
-        if (ret == -1 || !db_version) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed extracting db version ");
-            goto out;
-        }
-
-        SET_DB_PARAM_TO_DICT(this->name, out_dict, GFDB_IPC_CTR_RET_DB_VERSION,
-                             db_version, ret, error);
-
-    } /* if its a query for a db setting */
-    else if (strncmp(ctr_ipc_ops, GFDB_IPC_CTR_GET_DB_PARAM_OPS,
-                     SLEN(GFDB_IPC_CTR_GET_DB_PARAM_OPS)) == 0) {
-        ret = dict_get_str(in_dict, GFDB_IPC_CTR_GET_DB_KEY, &db_param_key);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed extracting db param key");
-            goto out;
-        }
-
-        ret = get_db_params(priv->_db_conn, db_param_key, &db_param);
-        if (ret == -1 || !db_param) {
-            goto out;
-        }
-
-        SET_DB_PARAM_TO_DICT(this->name, out_dict, db_param_key, db_param, ret,
-                             error);
-    } /* if its an attempt to compact the database */
-    else if (strncmp(ctr_ipc_ops, GFDB_IPC_CTR_SET_COMPACT_PRAGMA,
-                     SLEN(GFDB_IPC_CTR_SET_COMPACT_PRAGMA)) == 0) {
-        ret = pthread_mutex_lock(&priv->compact_lock);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed to acquire lock for compaction");
-            goto out;
-        }
-
-        if ((priv->compact_active || priv->compact_mode_switched)) {
-            /* Compaction in progress. LEAVE */
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Compaction already in progress.");
-            pthread_mutex_unlock(&priv->compact_lock);
-            goto out;
-        }
-        /* At this point, we should be the only one on the brick */
-        /* compacting */
-
-        /* Grab the arguments from the dictionary */
-        ret = dict_get_int32(in_dict, "compact_active", &result);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed to get compaction type");
-            goto out;
-        }
-
-        if (result) {
-            priv->compact_active = _gf_true;
-        }
-
-        ret = dict_get_int32(in_dict, "compact_mode_switched", &result);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed to see if compaction switched");
-            goto out;
-        }
-
-        if (result) {
-            priv->compact_mode_switched = _gf_true;
-            gf_msg("ctr-compact", GF_LOG_TRACE, 0, CTR_MSG_SET,
-                   "Pre-thread: Compact mode switch is true");
-        } else {
-            gf_msg("ctr-compact", GF_LOG_TRACE, 0, CTR_MSG_SET,
-                   "Pre-thread: Compact mode switch is false");
-        }
-
-        ret = pthread_mutex_unlock(&priv->compact_lock);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed to release lock for compaction");
-            goto out;
-        }
-
-        ret = gf_thread_create(&compact_thread, NULL, ctr_compact_thread,
-                               (void *)this, "ctrcomp");
-
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-                   "Failed to spawn compaction thread");
-            goto out;
-        }
-
-        goto out;
-    } /* default case */
-    else {
-        goto out;
-    }
-
-    ret = 0;
-    goto out;
-error:
-    GF_FREE(db_param_key);
-    GF_FREE(db_param);
-    GF_FREE(db_version);
-out:
-    return ret;
-}
-
-/* IPC Call from tier migrator to clear the heat on the DB */
-int32_t
-ctr_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *in_dict)
-{
-    int ret = -1;
-    gf_ctr_private_t *priv = NULL;
-    dict_t *out_dict = NULL;
-
-    GF_ASSERT(this);
-    priv = this->private;
-    GF_ASSERT(priv);
-    GF_ASSERT(priv->_db_conn);
-    GF_VALIDATE_OR_GOTO(this->name, in_dict, wind);
-
-    if (op != GF_IPC_TARGET_CTR)
-        goto wind;
-
-    out_dict = dict_new();
-    if (!out_dict) {
-        goto out;
-    }
-
-    ret = ctr_ipc_helper(this, in_dict, out_dict);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_SET,
-               "Failed in ctr_ipc_helper");
-    }
-out:
-
-    STACK_UNWIND_STRICT(ipc, frame, ret, 0, out_dict);
-
-    if (out_dict)
-        dict_unref(out_dict);
-
-    return 0;
-
-wind:
-    STACK_WIND(frame, default_ipc_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->ipc, op, in_dict);
-
-    return 0;
-}
-
-/* Call to initialize db for ctr xlator while ctr is enabled */
-int32_t
-initialize_ctr_resource(xlator_t *this, gf_ctr_private_t *priv)
-{
-    int ret_db = -1;
-    dict_t *params_dict = NULL;
-
-    if (!priv)
-        goto error;
-
-    /* For compaction */
-    priv->compact_active = _gf_false;
-    priv->compact_mode_switched = _gf_false;
-    ret_db = pthread_mutex_init(&priv->compact_lock, NULL);
-
-    if (ret_db) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: Failed initializing compaction mutex");
-        goto error;
-    }
-
-    params_dict = dict_new();
-    if (!params_dict) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INIT_DB_PARAMS_FAILED,
-               "DB Params cannot initialized!");
-        goto error;
-    }
-
-    /*Extract db params options*/
-    ret_db = extract_db_params(this, params_dict, priv->gfdb_db_type);
-    if (ret_db) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_EXTRACT_DB_PARAM_OPTIONS_FAILED,
-               "Failed extracting db params options");
-        goto error;
-    }
-
-    /*Create a memory pool for ctr xlator*/
-    this->local_pool = mem_pool_new(gf_ctr_local_t, 64);
-    if (!this->local_pool) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_CREATE_LOCAL_MEMORY_POOL_FAILED,
-               "failed to create local memory pool");
-        goto error;
-    }
-
-    /*Initialize Database Connection*/
-    priv->_db_conn = init_db(params_dict, priv->gfdb_db_type);
-    if (!priv->_db_conn) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: Failed initializing data base");
-        goto error;
-    }
-
-    ret_db = 0;
-    goto out;
-
-error:
-    if (this)
-        mem_pool_destroy(this->local_pool);
-
-    if (priv) {
-        GF_FREE(priv->ctr_db_path);
-    }
-    GF_FREE(priv);
-    ret_db = -1;
-out:
-    if (params_dict)
-        dict_unref(params_dict);
-
-    return ret_db;
-}
-
-/******************************************************************************/
-int
-reconfigure(xlator_t *this, dict_t *options)
-{
-    char *temp_str = NULL;
-    int ret = 0;
-    gf_ctr_private_t *priv = NULL;
-
-    priv = this->private;
-
-    if (dict_get_str(options, "changetimerecorder.frequency", &temp_str)) {
-        gf_msg(this->name, GF_LOG_TRACE, 0, CTR_MSG_SET, "set");
-    }
-
-    GF_OPTION_RECONF("ctr-enabled", priv->enabled, options, bool, out);
-    if (!priv->enabled) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_INFO, 0, CTR_MSG_XLATOR_DISABLED,
-               "CTR Xlator is not enabled so skip ctr reconfigure");
-        goto out;
-    }
-
-    /* If ctr is enabled after skip init for ctr xlator then call
-       initialize_ctr_resource during reconfigure phase to allocate resources
-       for xlator
-    */
-    if (priv->enabled && !priv->_db_conn) {
-        ret = initialize_ctr_resource(this, priv);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-                   "FATAL: Failed ctr initialize resource");
-            goto out;
-        }
-    }
-
-    GF_OPTION_RECONF("record-counters", priv->ctr_record_counter, options, bool,
-                     out);
-
-    GF_OPTION_RECONF("ctr-record-metadata-heat", priv->ctr_record_metadata_heat,
-                     options, bool, out);
-
-    GF_OPTION_RECONF("ctr_link_consistency", priv->ctr_link_consistency,
-                     options, bool, out);
-
-    GF_OPTION_RECONF("ctr_lookupheal_inode_timeout",
-                     priv->ctr_lookupheal_inode_timeout, options, uint64, out);
-
-    GF_OPTION_RECONF("ctr_lookupheal_link_timeout",
-                     priv->ctr_lookupheal_link_timeout, options, uint64, out);
-
-    GF_OPTION_RECONF("record-exit", priv->ctr_record_unwind, options, bool,
-                     out);
-
-    GF_OPTION_RECONF("record-entry", priv->ctr_record_wind, options, bool, out);
-
-    /* If database is sqlite */
-    if (priv->gfdb_db_type == GFDB_SQLITE3) {
-        /* AUTOCHECKPOINT */
-        if (dict_get_str(options, GFDB_SQL_PARAM_WAL_AUTOCHECK, &temp_str) ==
-            0) {
-            ret = set_db_params(priv->_db_conn, "wal_autocheckpoint", temp_str);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       CTR_MSG_SET_VALUE_TO_SQL_PARAM_FAILED,
-                       "Failed  to set %s", GFDB_SQL_PARAM_WAL_AUTOCHECK);
-            }
-        }
-
-        /* CACHE_SIZE */
-        if (dict_get_str(options, GFDB_SQL_PARAM_CACHE_SIZE, &temp_str) == 0) {
-            ret = set_db_params(priv->_db_conn, "cache_size", temp_str);
-            if (ret) {
-                gf_msg(this->name, GF_LOG_ERROR, 0,
-                       CTR_MSG_SET_VALUE_TO_SQL_PARAM_FAILED,
-                       "Failed  to set %s", GFDB_SQL_PARAM_CACHE_SIZE);
-            }
-        }
-    }
-
-    ret = 0;
-
-out:
-
-    return ret;
-}
-
-/****************************init********************************************/
-
-int32_t
-init(xlator_t *this)
-{
-    gf_ctr_private_t *priv = NULL;
-    int ret_db = -1;
-
-    if (!this) {
-        gf_msg("ctr", GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: ctr this is not initialized");
-        return -1;
-    }
-
-    if (!this->children || this->children->next) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: ctr should have exactly one child");
-        return -1;
-    }
-
-    if (!this->parents) {
-        gf_msg(this->name, GF_LOG_WARNING, 0, CTR_MSG_DANGLING_VOLUME,
-               "dangling volume. check volfile ");
-    }
-
-    priv = GF_CALLOC(1, sizeof(*priv), gf_ctr_mt_private_t);
-    if (!priv) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, CTR_MSG_CALLOC_FAILED,
-               "Calloc did not work!!!");
-        return -1;
-    }
-
-    /*Default values for the translator*/
-    priv->ctr_record_wind = _gf_true;
-    priv->ctr_record_unwind = _gf_false;
-    priv->ctr_hot_brick = _gf_false;
-    priv->gfdb_db_type = GFDB_SQLITE3;
-    priv->gfdb_sync_type = GFDB_DB_SYNC;
-    priv->_db_conn = NULL;
-    priv->ctr_lookupheal_link_timeout = CTR_DEFAULT_HARDLINK_EXP_PERIOD;
-    priv->ctr_lookupheal_inode_timeout = CTR_DEFAULT_INODE_EXP_PERIOD;
-
-    /*Extract ctr xlator options*/
-    ret_db = extract_ctr_options(this, priv);
-    if (ret_db) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_EXTRACT_CTR_XLATOR_OPTIONS_FAILED,
-               "Failed extracting ctr xlator options");
-        GF_FREE(priv);
-        return -1;
-    }
-
-    if (!priv->enabled) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_INFO, 0, CTR_MSG_XLATOR_DISABLED,
-               "CTR Xlator is not enabled so skip ctr init");
-        goto out;
-    }
-
-    ret_db = initialize_ctr_resource(this, priv);
-    if (ret_db) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_FATAL_ERROR,
-               "FATAL: Failed ctr initialize resource");
-        return -1;
-    }
-
-out:
-    this->private = (void *)priv;
-    return 0;
-}
-
-int
-notify(xlator_t *this, int event, void *data, ...)
-{
-    gf_ctr_private_t *priv = NULL;
-    int ret = 0;
-
-    priv = this->private;
-
-    if (!priv)
-        goto out;
-
-    ret = default_notify(this, event, data);
-
-out:
-    return ret;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    GF_VALIDATE_OR_GOTO("ctr", this, out);
-
-    ret = xlator_mem_acct_init(this, gf_ctr_mt_end + 1);
-
-    if (ret != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_MEM_ACC_INIT_FAILED,
-               "Memory accounting init"
-               "failed");
-        return ret;
-    }
-out:
-    return ret;
-}
-
-void
-fini(xlator_t *this)
-{
-    gf_ctr_private_t *priv = NULL;
-
-    priv = this->private;
-
-    if (priv && priv->enabled) {
-        if (fini_db(priv->_db_conn)) {
-            gf_msg(this->name, GF_LOG_WARNING, 0, CTR_MSG_CLOSE_DB_CONN_FAILED,
-                   "Failed closing "
-                   "db connection");
-        }
-
-        if (priv->_db_conn)
-            priv->_db_conn = NULL;
-
-        GF_FREE(priv->ctr_db_path);
-        if (pthread_mutex_destroy(&priv->compact_lock)) {
-            gf_msg(this->name, GF_LOG_WARNING, 0, CTR_MSG_CLOSE_DB_CONN_FAILED,
-                   "Failed to "
-                   "destroy the compaction mutex");
-        }
-    }
-    GF_FREE(priv);
-    mem_pool_destroy(this->local_pool);
-    this->local_pool = NULL;
-
-    return;
-}
-
-struct xlator_fops fops = {
-    /*lookup*/
-    .lookup = ctr_lookup,
-    /*write fops */
-    .mknod = ctr_mknod,
-    .create = ctr_create,
-    .truncate = ctr_truncate,
-    .ftruncate = ctr_ftruncate,
-    .setxattr = ctr_setxattr,
-    .fsetxattr = ctr_fsetxattr,
-    .removexattr = ctr_removexattr,
-    .fremovexattr = ctr_fremovexattr,
-    .unlink = ctr_unlink,
-    .link = ctr_link,
-    .rename = ctr_rename,
-    .writev = ctr_writev,
-    .setattr = ctr_setattr,
-    .fsetattr = ctr_fsetattr,
-    /*read fops*/
-    .readv = ctr_readv,
-    /* IPC call*/
-    .ipc = ctr_ipc};
-
-struct xlator_cbks cbks = {.forget = ctr_forget};
-
-struct volume_options options[] = {
-    {.key =
-         {
-             "ctr-enabled",
-         },
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off",
-     .description = "Enables the CTR",
-     .flags = OPT_FLAG_SETTABLE},
-    {.key = {"record-entry"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "on"},
-    {.key = {"record-exit"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off"},
-    {.key = {"record-counters"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off",
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .flags = OPT_FLAG_SETTABLE,
-     .tags = {}},
-    {.key = {"ctr-record-metadata-heat"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {"ctr_link_consistency"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {"ctr_lookupheal_link_timeout"},
-     .type = GF_OPTION_TYPE_INT,
-     .default_value = "300",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_2},
-     .tags = {}},
-    {.key = {"ctr_lookupheal_inode_timeout"},
-     .type = GF_OPTION_TYPE_INT,
-     .default_value = "300",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_2},
-     .tags = {}},
-    {.key = {"hot-brick"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .value = {"on", "off"},
-     .default_value = "off"},
-    {.key = {"db-type"},
-     .type = GF_OPTION_TYPE_STR,
-     .value = {"hashfile", "rocksdb", "changelog", "sqlite3", "hyperdex"},
-     .default_value = "sqlite3",
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .flags = OPT_FLAG_SETTABLE,
-     .tags = {}},
-    {.key = {"db-sync"},
-     .type = GF_OPTION_TYPE_STR,
-     .value = {"sync", "async"},
-     .default_value = "sync"},
-    {.key = {"db-path"}, .type = GF_OPTION_TYPE_PATH},
-    {.key = {"db-name"}, .type = GF_OPTION_TYPE_STR},
-    {.key = {GFDB_SQL_PARAM_SYNC},
-     .type = GF_OPTION_TYPE_STR,
-     .value = {"off", "normal", "full"},
-     .default_value = "normal"},
-    {.key = {GFDB_SQL_PARAM_JOURNAL_MODE},
-     .type = GF_OPTION_TYPE_STR,
-     .value = {"delete", "truncate", "persist", "memory", "wal", "off"},
-     .default_value = "wal",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {GFDB_SQL_PARAM_AUTO_VACUUM},
-     .type = GF_OPTION_TYPE_STR,
-     .value = {"off", "full", "incr"},
-     .default_value = "off",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {GFDB_SQL_PARAM_WAL_AUTOCHECK},
-     .type = GF_OPTION_TYPE_INT,
-     .default_value = "25000",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {GFDB_SQL_PARAM_CACHE_SIZE},
-     .type = GF_OPTION_TYPE_INT,
-     .default_value = "12500",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {GFDB_SQL_PARAM_PAGE_SIZE},
-     .type = GF_OPTION_TYPE_INT,
-     .default_value = "4096",
-     .flags = OPT_FLAG_SETTABLE,
-     .op_version = {GD_OP_VERSION_3_7_0},
-     .tags = {}},
-    {.key = {NULL}},
-};
diff --git a/xlators/features/changetimerecorder/src/changetimerecorder.h b/xlators/features/changetimerecorder/src/changetimerecorder.h
deleted file mode 100644
index 0150a1c91bc..00000000000
--- a/xlators/features/changetimerecorder/src/changetimerecorder.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-   Copyright (c) 2006-2015 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 __CTR_H
-#define __CTR_H
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/common-utils.h>
-#include "ctr_mem_types.h"
-#include "ctr-helper.h"
-
-#endif /* __CTR_H */
diff --git a/xlators/features/changetimerecorder/src/ctr-helper.c b/xlators/features/changetimerecorder/src/ctr-helper.c
deleted file mode 100644
index e1e65735cef..00000000000
--- a/xlators/features/changetimerecorder/src/ctr-helper.c
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
-   Copyright (c) 2015 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.
-*/
-
-#include "gfdb_sqlite3.h"
-#include "ctr-helper.h"
-#include "ctr-messages.h"
-
-/*******************************************************************************
- *
- *                      Fill unwind into db record
- *
- ******************************************************************************/
-int
-fill_db_record_for_unwind(xlator_t *this, gf_ctr_local_t *ctr_local,
-                          gfdb_fop_type_t fop_type, gfdb_fop_path_t fop_path)
-{
-    int ret = -1;
-    gfdb_time_t *ctr_uwtime = NULL;
-    gf_ctr_private_t *_priv = NULL;
-
-    GF_ASSERT(this);
-    _priv = this->private;
-    GF_ASSERT(_priv);
-
-    GF_ASSERT(ctr_local);
-
-    /*If not unwind path error*/
-    if (!isunwindpath(fop_path)) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_WRONG_FOP_PATH,
-               "Wrong fop_path. Should be unwind");
-        goto out;
-    }
-
-    ctr_uwtime = &CTR_DB_REC(ctr_local).gfdb_unwind_change_time;
-    CTR_DB_REC(ctr_local).gfdb_fop_path = fop_path;
-    CTR_DB_REC(ctr_local).gfdb_fop_type = fop_type;
-
-    ret = gettimeofday(ctr_uwtime, NULL);
-    if (ret == -1) {
-        gf_msg(this->name, GF_LOG_ERROR, errno,
-               CTR_MSG_FILL_UNWIND_TIME_REC_ERROR,
-               "Error "
-               "filling unwind time record %s",
-               strerror(errno));
-        goto out;
-    }
-
-    /* Special case i.e if its a tier rebalance
-     * + cold tier brick
-     * + its a create/mknod FOP
-     * we record unwind time as zero */
-    if (ctr_local->client_pid == GF_CLIENT_PID_TIER_DEFRAG &&
-        (!_priv->ctr_hot_brick) && isdentrycreatefop(fop_type)) {
-        memset(ctr_uwtime, 0, sizeof(*ctr_uwtime));
-    }
-    ret = 0;
-out:
-    return ret;
-}
-
-/*******************************************************************************
- *
- *                      Fill wind into db record
- *
- ******************************************************************************/
-int
-fill_db_record_for_wind(xlator_t *this, gf_ctr_local_t *ctr_local,
-                        gf_ctr_inode_context_t *ctr_inode_cx)
-{
-    int ret = -1;
-    gfdb_time_t *ctr_wtime = NULL;
-    gf_ctr_private_t *_priv = NULL;
-
-    GF_ASSERT(this);
-    _priv = this->private;
-    GF_ASSERT(_priv);
-    GF_ASSERT(ctr_local);
-    IS_CTR_INODE_CX_SANE(ctr_inode_cx);
-
-    /*if not wind path error!*/
-    if (!iswindpath(ctr_inode_cx->fop_path)) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_WRONG_FOP_PATH,
-               "Wrong fop_path. Should be wind");
-        goto out;
-    }
-
-    ctr_wtime = &CTR_DB_REC(ctr_local).gfdb_wind_change_time;
-    CTR_DB_REC(ctr_local).gfdb_fop_path = ctr_inode_cx->fop_path;
-    CTR_DB_REC(ctr_local).gfdb_fop_type = ctr_inode_cx->fop_type;
-    CTR_DB_REC(ctr_local).link_consistency = _priv->ctr_link_consistency;
-
-    ret = gettimeofday(ctr_wtime, NULL);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, errno,
-               CTR_MSG_FILL_UNWIND_TIME_REC_ERROR,
-               "Error filling wind time record %s", strerror(errno));
-        goto out;
-    }
-
-    /* Special case i.e if its a tier rebalance
-     * + cold tier brick
-     * + its a create/mknod FOP
-     * we record wind time as zero */
-    if (ctr_local->client_pid == GF_CLIENT_PID_TIER_DEFRAG &&
-        (!_priv->ctr_hot_brick) && isdentrycreatefop(ctr_inode_cx->fop_type)) {
-        memset(ctr_wtime, 0, sizeof(*ctr_wtime));
-    }
-
-    /* Copy gfid into db record */
-    gf_uuid_copy(CTR_DB_REC(ctr_local).gfid, *(ctr_inode_cx->gfid));
-
-    /* Copy older gfid if any */
-    if (ctr_inode_cx->old_gfid &&
-        (!gf_uuid_is_null(*(ctr_inode_cx->old_gfid)))) {
-        gf_uuid_copy(CTR_DB_REC(ctr_local).old_gfid, *(ctr_inode_cx->old_gfid));
-    }
-
-    /*Hard Links*/
-    if (isdentryfop(ctr_inode_cx->fop_type)) {
-        /*new link fop*/
-        if (NEW_LINK_CX(ctr_inode_cx)) {
-            gf_uuid_copy(CTR_DB_REC(ctr_local).pargfid,
-                         *((NEW_LINK_CX(ctr_inode_cx))->pargfid));
-            strcpy(CTR_DB_REC(ctr_local).file_name,
-                   NEW_LINK_CX(ctr_inode_cx)->basename);
-        }
-        /*rename fop*/
-        if (OLD_LINK_CX(ctr_inode_cx)) {
-            gf_uuid_copy(CTR_DB_REC(ctr_local).old_pargfid,
-                         *((OLD_LINK_CX(ctr_inode_cx))->pargfid));
-            strcpy(CTR_DB_REC(ctr_local).old_file_name,
-                   OLD_LINK_CX(ctr_inode_cx)->basename);
-        }
-    }
-
-    ret = 0;
-out:
-    /*On error roll back and clean the record*/
-    if (ret == -1) {
-        CLEAR_CTR_DB_RECORD(ctr_local);
-    }
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      CTR xlator init related functions
- *
- *
- * ****************************************************************************/
-static int
-extract_sql_params(xlator_t *this, dict_t *params_dict)
-{
-    int ret = -1;
-    char *db_path = NULL;
-    char *db_name = NULL;
-    char *db_full_path = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(params_dict);
-
-    /*Extract the path of the db*/
-    db_path = NULL;
-    GET_DB_PARAM_FROM_DICT_DEFAULT(this->name, this->options, "db-path",
-                                   db_path, "/var/run/gluster/");
-
-    /*Extract the name of the db*/
-    db_name = NULL;
-    GET_DB_PARAM_FROM_DICT_DEFAULT(this->name, this->options, "db-name",
-                                   db_name, "gf_ctr_db.db");
-
-    /*Construct full path of the db*/
-    ret = gf_asprintf(&db_full_path, "%s/%s", db_path, db_name);
-    if (ret < 0) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-               CTR_MSG_CONSTRUCT_DB_PATH_FAILED,
-               "Construction of full db path failed!");
-        goto out;
-    }
-
-    /*Setting the SQL DB Path*/
-    SET_DB_PARAM_TO_DICT(this->name, params_dict, GFDB_SQL_PARAM_DBPATH,
-                         db_full_path, ret, out);
-
-    /*Extract rest of the sql params*/
-    ret = gfdb_set_sql_params(this->name, this->options, params_dict);
-    if (ret) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-               CTR_MSG_SET_VALUE_TO_SQL_PARAM_FAILED,
-               "Failed setting values to sql param dict!");
-    }
-
-    ret = 0;
-
-out:
-    if (ret)
-        GF_FREE(db_full_path);
-    return ret;
-}
-
-int
-extract_db_params(xlator_t *this, dict_t *params_dict, gfdb_db_type_t db_type)
-{
-    int ret = -1;
-
-    GF_ASSERT(this);
-    GF_ASSERT(params_dict);
-
-    switch (db_type) {
-        case GFDB_SQLITE3:
-            ret = extract_sql_params(this, params_dict);
-            if (ret)
-                goto out;
-            break;
-        case GFDB_ROCKS_DB:
-        case GFDB_HYPERDEX:
-        case GFDB_HASH_FILE_STORE:
-        case GFDB_INVALID_DB:
-        case GFDB_DB_END:
-            goto out;
-    }
-    ret = 0;
-out:
-    return ret;
-}
-
-int
-extract_ctr_options(xlator_t *this, gf_ctr_private_t *_priv)
-{
-    int ret = -1;
-    char *_val_str = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(_priv);
-
-    /*Checking if the CTR Translator is enabled. By default its disabled*/
-    _priv->enabled = _gf_false;
-    GF_OPTION_INIT("ctr-enabled", _priv->enabled, bool, out);
-    if (!_priv->enabled) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_INFO, 0, CTR_MSG_XLATOR_DISABLED,
-               "CTR Xlator is disabled.");
-        ret = 0;
-        goto out;
-    }
-
-    /*Extract db type*/
-    GF_OPTION_INIT("db-type", _val_str, str, out);
-    _priv->gfdb_db_type = gf_string2gfdbdbtype(_val_str);
-
-    /*Extract flag for record on wind*/
-    GF_OPTION_INIT("record-entry", _priv->ctr_record_wind, bool, out);
-
-    /*Extract flag for record on unwind*/
-    GF_OPTION_INIT("record-exit", _priv->ctr_record_unwind, bool, out);
-
-    /*Extract flag for record on counters*/
-    GF_OPTION_INIT("record-counters", _priv->ctr_record_counter, bool, out);
-
-    /* Extract flag for record metadata heat */
-    GF_OPTION_INIT("ctr-record-metadata-heat", _priv->ctr_record_metadata_heat,
-                   bool, out);
-
-    /*Extract flag for link consistency*/
-    GF_OPTION_INIT("ctr_link_consistency", _priv->ctr_link_consistency, bool,
-                   out);
-
-    /*Extract ctr_lookupheal_inode_timeout */
-    GF_OPTION_INIT("ctr_lookupheal_inode_timeout",
-                   _priv->ctr_lookupheal_inode_timeout, uint64, out);
-
-    /*Extract ctr_lookupheal_link_timeout*/
-    GF_OPTION_INIT("ctr_lookupheal_link_timeout",
-                   _priv->ctr_lookupheal_link_timeout, uint64, out);
-
-    /*Extract flag for hot tier brick*/
-    GF_OPTION_INIT("hot-brick", _priv->ctr_hot_brick, bool, out);
-
-    /*Extract flag for sync mode*/
-    GF_OPTION_INIT("db-sync", _val_str, str, out);
-    _priv->gfdb_sync_type = gf_string2gfdbdbsync(_val_str);
-
-    ret = 0;
-
-out:
-    return ret;
-}
diff --git a/xlators/features/changetimerecorder/src/ctr-helper.h b/xlators/features/changetimerecorder/src/ctr-helper.h
deleted file mode 100644
index 517fbb0b7de..00000000000
--- a/xlators/features/changetimerecorder/src/ctr-helper.h
+++ /dev/null
@@ -1,854 +0,0 @@
-/*
-   Copyright (c) 2015 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 __CTR_HELPER_H
-#define __CTR_HELPER_H
-
-#include <glusterfs/xlator.h>
-#include "ctr_mem_types.h"
-#include <glusterfs/iatt.h>
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/defaults.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/common-utils.h>
-#include <time.h>
-#include <sys/time.h>
-#include <pthread.h>
-
-#include "gfdb_data_store.h"
-#include "ctr-xlator-ctx.h"
-#include "ctr-messages.h"
-
-#define CTR_DEFAULT_HARDLINK_EXP_PERIOD 300 /* Five mins */
-#define CTR_DEFAULT_INODE_EXP_PERIOD 300    /* Five mins */
-
-typedef struct ctr_query_cbk_args {
-    int query_fd;
-    int count;
-} ctr_query_cbk_args_t;
-
-/*CTR Xlator Private structure*/
-typedef struct gf_ctr_private {
-    gf_boolean_t enabled;
-    char *ctr_db_path;
-    gf_boolean_t ctr_hot_brick;
-    gf_boolean_t ctr_record_wind;
-    gf_boolean_t ctr_record_unwind;
-    gf_boolean_t ctr_record_counter;
-    gf_boolean_t ctr_record_metadata_heat;
-    gf_boolean_t ctr_link_consistency;
-    gfdb_db_type_t gfdb_db_type;
-    gfdb_sync_type_t gfdb_sync_type;
-    gfdb_conn_node_t *_db_conn;
-    uint64_t ctr_lookupheal_link_timeout;
-    uint64_t ctr_lookupheal_inode_timeout;
-    gf_boolean_t compact_active;
-    gf_boolean_t compact_mode_switched;
-    pthread_mutex_t compact_lock;
-} gf_ctr_private_t;
-
-/*
- * gf_ctr_local_t is the ctr xlator local data structure that is stored in
- * the call_frame of each FOP.
- *
- * gfdb_db_record: The gf_ctr_local contains a gfdb_db_record object, which is
- * used by the insert_record() api from the libgfdb. The gfdb_db_record object
- * will contain all the inode and hardlink(only for dentry fops: create,
- * mknod,link, unlink, rename).The ctr_local is keep alive till the unwind
- * call and will be release during the unwind. The same gfdb_db_record will
- * used for the unwind insert_record() api, to record unwind in the database.
- *
- * ia_inode_type in gf_ctr_local will tell the type of the inode. This is
- * important for during the unwind path. As we will not have the inode during
- * the unwind path. We would have include this in the gfdb_db_record itself
- * but currently we record only file inode information.
- *
- * is_internal_fop in gf_ctr_local will tell us if this is a internal fop and
- * take special/no action. We don't record change/access times or increement
- * heat counter for internal fops from rebalancer.
- * */
-typedef struct gf_ctr_local {
-    gfdb_db_record_t gfdb_db_record;
-    ia_type_t ia_inode_type;
-    gf_boolean_t is_internal_fop;
-    gf_special_pid_t client_pid;
-} gf_ctr_local_t;
-/*
- * Easy access of gfdb_db_record of ctr_local
- * */
-#define CTR_DB_REC(ctr_local) (ctr_local->gfdb_db_record)
-
-/*Clear db record*/
-#define CLEAR_CTR_DB_RECORD(ctr_local)                                         \
-    do {                                                                       \
-        ctr_local->gfdb_db_record.gfdb_fop_path = GFDB_FOP_INVALID;            \
-        memset(&(ctr_local->gfdb_db_record.gfdb_wind_change_time), 0,          \
-               sizeof(gfdb_time_t));                                           \
-        memset(&(ctr_local->gfdb_db_record.gfdb_unwind_change_time), 0,        \
-               sizeof(gfdb_time_t));                                           \
-        gf_uuid_clear(ctr_local->gfdb_db_record.gfid);                         \
-        gf_uuid_clear(ctr_local->gfdb_db_record.pargfid);                      \
-        memset(ctr_local->gfdb_db_record.file_name, 0, GF_NAME_MAX + 1);       \
-        memset(ctr_local->gfdb_db_record.old_file_name, 0, GF_NAME_MAX + 1);   \
-        ctr_local->gfdb_db_record.gfdb_fop_type = GFDB_FOP_INVALID_OP;         \
-        ctr_local->ia_inode_type = IA_INVAL;                                   \
-    } while (0)
-
-static gf_ctr_local_t *
-init_ctr_local_t(xlator_t *this)
-{
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(this);
-
-    ctr_local = mem_get0(this->local_pool);
-    if (!ctr_local) {
-        gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0,
-               CTR_MSG_CREATE_CTR_LOCAL_ERROR_WIND,
-               "Error while creating ctr local");
-        goto out;
-    }
-
-    CLEAR_CTR_DB_RECORD(ctr_local);
-out:
-    return ctr_local;
-}
-
-static void
-free_ctr_local(gf_ctr_local_t *ctr_local)
-{
-    if (ctr_local)
-        mem_put(ctr_local);
-}
-
-/******************************************************************************
- *
- *
- *                      Context Carrier Structures
- *
- *
- * ****************************************************************************/
-
-/*
- * Context Carrier structures are used to carry relevant information about
- * inodes and links from the fops calls to the ctr_insert_wind.
- * These structure just have pointers to the original data and donot
- * do a deep copy of any data. This info is deep copied to
- * ctr_local->gfdb_db_record and passed to insert_record() api of libgfdb. This
- * info remains persistent for the unwind in  ctr_local->gfdb_db_record
- * and once used will be destroyed.
- *
- * gf_ctr_link_context_t : Context structure for hard links
- * gf_ctr_inode_context_t : Context structure for inodes
- *
- * */
-
-/*Context Carrier Structure for hard links*/
-typedef struct gf_ctr_link_context {
-    uuid_t *pargfid;
-    const char *basename;
-} gf_ctr_link_context_t;
-
-/*Context Carrier Structure for inodes*/
-typedef struct gf_ctr_inode_context {
-    ia_type_t ia_type;
-    uuid_t *gfid;
-    uuid_t *old_gfid;
-    gf_ctr_link_context_t *new_link_cx;
-    gf_ctr_link_context_t *old_link_cx;
-    gfdb_fop_type_t fop_type;
-    gfdb_fop_path_t fop_path;
-    gf_boolean_t is_internal_fop;
-    /* Indicating metadata fops */
-    gf_boolean_t is_metadata_fop;
-} gf_ctr_inode_context_t;
-
-/*******************Util Macros for Context Carrier Structures*****************/
-
-/*Checks if ctr_link_cx is sane!*/
-#define IS_CTR_LINK_CX_SANE(ctr_link_cx)                                       \
-    do {                                                                       \
-        if (ctr_link_cx) {                                                     \
-            if (ctr_link_cx->pargfid)                                          \
-                GF_ASSERT(*(ctr_link_cx->pargfid));                            \
-            GF_ASSERT(ctr_link_cx->basename);                                  \
-        };                                                                     \
-    } while (0)
-
-/*Clear and fill the ctr_link_context with values*/
-#define FILL_CTR_LINK_CX(ctr_link_cx, _pargfid, _basename, label)              \
-    do {                                                                       \
-        GF_VALIDATE_OR_GOTO("ctr", ctr_link_cx, label);                        \
-        GF_VALIDATE_OR_GOTO("ctr", _pargfid, label);                           \
-        GF_VALIDATE_OR_GOTO("ctr", _basename, label);                          \
-        memset(ctr_link_cx, 0, sizeof(*ctr_link_cx));                          \
-        ctr_link_cx->pargfid = &_pargfid;                                      \
-        ctr_link_cx->basename = _basename;                                     \
-    } while (0)
-
-#define NEW_LINK_CX(ctr_inode_cx) ctr_inode_cx->new_link_cx
-
-#define OLD_LINK_CX(ctr_inode_cx) ctr_inode_cx->old_link_cx
-
-/*Checks if ctr_inode_cx is sane!*/
-#define IS_CTR_INODE_CX_SANE(ctr_inode_cx)                                     \
-    do {                                                                       \
-        GF_ASSERT(ctr_inode_cx);                                               \
-        GF_ASSERT(ctr_inode_cx->gfid);                                         \
-        GF_ASSERT(*(ctr_inode_cx->gfid));                                      \
-        GF_ASSERT(ctr_inode_cx->fop_type != GFDB_FOP_INVALID_OP);              \
-        GF_ASSERT(ctr_inode_cx->fop_path != GFDB_FOP_INVALID);                 \
-        IS_CTR_LINK_CX_SANE(NEW_LINK_CX(ctr_inode_cx));                        \
-        IS_CTR_LINK_CX_SANE(OLD_LINK_CX(ctr_inode_cx));                        \
-    } while (0)
-
-/*Clear and fill the ctr_inode_context with values*/
-#define FILL_CTR_INODE_CONTEXT(ctr_inode_cx, _ia_type, _gfid, _new_link_cx,    \
-                               _old_link_cx, _fop_type, _fop_path)             \
-    do {                                                                       \
-        GF_ASSERT(ctr_inode_cx);                                               \
-        GF_ASSERT(_gfid);                                                      \
-        GF_ASSERT(_fop_type != GFDB_FOP_INVALID_OP);                           \
-        GF_ASSERT(_fop_path != GFDB_FOP_INVALID);                              \
-        memset(ctr_inode_cx, 0, sizeof(*ctr_inode_cx));                        \
-        ctr_inode_cx->ia_type = _ia_type;                                      \
-        ctr_inode_cx->gfid = &_gfid;                                           \
-        IS_CTR_LINK_CX_SANE(NEW_LINK_CX(ctr_inode_cx));                        \
-        if (_new_link_cx)                                                      \
-            NEW_LINK_CX(ctr_inode_cx) = _new_link_cx;                          \
-        IS_CTR_LINK_CX_SANE(OLD_LINK_CX(ctr_inode_cx));                        \
-        if (_old_link_cx)                                                      \
-            OLD_LINK_CX(ctr_inode_cx) = _old_link_cx;                          \
-        ctr_inode_cx->fop_type = _fop_type;                                    \
-        ctr_inode_cx->fop_path = _fop_path;                                    \
-    } while (0)
-
-/******************************************************************************
- *
- *                      Util functions or macros used by
- *                      insert wind and insert unwind
- *
- * ****************************************************************************/
-/* Free ctr frame local */
-static inline void
-ctr_free_frame_local(call_frame_t *frame)
-{
-    if (frame) {
-        free_ctr_local((gf_ctr_local_t *)frame->local);
-        frame->local = NULL;
-    }
-}
-
-/* Setting GF_REQUEST_LINK_COUNT_XDATA in dict
- * that has to be sent to POSIX Xlator to send
- * link count in unwind path.
- * return 0 for success with not creation of dict
- * return 1 for success with creation of dict
- * return -1 for failure.
- * */
-static inline int
-set_posix_link_request(xlator_t *this, dict_t **xdata)
-{
-    int ret = -1;
-    gf_boolean_t is_created = _gf_false;
-
-    GF_VALIDATE_OR_GOTO("ctr", this, out);
-    GF_VALIDATE_OR_GOTO(this->name, xdata, out);
-
-    /*create xdata if NULL*/
-    if (!*xdata) {
-        *xdata = dict_new();
-        is_created = _gf_true;
-        ret = 1;
-    } else {
-        ret = 0;
-    }
-
-    if (!*xdata) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_XDATA_NULL,
-               "xdata is NULL :Cannot send "
-               "GF_REQUEST_LINK_COUNT_XDATA to posix");
-        ret = -1;
-        goto out;
-    }
-
-    ret = dict_set_int32(*xdata, GF_REQUEST_LINK_COUNT_XDATA, 1);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_SET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-               "Failed setting GF_REQUEST_LINK_COUNT_XDATA");
-        ret = -1;
-        goto out;
-    }
-    ret = 0;
-out:
-    if (ret == -1) {
-        if (*xdata && is_created) {
-            dict_unref(*xdata);
-        }
-    }
-    return ret;
-}
-
-/*
- * If a bitrot fop
- * */
-#define BITROT_FOP(frame)                                                      \
-    (frame->root->pid == GF_CLIENT_PID_BITD ||                                 \
-     frame->root->pid == GF_CLIENT_PID_SCRUB)
-
-/*
- * If a rebalancer fop
- * */
-#define REBALANCE_FOP(frame) (frame->root->pid == GF_CLIENT_PID_DEFRAG)
-
-/*
- * If its a tiering rebalancer fop
- * */
-#define TIER_REBALANCE_FOP(frame)                                              \
-    (frame->root->pid == GF_CLIENT_PID_TIER_DEFRAG)
-
-/*
- * If its a AFR SELF HEAL
- * */
-#define AFR_SELF_HEAL_FOP(frame) (frame->root->pid == GF_CLIENT_PID_SELF_HEALD)
-
-/*
- * if a rebalancer fop goto
- * */
-#define CTR_IF_REBALANCE_FOP_THEN_GOTO(frame, label)                           \
-    do {                                                                       \
-        if (REBALANCE_FOP(frame))                                              \
-            goto label;                                                        \
-    } while (0)
-
-/*
- * Internal fop
- *
- * */
-static inline gf_boolean_t
-is_internal_fop(call_frame_t *frame, dict_t *xdata)
-{
-    gf_boolean_t ret = _gf_false;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-
-    if (AFR_SELF_HEAL_FOP(frame)) {
-        ret = _gf_true;
-    }
-    if (BITROT_FOP(frame)) {
-        ret = _gf_true;
-    }
-    if (REBALANCE_FOP(frame) || TIER_REBALANCE_FOP(frame)) {
-        ret = _gf_true;
-        if (xdata && dict_get(xdata, CTR_ATTACH_TIER_LOOKUP)) {
-            ret = _gf_false;
-        }
-    }
-    if (xdata && dict_get(xdata, GLUSTERFS_INTERNAL_FOP_KEY)) {
-        ret = _gf_true;
-    }
-
-    return ret;
-}
-
-#define CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, dict, label)                      \
-    do {                                                                       \
-        if (is_internal_fop(frame, dict))                                      \
-            goto label;                                                        \
-    } while (0)
-
-/* if fop has failed exit */
-#define CTR_IF_FOP_FAILED_THEN_GOTO(this, op_ret, op_errno, label)             \
-    do {                                                                       \
-        if (op_ret == -1) {                                                    \
-            gf_msg_trace(this->name, 0, "Failed fop with %s",                  \
-                         strerror(op_errno));                                  \
-            goto label;                                                        \
-        };                                                                     \
-    } while (0)
-
-/*
- * IS CTR Xlator is disabled then goto to label
- * */
-#define CTR_IS_DISABLED_THEN_GOTO(this, label)                                 \
-    do {                                                                       \
-        gf_ctr_private_t *_priv = NULL;                                        \
-        GF_ASSERT(this);                                                       \
-        GF_ASSERT(this->private);                                              \
-        _priv = this->private;                                                 \
-        if (!_priv->_db_conn)                                                  \
-            goto label;                                                        \
-    } while (0)
-
-/*
- * IS CTR record metadata heat is disabled then goto to label
- * */
-#define CTR_RECORD_METADATA_HEAT_IS_DISABLED_THEN_GOTO(this, label)            \
-    do {                                                                       \
-        gf_ctr_private_t *_priv = NULL;                                        \
-        GF_ASSERT(this);                                                       \
-        GF_ASSERT(this->private);                                              \
-        _priv = this->private;                                                 \
-        if (!_priv->ctr_record_metadata_heat)                                  \
-            goto label;                                                        \
-    } while (0)
-
-int
-fill_db_record_for_unwind(xlator_t *this, gf_ctr_local_t *ctr_local,
-                          gfdb_fop_type_t fop_type, gfdb_fop_path_t fop_path);
-
-int
-fill_db_record_for_wind(xlator_t *this, gf_ctr_local_t *ctr_local,
-                        gf_ctr_inode_context_t *ctr_inode_cx);
-
-/*******************************************************************************
- *                              CTR INSERT WIND
- * *****************************************************************************
- * Function used to insert/update record into the database during a wind fop
- * This function creates ctr_local structure into the frame of the fop
- * call.
- * ****************************************************************************/
-
-static inline int
-ctr_insert_wind(call_frame_t *frame, xlator_t *this,
-                gf_ctr_inode_context_t *ctr_inode_cx)
-{
-    int ret = -1;
-    gf_ctr_private_t *_priv = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(frame->root);
-    GF_ASSERT(this);
-    IS_CTR_INODE_CX_SANE(ctr_inode_cx);
-
-    _priv = this->private;
-    GF_ASSERT(_priv);
-
-    GF_ASSERT(_priv->_db_conn);
-
-    /*If record_wind option of CTR is on record wind for
-     * regular files only*/
-    if (_priv->ctr_record_wind && ctr_inode_cx->ia_type != IA_IFDIR) {
-        frame->local = init_ctr_local_t(this);
-        if (!frame->local) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_CREATE_CTR_LOCAL_ERROR_WIND,
-                   "WIND: Error while creating ctr local");
-            goto out;
-        };
-        ctr_local = frame->local;
-        ctr_local->client_pid = frame->root->pid;
-        ctr_local->is_internal_fop = ctr_inode_cx->is_internal_fop;
-
-        /* Decide whether to record counters or not */
-        CTR_DB_REC(ctr_local).do_record_counters = _gf_false;
-        /* If record counter is enabled */
-        if (_priv->ctr_record_counter) {
-            /* If not a internal fop */
-            if (!(ctr_local->is_internal_fop)) {
-                /* If its a metadata fop AND
-                 * record metadata heat
-                 * OR
-                 * its NOT a metadata fop */
-                if ((ctr_inode_cx->is_metadata_fop &&
-                     _priv->ctr_record_metadata_heat) ||
-                    (!ctr_inode_cx->is_metadata_fop)) {
-                    CTR_DB_REC(ctr_local).do_record_counters = _gf_true;
-                }
-            }
-        }
-
-        /* Decide whether to record times or not
-         * For non internal FOPS record times as usual*/
-        CTR_DB_REC(ctr_local).do_record_times = _gf_false;
-        if (!ctr_local->is_internal_fop) {
-            /* If its a metadata fop AND
-             * record metadata heat
-             * OR
-             * its NOT a metadata fop */
-            if ((ctr_inode_cx->is_metadata_fop &&
-                 _priv->ctr_record_metadata_heat) ||
-                (!ctr_inode_cx->is_metadata_fop)) {
-                CTR_DB_REC(ctr_local).do_record_times =
-                    (_priv->ctr_record_wind || _priv->ctr_record_unwind);
-            }
-        }
-        /* when its a internal FOPS*/
-        else {
-            /* Record times only for create
-             * i.e when the inode is created */
-            CTR_DB_REC(ctr_local).do_record_times = (isdentrycreatefop(
-                                                        ctr_inode_cx->fop_type))
-                                                        ? _gf_true
-                                                        : _gf_false;
-        }
-
-        /*Fill the db record for insertion*/
-        ret = fill_db_record_for_wind(this, ctr_local, ctr_inode_cx);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_FILL_CTR_LOCAL_ERROR_WIND,
-                   "WIND: Error filling  ctr local");
-            goto out;
-        }
-
-        /*Insert the db record*/
-        ret = insert_record(_priv->_db_conn, &ctr_local->gfdb_db_record);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_INSERT_RECORD_WIND_FAILED,
-                   "WIND: Inserting of record failed!");
-            goto out;
-        }
-    }
-    ret = 0;
-out:
-
-    if (ret) {
-        free_ctr_local(ctr_local);
-        frame->local = NULL;
-    }
-
-    return ret;
-}
-
-/*******************************************************************************
- *                             CTR INSERT UNWIND
- * *****************************************************************************
- * Function used to insert/update record into the database during a unwind fop
- * This function destroys ctr_local structure into the frame of the fop
- * call at the end.
- * ****************************************************************************/
-static inline int
-ctr_insert_unwind(call_frame_t *frame, xlator_t *this, gfdb_fop_type_t fop_type,
-                  gfdb_fop_path_t fop_path)
-{
-    int ret = -1;
-    gf_ctr_private_t *_priv = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-
-    _priv = this->private;
-    GF_ASSERT(_priv);
-
-    GF_ASSERT(_priv->_db_conn);
-
-    ctr_local = frame->local;
-
-    if (ctr_local && (_priv->ctr_record_unwind || isdentryfop(fop_type)) &&
-        (ctr_local->ia_inode_type != IA_IFDIR)) {
-        CTR_DB_REC(ctr_local).do_record_uwind_time = _priv->ctr_record_unwind;
-
-        ret = fill_db_record_for_unwind(this, ctr_local, fop_type, fop_path);
-        if (ret == -1) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_FILL_CTR_LOCAL_ERROR_UNWIND,
-                   "UNWIND: Error filling ctr local");
-            goto out;
-        }
-
-        ret = insert_record(_priv->_db_conn, &ctr_local->gfdb_db_record);
-        if (ret == -1) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_FILL_CTR_LOCAL_ERROR_UNWIND,
-                   "UNWIND: Error filling ctr local");
-            goto out;
-        }
-    }
-    ret = 0;
-out:
-    return ret;
-}
-
-/******************************************************************************
- *                          Delete file/flink record/s from db
- * ****************************************************************************/
-static inline int
-ctr_delete_hard_link_from_db(xlator_t *this, uuid_t gfid, uuid_t pargfid,
-                             char *basename, gfdb_fop_type_t fop_type,
-                             gfdb_fop_path_t fop_path)
-{
-    int ret = -1;
-    gfdb_db_record_t gfdb_db_record;
-    gf_ctr_private_t *_priv = NULL;
-
-    _priv = this->private;
-    GF_VALIDATE_OR_GOTO(this->name, _priv, out);
-    GF_VALIDATE_OR_GOTO(this->name, (!gf_uuid_is_null(gfid)), out);
-    GF_VALIDATE_OR_GOTO(this->name, (!gf_uuid_is_null(pargfid)), out);
-    GF_VALIDATE_OR_GOTO(this->name, (fop_type == GFDB_FOP_DENTRY_WRITE), out);
-    GF_VALIDATE_OR_GOTO(
-        this->name, (fop_path == GFDB_FOP_UNDEL || GFDB_FOP_UNDEL_ALL), out);
-
-    /* Set gfdb_db_record to 0 */
-    memset(&gfdb_db_record, 0, sizeof(gfdb_db_record));
-
-    /* Copy basename */
-    if (snprintf(gfdb_db_record.file_name, GF_NAME_MAX, "%s", basename) >=
-        GF_NAME_MAX)
-        goto out;
-
-    /* Copy gfid into db record */
-    gf_uuid_copy(gfdb_db_record.gfid, gfid);
-
-    /* Copy pargid into db record */
-    gf_uuid_copy(gfdb_db_record.pargfid, pargfid);
-
-    gfdb_db_record.gfdb_fop_path = fop_path;
-    gfdb_db_record.gfdb_fop_type = fop_type;
-
-    /*send delete request to db*/
-    ret = insert_record(_priv->_db_conn, &gfdb_db_record);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_INSERT_RECORD_WIND_FAILED,
-               "Failed to delete record. %s", basename);
-        goto out;
-    }
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/******************************* Hard link function ***************************/
-
-static inline gf_boolean_t
-__is_inode_expired(ctr_xlator_ctx_t *ctr_xlator_ctx, gf_ctr_private_t *_priv,
-                   gfdb_time_t *current_time)
-{
-    gf_boolean_t ret = _gf_false;
-    uint64_t time_diff = 0;
-
-    GF_ASSERT(ctr_xlator_ctx);
-    GF_ASSERT(_priv);
-    GF_ASSERT(current_time);
-
-    time_diff = current_time->tv_sec - ctr_xlator_ctx->inode_heal_period;
-
-    ret = (time_diff >= _priv->ctr_lookupheal_inode_timeout) ? _gf_true
-                                                             : _gf_false;
-    return ret;
-}
-
-static inline gf_boolean_t
-__is_hardlink_expired(ctr_hard_link_t *ctr_hard_link, gf_ctr_private_t *_priv,
-                      gfdb_time_t *current_time)
-{
-    gf_boolean_t ret = _gf_false;
-    uint64_t time_diff = 0;
-
-    GF_ASSERT(ctr_hard_link);
-    GF_ASSERT(_priv);
-    GF_ASSERT(current_time);
-
-    time_diff = current_time->tv_sec - ctr_hard_link->hardlink_heal_period;
-
-    ret = ret || (time_diff >= _priv->ctr_lookupheal_link_timeout) ? _gf_true
-                                                                   : _gf_false;
-
-    return ret;
-}
-
-/* Return values of heal*/
-typedef enum ctr_heal_ret_val {
-    CTR_CTX_ERROR = -1,
-    /* No healing required */
-    CTR_TRY_NO_HEAL = 0,
-    /* Try healing hard link */
-    CTR_TRY_HARDLINK_HEAL = 1,
-    /* Try healing inode */
-    CTR_TRY_INODE_HEAL = 2,
-} ctr_heal_ret_val_t;
-
-/**
- * @brief Function to add hard link to the inode context variable.
- *        The inode context maintainences a in-memory list. This is used
- *        smart healing of database.
- * @param frame of the FOP
- * @param this is the Xlator instant
- * @param inode
- * @return Return ctr_heal_ret_val_t
- */
-
-static inline ctr_heal_ret_val_t
-add_hard_link_ctx(call_frame_t *frame, xlator_t *this, inode_t *inode)
-{
-    ctr_heal_ret_val_t ret_val = CTR_TRY_NO_HEAL;
-    int ret = -1;
-    gf_ctr_local_t *ctr_local = NULL;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-    ctr_hard_link_t *ctr_hard_link = NULL;
-    gf_ctr_private_t *_priv = NULL;
-    gfdb_time_t current_time = {0};
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-    GF_ASSERT(inode);
-    GF_ASSERT(this->private);
-
-    _priv = this->private;
-
-    ctr_local = frame->local;
-    if (!ctr_local) {
-        goto out;
-    }
-
-    ctr_xlator_ctx = init_ctr_xlator_ctx(this, inode);
-    if (!ctr_xlator_ctx) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_ACCESS_CTR_INODE_CONTEXT_FAILED,
-               "Failed accessing ctr inode context");
-        goto out;
-    }
-
-    LOCK(&ctr_xlator_ctx->lock);
-
-    /* Check if the hard link already exists
-     * in the ctr inode context*/
-    ctr_hard_link = ctr_search_hard_link_ctx(this, ctr_xlator_ctx,
-                                             CTR_DB_REC(ctr_local).pargfid,
-                                             CTR_DB_REC(ctr_local).file_name);
-    /* if there then ignore */
-    if (ctr_hard_link) {
-        ret = gettimeofday(&current_time, NULL);
-        if (ret == -1) {
-            gf_log(this->name, GF_LOG_ERROR, "Failed to get current time");
-            ret_val = CTR_CTX_ERROR;
-            goto unlock;
-        }
-
-        if (__is_hardlink_expired(ctr_hard_link, _priv, &current_time)) {
-            ctr_hard_link->hardlink_heal_period = current_time.tv_sec;
-            ret_val = ret_val | CTR_TRY_HARDLINK_HEAL;
-        }
-
-        if (__is_inode_expired(ctr_xlator_ctx, _priv, &current_time)) {
-            ctr_xlator_ctx->inode_heal_period = current_time.tv_sec;
-            ret_val = ret_val | CTR_TRY_INODE_HEAL;
-        }
-
-        goto unlock;
-    }
-
-    /* Add the hard link to the list*/
-    ret = ctr_add_hard_link(this, ctr_xlator_ctx, CTR_DB_REC(ctr_local).pargfid,
-                            CTR_DB_REC(ctr_local).file_name);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_ADD_HARDLINK_TO_CTR_INODE_CONTEXT_FAILED,
-               "Failed to add hardlink to the ctr inode context");
-        ret_val = CTR_CTX_ERROR;
-        goto unlock;
-    }
-
-    ret_val = CTR_TRY_NO_HEAL;
-unlock:
-    UNLOCK(&ctr_xlator_ctx->lock);
-out:
-    return ret_val;
-}
-
-static inline int
-delete_hard_link_ctx(call_frame_t *frame, xlator_t *this, inode_t *inode)
-{
-    int ret = -1;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-    GF_ASSERT(inode);
-
-    ctr_local = frame->local;
-    if (!ctr_local) {
-        goto out;
-    }
-
-    ctr_xlator_ctx = get_ctr_xlator_ctx(this, inode);
-    if (!ctr_xlator_ctx) {
-        /* Since there is no ctr inode context so nothing more to do */
-        ret = 0;
-        goto out;
-    }
-
-    ret = ctr_delete_hard_link(this, ctr_xlator_ctx,
-                               CTR_DB_REC(ctr_local).pargfid,
-                               CTR_DB_REC(ctr_local).file_name);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_DELETE_HARDLINK_FAILED,
-               "Failed to delete hard link");
-        goto out;
-    }
-
-    ret = 0;
-
-out:
-    return ret;
-}
-
-static inline int
-update_hard_link_ctx(call_frame_t *frame, xlator_t *this, inode_t *inode)
-{
-    int ret = -1;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-    gf_ctr_local_t *ctr_local = NULL;
-
-    GF_ASSERT(frame);
-    GF_ASSERT(this);
-    GF_ASSERT(inode);
-
-    ctr_local = frame->local;
-    if (!ctr_local) {
-        goto out;
-    }
-
-    ctr_xlator_ctx = init_ctr_xlator_ctx(this, inode);
-    if (!ctr_xlator_ctx) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               CTR_MSG_ACCESS_CTR_INODE_CONTEXT_FAILED,
-               "Failed accessing ctr inode context");
-        goto out;
-    }
-
-    ret = ctr_update_hard_link(
-        this, ctr_xlator_ctx, CTR_DB_REC(ctr_local).pargfid,
-        CTR_DB_REC(ctr_local).file_name, CTR_DB_REC(ctr_local).old_pargfid,
-        CTR_DB_REC(ctr_local).old_file_name);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_DELETE_HARDLINK_FAILED,
-               "Failed to delete hard link");
-        goto out;
-    }
-
-    ret = 0;
-
-out:
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      CTR xlator init related functions
- *
- *
- * ****************************************************************************/
-int
-extract_db_params(xlator_t *this, dict_t *params_dict, gfdb_db_type_t db_type);
-
-int
-extract_ctr_options(xlator_t *this, gf_ctr_private_t *_priv);
-
-#endif
diff --git a/xlators/features/changetimerecorder/src/ctr-messages.h b/xlators/features/changetimerecorder/src/ctr-messages.h
deleted file mode 100644
index 23adf0aec09..00000000000
--- a/xlators/features/changetimerecorder/src/ctr-messages.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- Copyright (c) 2013 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 _CTR_MESSAGES_H_
-#define _CTR_MESSAGES_H_
-
-#include <glusterfs/glfs-message-id.h>
-
-/* To add new message IDs, append new identifiers at the end of the list.
- *
- * Never remove a message ID. If it's not used anymore, you can rename it or
- * leave it as it is, but not delete it. This is to prevent reutilization of
- * IDs by other messages.
- *
- * The component name must match one of the entries defined in
- * glfs-message-id.h.
- */
-
-GLFS_MSGID(
-    CTR, CTR_MSG_CREATE_CTR_LOCAL_ERROR_WIND,
-    CTR_MSG_FILL_CTR_LOCAL_ERROR_UNWIND, CTR_MSG_FILL_CTR_LOCAL_ERROR_WIND,
-    CTR_MSG_INSERT_LINK_WIND_FAILED, CTR_MSG_INSERT_WRITEV_WIND_FAILED,
-    CTR_MSG_INSERT_WRITEV_UNWIND_FAILED, CTR_MSG_INSERT_SETATTR_WIND_FAILED,
-    CTR_MSG_INSERT_SETATTR_UNWIND_FAILED,
-    CTR_MSG_INSERT_FREMOVEXATTR_UNWIND_FAILED,
-    CTR_MSG_INSERT_FREMOVEXATTR_WIND_FAILED,
-    CTR_MSG_INSERT_REMOVEXATTR_WIND_FAILED,
-    CTR_MSG_INSERT_REMOVEXATTR_UNWIND_FAILED,
-    CTR_MSG_INSERT_TRUNCATE_WIND_FAILED, CTR_MSG_INSERT_TRUNCATE_UNWIND_FAILED,
-    CTR_MSG_INSERT_FTRUNCATE_UNWIND_FAILED,
-    CTR_MSG_INSERT_FTRUNCATE_WIND_FAILED, CTR_MSG_INSERT_RENAME_WIND_FAILED,
-    CTR_MSG_INSERT_RENAME_UNWIND_FAILED,
-    CTR_MSG_ACCESS_CTR_INODE_CONTEXT_FAILED, CTR_MSG_ADD_HARDLINK_FAILED,
-    CTR_MSG_DELETE_HARDLINK_FAILED, CTR_MSG_UPDATE_HARDLINK_FAILED,
-    CTR_MSG_GET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-    CTR_MSG_SET_CTR_RESPONSE_LINK_COUNT_XDATA_FAILED,
-    CTR_MSG_INSERT_UNLINK_UNWIND_FAILED, CTR_MSG_INSERT_UNLINK_WIND_FAILED,
-    CTR_MSG_XDATA_NULL, CTR_MSG_INSERT_FSYNC_WIND_FAILED,
-    CTR_MSG_INSERT_FSYNC_UNWIND_FAILED, CTR_MSG_INSERT_MKNOD_UNWIND_FAILED,
-    CTR_MSG_INSERT_MKNOD_WIND_FAILED, CTR_MSG_INSERT_CREATE_WIND_FAILED,
-    CTR_MSG_INSERT_CREATE_UNWIND_FAILED, CTR_MSG_INSERT_RECORD_WIND_FAILED,
-    CTR_MSG_INSERT_READV_WIND_FAILED, CTR_MSG_GET_GFID_FROM_DICT_FAILED,
-    CTR_MSG_SET, CTR_MSG_FATAL_ERROR, CTR_MSG_DANGLING_VOLUME,
-    CTR_MSG_CALLOC_FAILED, CTR_MSG_EXTRACT_CTR_XLATOR_OPTIONS_FAILED,
-    CTR_MSG_INIT_DB_PARAMS_FAILED, CTR_MSG_CREATE_LOCAL_MEMORY_POOL_FAILED,
-    CTR_MSG_MEM_ACC_INIT_FAILED, CTR_MSG_CLOSE_DB_CONN_FAILED,
-    CTR_MSG_FILL_UNWIND_TIME_REC_ERROR, CTR_MSG_WRONG_FOP_PATH,
-    CTR_MSG_CONSTRUCT_DB_PATH_FAILED, CTR_MSG_SET_VALUE_TO_SQL_PARAM_FAILED,
-    CTR_MSG_XLATOR_DISABLED, CTR_MSG_HARDLINK_MISSING_IN_LIST,
-    CTR_MSG_ADD_HARDLINK_TO_LIST_FAILED, CTR_MSG_INIT_LOCK_FAILED,
-    CTR_MSG_COPY_FAILED, CTR_MSG_EXTRACT_DB_PARAM_OPTIONS_FAILED,
-    CTR_MSG_ADD_HARDLINK_TO_CTR_INODE_CONTEXT_FAILED, CTR_MSG_NULL_LOCAL);
-
-#endif /* !_CTR_MESSAGES_H_ */
diff --git a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.c b/xlators/features/changetimerecorder/src/ctr-xlator-ctx.c
deleted file mode 100644
index b6b66d56731..00000000000
--- a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.c
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
-   Copyright (c) 2015 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.
-*/
-
-#include "ctr-xlator-ctx.h"
-#include "ctr-messages.h"
-#include <time.h>
-#include <sys/time.h>
-
-#define IS_THE_ONLY_HARDLINK(ctr_hard_link)                                    \
-    (ctr_hard_link->list.next == ctr_hard_link->list.prev)
-
-static void
-fini_ctr_hard_link(ctr_hard_link_t **ctr_hard_link)
-{
-    GF_ASSERT(ctr_hard_link);
-
-    if (*ctr_hard_link)
-        return;
-    GF_FREE((*ctr_hard_link)->base_name);
-    GF_FREE(*ctr_hard_link);
-    *ctr_hard_link = NULL;
-}
-
-/* Please lock the ctr_xlator_ctx before using this function */
-ctr_hard_link_t *
-ctr_search_hard_link_ctx(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                         uuid_t pgfid, const char *base_name)
-{
-    ctr_hard_link_t *_hard_link = NULL;
-    ctr_hard_link_t *searched_hardlink = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(ctr_xlator_ctx);
-
-    if (pgfid == NULL || base_name == NULL)
-        goto out;
-
-    /*linear search*/
-    list_for_each_entry(_hard_link, &ctr_xlator_ctx->hardlink_list, list)
-    {
-        if (gf_uuid_compare(_hard_link->pgfid, pgfid) == 0 &&
-            _hard_link->base_name &&
-            strcmp(_hard_link->base_name, base_name) == 0) {
-            searched_hardlink = _hard_link;
-            break;
-        }
-    }
-
-out:
-    return searched_hardlink;
-}
-
-/* Please lock the ctr_xlator_ctx before using this function */
-int
-ctr_add_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                  uuid_t pgfid, const char *base_name)
-{
-    int ret = -1;
-    ctr_hard_link_t *ctr_hard_link = NULL;
-    struct timeval current_time = {0};
-
-    GF_ASSERT(this);
-    GF_ASSERT(ctr_xlator_ctx);
-
-    if (pgfid == NULL || base_name == NULL)
-        goto out;
-
-    ctr_hard_link = GF_CALLOC(1, sizeof(*ctr_hard_link), gf_ctr_mt_hard_link_t);
-    if (!ctr_hard_link) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, CTR_MSG_CALLOC_FAILED,
-               "Failed allocating "
-               "ctr_hard_link");
-        goto out;
-    }
-
-    /*Initialize the ctr_hard_link object and
-     * Assign the values : parent GFID and basename*/
-    INIT_LIST_HEAD(&ctr_hard_link->list);
-    gf_uuid_copy(ctr_hard_link->pgfid, pgfid);
-    ret = gf_asprintf(&ctr_hard_link->base_name, "%s", base_name);
-    if (ret < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_COPY_FAILED,
-               "Failed copying basename"
-               "to ctr_hard_link");
-        goto error;
-    }
-
-    ret = gettimeofday(&current_time, NULL);
-    if (ret == -1) {
-        gf_log(this->name, GF_LOG_ERROR, "Failed to get current time");
-        goto error;
-    }
-
-    /*Add the hard link to the list*/
-    list_add_tail(&ctr_hard_link->list, &ctr_xlator_ctx->hardlink_list);
-
-    ctr_hard_link->hardlink_heal_period = current_time.tv_sec;
-
-    /*aal izz well!*/
-    ret = 0;
-    goto out;
-error:
-    GF_FREE(ctr_hard_link);
-out:
-    return ret;
-}
-
-static void
-__delete_hard_link_from_list(ctr_hard_link_t **ctr_hard_link)
-{
-    GF_ASSERT(ctr_hard_link);
-    GF_ASSERT(*ctr_hard_link);
-
-    /*Remove hard link from list*/
-    list_del(&(*ctr_hard_link)->list);
-    fini_ctr_hard_link(ctr_hard_link);
-}
-
-int
-ctr_delete_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                     uuid_t pgfid, const char *base_name)
-{
-    int ret = -1;
-    ctr_hard_link_t *ctr_hard_link = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(ctr_xlator_ctx);
-
-    LOCK(&ctr_xlator_ctx->lock);
-
-    /*Check if the hard link is present */
-    ctr_hard_link = ctr_search_hard_link_ctx(this, ctr_xlator_ctx, pgfid,
-                                             base_name);
-    if (!ctr_hard_link) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_HARDLINK_MISSING_IN_LIST,
-               "Hard link doesn't exist in the list");
-        goto out;
-    }
-
-    __delete_hard_link_from_list(&ctr_hard_link);
-    ctr_hard_link = NULL;
-
-    ret = 0;
-out:
-    UNLOCK(&ctr_xlator_ctx->lock);
-
-    return ret;
-}
-
-int
-ctr_update_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                     uuid_t pgfid, const char *base_name, uuid_t old_pgfid,
-                     const char *old_base_name)
-{
-    int ret = -1;
-    ctr_hard_link_t *ctr_hard_link = NULL;
-    struct timeval current_time = {0};
-
-    GF_ASSERT(this);
-    GF_ASSERT(ctr_xlator_ctx);
-
-    LOCK(&ctr_xlator_ctx->lock);
-
-    /*Check if the hard link is present */
-    ctr_hard_link = ctr_search_hard_link_ctx(this, ctr_xlator_ctx, old_pgfid,
-                                             old_base_name);
-    if (!ctr_hard_link) {
-        gf_msg_trace(this->name, 0,
-                     "Hard link doesn't exist"
-                     " in the list");
-        /* Since the hard link is not present in the list
-         * we add it to the list */
-        ret = ctr_add_hard_link(this, ctr_xlator_ctx, pgfid, base_name);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, 0,
-                   CTR_MSG_ADD_HARDLINK_TO_LIST_FAILED,
-                   "Failed adding hard link to the list");
-            goto out;
-        }
-        ret = 0;
-        goto out;
-    }
-
-    /* update the hard link */
-    gf_uuid_copy(ctr_hard_link->pgfid, pgfid);
-    GF_FREE(ctr_hard_link->base_name);
-    ret = gf_asprintf(&ctr_hard_link->base_name, "%s", base_name);
-    if (ret < 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, CTR_MSG_COPY_FAILED,
-               "Failed copying basename"
-               "to ctr_hard_link");
-        /* delete the corrupted entry */
-        __delete_hard_link_from_list(&ctr_hard_link);
-        ctr_hard_link = NULL;
-        goto out;
-    }
-
-    ret = gettimeofday(&current_time, NULL);
-    if (ret == -1) {
-        gf_log(this->name, GF_LOG_ERROR, "Failed to get current time");
-        ctr_hard_link->hardlink_heal_period = 0;
-    } else {
-        ctr_hard_link->hardlink_heal_period = current_time.tv_sec;
-    }
-
-    ret = 0;
-
-out:
-    UNLOCK(&ctr_xlator_ctx->lock);
-
-    return ret;
-}
-
-/* Delete all hardlinks */
-static int
-ctr_delete_all_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx)
-{
-    int ret = -1;
-    ctr_hard_link_t *ctr_hard_link = NULL;
-    ctr_hard_link_t *tmp = NULL;
-
-    GF_ASSERT(ctr_xlator_ctx);
-
-    LOCK(&ctr_xlator_ctx->lock);
-
-    list_for_each_entry_safe(ctr_hard_link, tmp, &ctr_xlator_ctx->hardlink_list,
-                             list)
-    {
-        /*Remove hard link from list*/
-        __delete_hard_link_from_list(&ctr_hard_link);
-        ctr_hard_link = NULL;
-    }
-
-    UNLOCK(&ctr_xlator_ctx->lock);
-
-    ret = 0;
-
-    return ret;
-}
-
-/* Please lock the inode before using this function */
-static ctr_xlator_ctx_t *
-__get_ctr_xlator_ctx(xlator_t *this, inode_t *inode)
-{
-    int ret = 0;
-    uint64_t _addr = 0;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-
-    GF_ASSERT(this);
-    GF_ASSERT(inode);
-
-    ret = __inode_ctx_get(inode, this, &_addr);
-    if (ret < 0)
-        _addr = 0;
-    if (_addr != 0) {
-        ctr_xlator_ctx = (ctr_xlator_ctx_t *)(long)_addr;
-    }
-
-    return ctr_xlator_ctx;
-}
-
-ctr_xlator_ctx_t *
-init_ctr_xlator_ctx(xlator_t *this, inode_t *inode)
-{
-    int ret = -1;
-    uint64_t _addr = 0;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-    struct timeval current_time = {0};
-
-    GF_ASSERT(this);
-    GF_ASSERT(inode);
-
-    LOCK(&inode->lock);
-    {
-        ctr_xlator_ctx = __get_ctr_xlator_ctx(this, inode);
-        if (ctr_xlator_ctx) {
-            ret = 0;
-            goto out;
-        }
-        ctr_xlator_ctx = GF_CALLOC(1, sizeof(*ctr_xlator_ctx),
-                                   gf_ctr_mt_xlator_ctx);
-        if (!ctr_xlator_ctx)
-            goto out;
-
-        ret = LOCK_INIT(&ctr_xlator_ctx->lock);
-        if (ret) {
-            gf_msg(this->name, GF_LOG_ERROR, ret, CTR_MSG_INIT_LOCK_FAILED,
-                   "Failed init lock %s", strerror(ret));
-            goto out;
-        }
-        _addr = (uint64_t)(uintptr_t)ctr_xlator_ctx;
-
-        ret = __inode_ctx_set(inode, this, &_addr);
-        if (ret) {
-            goto out;
-        }
-
-        INIT_LIST_HEAD(&ctr_xlator_ctx->hardlink_list);
-
-        ret = gettimeofday(&current_time, NULL);
-        if (ret == -1) {
-            gf_log(this->name, GF_LOG_ERROR, "Failed to get current time");
-            goto out;
-        }
-
-        ctr_xlator_ctx->inode_heal_period = current_time.tv_sec;
-    }
-    ret = 0;
-out:
-    if (ret) {
-        GF_FREE(ctr_xlator_ctx);
-        ctr_xlator_ctx = NULL;
-    }
-
-    UNLOCK(&inode->lock);
-
-    return ctr_xlator_ctx;
-}
-
-void
-fini_ctr_xlator_ctx(xlator_t *this, inode_t *inode)
-{
-    int ret = 0;
-    uint64_t _addr = 0;
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-
-    inode_ctx_del(inode, this, &_addr);
-    if (!_addr)
-        return;
-
-    ctr_xlator_ctx = (ctr_xlator_ctx_t *)(long)_addr;
-
-    ret = ctr_delete_all_hard_link(this, ctr_xlator_ctx);
-    if (ret) {
-        gf_msg(this->name, GF_LOG_WARNING, 0, CTR_MSG_DELETE_HARDLINK_FAILED,
-               "Failed deleting all "
-               "hard links from inode context");
-    }
-
-    LOCK_DESTROY(&ctr_xlator_ctx->lock);
-
-    GF_FREE(ctr_xlator_ctx);
-}
-
-ctr_xlator_ctx_t *
-get_ctr_xlator_ctx(xlator_t *this, inode_t *inode)
-{
-    ctr_xlator_ctx_t *ctr_xlator_ctx = NULL;
-
-    LOCK(&inode->lock);
-    ctr_xlator_ctx = __get_ctr_xlator_ctx(this, inode);
-    UNLOCK(&inode->lock);
-
-    return ctr_xlator_ctx;
-}
diff --git a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.h b/xlators/features/changetimerecorder/src/ctr-xlator-ctx.h
deleted file mode 100644
index 4e3bf7e2798..00000000000
--- a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-   Copyright (c) 2015 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 __CTR_XLATOR_CTX_H
-#define __CTR_XLATOR_CTX_H
-
-#include <glusterfs/xlator.h>
-#include "ctr_mem_types.h"
-#include <glusterfs/iatt.h>
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/locking.h>
-#include <glusterfs/common-utils.h>
-#include <time.h>
-#include <sys/time.h>
-
-typedef struct ctr_hard_link {
-    uuid_t pgfid;
-    char *base_name;
-    /* Hardlink expiry : Defines the expiry period after which a
-     * database heal is attempted. */
-    uint64_t hardlink_heal_period;
-    struct list_head list;
-} ctr_hard_link_t;
-
-typedef struct ctr_xlator_ctx {
-    /* This represents the looked up hardlinks
-     * NOTE: This doesn't represent all physical hardlinks of the inode*/
-    struct list_head hardlink_list;
-    uint64_t inode_heal_period;
-    gf_lock_t lock;
-} ctr_xlator_ctx_t;
-
-ctr_hard_link_t *
-ctr_search_hard_link_ctx(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                         uuid_t pgfid, const char *base_name);
-
-int
-ctr_add_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                  uuid_t pgfid, const char *base_name);
-
-int
-ctr_delete_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                     uuid_t pgfid, const char *base_name);
-
-int
-ctr_update_hard_link(xlator_t *this, ctr_xlator_ctx_t *ctr_xlator_ctx,
-                     uuid_t pgfid, const char *base_name, uuid_t old_pgfid,
-                     const char *old_base_name);
-
-ctr_xlator_ctx_t *
-get_ctr_xlator_ctx(xlator_t *this, inode_t *inode);
-
-ctr_xlator_ctx_t *
-init_ctr_xlator_ctx(xlator_t *this, inode_t *inode);
-
-void
-fini_ctr_xlator_ctx(xlator_t *this, inode_t *inode);
-
-#endif
diff --git a/xlators/features/changetimerecorder/src/ctr_mem_types.h b/xlators/features/changetimerecorder/src/ctr_mem_types.h
deleted file mode 100644
index 7b8f531ddec..00000000000
--- a/xlators/features/changetimerecorder/src/ctr_mem_types.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (c) 2008-2015 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 __CTR_MEM_TYPES_H__
-#define __CTR_MEM_TYPES_H__
-
-#include "gfdb_mem-types.h"
-
-enum gf_ctr_mem_types_ {
-    gf_ctr_mt_private_t = gfdb_mt_end + 1,
-    gf_ctr_mt_xlator_ctx,
-    gf_ctr_mt_hard_link_t,
-    gf_ctr_mt_end
-};
-#endif
diff --git a/xlators/features/glupy/Makefile.am b/xlators/features/glupy/Makefile.am
deleted file mode 100644
index 060429ecf0f..00000000000
--- a/xlators/features/glupy/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src examples
-
-CLEANFILES =
diff --git a/xlators/features/glupy/doc/README.md b/xlators/features/glupy/doc/README.md
deleted file mode 100644
index 4b8b863ef39..00000000000
--- a/xlators/features/glupy/doc/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-This is just the very start for a GlusterFS[1] meta-translator that will
-allow translator code to be written in Python.  It's based on the standard
-Python embedding (not extending) techniques, plus a dash of the ctypes module.
-The interface is a pretty minimal adaptation of the dispatches and callbacks
-from the C API[2] to Python, as follows:
-
-* Dispatch functions and callbacks must be defined on an "xlator" class
-  derived from gluster.Translator so that they'll be auto-registered with
-  the C translator during initialization.
-
-* For each dispatch or callback function you want to intercept, you define a
-  Python function using the xxx\_fop\_t or xxx\_cbk\_t decorator.
-
-* The arguments for each operation are different, so you'll need to refer to
-  the C API.  GlusterFS-specific types are used (though only loc\_t is fully
-  defined so far) and type correctness is enforced by ctypes.
-
-* If you do intercept a dispatch function, it is your responsibility to call
-  xxx\_wind (like STACK\_WIND in the C API but operation-specific) to pass
-  the request to the next translator.  If you do not intercept a function, it
-  will default the same way as for C (pass through to the same operation with
-  the same arguments on the first child translator).
-
-* If you intercept a callback function, it is your responsibility to call
-  xxx\_unwind (like STACK\_UNWIND\_STRICT in the C API) to pass the request back
-  to the caller.
-
-So far only the lookup and create operations are handled this way, to support
-the "negative lookup" example.  Now that the basic infrastructure is in place,
-adding more functions should be very quick, though with that much boilerplate I
-might pause to write a code generator.  I also plan to add structure
-definitions and interfaces for some of the utility functions in libglusterfs
-(especially those having to do with inode and fd context) in the fairly near
-future.  Note that you can also use ctypes to get at anything not explicitly
-exposed to Python already.
-
-_If you're coming here because of the Linux Journal article, please note that
-the code has evolved since that was written. The version that matches the
-article is here:_
-
-https://github.com/jdarcy/glupy/tree/4bbae91ba459ea46ef32f2966562492e4ca9187a
-
-[1] http://www.gluster.org
-[2] http://pl.atyp.us/hekafs.org/dist/xlator_api_2.html
diff --git a/xlators/features/glupy/doc/TESTING b/xlators/features/glupy/doc/TESTING
deleted file mode 100644
index e05f17f498f..00000000000
--- a/xlators/features/glupy/doc/TESTING
+++ /dev/null
@@ -1,9 +0,0 @@
-Loading a translator written in Python using the glupy meta translator
--------------------------------------------------------------------------------
-'test.vol' is a simple volfile with the debug-trace Python translator on top
-of a brick. The volfile can be mounted using the following command.
-
-$ glusterfs --debug -f test.vol /path/to/mntpt
-
-If then file operations are performed on the newly mounted file system, log
-output would be printed by the Python translator on the standard output.
diff --git a/xlators/features/glupy/doc/test.vol b/xlators/features/glupy/doc/test.vol
deleted file mode 100644
index 0751a488c1f..00000000000
--- a/xlators/features/glupy/doc/test.vol
+++ /dev/null
@@ -1,10 +0,0 @@
-volume vol-posix
-    type storage/posix
-    option directory /path/to/brick
-end-volume
-
-volume vol-glupy
-    type features/glupy
-    option module-name debug-trace
-    subvolumes vol-posix
-end-volume
diff --git a/xlators/features/glupy/examples/Makefile.am b/xlators/features/glupy/examples/Makefile.am
deleted file mode 100644
index c26abeaafb6..00000000000
--- a/xlators/features/glupy/examples/Makefile.am
+++ /dev/null
@@ -1,5 +0,0 @@
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features
-
-glupyexamplesdir = $(xlatordir)/glupy
-
-glupyexamples_PYTHON = negative.py helloworld.py debug-trace.py
diff --git a/xlators/features/glupy/examples/debug-trace.py b/xlators/features/glupy/examples/debug-trace.py
deleted file mode 100644
index 6e012f6c547..00000000000
--- a/xlators/features/glupy/examples/debug-trace.py
+++ /dev/null
@@ -1,777 +0,0 @@
-
-from __future__ import print_function
-import sys
-import stat
-from uuid import UUID
-from time import strftime, localtime
-from gluster.glupy import *
-
-# This translator was written primarily to test the fop entry point definitions
-# and structure definitions in 'glupy.py'.
-
-# It is similar to the C language debug-trace translator, which logs the
-# arguments passed to the fops and their corresponding cbk functions.
-
-dl.get_id.restype = c_long
-dl.get_id.argtypes = [ POINTER(call_frame_t) ]
-
-dl.get_rootunique.restype = c_uint64
-dl.get_rootunique.argtypes = [ POINTER(call_frame_t) ]
-
-def uuid2str (gfid):
-        return str(UUID(''.join(map("{0:02x}".format, gfid))))
-
-
-def st_mode_from_ia (prot, filetype):
-        st_mode = 0
-        type_bit = 0
-        prot_bit = 0
-
-        if filetype == IA_IFREG:
-                type_bit = stat.S_IFREG
-        elif filetype == IA_IFDIR:
-                type_bit = stat.S_IFDIR
-        elif filetype == IA_IFLNK:
-                type_bit = stat.S_IFLNK
-        elif filetype == IA_IFBLK:
-                type_bit = stat.S_IFBLK
-        elif filetype == IA_IFCHR:
-                type_bit = stat.S_IFCHR
-        elif filetype == IA_IFIFO:
-                type_bit = stat.S_IFIFO
-        elif filetype == IA_IFSOCK:
-                type_bit = stat.S_IFSOCK
-        elif filetype == IA_INVAL:
-                pass
-
-
-        if prot.suid:
-                prot_bit |= stat.S_ISUID
-        if prot.sgid:
-                prot_bit |= stat.S_ISGID
-        if prot.sticky:
-                prot_bit |= stat.S_ISVTX
-
-        if prot.owner.read:
-                prot_bit |= stat.S_IRUSR
-        if prot.owner.write:
-                prot_bit |= stat.S_IWUSR
-        if prot.owner.execn:
-                prot_bit |= stat.S_IXUSR
-
-        if prot.group.read:
-                prot_bit |= stat.S_IRGRP
-        if prot.group.write:
-                prot_bit |= stat.S_IWGRP
-        if prot.group.execn:
-                prot_bit |= stat.S_IXGRP
-
-        if prot.other.read:
-                prot_bit |= stat.S_IROTH
-        if prot.other.write:
-                prot_bit |= stat.S_IWOTH
-        if prot.other.execn:
-                prot_bit |= stat.S_IXOTH
-
-        st_mode = (type_bit | prot_bit)
-
-        return st_mode
-
-
-def trace_stat2str (buf):
-        gfid = uuid2str(buf.contents.ia_gfid)
-        mode = st_mode_from_ia(buf.contents.ia_prot, buf.contents.ia_type)
-        atime_buf = strftime("[%b %d %H:%M:%S]",
-                             localtime(buf.contents.ia_atime))
-        mtime_buf = strftime("[%b %d %H:%M:%S]",
-                             localtime(buf.contents.ia_mtime))
-        ctime_buf = strftime("[%b %d %H:%M:%S]",
-                             localtime(buf.contents.ia_ctime))
-        return ("(gfid={0:s}, ino={1:d}, mode={2:o}, nlink={3:d}, uid ={4:d}, "+
-                "gid ={5:d}, size={6:d}, blocks={7:d}, atime={8:s}, mtime={9:s}, "+
-                "ctime={10:s})").format(gfid, buf.contents.ia_no, mode,
-                                        buf.contents.ia_nlink,
-                                        buf.contents.ia_uid,
-                                        buf.contents.ia_gid,
-                                        buf.contents.ia_size,
-                                        buf.contents.ia_blocks,
-                                        atime_buf, mtime_buf,
-                                        ctime_buf)
-
-class xlator(Translator):
-
-        def __init__(self, c_this):
-                Translator.__init__(self, c_this)
-                self.gfids = {}
-
-        def lookup_fop(self, frame, this, loc, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.gfid)
-                print(("GLUPY TRACE LOOKUP FOP- {0:d}: gfid={1:s}; " +
-                      "path={2:s}").format(unique, gfid, loc.contents.path))
-                self.gfids[key] = gfid
-                dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata)
-                return 0
-
-        def lookup_cbk(self, frame, cookie, this, op_ret, op_errno,
-                       inode, buf, xdata, postparent):
-                unique =dl.get_rootunique(frame)
-                key =dl.get_id(frame)
-                if op_ret == 0:
-                        gfid = uuid2str(buf.contents.ia_gfid)
-                        statstr = trace_stat2str(buf)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE LOOKUP CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; *buf={3:s}; " +
-                              "*postparent={4:s}").format(unique, gfid,
-                                                          op_ret, statstr,
-                                                          postparentstr))
-                else:
-                        gfid = self.gfids[key]
-                        print(("GLUPY TRACE LOOKUP CBK - {0:d}: gfid={1:s};" +
-                              " op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                      gfid,
-                                                                      op_ret,
-                                                                      op_errno))
-                del self.gfids[key]
-                dl.unwind_lookup(frame, cookie, this, op_ret, op_errno,
-                                 inode, buf, xdata, postparent)
-                return 0
-
-        def create_fop(self, frame, this, loc, flags, mode, umask, fd,
-                       xdata):
-                unique = dl.get_rootunique(frame)
-                gfid = uuid2str(loc.contents.gfid)
-                print(("GLUPY TRACE CREATE FOP- {0:d}: gfid={1:s}; path={2:s}; " +
-                      "fd={3:s}; flags=0{4:o}; mode=0{5:o}; " +
-                      "umask=0{6:o}").format(unique, gfid, loc.contents.path,
-                                             fd, flags, mode, umask))
-                dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode,
-                               umask, fd, xdata)
-                return 0
-
-        def create_cbk(self, frame, cookie, this, op_ret, op_errno, fd,
-                       inode, buf, preparent, postparent, xdata):
-                unique = dl.get_rootunique(frame)
-                if op_ret >= 0:
-                        gfid = uuid2str(inode.contents.gfid)
-                        statstr = trace_stat2str(buf)
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE CREATE CBK- {0:d}: gfid={1:s};" +
-                              " op_ret={2:d}; fd={3:s}; *stbuf={4:s}; " +
-                              "*preparent={5:s};" +
-                              " *postparent={6:s}").format(unique, gfid, op_ret,
-                                                           fd, statstr,
-                                                           preparentstr,
-                                                           postparentstr))
-                else:
-                        print(("GLUPY TRACE CREATE CBK- {0:d}: op_ret={1:d}; " +
-                              "op_errno={2:d}").format(unique, op_ret, op_errno))
-                dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd,
-                                 inode, buf, preparent, postparent, xdata)
-                return 0
-
-        def open_fop(self, frame, this, loc, flags, fd, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE OPEN FOP- {0:d}: gfid={1:s}; path={2:s}; "+
-                      "flags={3:d}; fd={4:s}").format(unique, gfid,
-                                                      loc.contents.path, flags,
-                                                      fd))
-                self.gfids[key] = gfid
-                dl.wind_open(frame, POINTER(xlator_t)(), loc, flags, fd, xdata)
-                return 0
-
-        def open_cbk(self, frame, cookie, this, op_ret, op_errno, fd, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE OPEN CBK- {0:d}: gfid={1:s}; op_ret={2:d}; "
-                      "op_errno={3:d}; *fd={4:s}").format(unique, gfid,
-                                                          op_ret, op_errno, fd))
-                del self.gfids[key]
-                dl.unwind_open(frame, cookie, this, op_ret, op_errno, fd,
-                               xdata)
-                return 0
-
-        def readv_fop(self, frame, this, fd, size, offset, flags, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE READV FOP- {0:d}: gfid={1:s}; "+
-                      "fd={2:s}; size ={3:d}; offset={4:d}; " +
-                      "flags=0{5:x}").format(unique, gfid, fd, size, offset,
-                                             flags))
-                self.gfids[key] = gfid
-                dl.wind_readv (frame, POINTER(xlator_t)(), fd, size, offset,
-                               flags, xdata)
-                return 0
-
-        def readv_cbk(self, frame, cookie, this, op_ret, op_errno, vector,
-                      count, buf, iobref, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret >= 0:
-                        statstr = trace_stat2str(buf)
-                        print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
-                              "op_ret={2:d}; *buf={3:s};").format(unique, gfid,
-                                                                  op_ret,
-                                                                  statstr))
-
-                else:
-                        print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_readv (frame, cookie, this, op_ret, op_errno,
-                                 vector, count, buf, iobref, xdata)
-                return 0
-
-        def writev_fop(self, frame, this, fd, vector, count, offset, flags,
-                       iobref, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE  WRITEV FOP- {0:d}: gfid={1:s}; " +
-                      "fd={2:s}; count={3:d}; offset={4:d}; " +
-                      "flags=0{5:x}").format(unique, gfid, fd, count, offset,
-                                             flags))
-                self.gfids[key] = gfid
-                dl.wind_writev(frame, POINTER(xlator_t)(), fd, vector, count,
-                               offset, flags, iobref, xdata)
-                return 0
-
-        def writev_cbk(self, frame, cookie, this, op_ret, op_errno, prebuf,
-                       postbuf, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                if op_ret >= 0:
-                        preopstr = trace_stat2str(prebuf)
-                        postopstr = trace_stat2str(postbuf)
-                        print(("GLUPY TRACE WRITEV CBK- {0:d}: op_ret={1:d}; " +
-                              "*prebuf={2:s}; " +
-                              "*postbuf={3:s}").format(unique, op_ret, preopstr,
-                                                       postopstr))
-                else:
-                        gfid = self.gfids[key]
-                        print(("GLUPY TRACE WRITEV CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_writev (frame, cookie, this, op_ret, op_errno,
-                                  prebuf, postbuf, xdata)
-                return 0
-
-        def opendir_fop(self, frame, this, loc, fd, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE OPENDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
-                      "fd={3:s}").format(unique, gfid, loc.contents.path, fd))
-                self.gfids[key] = gfid
-                dl.wind_opendir(frame, POINTER(xlator_t)(), loc, fd, xdata)
-                return 0
-
-        def opendir_cbk(self, frame, cookie, this, op_ret, op_errno, fd,
-                        xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE OPENDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
-                      " op_errno={3:d}; fd={4:s}").format(unique, gfid, op_ret,
-                                                          op_errno, fd))
-                del self.gfids[key]
-                dl.unwind_opendir(frame, cookie, this, op_ret, op_errno,
-                                  fd, xdata)
-                return 0
-
-        def readdir_fop(self, frame, this, fd, size, offset, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE READDIR FOP- {0:d}:  gfid={1:s}; fd={2:s}; " +
-                      "size={3:d}; offset={4:d}").format(unique, gfid, fd, size,
-                                                         offset))
-                self.gfids[key] = gfid
-                dl.wind_readdir(frame, POINTER(xlator_t)(), fd, size, offset,
-                                xdata)
-                return 0
-
-        def readdir_cbk(self, frame, cookie, this, op_ret, op_errno, buf,
-                        xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE READDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
-                      " op_errno={3:d}").format(unique, gfid, op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_readdir(frame, cookie, this, op_ret, op_errno, buf,
-                                  xdata)
-                return 0
-
-        def readdirp_fop(self, frame, this, fd, size, offset, dictionary):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE READDIRP FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
-                      " size={3:d}; offset={4:d}").format(unique, gfid, fd, size,
-                                                          offset))
-                self.gfids[key] = gfid
-                dl.wind_readdirp(frame, POINTER(xlator_t)(), fd, size, offset,
-                                 dictionary)
-                return 0
-
-        def readdirp_cbk(self, frame, cookie, this, op_ret, op_errno, buf,
-                         xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE READDIRP CBK- {0:d}: gfid={1:s}; "+
-                      "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_readdirp(frame, cookie, this, op_ret, op_errno, buf,
-                                  xdata)
-                return 0
-
-        def mkdir_fop(self, frame, this, loc, mode, umask, xdata):
-                unique = dl.get_rootunique(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE MKDIR FOP- {0:d}: gfid={1:s}; path={2:s}; " +
-                      "mode={3:d}; umask=0{4:o}").format(unique, gfid,
-                                                         loc.contents.path, mode,
-                                                         umask))
-                dl.wind_mkdir(frame, POINTER(xlator_t)(), loc, mode, umask,
-                              xdata)
-                return 0
-
-        def mkdir_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf,
-                      preparent, postparent,  xdata):
-                unique = dl.get_rootunique(frame)
-                if op_ret == 0:
-                        gfid = uuid2str(inode.contents.gfid)
-                        statstr = trace_stat2str(buf)
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE MKDIR CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; *stbuf={3:s}; *prebuf={4:s}; "+
-                              "*postbuf={5:s} ").format(unique, gfid, op_ret,
-                                                        statstr,
-                                                        preparentstr,
-                                                        postparentstr))
-                else:
-                        print(("GLUPY TRACE MKDIR CBK- {0:d}:  op_ret={1:d}; "+
-                              "op_errno={2:d}").format(unique, op_ret, op_errno))
-                dl.unwind_mkdir(frame, cookie, this, op_ret, op_errno, inode,
-                                buf, preparent, postparent, xdata)
-                return 0
-
-        def rmdir_fop(self, frame, this, loc, flags, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE RMDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
-                      "flags={3:d}").format(unique, gfid, loc.contents.path,
-                                            flags))
-                self.gfids[key] = gfid
-                dl.wind_rmdir(frame, POINTER(xlator_t)(), loc, flags, xdata)
-                return 0
-
-        def rmdir_cbk(self, frame, cookie, this, op_ret, op_errno, preparent,
-                      postparent, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; *prebuf={3:s}; "+
-                              "*postbuf={4:s}").format(unique, gfid, op_ret,
-                                                       preparentstr,
-                                                       postparentstr))
-                else:
-                        print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_rmdir(frame, cookie, this, op_ret, op_errno,
-                                preparent, postparent, xdata)
-                return 0
-
-        def stat_fop(self, frame, this, loc, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE STAT FOP- {0:d}: gfid={1:s}; " +
-                      " path={2:s}").format(unique, gfid, loc.contents.path))
-                self.gfids[key] = gfid
-                dl.wind_stat(frame, POINTER(xlator_t)(), loc, xdata)
-                return 0
-
-        def stat_cbk(self, frame, cookie, this, op_ret, op_errno, buf,
-                     xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        statstr = trace_stat2str(buf)
-                        print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d};  *buf={3:s};").format(unique,
-                                                                   gfid,
-                                                                   op_ret,
-                                                                   statstr))
-                else:
-                        print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_stat(frame, cookie, this, op_ret, op_errno,
-                               buf, xdata)
-                return 0
-
-        def fstat_fop(self, frame, this, fd, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE FSTAT FOP- {0:d}:  gfid={1:s}; " +
-                      "fd={2:s}").format(unique, gfid, fd))
-                self.gfids[key] = gfid
-                dl.wind_fstat(frame, POINTER(xlator_t)(), fd, xdata)
-                return 0
-
-        def fstat_cbk(self, frame, cookie, this, op_ret, op_errno, buf,
-                      xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        statstr = trace_stat2str(buf)
-                        print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
-                              " op_ret={2:d}; *buf={3:s}").format(unique,
-                                                                  gfid,
-                                                                  op_ret,
-                                                                  statstr))
-                else:
-                        print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique.
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_fstat(frame, cookie, this, op_ret, op_errno,
-                                buf, xdata)
-                return 0
-
-        def statfs_fop(self, frame, this, loc, xdata):
-                unique = dl.get_rootunique(frame)
-                if loc.contents.inode:
-                        gfid = uuid2str(loc.contents.inode.contents.gfid)
-                else:
-                        gfid = "0"
-                print(("GLUPY TRACE STATFS FOP- {0:d}: gfid={1:s}; "+
-                      "path={2:s}").format(unique, gfid, loc.contents.path))
-                dl.wind_statfs(frame, POINTER(xlator_t)(), loc, xdata)
-                return 0
-
-        def statfs_cbk(self, frame, cookie, this, op_ret, op_errno, buf,
-                       xdata):
-                unique = dl.get_rootunique(frame)
-                if op_ret == 0:
-                        #TBD: print buf (pointer to an iovec type object)
-                        print(("GLUPY TRACE STATFS CBK {0:d}: "+
-                              "op_ret={1:d}").format(unique, op_ret))
-                else:
-                        print(("GLUPY TRACE STATFS CBK-  {0:d}"+
-                              "op_ret={1:d}; op_errno={2:d}").format(unique,
-                                                                     op_ret,
-                                                                     op_errno))
-                dl.unwind_statfs(frame, cookie, this, op_ret, op_errno,
-                                 buf, xdata)
-                return 0
-
-        def getxattr_fop(self, frame, this, loc, name, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE GETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+
-                      " name={3:s}").format(unique, gfid, loc.contents.path,
-                                            name))
-                self.gfids[key]=gfid
-                dl.wind_getxattr(frame, POINTER(xlator_t)(), loc, name, xdata)
-                return 0
-
-        def getxattr_cbk(self, frame, cookie, this, op_ret, op_errno,
-                         dictionary, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE GETXATTR CBK- {0:d}: gfid={1:s}; "+
-                      "op_ret={2:d}; op_errno={3:d}; "+
-                      " dictionary={4:s}").format(unique, gfid, op_ret, op_errno,
-                                                  dictionary))
-                del self.gfids[key]
-                dl.unwind_getxattr(frame, cookie, this, op_ret, op_errno,
-                                   dictionary, xdata)
-                return 0
-
-        def fgetxattr_fop(self, frame, this, fd, name, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE FGETXATTR FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
-                      "name={3:s}").format(unique, gfid, fd, name))
-                self.gfids[key] = gfid
-                dl.wind_fgetxattr(frame, POINTER(xlator_t)(), fd, name, xdata)
-                return 0
-
-        def fgetxattr_cbk(self, frame, cookie, this, op_ret, op_errno,
-                          dictionary, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE FGETXATTR CBK- {0:d}: gfid={1:s}; "+
-                      "op_ret={2:d}; op_errno={3:d};"+
-                      " dictionary={4:s}").format(unique, gfid, op_ret,
-                                                  op_errno, dictionary))
-                del self.gfids[key]
-                dl.unwind_fgetxattr(frame, cookie, this, op_ret, op_errno,
-                                    dictionary, xdata)
-                return 0
-
-        def setxattr_fop(self, frame, this, loc, dictionary, flags, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE SETXATTR FOP- {0:d}:  gfid={1:s}; path={2:s};"+
-                      " flags={3:d}").format(unique, gfid, loc.contents.path,
-                                             flags))
-                self.gfids[key] = gfid
-                dl.wind_setxattr(frame, POINTER(xlator_t)(), loc, dictionary,
-                                 flags, xdata)
-                return 0
-
-        def setxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE SETXATTR CBK- {0:d}: gfid={1:s}; "+
-                      "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_setxattr(frame, cookie, this, op_ret, op_errno,
-                                   xdata)
-                return 0
-
-        def fsetxattr_fop(self, frame, this, fd, dictionary, flags, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print(("GLUPY TRACE FSETXATTR FOP- {0:d}: gfid={1:s}; fd={2:p}; "+
-                      "flags={3:d}").format(unique, gfid, fd, flags))
-                self.gfids[key] = gfid
-                dl.wind_fsetxattr(frame, POINTER(xlator_t)(), fd, dictionary,
-                                  flags, xdata)
-                return 0
-
-        def fsetxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE FSETXATTR CBK- {0:d}: gfid={1:s};  "+
-                      "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_fsetxattr(frame, cookie, this, op_ret, op_errno,
-                                   xdata)
-                return 0
-
-        def removexattr_fop(self, frame, this, loc, name, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE REMOVEXATTR FOP- {0:d}:  gfid={1:s}; "+
-                      "path={2:s}; name={3:s}").format(unique, gfid,
-                                                       loc.contents.path,
-                                                       name))
-                self.gfids[key] = gfid
-                dl.wind_removexattr(frame, POINTER(xlator_t)(), loc, name,
-                                    xdata)
-                return 0
-
-        def removexattr_cbk(self, frame, cookie, this, op_ret, op_errno,
-                            xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                print(("GLUPY TRACE REMOVEXATTR CBK- {0:d}: gfid={1:s} "+
-                      " op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                              op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_removexattr(frame, cookie, this, op_ret, op_errno,
-                                      xdata)
-                return 0
-
-        def link_fop(self, frame, this, oldloc, newloc, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                if (newloc.contents.inode):
-                        newgfid = uuid2str(newloc.contents.inode.contents.gfid)
-                else:
-                        newgfid = "0"
-                oldgfid = uuid2str(oldloc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE LINK FOP-{0:d}: oldgfid={1:s}; oldpath={2:s};"+
-                      "newgfid={3:s};"+
-                      "newpath={4:s}").format(unique, oldgfid,
-                                              oldloc.contents.path,
-                                              newgfid,
-                                              newloc.contents.path))
-                self.gfids[key] =  oldgfid
-                dl.wind_link(frame, POINTER(xlator_t)(), oldloc, newloc,
-                             xdata)
-                return 0
-
-        def link_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf,
-                     preparent, postparent, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        statstr = trace_stat2str(buf)
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE LINK CBK- {0:d}: op_ret={1:d} "+
-                              "*stbuf={2:s}; *prebuf={3:s}; "+
-                              "*postbuf={4:s} ").format(unique, op_ret, statstr,
-                                                        preparentstr,
-                                                        postparentstr))
-                else:
-                        print(("GLUPY TRACE LINK CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; "+
-                              "op_errno={3:d}").format(unique, gfid,
-                                                       op_ret, op_errno))
-                del self.gfids[key]
-                dl.unwind_link(frame, cookie, this, op_ret, op_errno, inode,
-                               buf, preparent, postparent, xdata)
-                return 0
-
-        def unlink_fop(self, frame, this, loc, xflag, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE UNLINK FOP- {0:d}; gfid={1:s}; path={2:s}; "+
-                      "flag={3:d}").format(unique, gfid, loc.contents.path,
-                                           xflag))
-                self.gfids[key] = gfid
-                dl.wind_unlink(frame, POINTER(xlator_t)(), loc, xflag,
-                               xdata)
-                return 0
-
-        def unlink_cbk(self, frame, cookie, this, op_ret, op_errno,
-                       preparent, postparent, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE UNLINK CBK- {0:d}: gfid ={1:s}; "+
-                              "op_ret={2:d}; *prebuf={3:s}; "+
-                              "*postbuf={4:s} ").format(unique, gfid, op_ret,
-                                                        preparentstr,
-                                                        postparentstr))
-                else:
-                        print(("GLUPY TRACE UNLINK CBK: {0:d}: gfid ={1:s}; "+
-                              "op_ret={2:d}; "+
-                              "op_errno={3:d}").format(unique, gfid, op_ret,
-                                                       op_errno))
-                del self.gfids[key]
-                dl.unwind_unlink(frame, cookie, this, op_ret, op_errno,
-                                 preparent, postparent, xdata)
-                return 0
-
-        def readlink_fop(self, frame, this, loc, size, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE READLINK FOP- {0:d}:  gfid={1:s}; path={2:s};"+
-                      " size={3:d}").format(unique, gfid, loc.contents.path,
-                                            size))
-                self.gfids[key] = gfid
-                dl.wind_readlink(frame, POINTER(xlator_t)(), loc, size,
-                               xdata)
-                return 0
-
-        def readlink_cbk(self, frame, cookie, this, op_ret, op_errno,
-                         buf, stbuf, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid  = self.gfids[key]
-                if op_ret == 0:
-                        statstr = trace_stat2str(stbuf)
-                        print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
-                              " op_ret={2:d}; op_errno={3:d}; *prebuf={4:s}; "+
-                              "*postbuf={5:s} ").format(unique, gfid,
-                                                        op_ret, op_errno,
-                                                        buf, statstr))
-                else:
-                        print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
-                              " op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                      gfid,
-                                                                      op_ret,
-                                                                      op_errno))
-                del self.gfids[key]
-                dl.unwind_readlink(frame, cookie, this, op_ret, op_errno, buf,
-                                   stbuf, xdata)
-                return 0
-
-        def symlink_fop(self, frame, this, linkpath, loc, umask, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print(("GLUPY TRACE SYMLINK FOP- {0:d}: gfid={1:s}; "+
-                      "linkpath={2:s}; path={3:s};"+
-                      "umask=0{4:o}").format(unique, gfid, linkpath,
-                                             loc.contents.path, umask))
-                self.gfids[key] = gfid
-                dl.wind_symlink(frame, POINTER(xlator_t)(), linkpath, loc,
-                                umask, xdata)
-                return 0
-
-        def symlink_cbk(self, frame, cookie, this, op_ret, op_errno,
-                        inode, buf, preparent, postparent, xdata):
-                unique = dl.get_rootunique(frame)
-                key = dl.get_id(frame)
-                gfid = self.gfids[key]
-                if op_ret == 0:
-                        statstr = trace_stat2str(buf)
-                        preparentstr = trace_stat2str(preparent)
-                        postparentstr = trace_stat2str(postparent)
-                        print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; *stbuf={3:s}; *preparent={4:s}; "+
-                              "*postparent={5:s}").format(unique, gfid,
-                                                          op_ret, statstr,
-                                                          preparentstr,
-                                                          postparentstr))
-                else:
-                        print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
-                              "op_ret={2:d}; op_errno={3:d}").format(unique,
-                                                                     gfid,
-                                                                     op_ret,
-                                                                     op_errno))
-                del self.gfids[key]
-                dl.unwind_symlink(frame, cookie, this, op_ret, op_errno,
-                                  inode, buf, preparent, postparent, xdata)
-                return 0
diff --git a/xlators/features/glupy/examples/helloworld.py b/xlators/features/glupy/examples/helloworld.py
deleted file mode 100644
index 282f9207949..00000000000
--- a/xlators/features/glupy/examples/helloworld.py
+++ /dev/null
@@ -1,21 +0,0 @@
-
-from __future__ import print_function
-import sys
-from gluster.glupy import *
-
-class xlator (Translator):
-
-    def __init__(self, c_this):
-        Translator.__init__(self, c_this)
-
-    def lookup_fop(self, frame, this, loc, xdata):
-        print("Python xlator: Hello!")
-        dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata)
-        return 0
-
-    def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf,
-                   xdata, postparent):
-        print("Python xlator: Hello again!")
-        dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, inode, buf,
-                         xdata, postparent)
-        return 0
diff --git a/xlators/features/glupy/examples/negative.py b/xlators/features/glupy/examples/negative.py
deleted file mode 100644
index e04b16aa553..00000000000
--- a/xlators/features/glupy/examples/negative.py
+++ /dev/null
@@ -1,93 +0,0 @@
-
-from __future__ import print_function
-import sys
-from uuid import UUID
-from gluster.glupy import *
-
-# Negative-lookup-caching example.  If a file wasn't there the last time we
-# looked, it's probably still not there.  This translator keeps track of
-# those failed lookups for us, and returns ENOENT without needing to pass the
-# call any further for repeated requests.
-
-# If we were doing this for real, we'd need separate caches for each xlator
-# instance.  The easiest way to do this would be to have xlator.__init__
-# "register" each instance in a module-global dict, with the key as the C
-# translator address and the value as the xlator object itself.  For testing
-# and teaching, it's sufficient just to have one cache.  The keys are parent
-# GFIDs, and the entries are lists of names within that parent that we know
-# don't exist.
-cache = {}
-
-# TBD: we need a better way of handling per-request data (frame->local in C).
-dl.get_id.restype = c_long
-dl.get_id.argtypes = [ POINTER(call_frame_t) ]
-
-def uuid2str (gfid):
-    return str(UUID(''.join(map("{0:02x}".format, gfid))))
-
-class xlator (Translator):
-
-    def __init__ (self, c_this):
-        self.requests = {}
-        Translator.__init__(self, c_this)
-
-    def lookup_fop (self, frame, this, loc, xdata):
-        pargfid = uuid2str(loc.contents.pargfid)
-        print("lookup FOP: %s:%s" % (pargfid, loc.contents.name))
-        # Check the cache.
-        if pargfid in cache:
-            if loc.contents.name in cache[pargfid]:
-                print("short-circuiting for %s:%s" % (pargfid,
-                    loc.contents.name))
-                dl.unwind_lookup(frame, 0, this, -1, 2, None, None, None, None)
-                return 0
-        key = dl.get_id(frame)
-        self.requests[key] = (pargfid, loc.contents.name[:])
-        # TBD: get real child xl from init, pass it here
-        dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata)
-        return 0
-
-    def lookup_cbk (self, frame, cookie, this, op_ret, op_errno, inode, buf,
-                    xdata, postparent):
-        print("lookup CBK: %d (%d)" % (op_ret, op_errno))
-        key = dl.get_id(frame)
-        pargfid, name = self.requests[key]
-        # Update the cache.
-        if op_ret == 0:
-            print("found %s, removing from cache" % name)
-            if pargfid in cache:
-                cache[pargfid].discard(name)
-        elif op_errno == 2:    # ENOENT
-            print("failed to find %s, adding to cache" % name)
-            if pargfid in cache:
-                cache[pargfid].add(name)
-            else:
-                cache[pargfid] = {name}
-        del self.requests[key]
-        dl.unwind_lookup(frame, cookie, this, op_ret, op_errno,
-                         inode, buf, xdata, postparent)
-        return 0
-
-    def create_fop (self, frame, this, loc, flags, mode, umask, fd, xdata):
-        pargfid = uuid2str(loc.contents.pargfid)
-        print("create FOP: %s:%s" % (pargfid, loc.contents.name))
-        key = dl.get_id(frame)
-        self.requests[key] = (pargfid, loc.contents.name[:])
-        # TBD: get real child xl from init, pass it here
-        dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode, umask, fd, xdata)
-        return 0
-
-    def create_cbk (self, frame, cookie, this, op_ret, op_errno, fd, inode,
-                    buf, preparent, postparent, xdata):
-        print("create CBK: %d (%d)" % (op_ret, op_errno))
-        key = dl.get_id(frame)
-        pargfid, name = self.requests[key]
-        # Update the cache.
-        if op_ret == 0:
-            print("created %s, removing from cache" % name)
-            if pargfid in cache:
-                cache[pargfid].discard(name)
-        del self.requests[key]
-        dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd, inode, buf,
-                         preparent, postparent, xdata)
-        return 0
diff --git a/xlators/features/glupy/src/Makefile.am b/xlators/features/glupy/src/Makefile.am
deleted file mode 100644
index 817b0d00f61..00000000000
--- a/xlators/features/glupy/src/Makefile.am
+++ /dev/null
@@ -1,36 +0,0 @@
-xlator_LTLIBRARIES = glupy.la
-
-# Ensure GLUSTER_PYTHON_PATH is passed to glupy.so
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features
-glupydir = $(xlatordir)/glupy
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) \
-	-I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src
-
-AM_CFLAGS = -Wall -fno-strict-aliasing \
-	-DGLUSTER_PYTHON_PATH=\"$(glupydir)\" \
-	-DPATH_GLUSTERFS_GLUPY_MODULE=\"${xlatordir}/glupy${shrext_cmds}\" \
-	$(GF_CFLAGS) $(PYTHON_CFLAGS)
-
-# Flags to build glupy.so with
-glupy_la_LDFLAGS = -module -nostartfiles \
-        -export-symbols $(top_srcdir)/xlators/features/glupy/src/glupy.sym \
-        $(GF_XLATOR_LDFLAGS) $(PYTHON_LIBS)
-
-glupy_la_SOURCES = glupy.c
-glupy_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	-lpthread $(LIB_DL)
-
-noinst_HEADERS = glupy.h
-
-# Install __init__.py into the Python site-packages area
-pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster
-pyglupy_PYTHON = __init__.py
-
-# Install glupy/__init_-.py into the Python site-packages area
-SUBDIRS = glupy
-
-CLEANFILES =
-
-EXTRA_DIST = glupy.sym
diff --git a/xlators/features/glupy/src/__init__.py.in b/xlators/features/glupy/src/__init__.py.in
deleted file mode 100644
index 3ad9513f40e..00000000000
--- a/xlators/features/glupy/src/__init__.py.in
+++ /dev/null
@@ -1,2 +0,0 @@
-from pkgutil import extend_path
-__path__ = extend_path(__path__, __name__)
diff --git a/xlators/features/glupy/src/glupy.c b/xlators/features/glupy/src/glupy.c
deleted file mode 100644
index e2241b49ad3..00000000000
--- a/xlators/features/glupy/src/glupy.c
+++ /dev/null
@@ -1,2446 +0,0 @@
-/*
-   Copyright (c) 2006-2014 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.
-*/
-
-#include <ctype.h>
-#include <dlfcn.h>
-#include <sys/uio.h>
-#include <Python.h>
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/defaults.h>
-
-#include "glupy.h"
-
-/* UTILITY FUNCTIONS FOR FOP-SPECIFIC CODE */
-
-pthread_key_t gil_init_key;
-
-PyGILState_STATE
-glupy_enter(void)
-{
-    if (!pthread_getspecific(gil_init_key)) {
-        PyEval_ReleaseLock();
-        (void)pthread_setspecific(gil_init_key, (void *)1);
-    }
-
-    return PyGILState_Ensure();
-}
-
-void
-glupy_leave(PyGILState_STATE gstate)
-{
-    PyGILState_Release(gstate);
-}
-
-/* FOP: LOOKUP */
-
-int32_t
-glupy_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, inode_t *inode,
-                 struct iatt *buf, dict_t *xdata, struct iatt *postparent)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_LOOKUP]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_lookup_cbk_t)(priv->cbks[GLUPY_LOOKUP]))(
-        frame, cookie, this, op_ret, op_errno, inode, buf, xdata, postparent);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata,
-                        postparent);
-    return 0;
-}
-
-int32_t
-glupy_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_LOOKUP]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_lookup_t)(priv->fops[GLUPY_LOOKUP]))(frame, this, loc, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, xdata);
-    return 0;
-}
-
-void
-wind_lookup(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_lookup_cbk, xl, xl->fops->lookup, loc, xdata);
-}
-
-void
-unwind_lookup(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
-              struct iatt *postparent)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata,
-                        postparent);
-}
-
-void
-set_lookup_fop(long py_this, fop_lookup_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_LOOKUP] = (long)fop;
-}
-
-void
-set_lookup_cbk(long py_this, fop_lookup_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_LOOKUP] = (long)cbk;
-}
-
-/* FOP: CREATE */
-
-int32_t
-glupy_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
-                 struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_CREATE]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_create_cbk_t)(priv->cbks[GLUPY_CREATE]))(
-        frame, cookie, this, op_ret, op_errno, fd, inode, buf, preparent,
-        postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf,
-                        preparent, postparent, xdata);
-    return 0;
-}
-
-int32_t
-glupy_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-             mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_CREATE]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_create_t)(priv->fops[GLUPY_CREATE]))(frame, this, loc, flags,
-                                                     mode, umask, fd, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_create_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
-               xdata);
-    return 0;
-}
-
-void
-wind_create(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags,
-            mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_create_cbk, xl, xl->fops->create, loc, flags, mode,
-               umask, fd, xdata);
-}
-
-void
-unwind_create(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf,
-              struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf,
-                        preparent, postparent, xdata);
-}
-
-void
-set_create_fop(long py_this, fop_create_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_CREATE] = (long)fop;
-}
-
-void
-set_create_cbk(long py_this, fop_create_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_CREATE] = (long)cbk;
-}
-
-/* FOP: OPEN */
-
-int32_t
-glupy_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_OPEN]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_open_cbk_t)(priv->cbks[GLUPY_OPEN]))(
-        frame, cookie, this, op_ret, op_errno, fd, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata);
-    return 0;
-}
-
-int32_t
-glupy_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           fd_t *fd, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_OPEN]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_open_t)(priv->fops[GLUPY_OPEN]))(frame, this, loc, flags, fd,
-                                                 xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_open_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
-    return 0;
-}
-
-void
-wind_open(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags,
-          fd_t *fd, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_open_cbk, xl, xl->fops->open, loc, flags, fd,
-               xdata);
-}
-
-void
-unwind_open(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-            int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata);
-}
-
-void
-set_open_fop(long py_this, fop_open_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->fops[GLUPY_OPEN] = (long)fop;
-}
-
-void
-set_open_cbk(long py_this, fop_open_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->cbks[GLUPY_OPEN] = (long)cbk;
-}
-
-/* FOP: READV */
-
-int32_t
-glupy_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                int32_t count, struct iatt *stbuf, struct iobref *iobref,
-                dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_READV]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_readv_cbk_t)(priv->cbks[GLUPY_READV]))(
-        frame, cookie, this, op_ret, op_errno, vector, count, stbuf, iobref,
-        xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf,
-                        iobref, xdata);
-    return 0;
-}
-
-int32_t
-glupy_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-            off_t offset, uint32_t flags, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_READV]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_readv_t)(priv->fops[GLUPY_READV]))(frame, this, fd, size,
-                                                   offset, flags, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_readv_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata);
-    return 0;
-}
-
-void
-wind_readv(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size,
-           off_t offset, uint32_t flags, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_readv_cbk, xl, xl->fops->readv, fd, size, offset,
-               flags, xdata);
-}
-
-void
-unwind_readv(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, struct iovec *vector, int32_t count,
-             struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf,
-                        iobref, xdata);
-}
-
-void
-set_readv_fop(long py_this, fop_readv_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->fops[GLUPY_READV] = (long)fop;
-}
-
-void
-set_readv_cbk(long py_this, fop_readv_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->cbks[GLUPY_READV] = (long)cbk;
-}
-
-/* FOP: WRITEV */
-
-int32_t
-glupy_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                 struct iatt *postbuf, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_WRITEV]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_writev_cbk_t)(priv->cbks[GLUPY_WRITEV]))(
-        frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf,
-                        xdata);
-    return 0;
-}
-
-int32_t
-glupy_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
-             struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
-             struct iobref *iobref, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_WRITEV]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_writev_t)(priv->fops[GLUPY_WRITEV]))(
-        frame, this, fd, vector, count, offset, flags, iobref, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_writev_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
-               flags, iobref, xdata);
-    return 0;
-}
-
-void
-wind_writev(call_frame_t *frame, xlator_t *xl, fd_t *fd, struct iovec *vector,
-            int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
-            dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_writev_cbk, xl, xl->fops->writev, fd, vector, count,
-               offset, flags, iobref, xdata);
-}
-
-void
-unwind_writev(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf,
-              dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf,
-                        xdata);
-}
-
-void
-set_writev_fop(long py_this, fop_writev_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->fops[GLUPY_WRITEV] = (long)fop;
-}
-
-void
-set_writev_cbk(long py_this, fop_writev_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-    priv->cbks[GLUPY_WRITEV] = (long)cbk;
-}
-
-/* FOP: OPENDIR */
-
-int32_t
-glupy_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_OPENDIR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_opendir_cbk_t)(priv->cbks[GLUPY_OPENDIR]))(
-        frame, cookie, this, op_ret, op_errno, fd, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata);
-    return 0;
-}
-
-int32_t
-glupy_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-              dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_OPENDIR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_opendir_t)(priv->fops[GLUPY_OPENDIR]))(frame, this, loc, fd,
-                                                       xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_opendir_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->opendir, loc, fd, xdata);
-    return 0;
-}
-
-void
-wind_opendir(call_frame_t *frame, xlator_t *xl, loc_t *loc, fd_t *fd,
-             dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_opendir_cbk, xl, xl->fops->opendir, loc, fd, xdata);
-}
-
-void
-unwind_opendir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-               int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata);
-}
-
-void
-set_opendir_fop(long py_this, fop_opendir_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_OPENDIR] = (long)fop;
-}
-
-void
-set_opendir_cbk(long py_this, fop_opendir_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_OPENDIR] = (long)cbk;
-}
-
-/* FOP: READDIR */
-
-int32_t
-glupy_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                  dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_READDIR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_readdir_cbk_t)(priv->cbks[GLUPY_READDIR]))(
-        frame, cookie, this, op_ret, op_errno, entries, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata);
-    return 0;
-}
-
-int32_t
-glupy_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-              off_t offset, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_READDIR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_readdir_t)(priv->fops[GLUPY_READDIR]))(frame, this, fd, size,
-                                                       offset, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_readdir_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata);
-    return 0;
-}
-
-void
-wind_readdir(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size,
-             off_t offset, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_readdir_cbk, xl, xl->fops->readdir, fd, size,
-               offset, xdata);
-}
-
-void
-unwind_readdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-               int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata);
-}
-
-void
-set_readdir_fop(long py_this, fop_readdir_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_READDIR] = (long)fop;
-}
-
-void
-set_readdir_cbk(long py_this, fop_readdir_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_READDIR] = (long)cbk;
-}
-
-/* FOP: READDIRP */
-
-int32_t
-glupy_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                   dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_READDIRP]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_readdirp_cbk_t)(priv->cbks[GLUPY_READDIRP]))(
-        frame, cookie, this, op_ret, op_errno, entries, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata);
-    return 0;
-}
-
-int32_t
-glupy_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-               off_t offset, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_READDIRP]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_readdirp_t)(priv->fops[GLUPY_READDIRP]))(frame, this, fd, size,
-                                                         offset, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_readdirp_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata);
-    return 0;
-}
-
-void
-wind_readdirp(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size,
-              off_t offset, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_readdirp_cbk, xl, xl->fops->readdirp, fd, size,
-               offset, xdata);
-}
-
-void
-unwind_readdirp(call_frame_t *frame, long cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
-                dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata);
-}
-
-void
-set_readdirp_fop(long py_this, fop_readdirp_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_READDIRP] = (long)fop;
-}
-
-void
-set_readdirp_cbk(long py_this, fop_readdirp_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_READDIRP] = (long)cbk;
-}
-
-/* FOP:STAT */
-
-int32_t
-glupy_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, struct iatt *buf,
-               dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_STAT]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_stat_cbk_t)(priv->cbks[GLUPY_STAT]))(
-        frame, cookie, this, op_ret, op_errno, buf, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata);
-    return 0;
-}
-
-int32_t
-glupy_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_STAT]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_stat_t)(priv->fops[GLUPY_STAT]))(frame, this, loc, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_stat_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->stat, loc, xdata);
-    return 0;
-}
-
-void
-wind_stat(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_stat_cbk, xl, xl->fops->stat, loc, xdata);
-}
-
-void
-unwind_stat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-            int32_t op_errno, struct iatt *buf, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata);
-}
-
-void
-set_stat_fop(long py_this, fop_stat_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_STAT] = (long)fop;
-}
-
-void
-set_stat_cbk(long py_this, fop_stat_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_STAT] = (long)cbk;
-}
-
-/* FOP: FSTAT */
-
-int32_t
-glupy_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_FSTAT]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_fstat_cbk_t)(priv->cbks[GLUPY_FSTAT]))(
-        frame, cookie, this, op_ret, op_errno, buf, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata);
-    return 0;
-}
-
-int32_t
-glupy_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_FSTAT]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_fstat_t)(priv->fops[GLUPY_FSTAT]))(frame, this, fd, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_fstat_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, xdata);
-    return 0;
-}
-
-void
-wind_fstat(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_fstat_cbk, xl, xl->fops->fstat, fd, xdata);
-}
-
-void
-unwind_fstat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, struct iatt *buf, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata);
-}
-
-void
-set_fstat_fop(long py_this, fop_fstat_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_FSTAT] = (long)fop;
-}
-
-void
-set_fstat_cbk(long py_this, fop_fstat_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_FSTAT] = (long)cbk;
-}
-
-/* FOP:STATFS */
-
-int32_t
-glupy_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct statvfs *buf,
-                 dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_STATFS]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_statfs_cbk_t)(priv->cbks[GLUPY_STATFS]))(
-        frame, cookie, this, op_ret, op_errno, buf, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata);
-    return 0;
-}
-
-int32_t
-glupy_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_STATFS]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_statfs_t)(priv->fops[GLUPY_STATFS]))(frame, this, loc, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_statfs_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->statfs, loc, xdata);
-    return 0;
-}
-
-void
-wind_statfs(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_statfs_cbk, xl, xl->fops->statfs, loc, xdata);
-}
-
-void
-unwind_statfs(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct statvfs *buf, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata);
-}
-
-void
-set_statfs_fop(long py_this, fop_statfs_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_STATFS] = (long)fop;
-}
-
-void
-set_statfs_cbk(long py_this, fop_statfs_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_STATFS] = (long)cbk;
-}
-
-/* FOP: SETXATTR */
-
-int32_t
-glupy_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_SETXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_setxattr_cbk_t)(priv->cbks[GLUPY_SETXATTR]))(
-        frame, cookie, this, op_ret, op_errno, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int32_t
-glupy_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-               int32_t flags, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_SETXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_setxattr_t)(priv->fops[GLUPY_SETXATTR]))(frame, this, loc, dict,
-                                                         flags, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_setxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
-    return 0;
-}
-
-void
-wind_setxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *dict,
-              int32_t flags, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_setxattr_cbk, xl, xl->fops->setxattr, loc, dict,
-               flags, xdata);
-}
-
-void
-unwind_setxattr(call_frame_t *frame, long cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata);
-}
-
-void
-set_setxattr_fop(long py_this, fop_setxattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_SETXATTR] = (long)fop;
-}
-
-void
-set_setxattr_cbk(long py_this, fop_setxattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_SETXATTR] = (long)cbk;
-}
-
-/* FOP: GETXATTR */
-
-int32_t
-glupy_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *dict,
-                   dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_GETXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_getxattr_cbk_t)(priv->cbks[GLUPY_GETXATTR]))(
-        frame, cookie, this, op_ret, op_errno, dict, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata);
-    return 0;
-}
-
-int32_t
-glupy_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-               const char *name, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_GETXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_getxattr_t)(priv->fops[GLUPY_GETXATTR]))(frame, this, loc, name,
-                                                         xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_getxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
-    return 0;
-}
-
-void
-wind_getxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, const char *name,
-              dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_getxattr_cbk, xl, xl->fops->getxattr, loc, name,
-               xdata);
-}
-
-void
-unwind_getxattr(call_frame_t *frame, long cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata);
-}
-
-void
-set_getxattr_fop(long py_this, fop_getxattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_GETXATTR] = (long)fop;
-}
-
-void
-set_getxattr_cbk(long py_this, fop_getxattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_GETXATTR] = (long)cbk;
-}
-
-/* FOP: FSETXATTR */
-
-int32_t
-glupy_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_FSETXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_fsetxattr_cbk_t)(priv->cbks[GLUPY_FSETXATTR]))(
-        frame, cookie, this, op_ret, op_errno, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int32_t
-glupy_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                int32_t flags, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_FSETXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_fsetxattr_t)(priv->fops[GLUPY_FSETXATTR]))(frame, this, fd,
-                                                           dict, flags, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_fsetxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
-    return 0;
-}
-
-void
-wind_fsetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *dict,
-               int32_t flags, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_fsetxattr_cbk, xl, xl->fops->fsetxattr, fd, dict,
-               flags, xdata);
-}
-
-void
-unwind_fsetxattr(call_frame_t *frame, long cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata);
-}
-
-void
-set_fsetxattr_fop(long py_this, fop_fsetxattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_FSETXATTR] = (long)fop;
-}
-
-void
-set_fsetxattr_cbk(long py_this, fop_fsetxattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_FSETXATTR] = (long)cbk;
-}
-
-/* FOP: FGETXATTR */
-
-int32_t
-glupy_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *dict,
-                    dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_FGETXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_fgetxattr_cbk_t)(priv->cbks[GLUPY_FGETXATTR]))(
-        frame, cookie, this, op_ret, op_errno, dict, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata);
-    return 0;
-}
-
-int32_t
-glupy_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
-                dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_FGETXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_fgetxattr_t)(priv->fops[GLUPY_FGETXATTR]))(frame, this, fd,
-                                                           name, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_fgetxattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
-    return 0;
-}
-
-void
-wind_fgetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name,
-               dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_fgetxattr_cbk, xl, xl->fops->fgetxattr, fd, name,
-               xdata);
-}
-
-void
-unwind_fgetxattr(call_frame_t *frame, long cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata);
-}
-
-void
-set_fgetxattr_fop(long py_this, fop_fgetxattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_FGETXATTR] = (long)fop;
-}
-
-void
-set_fgetxattr_cbk(long py_this, fop_fgetxattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_FGETXATTR] = (long)cbk;
-}
-
-/* FOP:REMOVEXATTR */
-
-int32_t
-glupy_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_REMOVEXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_removexattr_cbk_t)(priv->cbks[GLUPY_REMOVEXATTR]))(
-        frame, cookie, this, op_ret, op_errno, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int32_t
-glupy_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  const char *name, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_REMOVEXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_removexattr_t)(priv->fops[GLUPY_REMOVEXATTR]))(frame, this, loc,
-                                                               name, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_removexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
-    return 0;
-}
-
-void
-wind_removexattr(call_frame_t *frame, xlator_t *xl, loc_t *loc,
-                 const char *name, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_removexattr_cbk, xl, xl->fops->removexattr, loc,
-               name, xdata);
-}
-
-void
-unwind_removexattr(call_frame_t *frame, long cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata);
-}
-
-void
-set_removexattr_fop(long py_this, fop_removexattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_REMOVEXATTR] = (long)fop;
-}
-
-void
-set_removexattr_cbk(long py_this, fop_removexattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_REMOVEXATTR] = (long)cbk;
-}
-
-/* FOP:FREMOVEXATTR */
-
-int32_t
-glupy_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_FREMOVEXATTR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_fremovexattr_cbk_t)(priv->cbks[GLUPY_FREMOVEXATTR]))(
-        frame, cookie, this, op_ret, op_errno, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int32_t
-glupy_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   const char *name, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_FREMOVEXATTR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_fremovexattr_t)(priv->fops[GLUPY_FREMOVEXATTR]))(
-        frame, this, fd, name, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_fremovexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
-    return 0;
-}
-
-void
-wind_fremovexattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name,
-                  dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_fremovexattr_cbk, xl, xl->fops->fremovexattr, fd,
-               name, xdata);
-}
-
-void
-unwind_fremovexattr(call_frame_t *frame, long cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata);
-}
-
-void
-set_fremovexattr_fop(long py_this, fop_fremovexattr_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_FREMOVEXATTR] = (long)fop;
-}
-
-void
-set_fremovexattr_cbk(long py_this, fop_fremovexattr_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_FREMOVEXATTR] = (long)cbk;
-}
-
-/* FOP: LINK*/
-int32_t
-glupy_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-               int32_t op_ret, int32_t op_errno, inode_t *inode,
-               struct iatt *buf, struct iatt *preparent,
-               struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_LINK]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_link_cbk_t)(priv->cbks[GLUPY_LINK]))(
-        frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
-        postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int32_t
-glupy_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-           dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_LINK]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_link_t)(priv->fops[GLUPY_LINK]))(frame, this, oldloc, newloc,
-                                                 xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_link_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
-    return 0;
-}
-
-void
-wind_link(call_frame_t *frame, xlator_t *xl, loc_t *oldloc, loc_t *newloc,
-          dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_link_cbk, xl, xl->fops->link, oldloc, newloc,
-               xdata);
-}
-
-void
-unwind_link(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-            int32_t op_errno, inode_t *inode, struct iatt *buf,
-            struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-}
-
-void
-set_link_fop(long py_this, fop_link_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_LINK] = (long)fop;
-}
-
-void
-set_link_cbk(long py_this, fop_link_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_LINK] = (long)cbk;
-}
-
-/* FOP: SYMLINK*/
-int32_t
-glupy_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, inode_t *inode,
-                  struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_SYMLINK]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_symlink_cbk_t)(priv->cbks[GLUPY_SYMLINK]))(
-        frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
-        postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int32_t
-glupy_symlink(call_frame_t *frame, xlator_t *this, const char *linkname,
-              loc_t *loc, mode_t umask, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_SYMLINK]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_symlink_t)(priv->fops[GLUPY_SYMLINK]))(frame, this, linkname,
-                                                       loc, umask, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_symlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata);
-    return 0;
-}
-
-void
-wind_symlink(call_frame_t *frame, xlator_t *xl, const char *linkname,
-             loc_t *loc, mode_t umask, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_symlink_cbk, xl, xl->fops->symlink, linkname, loc,
-               umask, xdata);
-}
-
-void
-unwind_symlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-               int32_t op_errno, inode_t *inode, struct iatt *buf,
-               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-}
-
-void
-set_symlink_fop(long py_this, fop_symlink_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_SYMLINK] = (long)fop;
-}
-
-void
-set_symlink_cbk(long py_this, fop_symlink_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_SYMLINK] = (long)cbk;
-}
-
-/* FOP: READLINK */
-int32_t
-glupy_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, const char *path,
-                   struct iatt *buf, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_READLINK]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_readlink_cbk_t)(priv->cbks[GLUPY_READLINK]))(
-        frame, cookie, this, op_ret, op_errno, path, buf, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata);
-    return 0;
-}
-
-int32_t
-glupy_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-               dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_READLINK]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_readlink_t)(priv->fops[GLUPY_READLINK]))(frame, this, loc, size,
-                                                         xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_readlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readlink, loc, size, xdata);
-    return 0;
-}
-
-void
-wind_readlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, size_t size,
-              dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_readlink_cbk, xl, xl->fops->readlink, loc, size,
-               xdata);
-}
-
-void
-unwind_readlink(call_frame_t *frame, long cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, const char *path,
-                struct iatt *buf, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata);
-}
-
-void
-set_readlink_fop(long py_this, fop_readlink_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_READLINK] = (long)fop;
-}
-
-void
-set_readlink_cbk(long py_this, fop_readlink_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_READLINK] = (long)cbk;
-}
-
-/* FOP: UNLINK */
-
-int32_t
-glupy_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                 struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_UNLINK]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_unlink_cbk_t)(priv->cbks[GLUPY_UNLINK]))(
-        frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent,
-                        xdata);
-    return 0;
-}
-
-int32_t
-glupy_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
-             dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_UNLINK]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_unlink_t)(priv->fops[GLUPY_UNLINK]))(frame, this, loc, xflags,
-                                                     xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_unlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->unlink, loc, xflags, xdata);
-    return 0;
-}
-
-void
-wind_unlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags,
-            dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_unlink_cbk, xl, xl->fops->unlink, loc, xflags,
-               xdata);
-}
-
-void
-unwind_unlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-              int32_t op_errno, struct iatt *preparent, struct iatt *postparent,
-              dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent,
-                        xdata);
-}
-
-void
-set_unlink_fop(long py_this, fop_unlink_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_UNLINK] = (long)fop;
-}
-
-void
-set_unlink_cbk(long py_this, fop_unlink_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_UNLINK] = (long)cbk;
-}
-
-/* FOP: MKDIR */
-
-int32_t
-glupy_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, inode_t *inode,
-                struct iatt *buf, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_MKDIR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_mkdir_cbk_t)(priv->cbks[GLUPY_MKDIR]))(
-        frame, cookie, this, op_ret, op_errno, inode, buf, preparent,
-        postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int32_t
-glupy_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-            mode_t umask, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_MKDIR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_mkdir_t)(priv->fops[GLUPY_MKDIR]))(frame, this, loc, mode,
-                                                   umask, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_mkdir_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata);
-    return 0;
-}
-
-void
-wind_mkdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, mode_t mode,
-           mode_t umask, dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_mkdir_cbk, xl, xl->fops->mkdir, loc, mode, umask,
-               xdata);
-}
-
-void
-unwind_mkdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, inode_t *inode, struct iatt *buf,
-             struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-}
-
-void
-set_mkdir_fop(long py_this, fop_mkdir_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_MKDIR] = (long)fop;
-}
-
-void
-set_mkdir_cbk(long py_this, fop_mkdir_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_MKDIR] = (long)cbk;
-}
-
-/* FOP: RMDIR */
-
-int32_t
-glupy_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                struct iatt *postparent, dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-
-    if (!priv->cbks[GLUPY_RMDIR]) {
-        goto unwind;
-    }
-
-    gstate = glupy_enter();
-    ret = ((fop_rmdir_cbk_t)(priv->cbks[GLUPY_RMDIR]))(
-        frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-unwind:
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent,
-                        xdata);
-    return 0;
-}
-
-int32_t
-glupy_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags,
-            dict_t *xdata)
-{
-    glupy_private_t *priv = this->private;
-    PyGILState_STATE gstate;
-    int32_t ret;
-    static long next_id = 0;
-
-    if (!priv->fops[GLUPY_RMDIR]) {
-        goto wind;
-    }
-
-    gstate = glupy_enter();
-    frame->local = (void *)++next_id;
-    ret = ((fop_rmdir_t)(priv->fops[GLUPY_RMDIR]))(frame, this, loc, xflags,
-                                                   xdata);
-    glupy_leave(gstate);
-
-    return ret;
-
-wind:
-    STACK_WIND(frame, glupy_rmdir_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->rmdir, loc, xflags, xdata);
-    return 0;
-}
-
-void
-wind_rmdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags,
-           dict_t *xdata)
-{
-    xlator_t *this = THIS;
-
-    if (!xl || (xl == this)) {
-        xl = FIRST_CHILD(this);
-    }
-
-    STACK_WIND(frame, glupy_rmdir_cbk, xl, xl->fops->rmdir, loc, xflags, xdata);
-}
-
-void
-unwind_rmdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, struct iatt *preparent, struct iatt *postparent,
-             dict_t *xdata)
-{
-    frame->local = NULL;
-    STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent,
-                        xdata);
-}
-
-void
-set_rmdir_fop(long py_this, fop_rmdir_t fop)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->fops[GLUPY_RMDIR] = (long)fop;
-}
-
-void
-set_rmdir_cbk(long py_this, fop_rmdir_cbk_t cbk)
-{
-    glupy_private_t *priv = ((xlator_t *)py_this)->private;
-
-    priv->cbks[GLUPY_RMDIR] = (long)cbk;
-}
-
-/* NON-FOP-SPECIFIC CODE */
-
-long
-get_id(call_frame_t *frame)
-{
-    return (long)(frame->local);
-}
-
-uint64_t
-get_rootunique(call_frame_t *frame)
-{
-    return frame->root->unique;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    if (!this)
-        return ret;
-
-    ret = xlator_mem_acct_init(this, gf_glupy_mt_end);
-
-    if (ret != 0) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Memory accounting init"
-               " failed");
-        return ret;
-    }
-
-    return ret;
-}
-
-static void
-py_error_log(const char *name, PyObject *pystr)
-{
-#if PY_MAJOR_VERSION > 2
-    char scr[256];
-    if (PyUnicode_Check(pystr)) {
-        PyObject *tmp = PyUnicode_AsEncodedString(pystr, "UTF-8", "strict");
-        if (tmp != NULL) {
-            strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr));
-            Py_DECREF(tmp);
-        } else {
-            strncpy(scr, "string encoding error", sizeof(scr));
-        }
-    } else if (PyBytes_Check(pystr)) {
-        strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr));
-    } else {
-        strncpy(scr, "string encoding error", sizeof(scr));
-    }
-    gf_log(name, GF_LOG_ERROR, "Python error: %s", scr);
-#else
-    gf_log(name, GF_LOG_ERROR, "Python error: %s", PyString_AsString(pystr));
-#endif
-}
-
-static PyObject *
-encode(const char *str)
-{
-#if PY_MAJOR_VERSION > 2
-    return PyUnicode_FromString(str);
-#else
-    return PyString_FromString(str);
-#endif
-}
-
-int32_t
-init(xlator_t *this)
-{
-    glupy_private_t *priv = NULL;
-    char *module_name = NULL;
-    PyObject *py_mod_name = NULL;
-    PyObject *py_init_func = NULL;
-    PyObject *py_args = NULL;
-    PyObject *syspath = NULL;
-    PyObject *path = NULL;
-    PyObject *error_type = NULL;
-    PyObject *error_msg = NULL;
-    PyObject *error_bt = NULL;
-    static gf_boolean_t py_inited = _gf_false;
-    void *err_cleanup = &&err_return;
-    char libpython[16];
-
-    if (dict_get_str(this->options, "module-name", &module_name) != 0) {
-        gf_log(this->name, GF_LOG_ERROR, "missing module-name");
-        return -1;
-    }
-
-    priv = GF_CALLOC(1, sizeof(glupy_private_t), gf_glupy_mt_priv);
-    if (!priv) {
-        goto *err_cleanup;
-    }
-    this->private = priv;
-    err_cleanup = &&err_free_priv;
-
-    if (!py_inited) {
-        /* FIXME:
-         * This hack is necessary because glusterfs (rightly) loads
-         * glupy.so with RTLD_LOCAL but glupy needs libpython to be
-         * loaded with RTLD_GLOBAL even though glupy is correctly
-         * linked with libpython.
-         * This is needed because one of the internal modules of
-         * python 2.x (lib-dynload/_struct.so) does not explicitly
-         * link with libpython.
-         */
-        snprintf(libpython, sizeof(libpython), "libpython%d.%d.so",
-                 PY_MAJOR_VERSION, PY_MINOR_VERSION);
-        if (!dlopen(libpython, RTLD_NOW | RTLD_GLOBAL)) {
-            gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED,
-                   "dlopen(%s) failed: %s", libpython, dlerror());
-        }
-
-        /*
-         * This must be done before Py_Initialize(),
-         * because it will duplicate the environment,
-         * and fail to see later environment updates.
-         */
-        setenv("PATH_GLUSTERFS_GLUPY_MODULE", PATH_GLUSTERFS_GLUPY_MODULE, 1);
-
-        Py_Initialize();
-        PyEval_InitThreads();
-
-        (void)pthread_key_create(&gil_init_key, NULL);
-        (void)pthread_setspecific(gil_init_key, (void *)1);
-
-        /* PyEval_InitThreads takes this "for" us.  No thanks. */
-        PyEval_ReleaseLock();
-        py_inited = _gf_true;
-    }
-
-    /* Adjust python's path */
-    syspath = PySys_GetObject("path");
-    path = encode(GLUSTER_PYTHON_PATH);
-    PyList_Append(syspath, path);
-    Py_DECREF(path);
-
-    py_mod_name = encode(module_name);
-    if (!py_mod_name) {
-        gf_log(this->name, GF_LOG_ERROR, "could not create name");
-        if (PyErr_Occurred()) {
-            PyErr_Fetch(&error_type, &error_msg, &error_bt);
-            py_error_log(this->name, error_msg);
-        }
-        goto *err_cleanup;
-    }
-
-    gf_log(this->name, GF_LOG_DEBUG, "py_mod_name = %s", module_name);
-    priv->py_module = PyImport_Import(py_mod_name);
-    Py_DECREF(py_mod_name);
-    if (!priv->py_module) {
-        gf_log(this->name, GF_LOG_ERROR, "Python import of %s failed",
-               module_name);
-        if (PyErr_Occurred()) {
-            PyErr_Fetch(&error_type, &error_msg, &error_bt);
-            py_error_log(this->name, error_msg);
-        }
-        goto *err_cleanup;
-    }
-    gf_log(this->name, GF_LOG_INFO, "Import of %s succeeded", module_name);
-    err_cleanup = &&err_deref_module;
-
-    py_init_func = PyObject_GetAttrString(priv->py_module, "xlator");
-    if (!py_init_func || !PyCallable_Check(py_init_func)) {
-        gf_log(this->name, GF_LOG_ERROR, "missing init func");
-        if (PyErr_Occurred()) {
-            PyErr_Fetch(&error_type, &error_msg, &error_bt);
-            py_error_log(this->name, error_msg);
-        }
-        goto *err_cleanup;
-    }
-    err_cleanup = &&err_deref_init;
-
-    py_args = PyTuple_New(1);
-    if (!py_args) {
-        gf_log(this->name, GF_LOG_ERROR, "could not create args");
-        if (PyErr_Occurred()) {
-            PyErr_Fetch(&error_type, &error_msg, &error_bt);
-            py_error_log(this->name, error_msg);
-        }
-        goto *err_cleanup;
-    }
-    PyTuple_SetItem(py_args, 0, PyLong_FromLong((long)this));
-
-    /* TBD: pass in list of children */
-    priv->py_xlator = PyObject_CallObject(py_init_func, py_args);
-    Py_DECREF(py_args);
-    if (!priv->py_xlator) {
-        gf_log(this->name, GF_LOG_ERROR, "Python init failed");
-        if (PyErr_Occurred()) {
-            PyErr_Fetch(&error_type, &error_msg, &error_bt);
-            py_error_log(this->name, error_msg);
-        }
-        goto *err_cleanup;
-    }
-    gf_log(this->name, GF_LOG_DEBUG, "init returned %p", priv->py_xlator);
-
-    return 0;
-
-err_deref_init:
-    Py_DECREF(py_init_func);
-err_deref_module:
-    Py_DECREF(priv->py_module);
-err_free_priv:
-    GF_FREE(priv);
-err_return:
-    return -1;
-}
-
-void
-fini(xlator_t *this)
-{
-    glupy_private_t *priv = this->private;
-
-    if (!priv)
-        return;
-    Py_DECREF(priv->py_xlator);
-    Py_DECREF(priv->py_module);
-    this->private = NULL;
-    GF_FREE(priv);
-
-    return;
-}
-
-struct xlator_fops fops = {.lookup = glupy_lookup,
-                           .create = glupy_create,
-                           .open = glupy_open,
-                           .readv = glupy_readv,
-                           .writev = glupy_writev,
-                           .opendir = glupy_opendir,
-                           .readdir = glupy_readdir,
-                           .stat = glupy_stat,
-                           .fstat = glupy_fstat,
-                           .setxattr = glupy_setxattr,
-                           .getxattr = glupy_getxattr,
-                           .fsetxattr = glupy_fsetxattr,
-                           .fgetxattr = glupy_fgetxattr,
-                           .removexattr = glupy_removexattr,
-                           .fremovexattr = glupy_fremovexattr,
-                           .link = glupy_link,
-                           .unlink = glupy_unlink,
-                           .readlink = glupy_readlink,
-                           .symlink = glupy_symlink,
-                           .mkdir = glupy_mkdir,
-                           .rmdir = glupy_rmdir,
-                           .statfs = glupy_statfs,
-                           .readdirp = glupy_readdirp};
-
-struct xlator_cbks cbks = {};
-
-struct volume_options options[] = {
-    {.key = {NULL}},
-};
diff --git a/xlators/features/glupy/src/glupy.h b/xlators/features/glupy/src/glupy.h
deleted file mode 100644
index ca3ac170451..00000000000
--- a/xlators/features/glupy/src/glupy.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-   Copyright (c) 2006-2014 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 __GLUPY_H__
-#define __GLUPY_H__
-
-#include <glusterfs/mem-types.h>
-
-enum {
-    GLUPY_LOOKUP = 0,
-    GLUPY_CREATE,
-    GLUPY_OPEN,
-    GLUPY_READV,
-    GLUPY_WRITEV,
-    GLUPY_OPENDIR,
-    GLUPY_READDIR,
-    GLUPY_READDIRP,
-    GLUPY_STAT,
-    GLUPY_FSTAT,
-    GLUPY_STATFS,
-    GLUPY_SETXATTR,
-    GLUPY_GETXATTR,
-    GLUPY_FSETXATTR,
-    GLUPY_FGETXATTR,
-    GLUPY_REMOVEXATTR,
-    GLUPY_FREMOVEXATTR,
-    GLUPY_LINK,
-    GLUPY_UNLINK,
-    GLUPY_READLINK,
-    GLUPY_SYMLINK,
-    GLUPY_MKNOD,
-    GLUPY_MKDIR,
-    GLUPY_RMDIR,
-    GLUPY_N_FUNCS
-};
-
-typedef struct {
-    PyObject *py_module;
-    PyObject *py_xlator;
-    long fops[GLUPY_N_FUNCS];
-    long cbks[GLUPY_N_FUNCS];
-} glupy_private_t;
-
-enum gf_glupy_mem_types_ {
-    gf_glupy_mt_priv = gf_common_mt_end + 1,
-    gf_glupy_mt_end
-};
-
-#endif /* __GLUPY_H__ */
diff --git a/xlators/features/glupy/src/glupy.sym b/xlators/features/glupy/src/glupy.sym
deleted file mode 100644
index 55d9a300108..00000000000
--- a/xlators/features/glupy/src/glupy.sym
+++ /dev/null
@@ -1,101 +0,0 @@
-init
-fini
-fops
-cbks
-options
-notify
-mem_acct_init
-reconfigure
-dumpops
-set_lookup_fop
-set_lookup_cbk
-set_create_fop
-set_create_cbk
-set_open_fop
-set_open_cbk
-set_readv_fop
-set_readv_cbk
-set_writev_fop
-set_writev_cbk
-set_opendir_fop
-set_opendir_cbk
-set_readdir_fop
-set_readdir_cbk
-set_readdirp_fop
-set_readdirp_cbk
-set_stat_fop
-set_stat_cbk
-set_fstat_fop
-set_fstat_cbk
-set_statfs_fop
-set_statfs_cbk
-set_setxattr_fop
-set_setxattr_cbk
-set_getxattr_fop
-set_getxattr_cbk
-set_fsetxattr_fop
-set_fsetxattr_cbk
-set_fgetxattr_fop
-set_fgetxattr_cbk
-set_removexattr_fop
-set_removexattr_cbk
-set_fremovexattr_fop
-set_fremovexattr_cbk
-set_link_fop
-set_link_cbk
-set_symlink_fop
-set_symlink_cbk
-set_readlink_fop
-set_readlink_cbk
-set_unlink_fop
-set_unlink_cbk
-set_mkdir_fop
-set_mkdir_cbk
-set_rmdir_fop
-set_rmdir_cbk
-wind_lookup
-wind_create
-wind_open
-wind_readv
-wind_writev
-wind_opendir
-wind_readdir
-wind_readdirp
-wind_stat
-wind_fstat
-wind_statfs
-wind_setxattr
-wind_getxattr
-wind_fsetxattr
-wind_fgetxattr
-wind_removexattr
-wind_fremovexattr
-wind_link
-wind_symlink
-wind_readlink
-wind_unlink
-wind_mkdir
-wind_rmdir
-unwind_lookup
-unwind_create
-unwind_open
-unwind_readv
-unwind_writev
-unwind_opendir
-unwind_readdir
-unwind_readdirp
-unwind_stat
-unwind_fstat
-unwind_statfs
-unwind_setxattr
-unwind_getxattr
-unwind_fsetxattr
-unwind_fgetxattr
-unwind_removexattr
-unwind_fremovexattr
-unwind_link
-unwind_symlink
-unwind_readlink
-unwind_unlink
-unwind_mkdir
-unwind_rmdir
diff --git a/xlators/features/glupy/src/glupy/Makefile.am b/xlators/features/glupy/src/glupy/Makefile.am
deleted file mode 100644
index 573d2da12e1..00000000000
--- a/xlators/features/glupy/src/glupy/Makefile.am
+++ /dev/null
@@ -1,5 +0,0 @@
-# Install __init__.py into the Python site-packages area
-pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster/glupy
-pyglupy_PYTHON = __init__.py
-
-CLEANFILES =
diff --git a/xlators/features/glupy/src/glupy/__init__.py b/xlators/features/glupy/src/glupy/__init__.py
deleted file mode 100644
index 576fbdb9945..00000000000
--- a/xlators/features/glupy/src/glupy/__init__.py
+++ /dev/null
@@ -1,852 +0,0 @@
-##
-## Copyright (c) 2006-2014 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.
-##
-
-import sys
-import os
-from ctypes import *
-
-dl = CDLL(os.getenv("PATH_GLUSTERFS_GLUPY_MODULE", ""), RTLD_GLOBAL)
-
-
-class call_frame_t (Structure):
-        pass
-
-class dev_t (Structure):
-        pass
-
-
-class dict_t (Structure):
-        pass
-
-
-class gf_dirent_t (Structure):
-        pass
-
-
-class iobref_t (Structure):
-	pass
-
-
-class iovec_t (Structure):
-        pass
-
-
-class list_head (Structure):
-        pass
-
-list_head._fields_ = [
-                ("next", POINTER(list_head)),
-                ("prev", POINTER(list_head))
-        ]
-
-
-class rwxperm_t (Structure):
-        _fields_ = [
-                ("read", c_uint8, 1),
-                ("write", c_uint8, 1),
-                ("execn", c_uint8, 1)
-        ]
-
-
-class statvfs_t (Structure):
-        pass
-
-
-class xlator_t (Structure):
-        pass
-
-
-class ia_prot_t (Structure):
-        _fields_ = [
-                ("suid", c_uint8, 1),
-                ("sgid", c_uint8, 1),
-                ("sticky", c_uint8, 1),
-                ("owner", rwxperm_t),
-                ("group", rwxperm_t),
-                ("other", rwxperm_t)
-        ]
-
-# For checking file type.
-(IA_INVAL, IA_IFREG, IA_IFDIR, IA_IFLNK, IA_IFBLK, IA_IFCHR, IA_IFIFO,
- IA_IFSOCK) = range(8)
-
-
-class iatt_t (Structure):
-        _fields_ = [
-                ("ia_no", c_uint64),
-                ("ia_gfid", c_ubyte * 16),
-                ("ia_dev", c_uint64),
-                ("ia_type", c_uint),
-                ("ia_prot", ia_prot_t),
-                ("ia_nlink", c_uint32),
-                ("ia_uid", c_uint32),
-                ("ia_gid", c_uint32),
-                ("ia_rdev", c_uint64),
-                ("ia_size", c_uint64),
-                ("ia_blksize", c_uint32),
-                ("ia_blocks", c_uint64),
-                ("ia_atime", c_uint32 ),
-                ("ia_atime_nsec", c_uint32),
-                ("ia_mtime", c_uint32),
-                ("ia_mtime_nsec", c_uint32),
-                ("ia_ctime", c_uint32),
-                ("ia_ctime_nsec", c_uint32)
-        ]
-
-
-class mem_pool (Structure):
-        _fields_ = [
-                ("list", list_head),
-                ("hot_count", c_int),
-                ("cold_count", c_int),
-                ("lock", c_void_p),
-                ("padded_sizeof_type", c_ulong),
-                ("pool", c_void_p),
-                ("pool_end", c_void_p),
-                ("real_sizeof_type", c_int),
-                ("alloc_count", c_uint64),
-                ("pool_misses", c_uint64),
-                ("max_alloc", c_int),
-                ("curr_stdalloc", c_int),
-                ("max_stdalloc", c_int),
-                ("name", c_char_p),
-                ("global_list", list_head)
-        ]
-
-
-class U_ctx_key_inode (Union):
-        _fields_ = [
-                ("key", c_uint64),
-                ("xl_key", POINTER(xlator_t))
-        ]
-
-
-class U_ctx_value1 (Union):
-        _fields_ = [
-                ("value1", c_uint64),
-                ("ptr1", c_void_p)
-        ]
-
-
-class U_ctx_value2 (Union):
-        _fields_ = [
-                ("value2", c_uint64),
-                ("ptr2", c_void_p)
-        ]
-
-class inode_ctx (Structure):
-        _anonymous_ = ("u_key", "u_value1", "u_value2",)
-        _fields_ = [
-                ("u_key", U_ctx_key_inode),
-                ("u_value1", U_ctx_value1),
-                ("u_value2", U_ctx_value2)
-        ]
-
-class inode_t (Structure):
-        pass
-
-class inode_table_t (Structure):
-        _fields_ = [
-                ("lock", c_void_p),
-                ("hashsize", c_size_t),
-                ("name", c_char_p),
-                ("root", POINTER(inode_t)),
-                ("xl", POINTER(xlator_t)),
-                ("lru_limit", c_uint32),
-                ("inode_hash", POINTER(list_head)),
-                ("name_hash", POINTER(list_head)),
-                ("active", list_head),
-                ("active_size", c_uint32),
-                ("lru", list_head),
-                ("lru_size", c_uint32),
-                ("purge", list_head),
-                ("purge_size", c_uint32),
-                ("inode_pool", POINTER(mem_pool)),
-                ("dentry_pool", POINTER(mem_pool)),
-                ("fd_mem_pool", POINTER(mem_pool))
-        ]
-
-inode_t._fields_ = [
-                ("table", POINTER(inode_table_t)),
-                ("gfid", c_ubyte * 16),
-                ("lock", c_void_p),
-                ("nlookup", c_uint64),
-                ("fd_count", c_uint32),
-                ("ref", c_uint32),
-                ("ia_type", c_uint),
-                ("fd_list", list_head),
-                ("dentry_list", list_head),
-                ("hashv", list_head),
-                ("listv", list_head),
-                ("ctx", POINTER(inode_ctx))
-        ]
-
-
-
-class U_ctx_key_fd (Union):
-        _fields_ = [
-                ("key", c_uint64),
-                ("xl_key", c_void_p)
-        ]
-
-class fd_lk_ctx (Structure):
-        _fields_ = [
-                ("lk_list", list_head),
-                ("ref", c_int),
-                ("lock", c_void_p)
-        ]
-
-class fd_ctx (Structure):
-        _anonymous_ = ("u_key", "u_value1")
-        _fields_ = [
-                ("u_key", U_ctx_key_fd),
-                ("u_value1", U_ctx_value1)
-        ]
-
-class fd_t (Structure):
-        _fields_ = [
-                ("pid", c_uint64),
-                ("flags", c_int32),
-                ("refcount", c_int32),
-                ("inode_list", list_head),
-                ("inode", POINTER(inode_t)),
-                ("lock", c_void_p),
-                ("ctx", POINTER(fd_ctx)),
-                ("xl_count", c_int),
-                ("lk_ctx", POINTER(fd_lk_ctx)),
-                ("anonymous", c_uint)
-        ]
-
-class loc_t (Structure):
-        _fields_ = [
-                ("path", c_char_p),
-                ("name", c_char_p),
-                ("inode", POINTER(inode_t)),
-                ("parent", POINTER(inode_t)),
-                ("gfid", c_ubyte * 16),
-                ("pargfid", c_ubyte * 16),
-        ]
-
-
-
-def _init_op (a_class, fop, cbk, wind, unwind):
-        # Decorators, used by translators. We could pass the signatures as
-        # parameters, but it's actually kind of nice to keep them around for
-        # inspection.
-        a_class.fop_type = CFUNCTYPE(*a_class.fop_sig)
-        a_class.cbk_type = CFUNCTYPE(*a_class.cbk_sig)
-        # Dispatch-function registration.
-        fop.restype = None
-        fop.argtypes = [ c_long, a_class.fop_type ]
-        # Callback-function registration.
-        cbk.restype = None
-        cbk.argtypes = [ c_long, a_class.cbk_type ]
-        # STACK_WIND function.
-        wind.restype = None
-        wind.argtypes = list(a_class.fop_sig[1:])
-        # STACK_UNWIND function.
-        unwind.restype = None
-        unwind.argtypes = list(a_class.cbk_sig[1:])
-
-class OpLookup:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(inode_t), POINTER(iatt_t),
-                   POINTER(dict_t), POINTER(iatt_t))
-_init_op (OpLookup, dl.set_lookup_fop, dl.set_lookup_cbk,
-                    dl.wind_lookup,    dl.unwind_lookup)
-
-class OpCreate:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_int, c_uint, c_uint, POINTER(fd_t),
-                   POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(fd_t), POINTER(inode_t),
-                   POINTER(iatt_t), POINTER(iatt_t), POINTER(iatt_t),
-                   POINTER(dict_t))
-_init_op (OpCreate, dl.set_create_fop, dl.set_create_cbk,
-                    dl.wind_create,    dl.unwind_create)
-
-class OpOpen:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_int, POINTER(fd_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(fd_t), POINTER(dict_t))
-_init_op (OpOpen, dl.set_open_fop, dl.set_open_cbk,
-                  dl.wind_open,    dl.unwind_open)
-
-class OpReadv:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), c_size_t, c_long, c_uint32, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iovec_t), c_int, POINTER(iatt_t),
-                   POINTER(iobref_t), POINTER(dict_t))
-_init_op (OpReadv, dl.set_readv_fop, dl.set_readv_cbk,
-                   dl.wind_readv,    dl.unwind_readv)
-class OpWritev:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), POINTER(iovec_t), c_int, c_long, c_uint32,
-                   POINTER(iobref_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iatt_t), POINTER(iatt_t),
-                   POINTER(dict_t))
-_init_op (OpWritev, dl.set_writev_fop, dl.set_writev_cbk,
-                    dl.wind_writev,    dl.unwind_writev)
-
-class OpOpendir:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(fd_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(fd_t), POINTER(dict_t))
-_init_op (OpOpendir, dl.set_opendir_fop, dl.set_opendir_cbk,
-                     dl.wind_opendir,    dl.unwind_opendir)
-
-class OpReaddir:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), c_size_t, c_long, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t))
-_init_op (OpReaddir, dl.set_readdir_fop, dl.set_readdir_cbk,
-                     dl.wind_readdir,    dl.unwind_readdir)
-
-class OpReaddirp:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), c_size_t, c_long, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t))
-_init_op (OpReaddirp, dl.set_readdirp_fop, dl.set_readdirp_cbk,
-                      dl.wind_readdirp,    dl.unwind_readdirp)
-
-class OpStat:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpStat, dl.set_stat_fop, dl.set_stat_cbk,
-                  dl.wind_stat,    dl.unwind_stat)
-
-class OpFstat:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpFstat, dl.set_fstat_fop, dl.set_fstat_cbk,
-                   dl.wind_fstat,    dl.unwind_fstat)
-
-class OpStatfs:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(statvfs_t), POINTER(dict_t))
-_init_op (OpStatfs, dl.set_statfs_fop, dl.set_statfs_cbk,
-                    dl.wind_statfs,    dl.unwind_statfs)
-
-
-class OpSetxattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(dict_t), c_int32,
-                   POINTER (dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t))
-_init_op (OpSetxattr, dl.set_setxattr_fop, dl.set_setxattr_cbk,
-                      dl.wind_setxattr,    dl.unwind_setxattr)
-
-class OpGetxattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_char_p, POINTER (dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t), POINTER(dict_t))
-_init_op (OpGetxattr, dl.set_getxattr_fop, dl.set_getxattr_cbk,
-                      dl.wind_getxattr,    dl.unwind_getxattr)
-
-class OpFsetxattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), POINTER(dict_t), c_int32,
-                   POINTER (dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t))
-_init_op (OpFsetxattr, dl.set_fsetxattr_fop, dl.set_fsetxattr_cbk,
-                       dl.wind_fsetxattr,    dl.unwind_fsetxattr)
-
-class OpFgetxattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), c_char_p, POINTER (dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t), POINTER(dict_t))
-_init_op (OpFgetxattr, dl.set_fgetxattr_fop, dl.set_fgetxattr_cbk,
-                       dl.wind_fgetxattr,    dl.unwind_fgetxattr)
-
-class OpRemovexattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_char_p, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t))
-_init_op (OpRemovexattr, dl.set_removexattr_fop, dl.set_removexattr_cbk,
-                         dl.wind_removexattr,    dl.unwind_removexattr)
-
-
-class OpFremovexattr:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(fd_t), c_char_p, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(dict_t))
-_init_op (OpFremovexattr, dl.set_fremovexattr_fop, dl.set_fremovexattr_cbk,
-                          dl.wind_fremovexattr,    dl.unwind_fremovexattr)
-
-class OpLink:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), POINTER(loc_t), POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(inode_t), POINTER(iatt_t),
-                   POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpLink, dl.set_link_fop, dl.set_link_cbk,
-                  dl.wind_link,    dl.unwind_link)
-
-class OpSymlink:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   c_char_p, POINTER(loc_t), c_uint, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(inode_t), POINTER(iatt_t),
-                   POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpSymlink, dl.set_symlink_fop, dl.set_symlink_cbk,
-                     dl.wind_symlink,    dl.unwind_symlink)
-
-class OpUnlink:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_int, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iatt_t), POINTER(iatt_t),
-                   POINTER(dict_t))
-_init_op (OpUnlink, dl.set_unlink_fop, dl.set_unlink_cbk,
-                    dl.wind_unlink,    dl.unwind_unlink)
-
-class OpReadlink:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_size_t, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, c_char_p, POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpReadlink, dl.set_readlink_fop, dl.set_readlink_cbk,
-                      dl.wind_readlink,    dl.unwind_readlink)
-
-class OpMkdir:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_uint, c_uint, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(inode_t), POINTER(iatt_t),
-                   POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t))
-_init_op (OpMkdir, dl.set_mkdir_fop, dl.set_mkdir_cbk,
-                   dl.wind_mkdir,    dl.unwind_mkdir)
-
-class OpRmdir:
-        fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
-                   POINTER(loc_t), c_int, POINTER(dict_t))
-        cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
-                   c_int, c_int, POINTER(iatt_t), POINTER(iatt_t),
-                   POINTER(dict_t))
-_init_op (OpRmdir, dl.set_rmdir_fop, dl.set_rmdir_cbk,
-                   dl.wind_rmdir,    dl.unwind_rmdir)
-
-
-class Translator:
-        def __init__ (self, c_this):
-                # This is only here to keep references to the stubs we create,
-                # because ctypes doesn't and glupy.so can't because it doesn't
-                # get a pointer to the actual Python object. It's a dictionary
-                # instead of a list in case we ever allow changing fops/cbks
-                # after initialization and need to look them up.
-                self.stub_refs = {}
-                funcs = dir(self.__class__)
-                if "lookup_fop" in funcs:
-                        @OpLookup.fop_type
-                        def stub (frame, this, loc, xdata, s=self):
-                                return s.lookup_fop (frame, this, loc, xdata)
-                        self.stub_refs["lookup_fop"] = stub
-                        dl.set_lookup_fop(c_this, stub)
-                if "lookup_cbk" in funcs:
-                        @OpLookup.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, inode,
-                                  buf, xdata, postparent, s=self):
-                                return s.lookup_cbk(frame, cookie, this, op_ret,
-                                                    op_errno, inode, buf, xdata,
-                                                    postparent)
-                        self.stub_refs["lookup_cbk"] = stub
-                        dl.set_lookup_cbk(c_this, stub)
-                if "create_fop" in funcs:
-                        @OpCreate.fop_type
-                        def stub (frame, this, loc, flags, mode, umask, fd,
-                                  xdata, s=self):
-                                return s.create_fop (frame, this, loc, flags,
-                                                     mode, umask, fd, xdata)
-                        self.stub_refs["create_fop"] = stub
-                        dl.set_create_fop(c_this, stub)
-                if "create_cbk" in funcs:
-                        @OpCreate.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, fd,
-                                  inode, buf, preparent, postparent, xdata,
-                                  s=self):
-                                return s.create_cbk (frame, cookie, this,
-                                                     op_ret, op_errno, fd,
-                                                     inode, buf, preparent,
-                                                     postparent, xdata)
-                        self.stub_refs["create_cbk"] = stub
-                        dl.set_create_cbk(c_this, stub)
-                if "open_fop" in funcs:
-                        @OpOpen.fop_type
-                        def stub (frame, this, loc, flags, fd,
-                                  xdata, s=self):
-                                return s.open_fop (frame, this, loc, flags,
-                                                   fd, xdata)
-                        self.stub_refs["open_fop"] = stub
-                        dl.set_open_fop(c_this, stub)
-                if "open_cbk" in funcs:
-                        @OpOpen.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, fd,
-                                  xdata, s=self):
-                                return s.open_cbk (frame, cookie, this,
-                                                   op_ret, op_errno, fd,
-                                                   xdata)
-                        self.stub_refs["open_cbk"] = stub
-                        dl.set_open_cbk(c_this, stub)
-                if "readv_fop" in funcs:
-                        @OpReadv.fop_type
-                        def stub (frame, this, fd, size, offset, flags,
-                                  xdata, s=self):
-                                return s.readv_fop (frame, this, fd, size,
-                                                    offset, flags, xdata)
-                        self.stub_refs["readv_fop"] = stub
-                        dl.set_readv_fop(c_this, stub)
-                if "readv_cbk" in funcs:
-                        @OpReadv.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  vector, count, stbuf, iobref, xdata,
-                                  s=self):
-                                return s.readv_cbk (frame, cookie, this,
-                                                    op_ret, op_errno, vector,
-                                                    count, stbuf, iobref,
-                                                    xdata)
-                        self.stub_refs["readv_cbk"] = stub
-                        dl.set_readv_cbk(c_this, stub)
-                if "writev_fop" in funcs:
-                        @OpWritev.fop_type
-                        def stub (frame, this, fd, vector, count,
-                                  offset, flags, iobref, xdata, s=self):
-                                return s.writev_fop (frame, this, fd, vector,
-                                                     count, offset, flags,
-                                                     iobref, xdata)
-                        self.stub_refs["writev_fop"] = stub
-                        dl.set_writev_fop(c_this, stub)
-                if "writev_cbk" in funcs:
-                        @OpWritev.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  prebuf, postbuf, xdata, s=self):
-                                return s.writev_cbk (frame, cookie, this,
-                                                     op_ret, op_errno, prebuf,
-                                                     postbuf, xdata)
-                        self.stub_refs["writev_cbk"] = stub
-                        dl.set_writev_cbk(c_this, stub)
-                if "opendir_fop" in funcs:
-                        @OpOpendir.fop_type
-                        def stub (frame, this, loc, fd, xdata, s=self):
-                                return s.opendir_fop (frame, this, loc, fd,
-                                                      xdata)
-                        self.stub_refs["opendir_fop"] = stub
-                        dl.set_opendir_fop(c_this, stub)
-                if "opendir_cbk" in funcs:
-                        @OpOpendir.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, fd,
-                                  xdata, s=self):
-                                return s.opendir_cbk(frame, cookie, this,
-                                                     op_ret, op_errno, fd,
-                                                     xdata)
-                        self.stub_refs["opendir_cbk"] = stub
-                        dl.set_opendir_cbk(c_this, stub)
-                if "readdir_fop" in funcs:
-                        @OpReaddir.fop_type
-                        def stub (frame, this, fd, size, offset, xdata, s=self):
-                                return s.readdir_fop (frame, this, fd, size,
-                                                      offset, xdata)
-                        self.stub_refs["readdir_fop"] = stub
-                        dl.set_readdir_fop(c_this, stub)
-                if "readdir_cbk" in funcs:
-                        @OpReaddir.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  entries, xdata, s=self):
-                                return s.readdir_cbk(frame, cookie, this,
-                                                     op_ret, op_errno, entries,
-                                                     xdata)
-                        self.stub_refs["readdir_cbk"] = stub
-                        dl.set_readdir_cbk(c_this, stub)
-                if "readdirp_fop" in funcs:
-                        @OpReaddirp.fop_type
-                        def stub (frame, this, fd, size, offset, xdata, s=self):
-                                return s.readdirp_fop (frame, this, fd, size,
-                                                       offset, xdata)
-                        self.stub_refs["readdirp_fop"] = stub
-                        dl.set_readdirp_fop(c_this, stub)
-                if "readdirp_cbk" in funcs:
-                        @OpReaddirp.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  entries, xdata, s=self):
-                                return s.readdirp_cbk (frame, cookie, this,
-                                                       op_ret, op_errno,
-                                                       entries, xdata)
-                        self.stub_refs["readdirp_cbk"] = stub
-                        dl.set_readdirp_cbk(c_this, stub)
-                if "stat_fop" in funcs:
-                        @OpStat.fop_type
-                        def stub (frame, this, loc, xdata, s=self):
-                                return s.stat_fop (frame, this, loc, xdata)
-                        self.stub_refs["stat_fop"] = stub
-                        dl.set_stat_fop(c_this, stub)
-                if "stat_cbk" in funcs:
-                        @OpStat.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, buf,
-                                  xdata, s=self):
-                                return s.stat_cbk(frame, cookie, this, op_ret,
-                                                  op_errno, buf, xdata)
-                        self.stub_refs["stat_cbk"] = stub
-                        dl.set_stat_cbk(c_this, stub)
-                if "fstat_fop" in funcs:
-                        @OpFstat.fop_type
-                        def stub (frame, this, fd, xdata, s=self):
-                                return s.fstat_fop (frame, this, fd, xdata)
-                        self.stub_refs["fstat_fop"] = stub
-                        dl.set_fstat_fop(c_this, stub)
-                if "fstat_cbk" in funcs:
-                        @OpFstat.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, buf,
-                                  xdata, s=self):
-                                return s.fstat_cbk(frame, cookie, this, op_ret,
-                                                   op_errno, buf, xdata)
-                        self.stub_refs["fstat_cbk"] = stub
-                        dl.set_fstat_cbk(c_this, stub)
-                if "statfs_fop" in funcs:
-                        @OpStatfs.fop_type
-                        def stub (frame, this, loc, xdata, s=self):
-                                return s.statfs_fop (frame, this, loc, xdata)
-                        self.stub_refs["statfs_fop"] = stub
-                        dl.set_statfs_fop(c_this, stub)
-                if "statfs_cbk" in funcs:
-                        @OpStatfs.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, buf,
-                                  xdata, s=self):
-                                return s.statfs_cbk (frame, cookie, this,
-                                                     op_ret, op_errno, buf,
-                                                     xdata)
-                        self.stub_refs["statfs_cbk"] = stub
-                        dl.set_statfs_cbk(c_this, stub)
-                if "setxattr_fop" in funcs:
-                        @OpSetxattr.fop_type
-                        def stub (frame, this, loc, dictionary, flags, xdata,
-                                  s=self):
-                                return s.setxattr_fop (frame, this, loc,
-                                                       dictionary, flags,
-                                                       xdata)
-                        self.stub_refs["setxattr_fop"] = stub
-                        dl.set_setxattr_fop(c_this, stub)
-                if "setxattr_cbk" in funcs:
-                        @OpSetxattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, xdata,
-                                  s=self):
-                                return s.setxattr_cbk(frame, cookie, this,
-                                                      op_ret, op_errno, xdata)
-                        self.stub_refs["setxattr_cbk"] = stub
-                        dl.set_setxattr_cbk(c_this, stub)
-                if "getxattr_fop" in funcs:
-                        @OpGetxattr.fop_type
-                        def stub (frame, this, loc, name, xdata, s=self):
-                                return s.getxattr_fop (frame, this, loc, name,
-                                                       xdata)
-                        self.stub_refs["getxattr_fop"] = stub
-                        dl.set_getxattr_fop(c_this, stub)
-                if "getxattr_cbk" in funcs:
-                        @OpGetxattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  dictionary, xdata, s=self):
-                                return s.getxattr_cbk(frame, cookie, this,
-                                                      op_ret, op_errno,
-                                                      dictionary, xdata)
-                        self.stub_refs["getxattr_cbk"] = stub
-                        dl.set_getxattr_cbk(c_this, stub)
-                if "fsetxattr_fop" in funcs:
-                        @OpFsetxattr.fop_type
-                        def stub (frame, this, fd, dictionary, flags, xdata,
-                                  s=self):
-                                return s.fsetxattr_fop (frame, this, fd,
-                                                        dictionary, flags,
-                                                        xdata)
-                        self.stub_refs["fsetxattr_fop"] = stub
-                        dl.set_fsetxattr_fop(c_this, stub)
-                if "fsetxattr_cbk" in funcs:
-                        @OpFsetxattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, xdata,
-                                  s=self):
-                                return s.fsetxattr_cbk(frame, cookie, this,
-                                                       op_ret, op_errno, xdata)
-                        self.stub_refs["fsetxattr_cbk"] = stub
-                        dl.set_fsetxattr_cbk(c_this, stub)
-                if "fgetxattr_fop" in funcs:
-                        @OpFgetxattr.fop_type
-                        def stub (frame, this, fd, name, xdata, s=self):
-                                return s.fgetxattr_fop (frame, this, fd, name,
-                                                        xdata)
-                        self.stub_refs["fgetxattr_fop"] = stub
-                        dl.set_fgetxattr_fop(c_this, stub)
-                if "fgetxattr_cbk" in funcs:
-                        @OpFgetxattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  dictionary, xdata, s=self):
-                                return s.fgetxattr_cbk(frame, cookie, this,
-                                                       op_ret, op_errno,
-                                                       dictionary, xdata)
-                        self.stub_refs["fgetxattr_cbk"] = stub
-                        dl.set_fgetxattr_cbk(c_this, stub)
-                if "removexattr_fop" in funcs:
-                        @OpRemovexattr.fop_type
-                        def stub (frame, this, loc, name, xdata, s=self):
-                                return s.removexattr_fop (frame, this, loc,
-                                                          name, xdata)
-                        self.stub_refs["removexattr_fop"] = stub
-                        dl.set_removexattr_fop(c_this, stub)
-                if "removexattr_cbk" in funcs:
-                        @OpRemovexattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  xdata, s=self):
-                                return s.removexattr_cbk(frame, cookie, this,
-                                                         op_ret, op_errno,
-                                                         xdata)
-                        self.stub_refs["removexattr_cbk"] = stub
-                        dl.set_removexattr_cbk(c_this, stub)
-                if "fremovexattr_fop" in funcs:
-                        @OpFremovexattr.fop_type
-                        def stub (frame, this, fd, name, xdata, s=self):
-                                return s.fremovexattr_fop (frame, this, fd,
-                                                           name, xdata)
-                        self.stub_refs["fremovexattr_fop"] = stub
-                        dl.set_fremovexattr_fop(c_this, stub)
-                if "fremovexattr_cbk" in funcs:
-                        @OpFremovexattr.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  xdata, s=self):
-                                return s.fremovexattr_cbk(frame, cookie, this,
-                                                          op_ret, op_errno,
-                                                          xdata)
-                        self.stub_refs["fremovexattr_cbk"] = stub
-                        dl.set_fremovexattr_cbk(c_this, stub)
-                if "link_fop" in funcs:
-                        @OpLink.fop_type
-                        def stub (frame, this, oldloc, newloc,
-                                  xdata, s=self):
-                                return s.link_fop (frame, this, oldloc,
-                                                   newloc, xdata)
-                        self.stub_refs["link_fop"] = stub
-                        dl.set_link_fop(c_this, stub)
-                if "link_cbk" in funcs:
-                        @OpLink.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  inode, buf, preparent, postparent, xdata,
-                                  s=self):
-                                return s.link_cbk (frame, cookie, this,
-                                                   op_ret, op_errno, inode,
-                                                   buf, preparent,
-                                                   postparent, xdata)
-                        self.stub_refs["link_cbk"] = stub
-                        dl.set_link_cbk(c_this, stub)
-                if "symlink_fop" in funcs:
-                        @OpSymlink.fop_type
-                        def stub (frame, this, linkname, loc,
-                                  umask, xdata, s=self):
-                                return s.symlink_fop (frame, this, linkname,
-                                                      loc, umask, xdata)
-                        self.stub_refs["symlink_fop"] = stub
-                        dl.set_symlink_fop(c_this, stub)
-                if "symlink_cbk" in funcs:
-                        @OpSymlink.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  inode, buf, preparent, postparent, xdata,
-                                  s=self):
-                                return s.symlink_cbk (frame, cookie, this,
-                                                      op_ret, op_errno, inode,
-                                                      buf, preparent,
-                                                      postparent, xdata)
-                        self.stub_refs["symlink_cbk"] = stub
-                        dl.set_symlink_cbk(c_this, stub)
-                if "unlink_fop" in funcs:
-                        @OpUnlink.fop_type
-                        def stub (frame, this, loc, xflags,
-                                  xdata, s=self):
-                                return s.unlink_fop (frame, this, loc,
-                                                     xflags, xdata)
-                        self.stub_refs["unlink_fop"] = stub
-                        dl.set_unlink_fop(c_this, stub)
-                if "unlink_cbk" in funcs:
-                        @OpUnlink.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  preparent, postparent, xdata, s=self):
-                                return s.unlink_cbk (frame, cookie, this,
-                                                     op_ret, op_errno,
-                                                     preparent, postparent,
-                                                     xdata)
-                        self.stub_refs["unlink_cbk"] = stub
-                        dl.set_unlink_cbk(c_this, stub)
-                if "readlink_fop" in funcs:
-                        @OpReadlink.fop_type
-                        def stub (frame, this, loc, size,
-                                  xdata, s=self):
-                                return s.readlink_fop (frame, this, loc,
-                                                       size, xdata)
-                        self.stub_refs["readlink_fop"] = stub
-                        dl.set_readlink_fop(c_this, stub)
-                if "readlink_cbk" in funcs:
-                        @OpReadlink.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  path, buf, xdata, s=self):
-                                return s.readlink_cbk (frame, cookie, this,
-                                                       op_ret, op_errno,
-                                                       path, buf, xdata)
-                        self.stub_refs["readlink_cbk"] = stub
-                        dl.set_readlink_cbk(c_this, stub)
-                if "mkdir_fop" in funcs:
-                        @OpMkdir.fop_type
-                        def stub (frame, this, loc, mode, umask, xdata,
-                                  s=self):
-                                return s.mkdir_fop (frame, this, loc, mode,
-                                                    umask, xdata)
-                        self.stub_refs["mkdir_fop"] = stub
-                        dl.set_mkdir_fop(c_this, stub)
-                if "mkdir_cbk" in funcs:
-                        @OpMkdir.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno, inode,
-                                  buf, preparent, postparent, xdata, s=self):
-                                return s.mkdir_cbk (frame, cookie, this,
-                                                    op_ret, op_errno, inode,
-                                                    buf, preparent,
-                                                    postparent, xdata)
-                        self.stub_refs["mkdir_cbk"] = stub
-                        dl.set_mkdir_cbk(c_this, stub)
-                if "rmdir_fop" in funcs:
-                        @OpRmdir.fop_type
-                        def stub (frame, this, loc, xflags,
-                                  xdata, s=self):
-                                return s.rmdir_fop (frame, this, loc,
-                                                    xflags, xdata)
-                        self.stub_refs["rmdir_fop"] = stub
-                        dl.set_rmdir_fop(c_this, stub)
-                if "rmdir_cbk" in funcs:
-                        @OpRmdir.cbk_type
-                        def stub (frame, cookie, this, op_ret, op_errno,
-                                  preparent, postparent, xdata, s=self):
-                                return s.rmdir_cbk (frame, cookie, this,
-                                                    op_ret, op_errno,
-                                                    preparent, postparent,
-                                                    xdata)
-                        self.stub_refs["rmdir_cbk"] = stub
-                        dl.set_rmdir_cbk(c_this, stub)
diff --git a/xlators/features/glupy/src/setup.py.in b/xlators/features/glupy/src/setup.py.in
deleted file mode 100644
index 611e9695f76..00000000000
--- a/xlators/features/glupy/src/setup.py.in
+++ /dev/null
@@ -1,24 +0,0 @@
-from distutils.core import setup
-
-DESC = """GlusterFS is a distributed file-system capable of scaling to
-several petabytes. It aggregates various storage bricks over Infiniband
-RDMA or TCP/IP interconnect into one large parallel network file system.
-GlusterFS is one of the most sophisticated file systems in terms of
-features and extensibility.  It borrows a powerful concept called
-Translators from GNU Hurd kernel. Much of the code in GlusterFS is in
-user space and easily manageable.
-
-This package contains Glupy, the Python translator interface for GlusterFS."""
-
-setup(
-    name='glusterfs-glupy',
-    version='@PACKAGE_VERSION@',
-    description='Glupy is the Python translator interface for GlusterFS',
-    long_description=DESC,
-    author='Gluster Community',
-    author_email='gluster-devel@gluster.org',
-    license='LGPLv3',
-    url='http://gluster.org/',
-    package_dir={'gluster':''},
-    packages=['gluster']
-)
diff --git a/xlators/performance/symlink-cache/Makefile.am b/xlators/performance/symlink-cache/Makefile.am
deleted file mode 100644
index d471a3f9243..00000000000
--- a/xlators/performance/symlink-cache/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES = 
diff --git a/xlators/performance/symlink-cache/src/Makefile.am b/xlators/performance/symlink-cache/src/Makefile.am
deleted file mode 100644
index 0bfb03a68de..00000000000
--- a/xlators/performance/symlink-cache/src/Makefile.am
+++ /dev/null
@@ -1,16 +0,0 @@
-xlator_LTLIBRARIES = symlink-cache.la
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/testing/performance
-
-symlink_cache_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-
-symlink_cache_la_SOURCES = symlink-cache.c
-symlink_cache_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
-
-noinst_HEADERS = symlink-cache-messages.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src
-
-AM_CFLAGS = -Wall $(GF_CFLAGS)
-
-CLEANFILES = 
diff --git a/xlators/performance/symlink-cache/src/symlink-cache-messages.h b/xlators/performance/symlink-cache/src/symlink-cache-messages.h
deleted file mode 100644
index 40ff2e4b60b..00000000000
--- a/xlators/performance/symlink-cache/src/symlink-cache-messages.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*Copyright (c) 2015 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 _SYMLINK_CACHE_MESSAGES_H_
-#define _SYMLINK_CACHE_MESSAGES_H_
-
-#include <glusterfs/glfs-message-id.h>
-
-/* To add new message IDs, append new identifiers at the end of the list.
- *
- * Never remove a message ID. If it's not used anymore, you can rename it or
- * leave it as it is, but not delete it. This is to prevent reutilization of
- * IDs by other messages.
- *
- * The component name must match one of the entries defined in
- * glfs-message-id.h.
- */
-
-GLFS_MSGID(SYMLINK_CACHE, SYMLINK_CACHE_MSG_XLATOR_CHILD_MISCONFIGURED,
-           SYMLINK_CACHE_MSG_VOL_MISCONFIGURED, SYMLINK_CACHE_MSG_NO_MEMORY,
-           SYMLINK_CACHE_MSG_DICT_GET_FAILED,
-           SYMLINK_CACHE_MSG_DICT_SET_FAILED);
-
-#endif /* _SYMLINK_CACHE_MESSAGES_H_ */
diff --git a/xlators/performance/symlink-cache/src/symlink-cache.c b/xlators/performance/symlink-cache/src/symlink-cache.c
deleted file mode 100644
index 07c3623ee94..00000000000
--- a/xlators/performance/symlink-cache/src/symlink-cache.c
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
-  Copyright (c) 2008-2012 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.
-*/
-
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/logging.h>
-#include <glusterfs/dict.h>
-#include <glusterfs/xlator.h>
-#include <glusterfs/list.h>
-#include <glusterfs/compat.h>
-#include <glusterfs/compat-errno.h>
-#include <glusterfs/common-utils.h>
-#include "symlink-cache-messages.h"
-
-struct symlink_cache {
-    time_t ctime;
-    char *readlink;
-};
-
-static int
-symlink_inode_ctx_get(inode_t *inode, xlator_t *this, void **ctx)
-{
-    int ret = 0;
-    uint64_t tmp_ctx = 0;
-    ret = inode_ctx_get(inode, this, &tmp_ctx);
-    if (-1 == ret)
-        gf_msg(this->name, GF_LOG_ERROR, EINVAL,
-               SYMLINK_CACHE_MSG_DICT_GET_FAILED, "dict get failed");
-    else
-        *ctx = (void *)(long)tmp_ctx;
-
-    return 0;
-}
-
-static int
-symlink_inode_ctx_set(inode_t *inode, xlator_t *this, void *ctx)
-{
-    int ret = 0;
-    ret = inode_ctx_put(inode, this, (uint64_t)(long)ctx);
-    if (-1 == ret)
-        gf_msg(this->name, GF_LOG_ERROR, EINVAL,
-               SYMLINK_CACHE_MSG_DICT_SET_FAILED, "dict set failed");
-
-    return 0;
-}
-
-int
-sc_cache_update(xlator_t *this, inode_t *inode, const char *link)
-{
-    struct symlink_cache *sc = NULL;
-
-    symlink_inode_ctx_get(inode, this, VOID(&sc));
-    if (!sc)
-        return 0;
-
-    if (!sc->readlink) {
-        gf_msg_debug(this->name, 0, "updating cache: %s", link);
-
-        sc->readlink = strdup(link);
-    } else
-        gf_msg_debug(this->name, 0, "not updating existing cache: %s with %s",
-                     sc->readlink, link);
-
-    return 0;
-}
-
-int
-sc_cache_set(xlator_t *this, inode_t *inode, struct iatt *buf, const char *link)
-{
-    struct symlink_cache *sc = NULL;
-    int ret = -1;
-    int need_set = 0;
-
-    symlink_inode_ctx_get(inode, this, VOID(&sc));
-    if (!sc) {
-        need_set = 1;
-        sc = CALLOC(1, sizeof(*sc));
-        if (!sc) {
-            gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
-                   SYMLINK_CACHE_MSG_NO_MEMORY, "out of memory :(");
-            goto err;
-        }
-    }
-
-    if (sc->readlink) {
-        gf_msg_debug(this->name, 0,
-                     "replacing old cache: %s with new cache: %s", sc->readlink,
-                     link);
-        FREE(sc->readlink);
-        sc->readlink = NULL;
-    }
-
-    if (link) {
-        sc->readlink = strdup(link);
-        if (!sc->readlink) {
-            gf_msg(this->name, GF_LOG_ERROR, ENOMEM,
-                   SYMLINK_CACHE_MSG_NO_MEMORY, "out of memory :(");
-            goto err;
-        }
-    }
-
-    sc->ctime = buf->ia_ctime;
-
-    gf_msg_debug(this->name, 0, "setting symlink cache: %s", link);
-
-    if (need_set) {
-        ret = symlink_inode_ctx_set(inode, this, sc);
-
-        if (ret < 0) {
-            gf_msg(this->name, GF_LOG_ERROR, -ret, SYMLINK_CACHE_MSG_NO_MEMORY,
-                   "could not set inode context ");
-            goto err;
-        }
-    }
-
-    return 0;
-err:
-
-    if (sc) {
-        FREE(sc->readlink);
-        sc->readlink = NULL;
-        FREE(sc);
-    }
-
-    return -1;
-}
-
-int
-sc_cache_flush(xlator_t *this, inode_t *inode)
-{
-    struct symlink_cache *sc = NULL;
-
-    symlink_inode_ctx_get(inode, this, VOID(&sc));
-    if (!sc)
-        return 0;
-
-    if (sc->readlink) {
-        gf_msg_debug(this->name, 0, "flushing cache: %s", sc->readlink);
-
-        FREE(sc->readlink);
-        sc->readlink = NULL;
-    }
-
-    FREE(sc);
-
-    return 0;
-}
-
-int
-sc_cache_validate(xlator_t *this, inode_t *inode, struct iatt *buf)
-{
-    struct symlink_cache *sc = NULL;
-    uint64_t tmp_sc = 0;
-
-    if (!IA_ISLNK(buf->ia_type)) {
-        sc_cache_flush(this, inode);
-        return 0;
-    }
-
-    symlink_inode_ctx_get(inode, this, VOID(&sc));
-
-    if (!sc) {
-        sc_cache_set(this, inode, buf, NULL);
-        inode_ctx_get(inode, this, &tmp_sc);
-
-        if (!tmp_sc) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, SYMLINK_CACHE_MSG_NO_MEMORY,
-                   "out of memory :(");
-            return 0;
-        }
-        sc = (struct symlink_cache *)(long)tmp_sc;
-    }
-
-    if (sc->ctime == buf->ia_ctime)
-        return 0;
-
-    /* STALE */
-    if (sc->readlink) {
-        gf_msg_debug(this->name, 0, "flushing cache: %s", sc->readlink);
-
-        FREE(sc->readlink);
-        sc->readlink = NULL;
-    }
-
-    sc->ctime = buf->ia_ctime;
-
-    return 0;
-}
-
-int
-sc_cache_get(xlator_t *this, inode_t *inode, char **link)
-{
-    struct symlink_cache *sc = NULL;
-
-    symlink_inode_ctx_get(inode, this, VOID(&sc));
-
-    if (!sc)
-        return 0;
-
-    if (link && sc->readlink)
-        *link = strdup(sc->readlink);
-    return 0;
-}
-
-int
-sc_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, const char *link, struct iatt *sbuf,
-                dict_t *xdata)
-{
-    if (op_ret > 0)
-        sc_cache_update(this, frame->local, link);
-
-    inode_unref(frame->local);
-    frame->local = NULL;
-
-    STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, link, sbuf, xdata);
-    return 0;
-}
-
-int
-sc_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
-            dict_t *xdata)
-{
-    char *link = NULL;
-    int op_ret = -1;
-    struct iatt buf = {
-        0,
-    };
-
-    sc_cache_get(this, loc->inode, &link);
-
-    if (link) {
-        /* cache hit */
-        gf_msg_debug(this->name, 0, "cache hit %s -> %s", loc->path, link);
-
-        /*
-          libglusterfsclient, nfs or any other translators
-          using buf in readlink_cbk should be aware that @buf
-          is 0 filled
-        */
-        op_ret = strlen(link);
-        STACK_UNWIND_STRICT(readlink, frame, op_ret, 0, link, &buf, NULL);
-        FREE(link);
-        return 0;
-    }
-
-    frame->local = inode_ref(loc->inode);
-
-    STACK_WIND(frame, sc_readlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readlink, loc, size, xdata);
-
-    return 0;
-}
-
-int
-sc_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, inode_t *inode, struct iatt *buf,
-               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    if (op_ret == 0) {
-        if (frame->local) {
-            sc_cache_set(this, inode, buf, frame->local);
-        }
-    }
-
-    STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent,
-                        postparent, xdata);
-    return 0;
-}
-
-int
-sc_symlink(call_frame_t *frame, xlator_t *this, const char *dst, loc_t *src,
-           mode_t umask, dict_t *xdata)
-{
-    frame->local = strdup(dst);
-
-    STACK_WIND(frame, sc_symlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->symlink, dst, src, umask, xdata);
-
-    return 0;
-}
-
-int
-sc_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
-              struct iatt *postparent)
-{
-    if (op_ret == 0)
-        sc_cache_validate(this, inode, buf);
-    else
-        sc_cache_flush(this, inode);
-
-    STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata,
-                        postparent);
-    return 0;
-}
-
-int
-sc_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    STACK_WIND(frame, sc_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, xdata);
-
-    return 0;
-}
-
-int
-sc_forget(xlator_t *this, inode_t *inode)
-{
-    sc_cache_flush(this, inode);
-
-    return 0;
-}
-
-int32_t
-init(xlator_t *this)
-{
-    if (!this->children || this->children->next) {
-        gf_msg(this->name, GF_LOG_ERROR, 0,
-               SYMLINK_CACHE_MSG_XLATOR_CHILD_MISCONFIGURED,
-               "FATAL: volume (%s) not configured with exactly one "
-               "child",
-               this->name);
-        return -1;
-    }
-
-    if (!this->parents) {
-        gf_msg(this->name, GF_LOG_WARNING, 0,
-               SYMLINK_CACHE_MSG_VOL_MISCONFIGURED,
-               "dangling volume. check volfile ");
-    }
-
-    return 0;
-}
-
-void
-fini(xlator_t *this)
-{
-    return;
-}
-
-struct xlator_fops fops = {
-    .lookup = sc_lookup,
-    .symlink = sc_symlink,
-    .readlink = sc_readlink,
-};
-
-struct xlator_cbks cbks = {
-    .forget = sc_forget,
-};
-
-struct volume_options options[] = {
-    {
-        .key = {"symlink-cache"},
-        .type = GF_OPTION_TYPE_BOOL,
-        .default_value = "off",
-        .description = "enable/disable symlink-cache",
-        .op_version = {GD_OP_VERSION_6_0},
-        .flags = OPT_FLAG_SETTABLE,
-    },
-    {.key = {NULL}},
-};
diff --git a/xlators/cluster/stripe/Makefile.am b/xlators/playground/rot-13/Makefile.am
index d471a3f9243..d471a3f9243 100644
--- a/xlators/cluster/stripe/Makefile.am
+++ b/xlators/playground/rot-13/Makefile.am
diff --git a/xlators/encryption/rot-13/src/Makefile.am b/xlators/playground/rot-13/src/Makefile.am
index 9978661509d..9978661509d 100644
--- a/xlators/encryption/rot-13/src/Makefile.am
+++ b/xlators/playground/rot-13/src/Makefile.am
diff --git a/xlators/encryption/rot-13/src/rot-13.c b/xlators/playground/rot-13/src/rot-13.c
index 0f45ee31964..0f45ee31964 100644
--- a/xlators/encryption/rot-13/src/rot-13.c
+++ b/xlators/playground/rot-13/src/rot-13.c
diff --git a/xlators/encryption/rot-13/src/rot-13.h b/xlators/playground/rot-13/src/rot-13.h
index edbc99798b4..edbc99798b4 100644
--- a/xlators/encryption/rot-13/src/rot-13.h
+++ b/xlators/playground/rot-13/src/rot-13.h
diff --git a/xlators/storage/bd/Makefile.am b/xlators/storage/bd/Makefile.am
deleted file mode 100644
index a985f42a877..00000000000
--- a/xlators/storage/bd/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIRS = src
-
-CLEANFILES =
diff --git a/xlators/storage/bd/src/Makefile.am b/xlators/storage/bd/src/Makefile.am
deleted file mode 100644
index d56b42a1cbb..00000000000
--- a/xlators/storage/bd/src/Makefile.am
+++ /dev/null
@@ -1,21 +0,0 @@
-if ENABLE_BD_XLATOR
-xlator_LTLIBRARIES = bd.la
-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/storage
-
-bd_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)
-LIBBD = -llvm2app -lrt
-bd_la_SOURCES = bd.c bd-helper.c bd-aio.c
-bd_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	$(LIBBD) $(LIBAIO)
-
-noinst_HEADERS = bd.h bd-aio.h bd-mem-types.h
-
-AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \
-	-I$(top_srcdir)/rpc/rpc-lib/src
-
-AM_CFLAGS = -fno-strict-aliasing -Wall $(GF_CFLAGS)
-
-CLEANFILES =
-
-endif
diff --git a/xlators/storage/bd/src/bd-aio.c b/xlators/storage/bd/src/bd-aio.c
deleted file mode 100644
index db73dc8978c..00000000000
--- a/xlators/storage/bd/src/bd-aio.c
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
-  Copyright IBM, Corp. 2013
-
-  This file is part of GlusterFS.
-
-  Author: M. Mohan Kumar <mohan@in.ibm.com>
-
-  Based on posix-aio.c
-
-  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.
-*/
-
-#include <lvm2app.h>
-#include <sys/uio.h>
-
-#include <glusterfs/xlator.h>
-#include <glusterfs/glusterfs.h>
-#include <glusterfs/defaults.h>
-#include "bd.h"
-#include "bd-aio.h"
-
-#ifdef HAVE_LIBAIO
-#include <libaio.h>
-#include "bd-mem-types.h"
-
-struct bd_aio_cb {
-    struct iocb iocb;
-    call_frame_t *frame;
-    struct iobuf *iobuf;
-    struct iobref *iobref;
-    struct iatt prebuf;
-    int op;
-    off_t offset;
-    fd_t *fd;
-};
-
-void
-__bd_fd_set_odirect(fd_t *fd, bd_fd_t *bd_fd, int opflags, off_t offset,
-                    size_t size)
-{
-    int odirect = 0;
-    int flags = 0;
-    int ret = 0;
-
-    odirect = bd_fd->odirect;
-
-    if ((fd->flags | opflags) & O_DIRECT) {
-        /* if instructed, use O_DIRECT always */
-        odirect = 1;
-    } else {
-        /* else use O_DIRECT when feasible */
-        if ((offset | size) & 0xfff)
-            odirect = 0;
-        else
-            odirect = 1;
-    }
-
-    if (!odirect && bd_fd->odirect) {
-        flags = fcntl(bd_fd->fd, F_GETFL);
-        ret = fcntl(bd_fd->fd, F_SETFL, (flags & (~O_DIRECT)));
-        bd_fd->odirect = 0;
-    }
-
-    if (odirect && !bd_fd->odirect) {
-        flags = fcntl(bd_fd->fd, F_GETFL);
-        ret = fcntl(bd_fd->fd, F_SETFL, (flags | O_DIRECT));
-        bd_fd->odirect = 1;
-    }
-
-    if (ret) {
-        gf_log(THIS->name, GF_LOG_WARNING,
-               "fcntl() failed (%s). fd=%d flags=%d pfd->odirect=%d",
-               strerror(errno), bd_fd->fd, flags, bd_fd->odirect);
-    }
-}
-
-int
-bd_aio_readv_complete(struct bd_aio_cb *paiocb, int res, int res2)
-{
-    call_frame_t *frame = NULL;
-    xlator_t *this = NULL;
-    struct iobuf *iobuf = NULL;
-    struct iatt postbuf = {
-        0,
-    };
-    int op_ret = -1;
-    int op_errno = 0;
-    struct iovec iov;
-    struct iobref *iobref = NULL;
-    off_t offset = 0;
-    bd_attr_t *bdatt = NULL;
-
-    frame = paiocb->frame;
-    this = frame->this;
-    iobuf = paiocb->iobuf;
-    offset = paiocb->offset;
-
-    if (res < 0) {
-        op_ret = -1;
-        op_errno = -res;
-        gf_log(this->name, GF_LOG_ERROR,
-               "readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)",
-               paiocb->fd, paiocb->iocb.u.c.nbytes,
-               (unsigned long long)paiocb->offset, res, strerror(op_errno));
-        goto out;
-    }
-
-    bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt);
-    memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt));
-
-    op_ret = res;
-    op_errno = 0;
-
-    iobref = iobref_new();
-    if (!iobref) {
-        op_ret = -1;
-        op_errno = ENOMEM;
-        goto out;
-    }
-
-    iobref_add(iobref, iobuf);
-
-    iov.iov_base = iobuf_ptr(iobuf);
-    iov.iov_len = op_ret;
-
-    /* Hack to notify higher layers of EOF. */
-    if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size)
-        op_errno = ENOENT;
-
-out:
-    STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, &iov, 1, &postbuf,
-                        iobref, NULL);
-    if (iobuf)
-        iobuf_unref(iobuf);
-    if (iobref)
-        iobref_unref(iobref);
-
-    GF_FREE(paiocb);
-
-    return 0;
-}
-
-int
-bd_aio_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, uint32_t flags, dict_t *xdata)
-{
-    int32_t op_errno = EINVAL;
-    int _fd = -1;
-    struct iobuf *iobuf = NULL;
-    bd_fd_t *bd_fd = NULL;
-    int ret = -1;
-    struct bd_aio_cb *paiocb = NULL;
-    bd_priv_t *priv = NULL;
-    struct iocb *iocb = NULL;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-
-    priv = this->private;
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) {
-        STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
-                   xdata);
-        return 0;
-    }
-    _fd = bd_fd->fd;
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-    if (!size) {
-        op_errno = EINVAL;
-        gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size);
-        goto err;
-    }
-
-    iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
-    if (!iobuf) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb);
-    if (!paiocb) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    paiocb->frame = frame;
-    paiocb->iobuf = iobuf;
-    paiocb->offset = offset;
-    paiocb->op = GF_FOP_READ;
-    paiocb->fd = fd;
-
-    paiocb->iocb.data = paiocb;
-    paiocb->iocb.aio_fildes = _fd;
-    paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD;
-    paiocb->iocb.aio_reqprio = 0;
-    paiocb->iocb.u.c.buf = iobuf_ptr(iobuf);
-    paiocb->iocb.u.c.nbytes = size;
-    paiocb->iocb.u.c.offset = offset;
-
-    iocb = &paiocb->iocb;
-
-    LOCK(&fd->lock);
-    {
-        __bd_fd_set_odirect(fd, bd_fd, flags, offset, size);
-
-        ret = io_submit(priv->ctxp, 1, &iocb);
-    }
-    UNLOCK(&fd->lock);
-
-    if (ret != 1) {
-        gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret);
-        op_errno = -ret;
-        goto err;
-    }
-
-    return 0;
-err:
-    STACK_UNWIND_STRICT(readv, frame, -1, op_errno, 0, 0, 0, 0, 0);
-    if (iobuf)
-        iobuf_unref(iobuf);
-
-    if (paiocb)
-        GF_FREE(paiocb);
-
-    return 0;
-}
-
-int
-bd_aio_writev_complete(struct bd_aio_cb *paiocb, int res, int res2)
-{
-    call_frame_t *frame = NULL;
-    xlator_t *this = NULL;
-    struct iatt prebuf = {
-        0,
-    };
-    struct iatt postbuf = {
-        0,
-    };
-    int op_ret = -1;
-    int op_errno = 0;
-    bd_attr_t *bdatt = NULL;
-
-    frame = paiocb->frame;
-    prebuf = paiocb->prebuf;
-    this = frame->this;
-
-    if (res < 0) {
-        op_ret = -1;
-        op_errno = -res;
-        gf_log(this->name, GF_LOG_ERROR,
-               "writev(async) failed fd=%p,offset=%llu (%d/%s)", paiocb->fd,
-               (unsigned long long)paiocb->offset, res, strerror(op_errno));
-
-        goto out;
-    }
-
-    bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt);
-    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
-    memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt));
-
-    op_ret = res;
-    op_errno = 0;
-
-out:
-    STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, &prebuf, &postbuf,
-                        NULL);
-
-    if (paiocb->iobref)
-        iobref_unref(paiocb->iobref);
-    GF_FREE(paiocb);
-
-    return 0;
-}
-
-int
-bd_aio_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *iov,
-              int count, off_t offset, uint32_t flags, struct iobref *iobref,
-              dict_t *xdata)
-{
-    int32_t op_errno = EINVAL;
-    int _fd = -1;
-    bd_fd_t *bd_fd = NULL;
-    int ret = -1;
-    struct bd_aio_cb *paiocb = NULL;
-    bd_priv_t *priv = NULL;
-    struct iocb *iocb = NULL;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, err);
-    VALIDATE_OR_GOTO(this, err);
-    VALIDATE_OR_GOTO(fd, err);
-
-    priv = this->private;
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) {
-        STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->writev, fd, iov, count, offset,
-                   flags, iobref, xdata);
-        return 0;
-    }
-
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-
-    _fd = bd_fd->fd;
-
-    paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb);
-    if (!paiocb) {
-        op_errno = ENOMEM;
-        goto err;
-    }
-
-    paiocb->frame = frame;
-    paiocb->offset = offset;
-    paiocb->op = GF_FOP_WRITE;
-    paiocb->fd = fd;
-
-    paiocb->iocb.data = paiocb;
-    paiocb->iocb.aio_fildes = _fd;
-    paiocb->iobref = iobref_ref(iobref);
-    paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV;
-    paiocb->iocb.aio_reqprio = 0;
-    paiocb->iocb.u.v.vec = iov;
-    paiocb->iocb.u.v.nr = count;
-    paiocb->iocb.u.v.offset = offset;
-
-    iocb = &paiocb->iocb;
-
-    memcpy(&paiocb->prebuf, &bdatt->iatt, sizeof(struct iatt));
-    LOCK(&fd->lock);
-    {
-        __bd_fd_set_odirect(fd, bd_fd, flags, offset, iov_length(iov, count));
-
-        ret = io_submit(priv->ctxp, 1, &iocb);
-    }
-    UNLOCK(&fd->lock);
-
-    if (ret != 1) {
-        gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret);
-        op_errno = -ret;
-        goto err;
-    }
-
-    return 0;
-err:
-    STACK_UNWIND_STRICT(writev, frame, -1, op_errno, 0, 0, 0);
-
-    if (paiocb) {
-        if (paiocb->iobref)
-            iobref_unref(paiocb->iobref);
-        GF_FREE(paiocb);
-    }
-
-    return 0;
-}
-
-void *
-bd_aio_thread(void *data)
-{
-    xlator_t *this = NULL;
-    bd_priv_t *priv = NULL;
-    int ret = 0;
-    int i = 0;
-    struct io_event *event = NULL;
-    struct bd_aio_cb *paiocb = NULL;
-    struct io_event events[BD_AIO_MAX_NR_GETEVENTS];
-    struct timespec ts = {
-        0,
-    };
-
-    this = data;
-    THIS = this;
-    priv = this->private;
-
-    ts.tv_sec = 5;
-    for (;;) {
-        memset(&events[0], 0, sizeof(events));
-        ret = io_getevents(priv->ctxp, 1, BD_AIO_MAX_NR_GETEVENTS, &events[0],
-                           &ts);
-        if (ret < 0) {
-            if (ret == -EINTR)
-                continue;
-            gf_log(this->name, GF_LOG_ERROR,
-                   "io_getevents() returned %d, exiting", ret);
-            break;
-        }
-
-        for (i = 0; i < ret; i++) {
-            event = &events[i];
-
-            paiocb = event->data;
-
-            switch (paiocb->op) {
-                case GF_FOP_READ:
-                    bd_aio_readv_complete(paiocb, event->res, event->res2);
-                    break;
-                case GF_FOP_WRITE:
-                    bd_aio_writev_complete(paiocb, event->res, event->res2);
-                    break;
-                default:
-                    gf_log(this->name, GF_LOG_ERROR,
-                           "unknown op %d found in piocb", paiocb->op);
-                    break;
-            }
-        }
-    }
-
-    return NULL;
-}
-
-int
-bd_aio_init(xlator_t *this)
-{
-    bd_priv_t *priv = NULL;
-    int ret = 0;
-
-    priv = this->private;
-
-    ret = io_setup(BD_AIO_MAX_NR_EVENTS, &priv->ctxp);
-    if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "Linux AIO not available at run-time."
-               " Continuing with synchronous IO");
-        ret = 0;
-        goto out;
-    }
-
-    if (ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "io_setup() failed. ret=%d, errno=%d", ret, errno);
-        goto out;
-    }
-
-    ret = gf_thread_create(&priv->aiothread, NULL, bd_aio_thread, this,
-                           "bdaio");
-    if (ret != 0) {
-        io_destroy(priv->ctxp);
-        goto out;
-    }
-
-    this->fops->readv = bd_aio_readv;
-    this->fops->writev = bd_aio_writev;
-out:
-    return ret;
-}
-
-int
-bd_aio_on(xlator_t *this)
-{
-    bd_priv_t *priv = NULL;
-    int ret = 0;
-
-    priv = this->private;
-
-    if (!priv->aio_init_done) {
-        ret = bd_aio_init(this);
-        if (ret == 0)
-            priv->aio_capable = _gf_true;
-        else
-            priv->aio_capable = _gf_false;
-        priv->aio_init_done = _gf_true;
-    }
-
-    if (priv->aio_capable) {
-        this->fops->readv = bd_aio_readv;
-        this->fops->writev = bd_aio_writev;
-    }
-
-    return ret;
-}
-
-int
-bd_aio_off(xlator_t *this)
-{
-    this->fops->readv = bd_readv;
-    this->fops->writev = bd_writev;
-
-    return 0;
-}
-
-#else
-
-int
-bd_aio_on(xlator_t *this)
-{
-    gf_log(this->name, GF_LOG_INFO,
-           "Linux AIO not available at build-time."
-           " Continuing with synchronous IO");
-    return 0;
-}
-
-int
-bd_aio_off(xlator_t *this)
-{
-    gf_log(this->name, GF_LOG_INFO,
-           "Linux AIO not available at build-time."
-           " Continuing with synchronous IO");
-    return 0;
-}
-
-void
-__bd_fd_set_odirect(fd_t *fd, struct bd_fd *pfd, int opflags, off_t offset,
-                    size_t size)
-{
-    xlator_t *this = THIS;
-    gf_log(this->name, GF_LOG_INFO,
-           "Linux AIO not available at build-time."
-           " Continuing with synchronous IO");
-    return;
-}
-#endif
diff --git a/xlators/storage/bd/src/bd-aio.h b/xlators/storage/bd/src/bd-aio.h
deleted file mode 100644
index 23457673383..00000000000
--- a/xlators/storage/bd/src/bd-aio.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-   Copyright IBM, Corp. 2013
-
-   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 _BD_AIO_H
-#define _BD_AIO_H
-
-#include <glusterfs/xlator.h>
-#include <glusterfs/glusterfs.h>
-
-/*
- * Maximum number of concurrently submitted IO events. The heaviest load
- * GlusterFS has been able to handle had 60-80 concurrent calls
- */
-#define BD_AIO_MAX_NR_EVENTS 256
-
-/* Maximum number of completed IO operations to reap per getevents syscall */
-#define BD_AIO_MAX_NR_GETEVENTS 16
-
-int
-bd_aio_on(xlator_t *this);
-int
-bd_aio_off(xlator_t *this);
-
-int
-bd_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-         off_t offset, uint32_t flags, dict_t *xdata);
-
-int
-bd_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-          int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
-          dict_t *xdata);
-
-#endif /* !_BD_AIO_H */
diff --git a/xlators/storage/bd/src/bd-helper.c b/xlators/storage/bd/src/bd-helper.c
deleted file mode 100644
index 74c979ace00..00000000000
--- a/xlators/storage/bd/src/bd-helper.c
+++ /dev/null
@@ -1,1073 +0,0 @@
-#include <lvm2app.h>
-#ifdef HAVE_LIBAIO
-#include <libaio.h>
-#endif
-#include <linux/fs.h>
-#include <sys/ioctl.h>
-#include "bd.h"
-#include "bd-mem-types.h"
-#include <glusterfs/run.h>
-#include <glusterfs/lvm-defaults.h>
-#include <glusterfs/syscall.h>
-
-int
-bd_inode_ctx_set(inode_t *inode, xlator_t *this, bd_attr_t *ctx)
-{
-    int ret = -1;
-    uint64_t ctx_int = 0;
-
-    GF_VALIDATE_OR_GOTO(this->name, inode, out);
-    GF_VALIDATE_OR_GOTO(this->name, ctx, out);
-
-    ctx_int = (long)ctx;
-    ret = inode_ctx_set(inode, this, &ctx_int);
-out:
-    return ret;
-}
-
-int
-bd_inode_ctx_get(inode_t *inode, xlator_t *this, bd_attr_t **ctx)
-{
-    int ret = -1;
-    uint64_t ctx_int = 0;
-
-    GF_VALIDATE_OR_GOTO(this->name, inode, out);
-    ret = inode_ctx_get(inode, this, &ctx_int);
-    if (ret)
-        return ret;
-    if (ctx)
-        *ctx = (bd_attr_t *)ctx_int;
-out:
-    return ret;
-}
-
-void
-bd_local_free(xlator_t *this, bd_local_t *local)
-{
-    if (!local)
-        return;
-    if (local->fd)
-        fd_unref(local->fd);
-    else if (local->loc.path)
-        loc_wipe(&local->loc);
-    if (local->dict)
-        dict_unref(local->dict);
-    if (local->inode)
-        inode_unref(local->inode);
-    if (local->bdatt) {
-        GF_FREE(local->bdatt->type);
-        GF_FREE(local->bdatt);
-    }
-    mem_put(local);
-    local = NULL;
-}
-
-bd_local_t *
-bd_local_init(call_frame_t *frame, xlator_t *this)
-{
-    frame->local = mem_get0(this->local_pool);
-    if (!frame->local)
-        return NULL;
-
-    return frame->local;
-}
-
-/*
- * VG are set with the tag in GF_XATTR_VOL_ID_KEY:<uuid> format.
- * This function validates this tag against volume-uuid. Also goes
- * through LV list to find out if a thin-pool is configured or not.
- */
-int
-bd_scan_vg(xlator_t *this, bd_priv_t *priv)
-{
-    vg_t brick = NULL;
-    data_t *tmp_data = NULL;
-    struct dm_list *tags = NULL;
-    int op_ret = -1;
-    uuid_t dict_uuid = {
-        0,
-    };
-    uuid_t vg_uuid = {
-        0,
-    };
-    gf_boolean_t uuid = _gf_false;
-    lvm_str_list_t *strl = NULL;
-    struct dm_list *lv_dm_list = NULL;
-    lv_list_t *lv_list = NULL;
-    struct dm_list *dm_seglist = NULL;
-    lvseg_list_t *seglist = NULL;
-    lvm_property_value_t prop = {
-        0,
-    };
-    gf_boolean_t thin = _gf_false;
-    const char *lv_name = NULL;
-
-    brick = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!brick) {
-        gf_log(this->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg);
-        return ENOENT;
-    }
-
-    lv_dm_list = lvm_vg_list_lvs(brick);
-    if (!lv_dm_list)
-        goto check;
-
-    dm_list_iterate_items(lv_list, lv_dm_list)
-    {
-        dm_seglist = lvm_lv_list_lvsegs(lv_list->lv);
-        if (!dm_seglist)
-            continue;
-        dm_list_iterate_items(seglist, dm_seglist)
-        {
-            prop = lvm_lvseg_get_property(seglist->lvseg, "segtype");
-            if (!prop.is_valid || !prop.value.string)
-                continue;
-            if (!strcmp(prop.value.string, "thin-pool")) {
-                thin = _gf_true;
-                lv_name = lvm_lv_get_name(lv_list->lv);
-                priv->pool = gf_strdup(lv_name);
-                gf_log(THIS->name, GF_LOG_INFO,
-                       "Thin Pool "
-                       "\"%s\" will be used for thin LVs",
-                       lv_name);
-                break;
-            }
-        }
-    }
-
-check:
-    /* If there is no volume-id set in dict, we can't validate */
-    tmp_data = dict_get(this->options, "volume-id");
-    if (!tmp_data) {
-        op_ret = 0;
-        goto out;
-    }
-
-    op_ret = gf_uuid_parse(tmp_data->data, dict_uuid);
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "wrong volume-id (%s) set in volume file", tmp_data->data);
-        op_ret = -1;
-        goto out;
-    }
-
-    tags = lvm_vg_get_tags(brick);
-    if (!tags) { /* no tags in the VG */
-        gf_log(this->name, GF_LOG_ERROR,
-               "Extended attribute trusted.glusterfs."
-               "volume-id is absent");
-        op_ret = -1;
-        goto out;
-    }
-    dm_list_iterate_items(strl, tags)
-    {
-        if (!strncmp(strl->str, GF_XATTR_VOL_ID_KEY,
-                     SLEN(GF_XATTR_VOL_ID_KEY))) {
-            uuid = _gf_true;
-            break;
-        }
-    }
-    /* UUID tag is not set in VG */
-    if (!uuid) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "Extended attribute trusted.glusterfs."
-               "volume-id is absent");
-        op_ret = -1;
-        goto out;
-    }
-
-    op_ret = gf_uuid_parse(strl->str + SLEN(GF_XATTR_VOL_ID_KEY) + 1, vg_uuid);
-    if (op_ret < 0) {
-        gf_log(this->name, GF_LOG_ERROR, "wrong volume-id (%s) set in VG",
-               strl->str);
-        op_ret = -1;
-        goto out;
-    }
-    if (gf_uuid_compare(dict_uuid, vg_uuid)) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "mismatching volume-id (%s) received. "
-               "already is a part of volume %s ",
-               tmp_data->data, vg_uuid);
-        op_ret = -1;
-        goto out;
-    }
-
-    op_ret = 0;
-
-out:
-    lvm_vg_close(brick);
-
-    if (!thin)
-        gf_log(THIS->name, GF_LOG_WARNING,
-               "No thin pool found in "
-               "VG %s\n",
-               priv->vg);
-    else
-        priv->caps |= BD_CAPS_THIN;
-
-    return op_ret;
-}
-
-/* FIXME: Move this code to common place, so posix and bd xlator can use */
-char *
-page_aligned_alloc(size_t size, char **aligned_buf)
-{
-    char *alloc_buf = NULL;
-    char *buf = NULL;
-
-    alloc_buf = GF_CALLOC(1, (size + ALIGN_SIZE), gf_common_mt_char);
-    if (!alloc_buf)
-        return NULL;
-    /* page aligned buffer */
-    buf = GF_ALIGN_BUF(alloc_buf, ALIGN_SIZE);
-    *aligned_buf = buf;
-
-    return alloc_buf;
-}
-
-static int
-__bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd_p)
-{
-    int ret = -1;
-    int _fd = -1;
-    char *devpath = NULL;
-    bd_fd_t *bdfd = NULL;
-    uint64_t tmp_bdfd = 0;
-    bd_priv_t *priv = this->private;
-    bd_gfid_t gfid = {
-        0,
-    };
-    bd_attr_t *bdatt = NULL;
-
-    /* not bd file */
-    if (fd->inode->ia_type != IA_IFREG ||
-        bd_inode_ctx_get(fd->inode, this, &bdatt))
-        return 0;
-
-    ret = __fd_ctx_get(fd, this, &tmp_bdfd);
-    if (ret == 0) {
-        bdfd = (void *)(long)tmp_bdfd;
-        *bdfd_p = bdfd;
-        return 0;
-    }
-
-    uuid_utoa_r(fd->inode->gfid, gfid);
-    gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid);
-    if (!devpath)
-        goto out;
-
-    _fd = open(devpath, O_RDWR | O_LARGEFILE, 0);
-    if (_fd < 0) {
-        ret = errno;
-        gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
-               strerror(ret));
-        goto out;
-    }
-    bdfd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd);
-    BD_VALIDATE_MEM_ALLOC(bdfd, ret, out);
-
-    bdfd->fd = _fd;
-    bdfd->flag = O_RDWR | O_LARGEFILE;
-    if (__fd_ctx_set(fd, this, (uint64_t)(long)bdfd) < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p",
-               fd);
-        goto out;
-    }
-
-    *bdfd_p = bdfd;
-
-    ret = 0;
-out:
-    GF_FREE(devpath);
-    if (ret) {
-        if (_fd >= 0)
-            sys_close(_fd);
-        GF_FREE(bdfd);
-    }
-    return ret;
-}
-
-int
-bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd)
-{
-    int ret;
-
-    /* FIXME: Is it ok to fd->lock here ? */
-    LOCK(&fd->lock);
-    {
-        ret = __bd_fd_ctx_get(this, fd, bdfd);
-    }
-    UNLOCK(&fd->lock);
-
-    return ret;
-}
-
-/*
- * Validates if LV exists for given inode or not.
- * Returns 0 if LV exists and size also matches.
- * If LV does not exist -1 returned
- * If LV size mismatches, returns 1 also lv_size is updated with actual
- * size
- */
-int
-bd_validate_bd_xattr(xlator_t *this, char *bd, char **type, uint64_t *lv_size,
-                     uuid_t uuid)
-{
-    char *path = NULL;
-    int ret = -1;
-    bd_gfid_t gfid = {
-        0,
-    };
-    bd_priv_t *priv = this->private;
-    struct stat stbuf = {
-        0,
-    };
-    uint64_t size = 0;
-    vg_t vg = NULL;
-    lv_t lv = NULL;
-    char *bytes = NULL;
-
-    bytes = strrchr(bd, ':');
-    if (bytes) {
-        *bytes = '\0';
-        bytes++;
-        gf_string2bytesize_uint64(bytes, &size);
-    }
-
-    if (strcmp(bd, BD_LV) && strcmp(bd, BD_THIN)) {
-        gf_log(this->name, GF_LOG_WARNING, "invalid xattr %s", bd);
-        return -1;
-    }
-    *type = gf_strdup(bd);
-
-    /*
-     * Check if LV really exist, there could be a failure
-     * after setxattr and successful LV creation
-     */
-    uuid_utoa_r(uuid, gfid);
-    gf_asprintf(&path, "/dev/%s/%s", priv->vg, gfid);
-    if (!path) {
-        gf_log(this->name, GF_LOG_WARNING, "insufficient memory");
-        return 0;
-    }
-
-    /* Destination file does not exist */
-    if (sys_stat(path, &stbuf)) {
-        gf_log(this->name, GF_LOG_WARNING, "lstat failed for path %s", path);
-        GF_FREE(path);
-        return -1;
-    }
-
-    vg = lvm_vg_open(priv->handle, priv->vg, "r", 0);
-    if (!vg) {
-        gf_log(this->name, GF_LOG_WARNING, "VG %s does not exist?", priv->vg);
-        ret = -1;
-        goto out;
-    }
-
-    lv = lvm_lv_from_name(vg, gfid);
-    if (!lv) {
-        gf_log(this->name, GF_LOG_WARNING, "LV %s does not exist", gfid);
-        ret = -1;
-        goto out;
-    }
-
-    *lv_size = lvm_lv_get_size(lv);
-    if (size == *lv_size) {
-        ret = 0;
-        goto out;
-    }
-
-    ret = 1;
-
-out:
-    if (vg)
-        lvm_vg_close(vg);
-
-    GF_FREE(path);
-    return ret;
-}
-
-static int
-create_thin_lv(char *vg, char *pool, char *lv, uint64_t extent)
-{
-    int ret = -1;
-    runner_t runner = {
-        0,
-    };
-    char *path = NULL;
-    struct stat stat = {
-        0,
-    };
-
-    runinit(&runner);
-    runner_add_args(&runner, LVM_CREATE, NULL);
-    runner_add_args(&runner, "--thin", NULL);
-    runner_argprintf(&runner, "%s/%s", vg, pool);
-    runner_add_args(&runner, "--name", NULL);
-    runner_argprintf(&runner, "%s", lv);
-    runner_add_args(&runner, "--virtualsize", NULL);
-    runner_argprintf(&runner, "%ldB", extent);
-    runner_start(&runner);
-    runner_end(&runner);
-
-    gf_asprintf(&path, "/dev/%s/%s", vg, lv);
-    if (!path) {
-        ret = ENOMEM;
-        goto out;
-    }
-    if (sys_lstat(path, &stat) < 0)
-        ret = EAGAIN;
-    else
-        ret = 0;
-out:
-    GF_FREE(path);
-    return ret;
-}
-
-int
-bd_create(uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv)
-{
-    int ret = 0;
-    vg_t vg = NULL;
-    bd_gfid_t gfid = {
-        0,
-    };
-
-    uuid_utoa_r(uuid, gfid);
-
-    if (!strcmp(type, BD_THIN))
-        return create_thin_lv(priv->vg, priv->pool, gfid, size);
-
-    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!vg) {
-        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
-        return ENOENT;
-    }
-
-    if (!lvm_vg_create_lv_linear(vg, gfid, size)) {
-        gf_log(THIS->name, GF_LOG_WARNING,
-               "lvm_vg_create_lv_linear "
-               "failed");
-        ret = errno;
-    }
-
-    lvm_vg_close(vg);
-
-    return ret;
-}
-
-int32_t
-bd_resize(bd_priv_t *priv, uuid_t uuid, size_t size)
-{
-    uint64_t new_size = 0;
-    runner_t runner = {
-        0,
-    };
-    bd_gfid_t gfid = {
-        0,
-    };
-    int ret = 0;
-    vg_t vg = NULL;
-    lv_t lv = NULL;
-
-    uuid_utoa_r(uuid, gfid);
-
-    runinit(&runner);
-
-    runner_add_args(&runner, LVM_RESIZE, NULL);
-    runner_argprintf(&runner, "%s/%s", priv->vg, gfid);
-    runner_argprintf(&runner, "-L%ldb", size);
-    runner_add_args(&runner, "-f", NULL);
-
-    runner_start(&runner);
-    runner_end(&runner);
-
-    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!vg) {
-        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
-        return EAGAIN;
-    }
-
-    lv = lvm_lv_from_name(vg, gfid);
-    if (!lv) {
-        gf_log(THIS->name, GF_LOG_WARNING, "LV %s not found", gfid);
-        ret = EIO;
-        goto out;
-    }
-    new_size = lvm_lv_get_size(lv);
-
-    if (new_size != size) {
-        gf_log(THIS->name, GF_LOG_WARNING,
-               "resized LV size %" PRIu64
-               " does "
-               "not match requested size %zd",
-               new_size, size);
-        ret = EIO;
-    }
-
-out:
-    lvm_vg_close(vg);
-    return ret;
-}
-
-uint64_t
-bd_get_default_extent(bd_priv_t *priv)
-{
-    vg_t vg = NULL;
-    uint64_t size = 0;
-
-    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!vg) {
-        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
-        return 0;
-    }
-
-    size = lvm_vg_get_extent_size(vg);
-
-    lvm_vg_close(vg);
-
-    return size;
-}
-
-/*
- * Adjusts the user specified size to VG specific extent size
- */
-uint64_t
-bd_adjust_size(bd_priv_t *priv, size_t size)
-{
-    uint64_t extent = 0;
-    uint64_t nr_ex = 0;
-
-    extent = bd_get_default_extent(priv);
-    if (!extent)
-        return 0;
-
-    nr_ex = size / extent;
-    if (size % extent)
-        nr_ex++;
-
-    size = extent * nr_ex;
-
-    return size;
-}
-
-int
-bd_delete_lv(bd_priv_t *priv, const char *lv_name, int *op_errno)
-{
-    vg_t vg = NULL;
-    lv_t lv = NULL;
-    int ret = -1;
-
-    *op_errno = 0;
-    vg = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!vg) {
-        gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
-        *op_errno = ENOENT;
-        return -1;
-    }
-    lv = lvm_lv_from_name(vg, lv_name);
-    if (!lv) {
-        gf_log(THIS->name, GF_LOG_WARNING, "No such LV %s", lv_name);
-        *op_errno = ENOENT;
-        goto out;
-    }
-    ret = lvm_vg_remove_lv(lv);
-    if (ret < 0) {
-        gf_log(THIS->name, GF_LOG_WARNING, "removing LV %s failed", lv_name);
-        *op_errno = errno;
-        goto out;
-    }
-out:
-    lvm_vg_close(vg);
-
-    return ret;
-}
-
-void
-bd_update_amtime(struct iatt *iatt, int flag)
-{
-    struct timespec ts = {
-        0,
-    };
-
-    clock_gettime(CLOCK_REALTIME, &ts);
-    if (flag & GF_SET_ATTR_ATIME) {
-        iatt->ia_atime = ts.tv_sec;
-        iatt->ia_atime_nsec = ts.tv_nsec;
-    }
-    if (flag & GF_SET_ATTR_MTIME) {
-        iatt->ia_mtime = ts.tv_sec;
-        iatt->ia_mtime_nsec = ts.tv_nsec;
-    }
-}
-
-int
-bd_snapshot_create(bd_local_t *local, bd_priv_t *priv)
-{
-    char *path = NULL;
-    bd_gfid_t dest = {
-        0,
-    };
-    bd_gfid_t origin = {
-        0,
-    };
-    int ret = 0;
-    runner_t runner = {
-        0,
-    };
-    struct stat stat = {
-        0,
-    };
-
-    uuid_utoa_r(local->dloc->gfid, dest);
-    uuid_utoa_r(local->loc.gfid, origin);
-
-    gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest);
-    if (!path) {
-        gf_log(THIS->name, GF_LOG_WARNING, "Insufficient memory");
-        return ENOMEM;
-    }
-
-    runinit(&runner);
-    runner_add_args(&runner, LVM_CREATE, NULL);
-    runner_add_args(&runner, "--snapshot", NULL);
-    runner_argprintf(&runner, "/dev/%s/%s", priv->vg, origin);
-    runner_add_args(&runner, "--name", NULL);
-    runner_argprintf(&runner, "%s", dest);
-    if (strcmp(local->bdatt->type, BD_THIN))
-        runner_argprintf(&runner, "-L%ldB", local->size);
-    runner_start(&runner);
-    runner_end(&runner);
-
-    if (sys_lstat(path, &stat) < 0)
-        ret = EIO;
-
-    GF_FREE(path);
-    return ret;
-}
-
-int
-bd_clone(bd_local_t *local, bd_priv_t *priv)
-{
-    int ret = ENOMEM;
-    int fd1 = -1;
-    int fd2 = -1;
-    int i = 0;
-    char *buff = NULL;
-    ssize_t bytes = 0;
-    char *spath = NULL;
-    char *dpath = NULL;
-    struct iovec *vec = NULL;
-    bd_gfid_t source = {
-        0,
-    };
-    bd_gfid_t dest = {
-        0,
-    };
-    void *bufp[IOV_NR] = {
-        0,
-    };
-
-    vec = GF_CALLOC(IOV_NR, sizeof(struct iovec), gf_common_mt_iovec);
-    if (!vec)
-        return ENOMEM;
-
-    for (i = 0; i < IOV_NR; i++) {
-        bufp[i] = page_aligned_alloc(IOV_SIZE, &buff);
-        if (!buff)
-            goto out;
-        vec[i].iov_base = buff;
-        vec[i].iov_len = IOV_SIZE;
-    }
-
-    uuid_utoa_r(local->loc.gfid, source);
-    uuid_utoa_r(local->dloc->gfid, dest);
-
-    gf_asprintf(&spath, "/dev/%s/%s", priv->vg, source);
-    gf_asprintf(&dpath, "/dev/%s/%s", priv->vg, dest);
-    if (!spath || !dpath)
-        goto out;
-
-    ret = bd_create(local->dloc->gfid, local->size, local->bdatt->type, priv);
-    if (ret)
-        goto out;
-
-    fd1 = open(spath, O_RDONLY | O_DIRECT);
-    if (fd1 < 0) {
-        ret = errno;
-        goto out;
-    }
-    fd2 = open(dpath, O_WRONLY | O_DIRECT);
-    if (fd2 < 0) {
-        ret = errno;
-        goto out;
-    }
-
-    while (1) {
-        bytes = sys_readv(fd1, vec, IOV_NR);
-        if (bytes < 0) {
-            ret = errno;
-            gf_log(THIS->name, GF_LOG_WARNING, "read failed: %s",
-                   strerror(ret));
-            goto out;
-        }
-        if (!bytes)
-            break;
-        bytes = sys_writev(fd2, vec, IOV_NR);
-        if (bytes < 0) {
-            ret = errno;
-            gf_log(THIS->name, GF_LOG_WARNING, "write failed: %s",
-                   strerror(ret));
-            goto out;
-        }
-    }
-    ret = 0;
-
-out:
-    for (i = 0; i < IOV_NR; i++)
-        GF_FREE(bufp[i]);
-    GF_FREE(vec);
-
-    if (fd1 != -1)
-        sys_close(fd1);
-    if (fd2 != -1)
-        sys_close(fd2);
-
-    GF_FREE(spath);
-    GF_FREE(dpath);
-
-    return ret;
-}
-
-/*
- * Merges snapshot LV to origin LV and returns status
- */
-int
-bd_merge(bd_priv_t *priv, uuid_t gfid)
-{
-    bd_gfid_t dest = {
-        0,
-    };
-    char *path = NULL;
-    struct stat stat = {
-        0,
-    };
-    runner_t runner = {
-        0,
-    };
-    int ret = 0;
-
-    uuid_utoa_r(gfid, dest);
-    gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest);
-
-    runinit(&runner);
-    runner_add_args(&runner, LVM_CONVERT, NULL);
-    runner_add_args(&runner, "--merge", NULL);
-    runner_argprintf(&runner, "%s", path);
-    runner_start(&runner);
-    runner_end(&runner);
-
-    if (!sys_lstat(path, &stat))
-        ret = EIO;
-
-    GF_FREE(path);
-
-    return ret;
-}
-
-int
-bd_get_origin(bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict)
-{
-    vg_t brick = NULL;
-    lvm_property_value_t prop = {
-        0,
-    };
-    lv_t lv = NULL;
-    int ret = -1;
-    bd_gfid_t gfid = {
-        0,
-    };
-    inode_t *inode = NULL;
-    char *origin = NULL;
-
-    brick = lvm_vg_open(priv->handle, priv->vg, "w", 0);
-    if (!brick) {
-        gf_log(THIS->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg);
-        return ENOENT;
-    }
-
-    if (fd)
-        inode = fd->inode;
-    else
-        inode = loc->inode;
-
-    uuid_utoa_r(inode->gfid, gfid);
-    lv = lvm_lv_from_name(brick, gfid);
-    if (!lv) {
-        gf_log(THIS->name, GF_LOG_CRITICAL, "LV %s not found", gfid);
-        ret = ENOENT;
-        goto out;
-    }
-
-    prop = lvm_lv_get_property(lv, "origin");
-    if (!prop.is_valid || !prop.value.string) {
-        ret = ENODATA;
-        goto out;
-    }
-
-    origin = gf_strdup(prop.value.string);
-    ret = dict_set_dynstr(dict, BD_ORIGIN, origin);
-
-out:
-    lvm_vg_close(brick);
-    return ret;
-}
-
-#ifndef BLKZEROOUT
-
-int
-bd_do_manual_zerofill(int fd, off_t offset, off_t len, int o_direct)
-{
-    off_t num_vect = 0;
-    off_t num_loop = 1;
-    int idx = 0;
-    int op_ret = -1;
-    int vect_size = IOV_SIZE;
-    off_t remain = 0;
-    off_t extra = 0;
-    struct iovec *vector = NULL;
-    char *iov_base = NULL;
-    char *alloc_buf = NULL;
-
-    if (len == 0)
-        return 0;
-
-    if (len < IOV_SIZE)
-        vect_size = len;
-
-    num_vect = len / (vect_size);
-    remain = len % vect_size;
-
-    if (num_vect > MAX_NO_VECT) {
-        extra = num_vect % MAX_NO_VECT;
-        num_loop = num_vect / MAX_NO_VECT;
-        num_vect = MAX_NO_VECT;
-    }
-
-    vector = GF_CALLOC(num_vect, sizeof(struct iovec), gf_common_mt_iovec);
-    if (!vector)
-        return -1;
-
-    if (o_direct) {
-        alloc_buf = page_aligned_alloc(vect_size, &iov_base);
-        if (!alloc_buf) {
-            gf_log("bd_do_manual_zerofill", GF_LOG_DEBUG,
-                   "memory alloc failed, vect_size %d: %s", vect_size,
-                   strerror(errno));
-            GF_FREE(vector);
-            return -1;
-        }
-    } else {
-        iov_base = GF_CALLOC(vect_size, sizeof(char), gf_common_mt_char);
-        if (!iov_base) {
-            GF_FREE(vector);
-            return -1;
-        }
-    }
-
-    for (idx = 0; idx < num_vect; idx++) {
-        vector[idx].iov_base = iov_base;
-        vector[idx].iov_len = vect_size;
-    }
-
-    if (sys_lseek(fd, offset, SEEK_SET) < 0) {
-        op_ret = -1;
-        goto err;
-    }
-
-    for (idx = 0; idx < num_loop; idx++) {
-        op_ret = sys_writev(fd, vector, num_vect);
-        if (op_ret < 0)
-            goto err;
-    }
-    if (extra) {
-        op_ret = sys_writev(fd, vector, extra);
-        if (op_ret < 0)
-            goto err;
-    }
-    if (remain) {
-        vector[0].iov_len = remain;
-        op_ret = sys_writev(fd, vector, 1);
-        if (op_ret < 0)
-            goto err;
-    }
-    op_ret = 0;
-err:
-    if (o_direct)
-        GF_FREE(alloc_buf);
-    else
-        GF_FREE(iov_base);
-    GF_FREE(vector);
-    return op_ret;
-}
-
-#else
-
-/*
- * Issue Linux ZEROOUT ioctl to write '0' to a scsi device at given offset
- * and number of bytes. Each SCSI device's maximum write same bytes are exported
- * in sysfs file. Sending ioctl request greater than this bytes results in slow
- * performance. Read this file to get the maximum bytes and break down single
- * ZEROOUT request into multiple ZEROOUT request not exceeding maximum bytes.
- * From VG & LV name of device mapper identified and sysfs file read.
- * /sys/block/<block-device>/queue/write_same_max_bytes
- */
-int
-bd_do_ioctl_zerofill(bd_priv_t *priv, bd_attr_t *bdatt, int fd, char *vg,
-                     off_t offset, off_t len)
-{
-    char *dm = NULL;
-    char dmname[4096] = {
-        0,
-    };
-    char lvname[4096] = {
-        0,
-    };
-    char sysfs[4096] = {
-        0,
-    };
-    bd_gfid_t uuid = {
-        0,
-    };
-    char *p = NULL;
-    off_t max_bytes = 0;
-    int sysfd = -1;
-    int ret = 0;
-    uint64_t param[2] = {0, 0};
-    off_t nr_loop = 0;
-    char buff[16] = {
-        0,
-    };
-
-    uuid_utoa_r(bdatt->iatt.ia_gfid, uuid);
-    sprintf(lvname, "/dev/%s/%s", vg, uuid);
-
-    ret = sys_readlink(lvname, dmname, 4096);
-    if (ret < 0) {
-        gf_log("bd", GF_LOG_DEBUG, "Failed to read symbolic link '%s': %s",
-               lvname, strerror(errno));
-        goto skip;
-    }
-
-    dmname[ret] = '\0';
-
-    p = strrchr(dmname, '/');
-    if (p)
-        dm = p + 1;
-    else
-        dm = dmname;
-
-    sprintf(sysfs, "/sys/block/%s/queue/write_same_max_bytes", dm);
-    sysfd = open(sysfs, O_RDONLY);
-    if (sysfd < 0) {
-        gf_log("bd_do_ioctl_zerofill", GF_LOG_DEBUG,
-               "sysfs file %s does not exist", lvname);
-        goto skip;
-    }
-
-    sys_read(sysfd, buff, sizeof(buff));
-    sys_close(sysfd);
-
-    max_bytes = atoll(buff);
-
-skip:
-    /*
-     * If requested len is less than write_same_max_bytes,
-     * issue single ioctl to zeroout. Otherwise split the ioctls
-     */
-    if (!max_bytes || len <= max_bytes) {
-        param[0] = offset;
-        param[1] = len;
-
-        if (ioctl(fd, BLKZEROOUT, param) < 0)
-            return errno;
-        return 0;
-    }
-
-    /* Split ioctls to max write_same_max_bytes */
-    nr_loop = len / max_bytes;
-    for (; nr_loop; nr_loop--) {
-        param[0] = offset;
-        param[1] = max_bytes;
-
-        if (ioctl(fd, BLKZEROOUT, param) < 0)
-            return errno;
-
-        offset += max_bytes;
-    }
-
-    if (!(len % max_bytes))
-        return 0;
-
-    param[0] = offset;
-    param[1] = len % max_bytes;
-
-    if (ioctl(fd, BLKZEROOUT, param) < 0)
-        return errno;
-
-    return 0;
-}
-#endif
-
-int
-bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               size_t len, struct iatt *prebuf, struct iatt *postbuf)
-{
-    int ret = -1;
-    bd_fd_t *bd_fd = NULL;
-    bd_priv_t *priv = this->private;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(priv, out);
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0) {
-        gf_log(this->name, GF_LOG_DEBUG, "bd_fd is NULL from fd=%p", fd);
-        goto out;
-    }
-
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-#ifndef BLKZEROOUT
-    ret = bd_do_manual_zerofill(bd_fd->fd, offset, len, bd_fd->flag & O_DIRECT);
-#else
-    ret = bd_do_ioctl_zerofill(priv, bdatt, bd_fd->fd, priv->vg, offset, len);
-#endif
-    if (ret) {
-        gf_log(this->name, GF_LOG_ERROR,
-               "zerofill failed on fd %d length %zu %s", bd_fd->fd, len,
-               strerror(ret));
-        goto out;
-    }
-
-    if (bd_fd->flag & (O_SYNC | O_DSYNC)) {
-        ret = sys_fsync(bd_fd->fd);
-        if (ret) {
-            gf_log(this->name, GF_LOG_ERROR,
-                   "fsync() in writev on fd %d failed: %s", bd_fd->fd,
-                   strerror(errno));
-            return errno;
-        }
-    }
-
-    memcpy(prebuf, &bdatt->iatt, sizeof(struct iatt));
-    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
-    memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt));
-
-out:
-
-    return ret;
-}
diff --git a/xlators/storage/bd/src/bd-mem-types.h b/xlators/storage/bd/src/bd-mem-types.h
deleted file mode 100644
index 5cdbd6938e1..00000000000
--- a/xlators/storage/bd/src/bd-mem-types.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-  Copyright (c) 2008-2014 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 __BD_MEM_TYPES_H__
-#define __BD_MEM_TYPES_H__
-
-#include <glusterfs/mem-types.h>
-
-enum gf_bd_mem_types_ {
-    gf_bd_private = gf_common_mt_end + 1,
-    gf_bd_attr,
-    gf_bd_fd,
-    gf_bd_loc_t,
-    gf_bd_int32_t,
-    gf_bd_aio_cb,
-    gf_bd_mt_end
-};
-
-#endif
diff --git a/xlators/storage/bd/src/bd.c b/xlators/storage/bd/src/bd.c
deleted file mode 100644
index 3d1fa1b6b14..00000000000
--- a/xlators/storage/bd/src/bd.c
+++ /dev/null
@@ -1,2426 +0,0 @@
-/*
-  BD translator V2 - Exports Block devices on server side as regular
-  files to client
-
-  Now only exporting Logical volumes supported.
-
-  Copyright IBM, Corp. 2013
-
-  This file is part of GlusterFS.
-
-  Author:
-  M. Mohan Kumar <mohan@in.ibm.com>
-
-  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.
-*/
-
-#include <lvm2app.h>
-#include <openssl/md5.h>
-#include <time.h>
-#include <linux/fs.h>
-#include <sys/ioctl.h>
-#ifdef HAVE_LIBAIO
-#include <libaio.h>
-#endif
-
-#include "bd.h"
-#include "bd-aio.h"
-#include "bd-mem-types.h"
-#include <glusterfs/defaults.h>
-#include "glusterfs3-xdr.h"
-#include <glusterfs/run.h>
-#include "protocol-common.h"
-#include <glusterfs/checksum.h>
-#include <glusterfs/syscall.h>
-#include <glusterfs/lvm-defaults.h>
-
-/*
- * Call back function for setxattr and removexattr.
- * does not do anything. FIXME: How to handle remove/setxattr failure
- */
-int
-bd_null_rmsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, dict_t *xdata)
-{
-    STACK_DESTROY(frame->root);
-    return 0;
-}
-
-/*
- * returns 0 if a file is mapped to BD or not.
- */
-int
-bd_get_bd_info(call_frame_t *frame, xlator_t *this, dict_t *xattr, uuid_t gfid,
-               char **type, uint64_t *size)
-{
-    char *bd_xattr = NULL;
-    char *bd = NULL;
-    int ret = -1;
-    loc_t loc = {
-        0,
-    };
-    dict_t *dict = NULL;
-    char *p = NULL;
-    call_frame_t *bd_frame = NULL;
-
-    if (!xattr)
-        return 1;
-
-    if (dict_get_str(xattr, BD_XATTR, &p))
-        return 1;
-
-    bd_xattr = gf_strdup(p);
-
-    memcpy(loc.gfid, gfid, sizeof(uuid_t));
-
-    bd_frame = copy_frame(frame);
-    BD_VALIDATE_MEM_ALLOC(bd_frame, ret, out);
-
-    ret = bd_validate_bd_xattr(this, bd_xattr, type, size, gfid);
-    if (ret < 0) { /* LV does not exist */
-        STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->removexattr, &loc, BD_XATTR, NULL);
-
-        gf_log(this->name, GF_LOG_WARNING,
-               "Mapped LV not available for posix file <gfid:%s>, "
-               "deleting mapping",
-               uuid_utoa(gfid));
-    } else if (ret == 1) {
-        /* BD_XATTR size and LV size mismatch. Update BD_XATTR */
-        gf_asprintf(&bd, "%s:%ld", *type, *size);
-
-        dict = dict_new();
-        BD_VALIDATE_MEM_ALLOC(dict, ret, out);
-
-        ret = dict_set_dynstr(dict, BD_XATTR, bd);
-        if (ret)
-            goto out;
-
-        STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, &loc, dict, 0, NULL);
-    }
-
-out:
-    dict_del(xattr, BD_XATTR);
-    GF_FREE(bd_xattr);
-    GF_FREE(bd);
-    return ret;
-}
-
-/*
- * bd_lookup_cbk: Call back from posix_lookup.
- */
-int32_t
-bd_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, inode_t *inode, struct iatt *buf, dict_t *xattr,
-              struct iatt *postparent)
-{
-    int ret = -1;
-    bd_attr_t *bdatt = NULL;
-    uint64_t size = 0;
-    char *type = NULL;
-
-    /* only regular files are part of BD object */
-    if (op_ret < 0 || buf->ia_type != IA_IFREG)
-        goto out;
-
-    /* iatt already cached */
-    if (!bd_inode_ctx_get(inode, this, &bdatt))
-        goto next;
-
-    if (bd_get_bd_info(frame, this, xattr, buf->ia_gfid, &type, &size))
-        goto out;
-
-    /* BD file, update buf */
-    bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-    if (!bdatt) {
-        op_errno = ENOMEM;
-        goto out;
-    }
-    memcpy(&bdatt->iatt, buf, sizeof(struct iatt));
-    bdatt->type = type;
-
-    /* Cache LV size in inode_ctx */
-    ret = bd_inode_ctx_set(inode, this, bdatt);
-    if (ret < 0) {
-        GF_FREE(bdatt);
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    bdatt->iatt.ia_size = size;
-    bdatt->iatt.ia_blocks = size / 512;
-
-next:
-    dict_del(xattr, GF_CONTENT_KEY);
-    memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
-
-out:
-    BD_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xattr,
-                    postparent);
-    return 0;
-}
-
-/*
- * bd_lookup: Issues posix_lookup to find out if file is mapped to BD
- * bd_lookup -> posix_lookup -> bd_lookup_cbk
- */
-int32_t
-bd_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
-{
-    dict_t *bd_xattr = NULL;
-    bd_attr_t *bdatt = NULL;
-    int op_errno = EINVAL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(loc, out);
-    VALIDATE_OR_GOTO(loc->path, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    if (bd_inode_ctx_get(loc->inode, this, &bdatt) < 0) {
-        if (!xattr_req) {
-            bd_xattr = dict_new();
-            BD_VALIDATE_MEM_ALLOC(bd_xattr, op_errno, out);
-            xattr_req = bd_xattr;
-        }
-        if (dict_set_int8(xattr_req, BD_XATTR, 1) < 0)
-            goto out;
-    }
-
-    STACK_WIND(frame, bd_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, xattr_req);
-
-    if (bd_xattr)
-        dict_unref(bd_xattr);
-    return 0;
-out:
-    BD_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL);
-
-    return 0;
-}
-
-int
-bd_forget(xlator_t *this, inode_t *inode)
-{
-    int ret = -1;
-    uint64_t ctx = 0;
-    bd_attr_t *bdatt = NULL;
-
-    ret = bd_inode_ctx_get(inode, this, &bdatt);
-    if (!ret) {
-        inode_ctx_del(inode, this, &ctx);
-        GF_FREE(bdatt);
-    }
-    return 0;
-}
-
-int
-bd_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                int op_errno, gf_dirent_t *entries, dict_t *xdata)
-{
-    gf_dirent_t *entry = NULL;
-    uint64_t size = 0;
-    char *type = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    list_for_each_entry(entry, &entries->list, list)
-    {
-        if (entry->d_type != DT_REG)
-            continue;
-        if (!bd_get_bd_info(frame, this, entry->dict, entry->d_stat.ia_gfid,
-                            &type, &size)) {
-            entry->d_stat.ia_size = size;
-            entry->d_stat.ia_blocks = size / 512;
-            GF_FREE(type);
-        }
-    }
-
-out:
-    BD_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata);
-    return 0;
-}
-
-/*
- * bd_readdirp: In bd_readdirp_cbk if the file and BD_XATTR_SIZE is set
- * ia_size is updated with the LV(BD_XATTR_SIZE) size
- */
-int32_t
-bd_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-            off_t off, dict_t *dict)
-{
-    int op_errno = EINVAL;
-    bd_local_t *local = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    if (!dict) {
-        local = bd_local_init(frame, this);
-        BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-        local->dict = dict_new();
-        BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
-        dict = local->dict;
-    }
-
-    if (dict_set_int8(dict, BD_XATTR, 0)) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set key %s", BD_XATTR);
-        goto out;
-    }
-
-    STACK_WIND(frame, bd_readdirp_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict);
-
-    return 0;
-out:
-    BD_STACK_UNWIND(readdirp, frame, -1, op_errno, NULL, dict);
-    return 0;
-}
-
-int
-bd_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-            int op_errno, struct iatt *buf, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-    bd_attr_t *bdatt = NULL;
-
-    /* only regular files are part of BD object */
-    if (op_ret < 0 || buf->ia_type != IA_IFREG)
-        goto out;
-
-    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
-
-    /* update buf with LV size */
-    if (!bd_inode_ctx_get(local->inode, this, &bdatt))
-        memcpy(buf, bdatt, sizeof(struct iatt));
-
-out:
-    BD_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata);
-    return 0;
-}
-
-int
-bd_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    int op_errno = EINVAL;
-    bd_local_t *local = NULL;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(loc, out);
-    VALIDATE_OR_GOTO(loc->path, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    if (!bd_inode_ctx_get(loc->inode, this, &bdatt)) {
-        BD_STACK_UNWIND(stat, frame, 0, 0, &bdatt->iatt, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-    local->inode = inode_ref(loc->inode);
-
-    STACK_WIND(frame, bd_stat_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->stat, loc, xdata);
-    return 0;
-out:
-    BD_STACK_UNWIND(stat, frame, -1, op_errno, NULL, xdata);
-    return 0;
-}
-
-int
-bd_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-              int op_errno, struct statvfs *buff, dict_t *xdata)
-{
-    uint64_t size = 0;
-    uint64_t fr_size = 0;
-    bd_priv_t *priv = NULL;
-    vg_t vg = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    priv = this->private;
-
-    vg = lvm_vg_open(priv->handle, priv->vg, "r", 0);
-    if (!vg) {
-        gf_log(this->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg);
-        op_ret = -1;
-        op_errno = EAGAIN;
-        goto out;
-    }
-    size = lvm_vg_get_size(vg);
-    fr_size = lvm_vg_get_free_size(vg);
-    lvm_vg_close(vg);
-
-    buff->f_blocks += size / buff->f_frsize;
-    buff->f_bfree += fr_size / buff->f_frsize;
-    buff->f_bavail += fr_size / buff->f_frsize;
-
-out:
-    BD_STACK_UNWIND(statfs, frame, op_ret, op_errno, buff, xdata);
-    return 0;
-}
-
-/*
- * bd_statfs: Mimics statfs by returning used/free extents in the VG
- */
-int
-bd_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
-{
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(this->private, out);
-    VALIDATE_OR_GOTO(loc, out);
-
-    STACK_WIND(frame, bd_statfs_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->statfs, loc, xdata);
-    return 0;
-out:
-    BD_STACK_UNWIND(statfs, frame, -1, EINVAL, NULL, NULL);
-    return 0;
-}
-
-int
-bd_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-             int op_errno, struct iatt *buf, dict_t *xdata)
-{
-    bd_attr_t *bdatt = NULL;
-    bd_local_t *local = frame->local;
-
-    /* only regular files are part of BD object */
-    if (op_ret < 0 || buf->ia_type != IA_IFREG)
-        goto out;
-
-    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
-
-    /* update buf with LV size */
-    if (!bd_inode_ctx_get(local->inode, this, &bdatt))
-        memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
-
-out:
-    BD_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata);
-    return 0;
-}
-
-int
-bd_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    int op_errno = EINVAL;
-    bd_local_t *local = NULL;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    /* if its already cached return it */
-    if (!bd_inode_ctx_get(fd->inode, this, &bdatt)) {
-        BD_STACK_UNWIND(fstat, frame, 0, 0, &bdatt->iatt, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-    local->inode = inode_ref(fd->inode);
-
-    STACK_WIND(frame, bd_fstat_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, xdata);
-
-    return 0;
-out:
-    BD_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, xdata);
-    return 0;
-}
-
-/*
- * bd_readv: If posix file, invokes posix_readv otherwise reads from the BD
- * file
- */
-int
-bd_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-         off_t offset, uint32_t flags, dict_t *xdata)
-{
-    int ret = -1;
-    int _fd = -1;
-    int32_t op_ret = -1;
-    int32_t op_errno = 0;
-    bd_fd_t *bd_fd = NULL;
-    struct iovec vec = {
-        0,
-    };
-    struct iobuf *iobuf = NULL;
-    struct iobref *iobref = NULL;
-    uint64_t bd_size = 0;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) {
-        STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
-                   xdata);
-        return 0;
-    }
-    if (!size) {
-        op_errno = EINVAL;
-        gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size);
-        goto out;
-    }
-    iobuf = iobuf_get2(this->ctx->iobuf_pool, size);
-    if (!iobuf) {
-        op_errno = ENOMEM;
-        goto out;
-    }
-    _fd = bd_fd->fd;
-    op_ret = sys_pread(_fd, iobuf->ptr, size, offset);
-    if (op_ret == -1) {
-        op_errno = errno;
-        gf_log(this->name, GF_LOG_ERROR, "read failed on fd=%p: %s", fd,
-               strerror(op_errno));
-        goto out;
-    }
-
-    vec.iov_base = iobuf->ptr;
-    vec.iov_len = op_ret;
-
-    iobref = iobref_new();
-    iobref_add(iobref, iobuf);
-
-    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
-        op_errno = EINVAL;
-        op_ret = -1;
-        goto out;
-    }
-    bd_size = bdatt->iatt.ia_size;
-    if (!bd_size || (offset + vec.iov_len) >= bd_size)
-        op_errno = ENOENT;
-
-    op_ret = vec.iov_len;
-    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_ATIME);
-
-out:
-    BD_STACK_UNWIND(readv, frame, op_ret, op_errno, &vec, 1, &bdatt->iatt,
-                    iobref, NULL);
-
-    if (iobref)
-        iobref_unref(iobref);
-    if (iobuf)
-        iobuf_unref(iobuf);
-
-    return 0;
-}
-
-#ifdef BLKDISCARD
-/*
- * bd_discard: Sends BLKDISCARD ioctl to the block device
- */
-int
-bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-           size_t len, dict_t *xdata)
-{
-    int ret = -1;
-    int op_errno = EINVAL;
-    bd_fd_t *bd_fd = NULL;
-    uint64_t param[2] = {
-        0,
-    };
-    bd_attr_t *bdatt = NULL;
-    struct iatt prebuf = {
-        0,
-    };
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(this->private, out);
-    VALIDATE_OR_GOTO(fd, out);
-
-    /* posix */
-    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
-        STACK_WIND(frame, default_discard_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata);
-        return 0;
-    }
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    param[0] = offset;
-    param[1] = len;
-    ret = ioctl(bd_fd->fd, BLKDISCARD, param);
-    if (ret < 0) {
-        if (errno == ENOTTY)
-            op_errno = ENOSYS;
-        else
-            op_errno = errno;
-        goto out;
-    }
-    memcpy(&prebuf, &bdatt->iatt, sizeof(prebuf));
-    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
-
-    BD_STACK_UNWIND(discard, frame, ret, op_errno, &prebuf, &bdatt->iatt,
-                    xdata);
-    return 0;
-
-out:
-    BD_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-#else
-
-int
-bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-           size_t len, dict_t *xdata)
-{
-    BD_STACK_UNWIND(discard, frame, -1, ENOSYS, NULL, NULL, NULL);
-    return 0;
-}
-#endif
-
-/*
- * Call back from posix_open for opening the backing posix file
- * If it failed, close BD fd
- */
-int
-bd_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-            int op_errno, fd_t *fd, dict_t *xdata)
-{
-    bd_fd_t *bd_fd = NULL;
-    bd_attr_t *bdatt = NULL;
-
-    if (!op_ret)
-        goto out;
-
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-    if (!bdatt) /* posix file */
-        goto out;
-
-    /* posix open failed */
-    if (bd_fd_ctx_get(this, fd, &bd_fd) < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "bd_fd is NULL from fd=%p", fd);
-        goto out;
-    }
-    sys_close(bd_fd->fd);
-    GF_FREE(bd_fd);
-
-out:
-    BD_STACK_UNWIND(open, frame, op_ret, op_errno, fd, NULL);
-
-    return 0;
-}
-
-/*
- * bd_open: Opens BD file if given posix file is mapped to BD. Also opens
- * posix file.
- * fd contains both posix and BD fd
- */
-int32_t
-bd_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-        fd_t *fd, dict_t *xdata)
-{
-    int32_t ret = EINVAL;
-    bd_fd_t *bd_fd = NULL;
-    bd_attr_t *bdatt = NULL;
-    bd_gfid_t gfid = {
-        0,
-    };
-    char *devpath = NULL;
-    bd_priv_t *priv = this->private;
-    int _fd = -1;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(this->private, out);
-    VALIDATE_OR_GOTO(loc, out);
-    VALIDATE_OR_GOTO(fd, out);
-
-    /* not bd file */
-    if (fd->inode->ia_type != IA_IFREG ||
-        bd_inode_ctx_get(fd->inode, this, &bdatt))
-        goto posix;
-
-    uuid_utoa_r(fd->inode->gfid, gfid);
-    gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid);
-    BD_VALIDATE_MEM_ALLOC(devpath, ret, out);
-
-    _fd = open(devpath, flags | O_LARGEFILE, 0);
-    if (_fd < 0) {
-        ret = errno;
-        gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath,
-               strerror(ret));
-        goto out;
-    }
-    bd_fd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd);
-    BD_VALIDATE_MEM_ALLOC(bd_fd, ret, out);
-
-    bd_fd->fd = _fd;
-    bd_fd->flag = flags | O_LARGEFILE;
-
-    if (fd_ctx_set(fd, this, (uint64_t)(long)bd_fd) < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p",
-               fd);
-        goto out;
-    }
-
-    ret = 0;
-
-posix:
-
-    /* open posix equivalent of this file, fd needed for fd related
-       operations like fsetxattr, ftruncate etc */
-    STACK_WIND(frame, bd_open_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
-
-    GF_FREE(devpath);
-    return 0;
-out:
-    BD_STACK_UNWIND(open, frame, -1, ret, fd, NULL);
-
-    GF_FREE(devpath);
-    if (ret) {
-        if (_fd >= 0)
-            sys_close(_fd);
-        GF_FREE(bd_fd);
-    }
-
-    return 0;
-}
-
-/*
- * call back from posix_setattr after updating iatt to posix file.
- */
-int
-bd_fsync_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, struct iatt *pre,
-                     struct iatt *post, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-    bd_attr_t *bdatt = local->bdatt;
-
-    BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &bdatt->iatt, &bdatt->iatt,
-                    NULL);
-    return 0;
-}
-
-int
-bd_do_fsync(int fd, int datasync)
-{
-    int op_errno = 0;
-
-    if (datasync) {
-        if (sys_fdatasync(fd)) {
-            op_errno = errno;
-            gf_log(THIS->name, GF_LOG_ERROR, "fdatasync on fd=%d failed: %s",
-                   fd, strerror(errno));
-        }
-
-    } else
-
-    {
-        if (sys_fsync(fd)) {
-            op_errno = errno;
-            gf_log(THIS->name, GF_LOG_ERROR, "fsync on fd=%d failed: %s", fd,
-                   strerror(op_errno));
-        }
-    }
-
-    return op_errno;
-}
-
-/*
- * bd_fsync: Syncs if BD fd, forwards the request to posix
- * fsync -> posix_setattr -> posix_fsync
- */
-int32_t
-bd_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
-         dict_t *xdata)
-{
-    int ret = -1;
-    int32_t op_ret = -1;
-    int32_t op_errno = 0;
-    bd_fd_t *bd_fd = NULL;
-    bd_attr_t *bdatt = NULL;
-    bd_local_t *local = NULL;
-    int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
-    struct iatt prebuf = {
-        0,
-    };
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd || !bdatt) {
-        STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata);
-        return 0;
-    }
-
-    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
-
-    op_errno = bd_do_fsync(bd_fd->fd, datasync);
-    if (op_errno)
-        goto out;
-
-    /* For BD, Update the a|mtime during full fsync only */
-    if (!datasync) {
-        local = bd_local_init(frame, this);
-        /* In case of mem failure, should posix flush called ? */
-        BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-        local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-        BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
-
-        local->bdatt->type = gf_strdup(bdatt->type);
-        memcpy(&local->bdatt->iatt, &bdatt->iatt, sizeof(struct iatt));
-        bd_update_amtime(&local->bdatt->iatt, valid);
-        gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
-        STACK_WIND(frame, bd_fsync_setattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setattr, &local->loc,
-                   &local->bdatt->iatt, valid, NULL);
-        return 0;
-    }
-
-out:
-    BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &prebuf, &bdatt->iatt,
-                    NULL);
-    return 0;
-}
-
-int
-bd_flush_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, struct iatt *pre,
-                     struct iatt *post, dict_t *xdata)
-{
-    BD_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-int
-bd_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
-{
-    int ret = -1;
-    bd_fd_t *bd_fd = NULL;
-    bd_attr_t *bdatt = NULL;
-    int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME;
-    bd_local_t *local = NULL;
-    loc_t loc = {
-        0,
-    };
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(this->private, out);
-
-    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
-    if (!bdatt)
-        goto out;
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd || !bdatt) {
-        gf_log(this->name, GF_LOG_WARNING, "bdfd/bdatt is NULL from fd=%p", fd);
-        goto out;
-    }
-
-    local = bd_local_init(frame, this);
-    if (!local) {
-        gf_log(this->name, GF_LOG_ERROR, "out of memory");
-        goto out;
-    }
-
-    local->fd = fd_ref(fd);
-    gf_uuid_copy(loc.gfid, bdatt->iatt.ia_gfid);
-
-    /* Update the a|mtime during flush */
-    STACK_WIND(frame, bd_flush_setattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setattr, &loc, &bdatt->iatt, valid,
-               NULL);
-
-    return 0;
-
-out:
-    STACK_WIND(frame, default_flush_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->flush, fd, xdata);
-
-    return 0;
-}
-
-int32_t
-bd_release(xlator_t *this, fd_t *fd)
-{
-    int ret = -1;
-    bd_fd_t *bd_fd = NULL;
-    uint64_t tmp_bfd = 0;
-    bd_attr_t *bdatt = NULL;
-    bd_priv_t *priv = this->private;
-
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(priv, out);
-
-    ret = bd_inode_ctx_get(fd->inode, this, &bdatt);
-    if (ret || !bdatt) /* posix file */
-        goto out;
-
-    /* FIXME: Update amtime during release */
-
-    ret = fd_ctx_del(fd, this, &tmp_bfd);
-    if (ret < 0) {
-        gf_log(this->name, GF_LOG_WARNING, "bfd is NULL from fd=%p", fd);
-        goto out;
-    }
-    bd_fd = (bd_fd_t *)(long)tmp_bfd;
-
-    sys_close(bd_fd->fd);
-    GF_FREE(bd_fd);
-out:
-    return 0;
-}
-
-/*
- * Call back for removexattr after removing BD_XATTR in case of
- * bd create failure
- */
-int
-bd_setx_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-
-    if (local->fd)
-        BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata);
-    return 0;
-}
-
-/*
- * Call back after setting BD_XATTR. Creates BD. If BD creation is a failure
- * invokes posix_removexattr to remove created BD_XATTR
- */
-int
-bd_setx_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                 int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-    bd_attr_t *bdatt = NULL;
-
-    if (op_ret < 0)
-        goto next;
-
-    /* Create LV */
-    op_errno = bd_create(local->inode->gfid, local->bdatt->iatt.ia_size,
-                         local->bdatt->type, this->private);
-    if (!op_errno)
-        goto out;
-
-    /* LV creation failed, remove BD_XATTR */
-    if (local->fd)
-        STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fremovexattr, local->fd, BD_XATTR,
-                   NULL);
-    else
-        STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->removexattr, &local->loc, BD_XATTR,
-                   NULL);
-
-    return 0;
-out:
-
-    bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-    if (!bdatt) {
-        op_ret = -1;
-        op_errno = ENOMEM;
-        goto next;
-    }
-
-    memcpy(&bdatt->iatt, &local->bdatt->iatt, sizeof(struct iatt));
-    bdatt->type = gf_strdup(local->bdatt->type);
-
-    bd_inode_ctx_set(local->inode, THIS, bdatt);
-
-next:
-    if (local->fd)
-        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
-    else
-        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata);
-    return 0;
-}
-
-/*
- * Call back from posix_stat
- */
-int
-bd_setx_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                 int op_errno, struct iatt *iatt, dict_t *xdata)
-{
-    char *param = NULL;
-    char *type = NULL;
-    char *s_size = NULL;
-    char *p = NULL;
-    char *copy = NULL;
-    bd_local_t *local = frame->local;
-    bd_priv_t *priv = this->private;
-    char *bd = NULL;
-    uint64_t size = 0;
-
-    if (op_ret < 0)
-        goto out;
-
-    if (!IA_ISREG(iatt->ia_type)) {
-        op_errno = EOPNOTSUPP;
-        goto out;
-    }
-
-    param = copy = GF_MALLOC(local->data->len + 1, gf_common_mt_char);
-    BD_VALIDATE_MEM_ALLOC(param, op_errno, out);
-
-    strncpy(param, local->data->data, local->data->len);
-    param[local->data->len] = '\0';
-
-    type = strtok_r(param, ":", &p);
-    if (!type) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    if (strcmp(type, BD_LV) && strcmp(type, BD_THIN)) {
-        gf_log(this->name, GF_LOG_WARNING, "Invalid bd type %s given", type);
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    if (!strcmp(type, BD_THIN) && !(priv->caps & BD_CAPS_THIN)) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "THIN lv not supported by "
-               "this volume");
-        op_errno = EOPNOTSUPP;
-        goto out;
-    }
-
-    s_size = strtok_r(NULL, ":", &p);
-
-    /* If size not specified get default size */
-    if (!s_size)
-        size = bd_get_default_extent(priv);
-    else
-        gf_string2bytesize_uint64(s_size, &size);
-
-    gf_asprintf(&bd, "%s:%ld", type, size);
-    BD_VALIDATE_MEM_ALLOC(bd, op_errno, out);
-
-    local->dict = dict_new();
-    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
-
-    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
-
-    if (dict_set_dynstr(local->dict, BD_XATTR, bd) < 0) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    local->bdatt->type = gf_strdup(type);
-    memcpy(&local->bdatt->iatt, iatt, sizeof(struct iatt));
-    local->bdatt->iatt.ia_size = size;
-
-    if (local->fd)
-        STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
-                   0, NULL);
-    else
-        STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
-                   0, NULL);
-
-    if (copy)
-        GF_FREE(copy);
-    return 0;
-
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, xdata);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, xdata);
-
-    GF_FREE(bd);
-    GF_FREE(copy);
-    return 0;
-}
-
-int
-bd_offload_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-
-    if (local->fd)
-        BD_STACK_UNWIND(fsetxattr, frame, -1, EIO, NULL);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, EIO, NULL);
-
-    return 0;
-}
-
-int
-bd_offload_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-
-    if (op_ret < 0)
-        goto out;
-
-    if (local->offload == BD_OF_SNAPSHOT)
-        op_ret = bd_snapshot_create(frame->local, this->private);
-    else
-        op_ret = bd_clone(frame->local, this->private);
-
-    if (op_ret) {
-        STACK_WIND(frame, bd_offload_rm_xattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->removexattr, local->dloc, BD_XATTR,
-                   NULL);
-        return 0;
-    }
-
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
-    else
-        BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
-
-    return 0;
-}
-
-int
-bd_offload_getx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
-{
-    char *bd = NULL;
-    bd_local_t *local = frame->local;
-    char *type = NULL;
-    char *p = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    if (dict_get_str(xattr, BD_XATTR, &p)) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    type = gf_strdup(p);
-    BD_VALIDATE_MEM_ALLOC(type, op_errno, out);
-
-    p = strrchr(type, ':');
-    if (!p) {
-        op_errno = EINVAL;
-        gf_log(this->name, GF_LOG_WARNING, "source file xattr %s corrupted?",
-               type);
-        goto out;
-    }
-
-    *p = '\0';
-
-    /* For clone size is taken from source LV */
-    if (!local->size) {
-        p++;
-        gf_string2bytesize_uint64(p, &local->size);
-    }
-    gf_asprintf(&bd, "%s:%ld", type, local->size);
-    local->bdatt->type = gf_strdup(type);
-    dict_del(local->dict, LINKTO);
-    if (dict_set_dynstr(local->dict, BD_XATTR, bd)) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    STACK_WIND(frame, bd_offload_setx_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->setxattr, local->dloc, local->dict, 0,
-               NULL);
-
-    if (type)
-        GF_FREE(type);
-    return 0;
-
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
-
-    GF_FREE(type);
-    GF_FREE(bd);
-
-    return 0;
-}
-
-int
-bd_offload_dest_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, inode_t *inode,
-                           struct iatt *iatt, dict_t *xattr,
-                           struct iatt *postparent)
-{
-    bd_local_t *local = frame->local;
-    char *bd = NULL;
-    char *linkto = NULL;
-    int ret = -1;
-
-    if (op_ret < 0 && op_errno != ENODATA) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    if (!IA_ISREG(iatt->ia_type)) {
-        op_errno = EINVAL;
-        gf_log(this->name, GF_LOG_WARNING,
-               "destination gfid is not a "
-               "regular file");
-        goto out;
-    }
-
-    ret = dict_get_str(xattr, LINKTO, &linkto);
-    if (linkto) {
-        op_errno = EINVAL;
-        gf_log(this->name, GF_LOG_WARNING,
-               "destination file not "
-               "present in same brick");
-        goto out;
-    }
-
-    ret = dict_get_str(xattr, BD_XATTR, &bd);
-    if (bd) {
-        op_errno = EEXIST;
-        goto out;
-    }
-
-    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
-
-    STACK_WIND(frame, bd_offload_getx_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->getxattr, &local->loc, BD_XATTR, NULL);
-
-    return 0;
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
-
-    return (ret == 0) ? 0 : ret;
-}
-
-int
-bd_merge_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, struct iatt *preparent,
-                    struct iatt *postparent, dict_t *xdata)
-{
-    /* FIXME: if delete failed, remove xattr */
-
-    BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
-    return 0;
-}
-
-int
-bd_do_merge(call_frame_t *frame, xlator_t *this)
-{
-    bd_local_t *local = frame->local;
-    inode_t *parent = NULL;
-    char *p = NULL;
-    int op_errno = 0;
-
-    op_errno = bd_merge(this->private, local->inode->gfid);
-    if (op_errno)
-        goto out;
-
-    /*
-     * posix_unlink needs loc->pargfid to be valid, but setxattr FOP does
-     * not have loc->pargfid set. Get parent's gfid by getting parents inode
-     */
-    parent = inode_parent(local->inode, NULL, NULL);
-    if (!parent) {
-        /*
-         * FIXME: Snapshot LV already deleted.
-         * remove xattr, instead of returning failure
-         */
-        op_errno = EINVAL;
-        goto out;
-    }
-    gf_uuid_copy(local->loc.pargfid, parent->gfid);
-
-    p = strrchr(local->loc.path, '/');
-    if (p)
-        p++;
-    local->loc.name = p;
-
-    STACK_WIND(frame, bd_merge_unlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
-
-    return 0;
-out:
-    BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
-
-    return op_errno;
-}
-
-int
-bd_offload(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd,
-           bd_offload_t offload)
-{
-    char *param = NULL;
-    char *param_copy = NULL;
-    char *p = NULL;
-    char *size = NULL;
-    char *gfid = NULL;
-    int op_errno = 0;
-    bd_local_t *local = frame->local;
-
-    param = GF_MALLOC(local->data->len + 1, gf_common_mt_char);
-    BD_VALIDATE_MEM_ALLOC(param, op_errno, out);
-    param_copy = param;
-
-    local->dict = dict_new();
-    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
-
-    local->dloc = GF_CALLOC(1, sizeof(loc_t), gf_bd_loc_t);
-    BD_VALIDATE_MEM_ALLOC(local->dloc, op_errno, out);
-
-    strncpy(param, local->data->data, local->data->len);
-    param[local->data->len] = '\0';
-
-    gfid = strtok_r(param, ":", &p);
-    size = strtok_r(NULL, ":", &p);
-    if (size)
-        gf_string2bytesize_uint64(size, &local->size);
-    else if (offload != BD_OF_CLONE)
-        local->size = bd_get_default_extent(this->private);
-
-    if (dict_set_int8(local->dict, BD_XATTR, 1) < 0) {
-        op_errno = EINVAL;
-        goto out;
-    }
-    if (dict_set_int8(local->dict, LINKTO, 1) < 0) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    gf_uuid_parse(gfid, local->dloc->gfid);
-    local->offload = offload;
-
-    STACK_WIND(frame, bd_offload_dest_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, local->dloc, local->dict);
-
-    if (param_copy)
-        GF_FREE(param_copy);
-    return 0;
-
-out:
-    if (fd)
-        BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL);
-    else
-        BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
-
-    GF_FREE(param_copy);
-    return 0;
-}
-
-/*
- * bd_setxattr: Used to create & map an LV to a posix file using
- * BD_XATTR xattr
- * bd_setxattr -> posix_stat -> bd_setx_stat_cbk -> posix_setxattr ->
- * bd_setx_setx_cbk -> create_lv
- * if create_lv failed, posix_removexattr -> bd_setx_rm_xattr_cbk
- */
-int
-bd_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-            int flags, dict_t *xdata)
-{
-    int op_errno = 0;
-    data_t *data = NULL;
-    bd_local_t *local = NULL;
-    bd_attr_t *bdatt = NULL;
-    bd_offload_t cl_type = BD_OF_NONE;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-
-    if ((data = dict_get(dict, BD_XATTR)))
-        cl_type = BD_OF_NONE;
-    else if ((data = dict_get(dict, BD_CLONE)))
-        cl_type = BD_OF_CLONE;
-    else if ((data = dict_get(dict, BD_SNAPSHOT)))
-        cl_type = BD_OF_SNAPSHOT;
-    else if ((data = dict_get(dict, BD_MERGE)))
-        cl_type = BD_OF_MERGE;
-
-    bd_inode_ctx_get(loc->inode, this, &bdatt);
-    if (!cl_type && !data) {
-        STACK_WIND(frame, default_setxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-    local->data = data;
-    loc_copy(&local->loc, loc);
-    local->inode = inode_ref(loc->inode);
-
-    if (cl_type) {
-        /* For cloning/snapshot, source file must be mapped to LV */
-        if (!bdatt) {
-            gf_log(this->name, GF_LOG_WARNING, "%s not mapped to BD",
-                   loc->path);
-            op_errno = EINVAL;
-            goto out;
-        }
-        if (cl_type == BD_OF_MERGE)
-            bd_do_merge(frame, this);
-        else
-            bd_offload(frame, this, loc, NULL, cl_type);
-    } else if (data) {
-        if (bdatt) {
-            gf_log(this->name, GF_LOG_WARNING, "%s already mapped to BD",
-                   loc->path);
-            op_errno = EEXIST;
-            goto out;
-        }
-        STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->stat, loc, xdata);
-    }
-
-    return 0;
-out:
-    if (op_errno)
-        STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata);
-
-    return 0;
-}
-
-/*
- * bd_fsetxattr: Used to create/map an LV to a posix file using
- * BD_XATTR xattr
- * bd_fsetxattr ->  posix_fstat -> bd_setx_stat_cbk -> posix_fsetxattr ->
- * bd_setx_setx_cbk -> create_lv
- * if create_lv failed, posix_removexattr -> bd_setx_rm_xattr_cbk
- * -> bd_fsetxattr_cbk
- */
-int32_t
-bd_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-             int flags, dict_t *xdata)
-{
-    int op_errno = 0;
-    data_t *data = NULL;
-    bd_attr_t *bdatt = NULL;
-    bd_local_t *local = NULL;
-    bd_offload_t cl_type = BD_OF_NONE;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(this->private, out);
-    VALIDATE_OR_GOTO(fd, out);
-
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-
-    if ((data = dict_get(dict, BD_XATTR)))
-        cl_type = BD_OF_NONE;
-    else if ((data = dict_get(dict, BD_CLONE)))
-        cl_type = BD_OF_CLONE;
-    else if ((data = dict_get(dict, BD_SNAPSHOT)))
-        cl_type = BD_OF_SNAPSHOT;
-    else if ((data = dict_get(dict, BD_MERGE))) {
-        /*
-         * bd_merge is not supported for fsetxattr, because snapshot LV
-         * is opened and it causes problem in snapshot merge
-         */
-        op_errno = EOPNOTSUPP;
-        goto out;
-    }
-
-    bd_inode_ctx_get(fd->inode, this, &bdatt);
-
-    if (!cl_type && !data) {
-        /* non bd file object */
-        STACK_WIND(frame, default_fsetxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-    local->inode = inode_ref(fd->inode);
-    local->fd = fd_ref(fd);
-    local->data = data;
-
-    if (cl_type) {
-        /* For cloning/snapshot, source file must be mapped to LV */
-        if (!bdatt) {
-            gf_log(this->name, GF_LOG_WARNING, "fd %p not mapped to BD", fd);
-            op_errno = EINVAL;
-            goto out;
-        }
-        bd_offload(frame, this, NULL, fd, cl_type);
-    } else if (data) {
-        if (bdatt) {
-            gf_log(this->name, GF_LOG_WARNING, "fd %p already mapped to BD",
-                   fd);
-            op_errno = EEXIST;
-            goto out;
-        }
-        STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fstat, fd, xdata);
-    }
-
-    return 0;
-out:
-
-    BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL);
-
-    return 0;
-}
-
-int32_t
-bd_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
-               const char *name, dict_t *xdata)
-{
-    if (!strcmp(name, BD_XATTR))
-        goto out;
-
-    STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
-    return 0;
-out:
-    BD_STACK_UNWIND(removexattr, frame, -1, ENODATA, NULL);
-    return 0;
-}
-
-int32_t
-bd_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
-                dict_t *xdata)
-{
-    if (!strcmp(name, BD_XATTR))
-        goto out;
-
-    STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
-
-    return 0;
-out:
-    BD_STACK_UNWIND(fremovexattr, frame, -1, ENODATA, NULL);
-    return 0;
-}
-
-int
-bd_trunc_setxattr_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-
-    if (local->fd)
-        BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL);
-    else
-        BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL);
-
-    return 0;
-}
-
-/*
- * Call back for setxattr after setting BD_XATTR_SIZE.
- */
-int
-bd_trunc_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno, dict_t *xdata)
-{
-    bd_local_t *local = frame->local;
-    bd_attr_t *bdatt = NULL;
-    struct iatt prebuf = {
-        0,
-    };
-    char *bd = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    bd_inode_ctx_get(local->inode, this, &bdatt);
-    if (!bdatt)
-        goto revert_xattr;
-
-    op_errno = bd_resize(this->private, local->inode->gfid,
-                         local->bdatt->iatt.ia_size);
-    if (op_errno)
-        goto revert_xattr;
-
-    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
-    /* LV resized, update new size in the cache */
-    bdatt->iatt.ia_size = local->bdatt->iatt.ia_size;
-
-    if (local->fd)
-        BD_STACK_UNWIND(ftruncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL);
-    else
-        BD_STACK_UNWIND(truncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL);
-
-    return 0;
-
-revert_xattr:
-    /* revert setxattr */
-    op_ret = dict_get_str(local->dict, BD_XATTR, &bd);
-    GF_FREE(bd);
-    bd = NULL;
-    if (bdatt)
-        gf_asprintf(&bd, "%s:%ld", bdatt->type, bdatt->iatt.ia_size);
-
-    if (local->fd)
-        STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
-                   0, NULL);
-    else
-        STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
-                   0, NULL);
-
-    if (bd)
-        GF_FREE(bd);
-    return 0;
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL);
-    else
-        BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL);
-
-    return 0;
-}
-
-/*
- * call back from posix_[f]truncate_stat
- * If offset > LV size, it resizes the LV and calls posix_setxattr
- * to update new LV size in xattr else calls posix_setattr for updating
- * the posix file so that truncate fop behaves properly
- */
-int
-bd_trunc_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-                  int op_errno, struct iatt *buf, dict_t *xdata)
-{
-    char *bd = NULL;
-    bd_local_t *local = frame->local;
-    bd_attr_t *bdatt = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    local->dict = dict_new();
-    BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out);
-
-    bd_inode_ctx_get(local->inode, this, &bdatt);
-    if (!bdatt) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    gf_asprintf(&bd, "%s:%ld", bdatt->type, local->bdatt->iatt.ia_size);
-    if (dict_set_dynstr(local->dict, BD_XATTR, bd)) {
-        op_errno = EINVAL;
-        goto out;
-    }
-
-    if (local->fd)
-        STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict,
-                   0, NULL);
-    else
-        STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict,
-                   0, NULL);
-
-    return 0;
-out:
-    if (local->fd)
-        BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
-    else
-        BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
-    GF_FREE(bd);
-    return 0;
-}
-
-void
-bd_do_trunc(call_frame_t *frame, xlator_t *this, fd_t *fd, loc_t *loc,
-            off_t offset, bd_attr_t *bdatt)
-{
-    bd_local_t *local = NULL;
-    struct iatt prebuf = {
-        0,
-    };
-    int op_errno = 0;
-    int op_ret = -1;
-
-    /* If requested size is less than LV size, return success */
-    if (offset <= bdatt->iatt.ia_size) {
-        memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
-        bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
-        op_ret = 0;
-        goto out;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-    local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr);
-    BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out);
-
-    if (fd) {
-        local->inode = inode_ref(fd->inode);
-        local->fd = fd_ref(fd);
-    } else {
-        local->inode = inode_ref(loc->inode);
-        loc_copy(&local->loc, loc);
-    }
-
-    local->bdatt->iatt.ia_size = bd_adjust_size(this->private, offset);
-
-    STACK_WIND(frame, bd_trunc_stat_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->fstat, fd, NULL);
-
-    return;
-
-out:
-    if (fd)
-        BD_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, &prebuf,
-                        &bdatt->iatt, NULL);
-    else
-        BD_STACK_UNWIND(truncate, frame, op_ret, op_errno, &prebuf,
-                        &bdatt->iatt, NULL);
-    return;
-}
-
-/*
- * bd_ftruncate: Resizes a LV if fd belongs to BD.
- */
-int32_t
-bd_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             dict_t *xdata)
-{
-    int op_errno = 0;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-
-    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
-        STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
-        return 0;
-    }
-
-    bd_do_trunc(frame, this, fd, NULL, offset, bdatt);
-    return 0;
-out:
-    BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-/*
- * bd_truncate: Resizes a LV if file maps to LV.
- */
-int32_t
-bd_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
-            dict_t *xdata)
-{
-    int op_errno = 0;
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(loc, out);
-
-    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
-        STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
-        return 0;
-    }
-
-    bd_do_trunc(frame, this, NULL, loc, offset, bdatt);
-    return 0;
-
-out:
-    BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-__bd_pwritev(int fd, struct iovec *vector, int count, off_t offset,
-             uint64_t bd_size)
-{
-    int index = 0;
-    int retval = 0;
-
-    if (!vector)
-        return -EFAULT;
-
-    retval = sys_pwritev(fd, vector, count, offset);
-    if (retval == -1) {
-        int64_t off = offset;
-        gf_log(THIS->name, GF_LOG_WARNING,
-               "base %p, length %zd, offset %" PRId64 ", message %s",
-               vector[index].iov_base, vector[index].iov_len, off,
-               strerror(errno));
-        retval = -errno;
-        goto err;
-    }
-/*
-
-
-        internal_offset = offset;
-        for (index = 0; index < count; index++) {
-                if (internal_offset > bd_size) {
-                        op_ret = -ENOSPC;
-                        goto err;
-                }
-                if (internal_offset + vector[index].iov_len > bd_size) {
-                        vector[index].iov_len = bd_size - internal_offset;
-                        no_space = 1;
-                }
-                retval = sys_pwritev (fd, vector[index].iov_base,
-                                      vector[index].iov_len, internal_offset);
-                if (retval == -1) {
-                        gf_log (THIS->name, GF_LOG_WARNING,
-                                "base %p, length %ld, offset %ld, message %s",
-                                vector[index].iov_base, vector[index].iov_len,
-                                internal_offset, strerror (errno));
-                        op_ret = -errno;
-                        goto err;
-                }
-                op_ret += retval;
-                internal_offset += retval;
-                if (no_space)
-                        break;
-        }
-*/
-err:
-    return retval;
-}
-
-/*
- * bd_writev: Writes to LV if its BD file or forwards the request to posix_write
- * bd_writev -> posix_writev -> bd_writev_cbk
- */
-int
-bd_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-          int32_t count, off_t offset, uint32_t flags, struct iobref *iobref,
-          dict_t *xdict)
-{
-    int32_t op_ret = -1;
-    int32_t op_errno = 0;
-    int _fd = -1;
-    bd_fd_t *bd_fd = NULL;
-    int ret = -1;
-    uint64_t size = 0;
-    struct iatt prebuf = {
-        0,
-    };
-    bd_attr_t *bdatt = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-    VALIDATE_OR_GOTO(vector, out);
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) { /* posix fd */
-        STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
-                   flags, iobref, xdict);
-        return 0;
-    }
-
-    _fd = bd_fd->fd;
-
-    if (bd_inode_ctx_get(fd->inode, this, &bdatt)) {
-        op_ret = -1;
-        op_errno = EINVAL;
-        goto out;
-    }
-    size = bdatt->iatt.ia_size;
-
-    op_ret = __bd_pwritev(_fd, vector, count, offset, size);
-    if (op_ret < 0) {
-        op_errno = -op_ret;
-        op_ret = -1;
-        gf_log(this->name, GF_LOG_ERROR, "write failed: offset %" PRIu64 ", %s",
-               offset, strerror(op_errno));
-        goto out;
-    }
-
-    memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt));
-    bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME);
-out:
-
-    BD_STACK_UNWIND(writev, frame, op_ret, op_errno, &prebuf, &bdatt->iatt,
-                    NULL);
-    return 0;
-}
-
-int
-bd_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-               int op_errno, struct iatt *prebuf, struct iatt *postbuf,
-               dict_t *xdata)
-{
-    bd_attr_t *bdatt = NULL;
-    int *valid = cookie;
-    bd_local_t *local = frame->local;
-
-    if (op_ret < 0 || !valid || !local)
-        goto out;
-
-    if (bd_inode_ctx_get(local->inode, this, &bdatt))
-        goto out;
-
-    if (*valid & GF_SET_ATTR_UID)
-        bdatt->iatt.ia_uid = postbuf->ia_uid;
-    else if (*valid & GF_SET_ATTR_GID)
-        bdatt->iatt.ia_gid = postbuf->ia_gid;
-    else if (*valid & GF_SET_ATTR_MODE) {
-        bdatt->iatt.ia_type = postbuf->ia_type;
-        bdatt->iatt.ia_prot = postbuf->ia_prot;
-    } else if (*valid & GF_SET_ATTR_ATIME) {
-        bdatt->iatt.ia_atime = postbuf->ia_atime;
-        bdatt->iatt.ia_atime_nsec = postbuf->ia_atime_nsec;
-    } else if (*valid & GF_SET_ATTR_MTIME) {
-        bdatt->iatt.ia_mtime = postbuf->ia_mtime;
-        bdatt->iatt.ia_mtime_nsec = postbuf->ia_mtime_nsec;
-    }
-
-    bdatt->iatt.ia_ctime = postbuf->ia_ctime;
-    bdatt->iatt.ia_ctime_nsec = postbuf->ia_ctime_nsec;
-
-    memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt));
-out:
-    GF_FREE(valid);
-    BD_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata);
-    return 0;
-}
-
-int
-bd_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf,
-           int32_t valid, dict_t *xdata)
-{
-    bd_local_t *local = NULL;
-    bd_attr_t *bdatt = NULL;
-    int *ck_valid = NULL;
-
-    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
-        STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    if (!local) {
-        gf_log(this->name, GF_LOG_ERROR, "out of memory");
-        goto out;
-    }
-
-    ck_valid = GF_CALLOC(1, sizeof(valid), gf_bd_int32_t);
-    if (!ck_valid) {
-        gf_log(this->name, GF_LOG_ERROR, "out of memory");
-        goto out;
-    }
-
-    local->inode = inode_ref(loc->inode);
-    *ck_valid = valid;
-
-    STACK_WIND_COOKIE(frame, bd_setattr_cbk, ck_valid, FIRST_CHILD(this),
-                      FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid,
-                      xdata);
-    GF_FREE(ck_valid);
-    return 0;
-out:
-    BD_STACK_UNWIND(setattr, frame, -1, ENOMEM, NULL, NULL, xdata);
-    return 0;
-}
-
-int
-bd_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
-            int op_errno, inode_t *inode, struct iatt *buf,
-            struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
-{
-    bd_attr_t *bdatt = NULL;
-
-    if (op_ret < 0)
-        goto out;
-
-    if (bd_inode_ctx_get(inode, this, &bdatt))
-        goto out;
-
-    bdatt->iatt.ia_ctime = buf->ia_ctime;
-    bdatt->iatt.ia_ctime_nsec = buf->ia_ctime_nsec;
-    bdatt->iatt.ia_nlink = buf->ia_nlink;
-    memcpy(buf, &bdatt->iatt, sizeof(struct iatt));
-
-out:
-    BD_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent,
-                    postparent, NULL);
-    return 0;
-}
-
-int
-bd_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
-        dict_t *xdata)
-{
-    STACK_WIND(frame, bd_link_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
-    return 0;
-}
-
-int
-bd_handle_special_xattrs(call_frame_t *frame, xlator_t *this, loc_t *loc,
-                         fd_t *fd, const char *name, dict_t *xdata)
-{
-    dict_t *xattr = NULL;
-    int op_ret = -1;
-    int op_errno = ENOMEM;
-    ;
-    bd_priv_t *priv = this->private;
-
-    xattr = dict_new();
-    if (!xattr)
-        goto out;
-
-    if (!strcmp(name, VOL_TYPE))
-        op_ret = dict_set_int64(xattr, (char *)name, 1);
-    else if (!strcmp(name, VOL_CAPS))
-        op_ret = dict_set_int64(xattr, (char *)name, priv->caps);
-    else
-        op_ret = bd_get_origin(this->private, loc, fd, xattr);
-
-out:
-    if (loc)
-        BD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata);
-    else
-        BD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata);
-
-    op_ret = dict_reset(xattr);
-    dict_unref(xattr);
-
-    return 0;
-}
-
-int
-bd_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
-             dict_t *xdata)
-{
-    if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) ||
-                 !strcmp(name, BD_ORIGIN)))
-        bd_handle_special_xattrs(frame, this, NULL, fd, name, xdata);
-    else
-        STACK_WIND(frame, default_fgetxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
-    return 0;
-}
-
-int
-bd_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name,
-            dict_t *xdata)
-{
-    if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) ||
-                 !strcmp(name, BD_ORIGIN)))
-        bd_handle_special_xattrs(frame, this, loc, NULL, name, xdata);
-    else
-        STACK_WIND(frame, default_getxattr_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
-
-    return 0;
-}
-
-int
-bd_unlink_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-                     dict_t *xattr, struct iatt *postparent)
-{
-    bd_gfid_t gfid = {
-        0,
-    };
-    bd_local_t *local = frame->local;
-
-    if (buf->ia_nlink > 1)
-        goto posix;
-
-    BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out);
-
-    uuid_utoa_r(inode->gfid, gfid);
-    if (bd_delete_lv(this->private, gfid, &op_errno) < 0) {
-        if (op_errno != ENOENT)
-            goto out;
-    }
-
-posix:
-    /* remove posix */
-    STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL);
-
-    return 0;
-out:
-    BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int
-bd_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
-          dict_t *xdata)
-{
-    int op_errno = 0;
-    bd_attr_t *bdatt = NULL;
-    bd_local_t *local = NULL;
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(loc, out);
-
-    if (bd_inode_ctx_get(loc->inode, this, &bdatt)) {
-        STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
-        return 0;
-    }
-
-    local = bd_local_init(frame, this);
-    BD_VALIDATE_MEM_ALLOC(local, op_errno, out);
-
-    loc_copy(&local->loc, loc);
-
-    STACK_WIND(frame, bd_unlink_lookup_cbk, FIRST_CHILD(this),
-               FIRST_CHILD(this)->fops->lookup, loc, NULL);
-    return 0;
-out:
-    BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL);
-    return 0;
-}
-
-int32_t
-bd_priv(xlator_t *this)
-{
-    return 0;
-}
-
-int32_t
-bd_inode(xlator_t *this)
-{
-    return 0;
-}
-
-int32_t
-bd_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-             int32_t len, dict_t *xdata)
-{
-    int op_ret = -1;
-    int op_errno = 0;
-    int ret = 0;
-    int _fd = -1;
-    char *alloc_buf = NULL;
-    char *buf = NULL;
-    int32_t weak_checksum = 0;
-    bd_fd_t *bd_fd = NULL;
-    unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0};
-
-    VALIDATE_OR_GOTO(frame, out);
-    VALIDATE_OR_GOTO(this, out);
-    VALIDATE_OR_GOTO(fd, out);
-
-    ret = bd_fd_ctx_get(this, fd, &bd_fd);
-    if (ret < 0 || !bd_fd) {
-        STACK_WIND(frame, default_rchecksum_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata);
-        return 0;
-    }
-
-    alloc_buf = page_aligned_alloc(len, &buf);
-    if (!alloc_buf) {
-        op_errno = ENOMEM;
-        goto out;
-    }
-
-    _fd = bd_fd->fd;
-
-    LOCK(&fd->lock);
-    {
-        ret = sys_pread(_fd, buf, len, offset);
-        if (ret < 0) {
-            gf_log(this->name, GF_LOG_WARNING,
-                   "pread of %d bytes returned %d (%s)", len, ret,
-                   strerror(errno));
-            op_errno = errno;
-        }
-    }
-    UNLOCK(&fd->lock);
-
-    if (ret < 0)
-        goto out;
-
-    weak_checksum = gf_rsync_weak_checksum((unsigned char *)buf, (size_t)len);
-    gf_rsync_strong_checksum((unsigned char *)buf, (size_t)len,
-                             (unsigned char *)strong_checksum);
-
-    op_ret = 0;
-out:
-    BD_STACK_UNWIND(rchecksum, frame, op_ret, op_errno, weak_checksum,
-                    strong_checksum, NULL);
-
-    GF_FREE(alloc_buf);
-
-    return 0;
-}
-
-static int
-bd_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-            off_t len, dict_t *xdata)
-{
-    int32_t ret = 0;
-    struct iatt statpre = {
-        0,
-    };
-    struct iatt statpost = {
-        0,
-    };
-    bd_attr_t *bdatt = NULL;
-
-    /* iatt already cached */
-    if (bd_inode_ctx_get(fd->inode, this, &bdatt) < 0) {
-        STACK_WIND(frame, default_zerofill_cbk, FIRST_CHILD(this),
-                   FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata);
-        return 0;
-    }
-
-    ret = bd_do_zerofill(frame, this, fd, offset, len, &statpre, &statpost);
-    if (ret)
-        goto err;
-
-    STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL);
-    return 0;
-
-err:
-    STACK_UNWIND_STRICT(zerofill, frame, -1, (ret == -1 ? 0 : ret), NULL, NULL,
-                        NULL);
-    return 0;
-}
-
-/**
- * notify - when parent sends PARENT_UP, send CHILD_UP event from here
- */
-int32_t
-notify(xlator_t *this, int32_t event, void *data, ...)
-{
-    switch (event) {
-        case GF_EVENT_PARENT_UP: {
-            /* Tell the parent that bd xlator is up */
-            default_notify(this, GF_EVENT_CHILD_UP, data);
-        } break;
-        default:
-            break;
-    }
-    return 0;
-}
-
-int32_t
-mem_acct_init(xlator_t *this)
-{
-    int ret = -1;
-
-    if (!this)
-        return ret;
-
-    ret = xlator_mem_acct_init(this, gf_bd_mt_end + 1);
-
-    if (ret != 0)
-        gf_log(this->name, GF_LOG_ERROR,
-               "Memory accounting init"
-               "failed");
-
-    return ret;
-}
-
-int
-reconfigure(xlator_t *this, dict_t *options)
-{
-    int ret = -1;
-    bd_priv_t *priv = this->private;
-
-    GF_OPTION_RECONF("bd-aio", priv->aio_configured, options, bool, out);
-
-    if (priv->aio_configured)
-        bd_aio_on(this);
-    else
-        bd_aio_off(this);
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/**
- * bd xlator init - Validate configured VG
- */
-int
-init(xlator_t *this)
-{
-    char *vg_data = NULL;
-    char *device = NULL;
-    bd_priv_t *_private = NULL;
-
-    if (!this->children) {
-        gf_log(this->name, GF_LOG_CRITICAL,
-               "FATAL: storage/bd needs posix as subvolume");
-        return -1;
-    }
-
-    if (!this->parents) {
-        gf_log(this->name, GF_LOG_WARNING,
-               "Volume is dangling. Please check the volume file.");
-    }
-
-    GF_OPTION_INIT("export", vg_data, str, error);
-    GF_OPTION_INIT("device", device, str, error);
-
-    /* Now we support only LV device */
-    if (strcasecmp(device, BACKEND_VG)) {
-        gf_log(this->name, GF_LOG_CRITICAL, "FATAL: unknown %s backend %s",
-               BD_XLATOR, device);
-        return -1;
-    }
-
-    this->local_pool = mem_pool_new(bd_local_t, 64);
-    if (!this->local_pool) {
-        gf_log(this->name, GF_LOG_CRITICAL,
-               "FATAL: Failed to create bd memory pool");
-        return -1;
-    }
-
-    _private = GF_CALLOC(1, sizeof(*_private), gf_bd_private);
-    if (!_private)
-        goto error;
-
-    this->private = _private;
-    _private->vg = gf_strdup(vg_data);
-    if (!_private->vg)
-        goto error;
-
-    _private->handle = lvm_init(NULL);
-    if (!_private->handle) {
-        gf_log(this->name, GF_LOG_CRITICAL, "lvm_init failed");
-        goto error;
-    }
-    _private->caps = BD_CAPS_BD;
-    if (bd_scan_vg(this, _private))
-        goto error;
-
-    _private->aio_init_done = _gf_false;
-    _private->aio_capable = _gf_false;
-
-    GF_OPTION_INIT("bd-aio", _private->aio_configured, bool, error);
-    if (_private->aio_configured) {
-        if (bd_aio_on(this)) {
-            gf_log(this->name, GF_LOG_ERROR, "BD AIO init failed");
-            goto error;
-        }
-    }
-
-    _private->caps |= BD_CAPS_OFFLOAD_COPY | BD_CAPS_OFFLOAD_SNAPSHOT |
-                      BD_CAPS_OFFLOAD_ZERO;
-
-    return 0;
-error:
-    if (_private) {
-        GF_FREE(_private->vg);
-        if (_private->handle)
-            lvm_quit(_private->handle);
-        GF_FREE(_private);
-    }
-
-    mem_pool_destroy(this->local_pool);
-
-    return -1;
-}
-
-void
-fini(xlator_t *this)
-{
-    bd_priv_t *priv = this->private;
-    mem_pool_destroy(this->local_pool);
-    this->local_pool = NULL;
-    if (!priv)
-        return;
-    lvm_quit(priv->handle);
-    GF_FREE(priv->vg);
-    this->private = NULL;
-    GF_FREE(priv);
-    return;
-}
-
-struct xlator_dumpops dumpops = {
-    .priv = bd_priv,
-    .inode = bd_inode,
-};
-
-struct xlator_fops fops = {
-    .readdirp = bd_readdirp,
-    .lookup = bd_lookup,
-    .stat = bd_stat,
-    .statfs = bd_statfs,
-    .open = bd_open,
-    .fstat = bd_fstat,
-    .rchecksum = bd_rchecksum,
-    .readv = bd_readv,
-    .fsync = bd_fsync,
-    .setxattr = bd_setxattr,
-    .fsetxattr = bd_fsetxattr,
-    .removexattr = bd_removexattr,
-    .fremovexattr = bd_fremovexattr,
-    .truncate = bd_truncate,
-    .ftruncate = bd_ftruncate,
-    .writev = bd_writev,
-    .getxattr = bd_getxattr,
-    .fgetxattr = bd_fgetxattr,
-    .unlink = bd_unlink,
-    .link = bd_link,
-    .flush = bd_flush,
-    .setattr = bd_setattr,
-    .discard = bd_discard,
-    .zerofill = bd_zerofill,
-};
-
-struct xlator_cbks cbks = {
-    .release = bd_release,
-    .forget = bd_forget,
-};
-
-struct volume_options options[] = {
-    {.key = {"export"}, .type = GF_OPTION_TYPE_STR},
-    {.key = {"device"},
-     .type = GF_OPTION_TYPE_STR,
-     .default_value = BACKEND_VG},
-    {.key = {"bd-aio"},
-     .type = GF_OPTION_TYPE_BOOL,
-     .default_value = "off",
-     .description = "Support for native Linux AIO"},
-
-    {.key = {NULL}}};
diff --git a/xlators/storage/bd/src/bd.h b/xlators/storage/bd/src/bd.h
deleted file mode 100644
index f73781a0fe6..00000000000
--- a/xlators/storage/bd/src/bd.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
-  BD translator - Exports Block devices on server side as regular
-  files to client
-
-  Copyright IBM, Corp. 2012
-
-  This file is part of GlusterFS.
-
-  Author:
-  M. Mohan Kumar <mohan@in.ibm.com>
-
-  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 _BD_H
-#define _BD_H
-
-#ifdef HAVE_LIBAIO
-#include <libaio.h>
-#endif
-
-#include <glusterfs/xlator.h>
-#include <glusterfs/mem-types.h>
-
-#define BD_XLATOR "block device mapper xlator"
-#define BACKEND_VG "vg"
-#define GF_XATTR "user.glusterfs"
-#define BD_XATTR GF_XATTR ".bd"
-
-#define BD_LV "lv"
-#define BD_THIN "thin"
-
-#define VOL_TYPE "volume.type"
-#define VOL_CAPS "volume.caps"
-
-#define ALIGN_SIZE 4096
-
-#define BD_CAPS_BD 0x01
-#define BD_CAPS_THIN 0x02
-#define BD_CAPS_OFFLOAD_COPY 0x04
-#define BD_CAPS_OFFLOAD_SNAPSHOT 0x08
-#define BD_CAPS_OFFLOAD_ZERO 0x20
-
-#define BD_CLONE "clone"
-#define BD_SNAPSHOT "snapshot"
-#define BD_MERGE "merge"
-#define BD_ORIGIN "list-origin"
-
-#define IOV_NR 4
-#define IOV_SIZE (64 * 1024)
-
-#define ALIGN_SIZE 4096
-#define LINKTO "trusted.glusterfs.dht.linkto"
-
-#define MAX_NO_VECT 1024
-
-#define BD_VALIDATE_MEM_ALLOC(buff, op_errno, label)                           \
-    if (!buff) {                                                               \
-        op_errno = ENOMEM;                                                     \
-        gf_log(this->name, GF_LOG_ERROR, "out of memory");                     \
-        goto label;                                                            \
-    }
-
-#define BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, label)                      \
-    if (!local) {                                                              \
-        op_errno = EINVAL;                                                     \
-        goto label;                                                            \
-    }
-
-#define BD_STACK_UNWIND(typ, frame, args...)                                   \
-    do {                                                                       \
-        bd_local_t *__local = frame->local;                                    \
-        xlator_t *__this = frame->this;                                        \
-                                                                               \
-        frame->local = NULL;                                                   \
-        STACK_UNWIND_STRICT(typ, frame, args);                                 \
-        if (__local)                                                           \
-            bd_local_free(__this, __local);                                    \
-    } while (0)
-
-typedef char bd_gfid_t[GF_UUID_BUF_SIZE];
-
-/**
- * bd_fd - internal structure
- */
-typedef struct bd_fd {
-    int fd;
-    int32_t flag;
-    int odirect;
-} bd_fd_t;
-
-typedef struct bd_priv {
-    lvm_t handle;
-    char *vg;
-    char *pool;
-    int caps;
-    gf_boolean_t aio_init_done;
-    gf_boolean_t aio_capable;
-    gf_boolean_t aio_configured;
-#ifdef HAVE_LIBAIO
-    io_context_t ctxp;
-    pthread_t aiothread;
-#endif
-} bd_priv_t;
-
-typedef enum bd_type {
-    BD_TYPE_NONE,
-    BD_TYPE_LV,
-} bd_type_t;
-
-typedef struct {
-    struct iatt iatt;
-    char *type;
-} bd_attr_t;
-
-typedef enum {
-    BD_OF_NONE,
-    BD_OF_CLONE,
-    BD_OF_SNAPSHOT,
-    BD_OF_MERGE,
-} bd_offload_t;
-
-typedef struct {
-    dict_t *dict;
-    bd_attr_t *bdatt;
-    inode_t *inode;
-    loc_t loc;
-    fd_t *fd;
-    data_t *data; /* for setxattr */
-    bd_offload_t offload;
-    uint64_t size;
-    loc_t *dloc;
-} bd_local_t;
-
-/* Prototypes */
-int
-bd_inode_ctx_set(inode_t *inode, xlator_t *this, bd_attr_t *ctx);
-int
-bd_inode_ctx_get(inode_t *inode, xlator_t *this, bd_attr_t **ctx);
-int
-bd_scan_vg(xlator_t *this, bd_priv_t *priv);
-bd_local_t *
-bd_local_init(call_frame_t *frame, xlator_t *this);
-void
-bd_local_free(xlator_t *this, bd_local_t *local);
-int
-bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd);
-char *
-page_aligned_alloc(size_t size, char **aligned_buf);
-int
-bd_validate_bd_xattr(xlator_t *this, char *bd, char **type, uint64_t *lv_size,
-                     uuid_t uuid);
-uint64_t
-bd_get_default_extent(bd_priv_t *priv);
-uint64_t
-bd_adjust_size(bd_priv_t *priv, size_t size);
-int
-bd_create(uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv);
-int
-bd_resize(bd_priv_t *priv, uuid_t uuid, size_t size);
-int
-bd_delete_lv(bd_priv_t *priv, const char *lv_name, int *op_errno);
-int
-bd_snapshot_create(bd_local_t *local, bd_priv_t *priv);
-int
-bd_clone(bd_local_t *local, bd_priv_t *priv);
-
-int
-bd_merge(bd_priv_t *priv, uuid_t gfid);
-int
-bd_get_origin(bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict);
-void
-bd_update_amtime(struct iatt *iatt, int flag);
-int
-bd_snapshot_create(bd_local_t *local, bd_priv_t *priv);
-int
-bd_clone(bd_local_t *local, bd_priv_t *priv);
-int
-bd_merge(bd_priv_t *priv, uuid_t gfid);
-int
-bd_get_origin(bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict);
-int
-bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
-               size_t len, struct iatt *prebuf, struct iatt *postbuf);
-
-#endif