afr: let eager-locking do its own overlap checks

Today there is a non-obvious dependence of eager-locking on
write-behind. The reason is that eager-locking works as long
as the inheriting transaction has no overlaps with any of the
transactions already in progress. While write-behind provides
non-overlapping writes as a side-effect most of times (and only
guarantees it when strict-write-ordering option is enabled,
which is not on by default) eager-lock needs the behavior
as a guarantee. This is leading to complex and unwanted checks
for the presence of write-behind in the graph, for the simple
task of checking for overlaps.

This patch removes the interdependence between eager-locking
and write-behind by making eager-locking do its own overlap checks
with in-progress writes.

Change-Id: Iccba1185aeb5f1e7f060089c895a62840787133f
BUG: 912581
Signed-off-by: Anand Avati <avati@redhat.com>
Reviewed-on: http://review.gluster.org/4782
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

1 files changed, 78 insertions, 0 deletions

diff --git a/xlators/cluster/afr/src/afr-transaction.c b/xlators/cluster/afr/src/afr-transaction.c
index 502e1ed496f..644544abcc7 100644
--- a/xlators/cluster/afr/src/afr-transaction.c
+++ b/xlators/cluster/afr/src/afr-transaction.c
@@ -1647,6 +1647,17 @@ afr_transaction_resume (call_frame_t *frame, xlator_t *this)
         int_lock = &local->internal_lock;
         priv     = this->private;
 
+	if (local->transaction.eager_lock_on) {
+		/* We don't need to retain "local" in the
+		   fd list anymore, writes to all subvols
+		   are finished by now */
+		LOCK (&local->fd->lock);
+		{
+			list_del_init (&local->transaction.eager_locked);
+		}
+		UNLOCK (&local->fd->lock);
+	}
+
 	afr_restore_lk_owner (frame);
 
         if (__fop_changelog_needed (frame, this)) {
@@ -1681,6 +1692,71 @@ afr_transaction_fop_failed (call_frame_t *frame, xlator_t *this, int child_index
                            child_index, local->transaction.type);
 }
 
+
+
+static gf_boolean_t
+afr_locals_overlap (afr_local_t *local1, afr_local_t *local2)
+{
+	uint64_t start1 = local1->transaction.start;
+	uint64_t start2 = local2->transaction.start;
+	uint64_t end1 = 0;
+	uint64_t end2 = 0;
+
+	if (local1->transaction.len)
+		end1 = start1 + local1->transaction.len - 1;
+	else
+		end1 = ULLONG_MAX;
+
+	if (local2->transaction.len)
+		end2 = start2 + local2->transaction.len - 1;
+	else
+		end2 = ULLONG_MAX;
+
+	return ((end1 >= start2) && (end2 >= start1));
+}
+
+
+void
+afr_transaction_eager_lock_init (afr_local_t *local, xlator_t *this)
+{
+	afr_private_t *priv = NULL;
+	afr_fd_ctx_t  *fdctx = NULL;
+	afr_local_t   *each = NULL;
+
+	priv = this->private;
+
+	if (!local->fd)
+		return;
+
+	if (local->transaction.type != AFR_DATA_TRANSACTION)
+		return;
+
+	if (!priv->eager_lock)
+		return;
+
+	fdctx = afr_fd_ctx_get (local->fd, this);
+	if (!fdctx)
+		return;
+
+	LOCK (&local->fd->lock);
+	{
+		list_for_each_entry (each, &fdctx->eager_locked,
+				     transaction.eager_locked) {
+			if (afr_locals_overlap (each, local)) {
+				local->transaction.eager_lock_on = _gf_false;
+				goto unlock;
+			}
+		}
+
+		local->transaction.eager_lock_on = _gf_true;
+		list_add_tail (&local->transaction.eager_locked,
+			       &fdctx->eager_locked);
+	}
+unlock:
+	UNLOCK (&local->fd->lock);
+}
+
+
 int
 afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
 {
@@ -1700,6 +1776,8 @@ afr_transaction (call_frame_t *frame, xlator_t *this, afr_transaction_type type)
             goto out;
         }
 
+	afr_transaction_eager_lock_init (local, this);
+
         if (local->fd && local->transaction.eager_lock_on)
                 afr_set_lk_owner (frame, this, local->fd);
         else