cluster/afr: Wake up post-op on non-co-operative transaction

Problem:
The problem is observed when kernel untar is done. One file untar
happens every second. The reason for this is, setattr lock is blocked
on the prev fd data-transaction full-lock (because of eager-lock).
Because of post-op-delay the post-op (xattrop + unlock) of the prev
data-transaction happens after 1 sec.
Until this the setattr is blocked resulting in performance problems
in untar.

Fix:
Whenever an loc data, meta-data transaction comes, it should wakeup
the prev-post-op on the same process' fd.

Tests:
The performance problem in untar went away. I put a breakpoint in
client_finodelk for a 2G file dd and the inodelk is hit only 4 times.
This confirms that the change does not affect post-op-delay in a
-ve way.

Change-Id: Ice3c2a1211f4dca6520a19bc4ba6cb9efb2902ad
BUG: 845754
Signed-off-by: Pranith Kumar K <pranithk@gluster.com>
Reviewed-on: http://review.gluster.org/3975
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Jeff Darcy <jdarcy@redhat.com>
Reviewed-by: Anand Avati <avati@redhat.com>

1 files changed, 23 insertions, 0 deletions

diff --git a/xlators/cluster/afr/src/afr-transaction.c b/xlators/cluster/afr/src/afr-transaction.c
index ddf0af31794..f5094e1cfd9 100644
--- a/xlators/cluster/afr/src/afr-transaction.c
+++ b/xlators/cluster/afr/src/afr-transaction.c
@@ -1433,11 +1433,25 @@ afr_transaction_fop_failed (call_frame_t *frame, xlator_t *this, int child_index
                            child_index, local->transaction.type);
 }
 
+gf_boolean_t
+_does_transaction_conflict_with_delayed_post_op (call_frame_t *frame)
+{
+        afr_local_t     *local = frame->local;
+        //check if it is going to compete with inode lock from the fd
+        if (local->fd)
+                return _gf_false;
+        if ((local->transaction.type == AFR_DATA_TRANSACTION) ||
+            (local->transaction.type == AFR_METADATA_TRANSACTION))
+                return _gf_true;
+        return _gf_false;
+}
+
 int
 afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
 {
         afr_local_t *   local = NULL;
         afr_private_t * priv  = NULL;
+        fd_t            *fd   = NULL;
 
         local = frame->local;
         priv  = this->private;
@@ -1453,6 +1467,15 @@ afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
         local->transaction.resume = afr_transaction_resume;
         local->transaction.type   = type;
 
+        if (_does_transaction_conflict_with_delayed_post_op (frame) &&
+            local->loc.inode) {
+                fd = fd_lookup (local->loc.inode, frame->root->pid);
+                if (fd) {
+                        afr_delayed_changelog_wake_up (this, fd);
+                        fd_unref (fd);
+                }
+        }
+
         if (afr_lock_server_count (priv, local->transaction.type) == 0) {
                 afr_internal_lock_finish (frame, this);
         } else {