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>

10 files changed, 0 insertions, 4067 deletions

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