cluster/dht: instruct marker whenever it shouldn't do accounting

This is needed for two reasons:

* since dht-linkfiles are internal, they shouldn't be accounted.
* hardlink handling in marker is broken. link/unlink of hardlinks
  present in same directory can break marker accounting. Hence, if src
  and dst are in same directory in case of rename, dht - if it breaks
  rename into link/unlink operations - should instruct marker to not to
  do accounting.

Change-Id: I9c9f7384569f75a2792f6450ee7a5279bf751ae7
BUG: 1022995
Signed-off-by: Raghavendra G <rgowdapp@redhat.com>
Reviewed-on: http://review.gluster.org/6203
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

2 files changed, 99 insertions, 52 deletions

diff --git a/xlators/cluster/dht/src/dht-rename.c b/xlators/cluster/dht/src/dht-rename.c
index 5d6f4f2322e..925538cc80c 100644
--- a/xlators/cluster/dht/src/dht-rename.c
+++ b/xlators/cluster/dht/src/dht-rename.c
@@ -319,6 +319,22 @@ err:
                                 " internal dict key for %s", local->loc.path); \
                 }                                                              \
         }while (0)
+
+#define DHT_MARKER_DONT_ACCOUNT(xattr) do {                             \
+                int tmp = -1;                                                  \
+                if (!xattr) {                                                  \
+                        xattr = dict_new ();                                   \
+                        if (!xattr)                                            \
+                                break;                                         \
+                }                                                              \
+                tmp = dict_set_str (xattr, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY,  \
+                                    "yes");                                    \
+                if (tmp) {                                                     \
+                        gf_log (this->name, GF_LOG_ERROR, "Failed to set"      \
+                                " marker dont account key for %s", local->loc.path); \
+                }                                                              \
+        }while (0)
+
 int
 dht_rename_done (call_frame_t *frame, xlator_t *this)
 {
@@ -416,21 +432,45 @@ dht_rename_cleanup (call_frame_t *frame)
         DHT_MARK_FOP_INTERNAL (xattr);
 
         if (dst_hashed != src_hashed && dst_hashed != src_cached) {
+                dict_t *xattr_new = NULL;
+
                 gf_log (this->name, GF_LOG_TRACE,
                         "unlinking linkfile %s @ %s => %s",
                         local->loc.path, dst_hashed->name, src_cached->name);
+
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
+
+                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+
                 STACK_WIND (frame, dht_rename_unlink_cbk,
                             dst_hashed, dst_hashed->fops->unlink,
-                            &local->loc, 0, xattr);
+                            &local->loc, 0, xattr_new);
+
+                dict_unref (xattr_new);
+                xattr_new = NULL;
         }
 
         if (src_cached != dst_hashed) {
+                dict_t *xattr_new = NULL;
+
                 gf_log (this->name, GF_LOG_TRACE,
                         "unlinking link %s => %s (%s)", local->loc.path,
                         local->loc2.path, src_cached->name);
+
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
+                if (uuid_compare (local->loc.pargfid,
+                                  local->loc2.pargfid) == 0) {
+                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
+                }
+
                 STACK_WIND (frame, dht_rename_unlink_cbk,
                             src_cached, src_cached->fops->unlink,
-                            &local->loc2, 0, xattr);
+                            &local->loc2, 0, xattr_new);
+
+                dict_unref (xattr_new);
+                xattr_new = NULL;
         }
 
         if (xattr)
@@ -586,23 +626,44 @@ err:
         DHT_MARK_FOP_INTERNAL (xattr);
 
         if (src_cached != dst_hashed && src_cached != dst_cached) {
+                dict_t *xattr_new = NULL;
+
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
                 gf_log (this->name, GF_LOG_TRACE,
                         "deleting old src datafile %s @ %s",
                         local->loc.path, src_cached->name);
 
+                if (uuid_compare (local->loc.pargfid,
+                                  local->loc2.pargfid) == 0) {
+                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
+                }
+
                 STACK_WIND (frame, dht_rename_unlink_cbk,
                             src_cached, src_cached->fops->unlink,
-                            &local->loc, 0, xattr);
+                            &local->loc, 0, xattr_new);
+
+                dict_unref (xattr_new);
+                xattr_new = NULL;
         }
 
         if (src_hashed != rename_subvol && src_hashed != src_cached) {
+                dict_t *xattr_new = NULL;
+
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
                 gf_log (this->name, GF_LOG_TRACE,
                         "deleting old src linkfile %s @ %s",
                         local->loc.path, src_hashed->name);
 
+                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+
                 STACK_WIND (frame, dht_rename_unlink_cbk,
                             src_hashed, src_hashed->fops->unlink,
-                            &local->loc, 0, xattr);
+                            &local->loc, 0, xattr_new);
+
+                dict_unref (xattr_new);
+                xattr_new = NULL;
         }
 
         if (dst_cached
@@ -644,12 +705,13 @@ cleanup:
 int
 dht_do_rename (call_frame_t *frame)
 {
-        dht_local_t *local = NULL;
-        xlator_t    *dst_hashed = NULL;
-        xlator_t    *src_cached = NULL;
-        xlator_t    *dst_cached = NULL;
-        xlator_t    *this = NULL;
+        dht_local_t *local         = NULL;
+        xlator_t    *dst_hashed    = NULL;
+        xlator_t    *src_cached    = NULL;
+        xlator_t    *dst_cached    = NULL;
+        xlator_t    *this          = NULL;
         xlator_t    *rename_subvol = NULL;
+        dict_t      *dict          = NULL;
 
 
         local = frame->local;
@@ -664,6 +726,10 @@ dht_do_rename (call_frame_t *frame)
         else
                 rename_subvol = dst_hashed;
 
+        if ((src_cached != dst_hashed) && (rename_subvol == dst_hashed)) {
+                DHT_MARKER_DONT_ACCOUNT(dict);
+        }
+
         gf_log (this->name, GF_LOG_TRACE,
                 "renaming %s => %s (%s)",
                 local->loc.path, local->loc2.path, rename_subvol->name);
@@ -672,7 +738,7 @@ dht_do_rename (call_frame_t *frame)
                 FRAME_SU_DO (frame, dht_local_t);
         STACK_WIND (frame, dht_rename_cbk,
                     rename_subvol, rename_subvol->fops->rename,
-                    &local->loc, &local->loc2, NULL);
+                    &local->loc, &local->loc2, dict);
 
         return 0;
 }
