diff options
Diffstat (limited to 'xlators/features/changetimerecorder')
9 files changed, 0 insertions, 3291 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 630dd8e6e15..00000000000 --- a/xlators/features/changetimerecorder/src/Makefile.am +++ /dev/null @@ -1,23 +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 -avoid-version - -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 = 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 \ - -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 7fd62584752..00000000000 --- a/xlators/features/changetimerecorder/src/changetimerecorder.c +++ /dev/null @@ -1,1691 +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" - -/*******************************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 dont 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 dont track afr-self-heal/dht-rebalancer traffic for healing. - -*/ - - -/* This function doesnot write anything to the db, - * just created the local variable - * for the frame and sets values for the ctr_db_record */ -static inline 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; - ctr_local->client_pid = frame->root->pid; - /*Definately no internal fops will reach here*/ - ctr_local->is_internal_fop = _gf_false; - /*Dont 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)); - strcpy (CTR_DB_REC(ctr_local).file_name, - NEW_LINK_CX(ctr_inode_cx)->basename); - strcpy (CTR_DB_REC(ctr_local).file_path, - NEW_LINK_CX(ctr_inode_cx)->basepath); - - /* 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 dont 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 inline 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); - CTR_IF_INTERNAL_FOP_THEN_GOTO (frame, dict, out); - - /* if the lookup failed lookup dont 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 dont 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); - - /* Dont handle nameless lookups*/ - if (!loc->parent) - goto out; - - /*fill ctr link context*/ - FILL_CTR_LINK_CX(_link_cx, loc->parent->gfid, loc->name, - loc->path, 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 inserting 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); - - 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 inserting writev unwind"); - } - - -out: - 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 inserting 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); - - 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 inserting setattr unwind"); - } - -out: - 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); - - /*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 inserting setattr wind"); - } -out: - - STACK_WIND (frame, ctr_setattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, loc, 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); - - - 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 inserting fremovexattr unwind"); - } - -out: - 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); - - - /*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 inserting 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_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 inserting removexattr unwind"); - } - -out: - 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); - - - /*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 inserting 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); - - - 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 inserting truncate unwind"); - } - - -out: - 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 inserting 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); - - 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 inserting ftruncate unwind"); - } - -out: - 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 inserting 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; - - CTR_IS_DISABLED_THEN_GOTO(this, 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 inserting rename unwind"); - } - -out: - 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; - - 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, - oldloc->path, out); - - /*Fill new link context*/ - FILL_CTR_LINK_CX(_nlink_cx, newloc->pargfid, newloc->name, - newloc->path, 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); - - /*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 inserting rename wind"); - } else { - /* We are doing updation of hard link in inode context in wind - * As we dont 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"); - } - } - -out: - STACK_WIND (frame, ctr_rename_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->rename, - oldloc, newloc, 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); - - if (!xdata) - goto out; - - /* - * - * Extracting CTR_RESPONSE_LINK_COUNT_XDATA from POSIX Xlator - * - * */ - ret = dict_get_uint32 (xdata , CTR_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 CTR_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 inserting 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 inserting unlink unwind"); - } - } - -out: - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, preparent, - postparent, NULL); - - 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, loc->path, 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 = CTR_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, _inode_cx); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - CTR_MSG_INSERT_UNLINK_UNWIND_FAILED, - "Failed inserting unlink wind"); - } else { - /* We are doing delete of hard link in inode context in wind - * As we dont 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 CTR_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 " - "CTR_REQUEST_LINK_COUNT_XDATA to posix"); - goto out; - } - - ret = dict_set_int32 (xdata, CTR_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 CTR_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); - - 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 inserting fsync unwind"); - } - -out: - 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 inserting 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 inserting fsync unwind"); - } - - -out: - 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); - - /*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 inserting setxattr wind"); - } - -out: - STACK_WIND (frame, ctr_setxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setxattr, - loc, xattr, 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); - - /* 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 inserting mknod unwind"); - } - -out: - 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; - void *uuid_req = NULL; - 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_ptr (xdata, "gfid-req", &uuid_req); - if (ret) { - gf_msg_debug (this->name, 0, "failed to get gfid from dict"); - goto out; - } - gf_uuid_copy (gfid, uuid_req); - - /*fill ctr link context*/ - FILL_CTR_LINK_CX (_link_cx, loc->pargfid, loc->name, loc->path, 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 inserting 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); - - - 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 inserting create unwind"); - } - -out: - 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; - void *uuid_req = NULL; - 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_ptr (xdata, "gfid-req", &uuid_req); - 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; - } - gf_uuid_copy (gfid, uuid_req); - - /*fill ctr link context*/ - FILL_CTR_LINK_CX(_link_cx, loc->pargfid, loc->name, loc->path, 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 = CTR_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 inserting 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); - - /* 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 inserting create unwind"); - } - -out: - 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, - newloc->path, 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 = CTR_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, _inode_cx); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - CTR_MSG_INSERT_LINK_WIND_FAILED, - "Failed inserting 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); - - 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 inserting create unwind"); - } - -out: - 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 inserting readv wind"); - } - -out: - STACK_WIND (frame, ctr_readv_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->readv, - fd, size, off, flags, xdata); - return 0; -} -/******************************************************************************/ - -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_INFO, 0, CTR_MSG_SET, "set!"); - } - - GF_OPTION_RECONF ("ctr-enabled", _priv->enabled, options, - bool, out); - - GF_OPTION_RECONF ("record-counters", _priv->ctr_record_counter, options, - bool, out); - - GF_OPTION_RECONF ("ctr_link_consistency", _priv->ctr_link_consistency, - options, bool, out); - - GF_OPTION_RECONF ("ctr_inode_heal_expire_period", - _priv->ctr_inode_heal_expire_period, - options, uint64, out); - - GF_OPTION_RECONF ("ctr_hardlink_heal_expire_period", - _priv->ctr_hardlink_heal_expire_period, - 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); - -out: - - return ret; -} - -/****************************init********************************************/ - -int32_t -init (xlator_t *this) -{ - gf_ctr_private_t *_priv = NULL; - int ret_db = -1; - dict_t *params_dict = NULL; - - GF_VALIDATE_OR_GOTO ("ctr", this, error); - - 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"); - goto error; - } - - 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 didnt work!!!"); - goto error; - } - - /*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->enabled = _gf_true; - _priv->_db_conn = NULL; - _priv->ctr_hardlink_heal_expire_period = - CTR_DEFAULT_HARDLINK_EXP_PERIOD; - _priv->ctr_inode_heal_expire_period = - 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"); - 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 handling */ -error: - - if (this) - mem_pool_destroy (this->local_pool); - - if (_priv) { - GF_FREE (_priv->ctr_db_path); - } - GF_FREE (_priv); - - if (params_dict) - dict_unref (params_dict); - - return -1; - -out: - - if (params_dict) - dict_unref (params_dict); - - this->private = (void *)_priv; - return 0; -} - -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) { - if (fini_db (priv->_db_conn)) { - gf_msg (this->name, GF_LOG_WARNING, 0, - CTR_MSG_CLOSE_DB_CONN_FAILED, "Failed closing " - "db connection"); - } - GF_FREE (priv->ctr_db_path); - } - GF_FREE (priv); - mem_pool_destroy (this->local_pool); - - 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, - .removexattr = ctr_removexattr, - .unlink = ctr_unlink, - .link = ctr_link, - .rename = ctr_rename, - .writev = ctr_writev, - .setattr = ctr_setattr, - /*read fops*/ - .readv = ctr_readv -}; - -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" - }, - { .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" - }, - { .key = {"ctr_link_consistency"}, - .type = GF_OPTION_TYPE_BOOL, - .value = {"on", "off"}, - .default_value = "off" - }, - { .key = {"ctr_hardlink_heal_expire_period"}, - .type = GF_OPTION_TYPE_INT, - .default_value = "300" - }, - { .key = {"ctr_inode_heal_expire_period"}, - .type = GF_OPTION_TYPE_INT, - .default_value = "300" - }, - { .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" - }, - { .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" - }, - { .key = {GFDB_SQL_PARAM_AUTO_VACUUM}, - .type = GF_OPTION_TYPE_STR, - .value = {"off", "full", "incr"}, - .default_value = "off" - }, - { .key = {GFDB_SQL_PARAM_WAL_AUTOCHECK}, - .type = GF_OPTION_TYPE_INT, - .default_value = "1000" - }, - { .key = {GFDB_SQL_PARAM_CACHE_SIZE}, - .type = GF_OPTION_TYPE_INT, - .default_value = "1000" - }, - { .key = {GFDB_SQL_PARAM_PAGE_SIZE}, - .type = GF_OPTION_TYPE_INT, - .default_value = "4096" - }, - { .key = {NULL} }, -}; diff --git a/xlators/features/changetimerecorder/src/changetimerecorder.h b/xlators/features/changetimerecorder/src/changetimerecorder.h deleted file mode 100644 index 2a8bbd18c5b..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.h" -#include "xlator.h" -#include "logging.h" -#include "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 047abd9f032..00000000000 --- a/xlators/features/changetimerecorder/src/ctr-helper.c +++ /dev/null @@ -1,300 +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)); - - /*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); - strcpy (CTR_DB_REC(ctr_local).file_path, - NEW_LINK_CX(ctr_inode_cx)->basepath); - } - /*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); - strcpy (CTR_DB_REC(ctr_local).old_path, - OLD_LINK_CX(ctr_inode_cx)->basepath); - } - } - - 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); - - /*Extact 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: - ret = -1; - break; - } - 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 link consistency*/ - GF_OPTION_INIT ("ctr_link_consistency", _priv->ctr_link_consistency, - bool, out); - - /*Extract ctr_inode_heal_expire_period */ - GF_OPTION_INIT ("ctr_inode_heal_expire_period", - _priv->ctr_inode_heal_expire_period, - uint64, out); - - /*Extract ctr_hardlink_heal_expire_period*/ - GF_OPTION_INIT ("ctr_hardlink_heal_expire_period", - _priv->ctr_hardlink_heal_expire_period, - 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 0c4f3e2cd8c..00000000000 --- a/xlators/features/changetimerecorder/src/ctr-helper.h +++ /dev/null @@ -1,730 +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 "xlator.h" -#include "ctr_mem_types.h" -#include "iatt.h" -#include "glusterfs.h" -#include "xlator.h" -#include "logging.h" -#include "common-utils.h" -#include <time.h> -#include <sys/time.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 */ - -/*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_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_hardlink_heal_expire_period; - uint64_t ctr_inode_heal_expire_period; -} 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 dont record change/acces 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_client_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, PATH_MAX);\ - memset(ctr_local->gfdb_db_record.old_file_name, 0, PATH_MAX);\ - 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 relavent 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; - /*basepath is redundent. Will go off*/ - const char *basepath; -} gf_ctr_link_context_t; - - /*Context Carrier Structure for inodes*/ -typedef struct gf_ctr_inode_context { - ia_type_t ia_type; - uuid_t *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; -} 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);\ - GF_ASSERT (ctr_link_cx->basepath);\ - };\ -} while (0) - -/*Clear and fill the ctr_link_context with values*/ -#define FILL_CTR_LINK_CX(ctr_link_cx, _pargfid, _basename, _basepath, 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);\ - GF_VALIDATE_OR_GOTO ("ctr", _basepath, label);\ - memset (ctr_link_cx, 0, sizeof (*ctr_link_cx));\ - ctr_link_cx->pargfid = &_pargfid;\ - ctr_link_cx->basename = _basename;\ - ctr_link_cx->basepath = _basepath;\ -} 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 - * - * ****************************************************************************/ - -/* - * 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_AFR_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 - * - * */ -#define CTR_IS_INTERNAL_FOP(frame, dict)\ - (AFR_SELF_HEAL_FOP (frame) \ - || REBALANCE_FOP (frame) \ - || TIER_REBALANCE_FOP (frame) \ - || (dict && \ - dict_get (dict, GLUSTERFS_INTERNAL_FOP_KEY))) - -/** - * ignore internal fops for all clients except AFR self-heal daemon - */ -#define CTR_IF_INTERNAL_FOP_THEN_GOTO(frame, dict, label)\ -do {\ - GF_ASSERT(frame);\ - GF_ASSERT(frame->root);\ - if (CTR_IS_INTERNAL_FOP(frame, dict)) \ - 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->enabled)\ - 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 = - _priv->ctr_record_counter && - !(ctr_local->is_internal_fop); - - /* Decide whether to record times or not - * For non internal FOPS record times as usual*/ - if (!ctr_local->is_internal_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: - free_ctr_local (ctr_local); - frame->local = NULL; - 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_inode_heal_expire_period) ? - _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_hardlink_heal_expire_period) ? - _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 (¤t_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, ¤t_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, ¤t_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-xlator-ctx.c b/xlators/features/changetimerecorder/src/ctr-xlator-ctx.c deleted file mode 100644 index b5a54c0b5e4..00000000000 --- a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.c +++ /dev/null @@ -1,409 +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 inline 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 (¤t_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 doesnt 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 doesnt 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 (¤t_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 inline 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 inline 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) ctr_xlator_ctx; - - ret = __inode_ctx_set (inode, this, &_addr); - if (ret) { - goto out; - } - - INIT_LIST_HEAD (&ctr_xlator_ctx->hardlink_list); - - ret = gettimeofday (¤t_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 7f1c6cb1712..00000000000 --- a/xlators/features/changetimerecorder/src/ctr-xlator-ctx.h +++ /dev/null @@ -1,90 +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 "xlator.h" -#include "ctr_mem_types.h" -#include "iatt.h" -#include "glusterfs.h" -#include "xlator.h" -#include "logging.h" -#include "locking.h" -#include "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 f408c028e24..00000000000 --- a/xlators/features/changetimerecorder/src/ctr_mem_types.h +++ /dev/null @@ -1,24 +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 - |