@@ -782,16 +848,24 @@ dht_rename_create_links (call_frame_t *frame)
         DHT_MARK_FOP_INTERNAL (xattr);
 
         if (src_cached == dst_cached) {
+                dict_t *xattr_new = NULL;
+
                 if (dst_hashed == dst_cached)
                         goto nolinks;
 
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
 		gf_log (this->name, GF_LOG_TRACE,
 			"unlinking dst linkfile %s @ %s",
 			local->loc2.path, dst_hashed->name);
 
+                DHT_MARKER_DONT_ACCOUNT(xattr_new);
+
 		STACK_WIND (frame, dht_rename_unlink_links_cbk,
 			    dst_hashed, dst_hashed->fops->unlink,
-			    &local->loc2, 0, xattr);
+			    &local->loc2, 0, xattr_new);
+
+                dict_unref (xattr_new);
                 return 0;
         }
 
@@ -813,12 +887,23 @@ dht_rename_create_links (call_frame_t *frame)
 	}
 
 	if (src_cached != dst_hashed) {
+                dict_t *xattr_new = NULL;
+
+                xattr_new = dict_copy_with_ref (xattr, NULL);
+
 		gf_log (this->name, GF_LOG_TRACE,
 			"link %s => %s (%s)", local->loc.path,
 			local->loc2.path, src_cached->name);
+                if (uuid_compare (local->loc.pargfid,
+                                  local->loc2.pargfid) == 0) {
+                        DHT_MARKER_DONT_ACCOUNT(xattr_new);
+                }
+
 		STACK_WIND (frame, dht_rename_links_cbk,
 			    src_cached, src_cached->fops->link,
-			    &local->loc, &local->loc2, xattr);
+			    &local->loc, &local->loc2, xattr_new);
+
+                dict_unref (xattr_new);
 	}
 
 nolinks:
diff --git a/xlators/features/marker/src/marker.c b/xlators/features/marker/src/marker.c
index e448bc08f67..dbe9d530fad 100644
--- a/xlators/features/marker/src/marker.c
+++ b/xlators/features/marker/src/marker.c
@@ -820,37 +820,6 @@ out:
 
 
 int32_t
-marker_unlink_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
-                        dict_t *xdata)
-{
-        marker_local_t *local = NULL;
-
-        local = frame->local;
-        if (op_ret < 0) {
-                goto err;
-        }
-
-        if (local == NULL) {
-                op_errno = EINVAL;
-                goto err;
-        }
-
-        local->ia_nlink = buf->ia_nlink;
-
-        STACK_WIND (frame, marker_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
-                    local->xdata);
-        return 0;
-err:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL, NULL);
-        marker_local_unref (local);
-        return 0;
-}
-
-
-int32_t
 marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
                dict_t *xdata)
 {
@@ -874,18 +843,11 @@ marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
         if (ret == -1)
                 goto err;
 
-        if (xdata && dict_get (xdata, GLUSTERFS_INTERNAL_FOP_KEY)) {
+        if (xdata && dict_get (xdata, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY)) {
                 local->skip_txn = 1;
                 goto unlink_wind;
         }
 
-        if (uuid_is_null (loc->gfid) && loc->inode)
-                uuid_copy (loc->gfid, loc->inode->gfid);
-
-        STACK_WIND (frame, marker_unlink_stat_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->stat, loc, xdata);
-        return 0;
-
 unlink_wind:
         STACK_WIND (frame, marker_unlink_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
@@ -960,7 +922,7 @@ marker_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
         if (ret == -1)
                 goto err;
 
-        if (xdata && dict_get (xdata, GLUSTERFS_INTERNAL_FOP_KEY))
+        if (xdata && dict_get (xdata, GLUSTERFS_MARKER_DONT_ACCOUNT_KEY))
                 local->skip_txn = 1;
 wind:
         STACK_WIND (frame, marker_link_cbk, FIRST_CHILD(this),