From 54d4ea44fec96560aad9c41f7e4f5aad164ffb8b Mon Sep 17 00:00:00 2001

From: Ravishankar N <ravishankar@redhat.com>

Date: Fri, 5 Jun 2020 14:14:15 +0530

Subject: [PATCH 424/449] afr: make heal info lockless

Changes in locks xlator:

Added support for per-domain inodelk count requests.

Caller needs to set GLUSTERFS_MULTIPLE_DOM_LK_CNT_REQUESTS key in the

dict and then set each key with name

'GLUSTERFS_INODELK_DOM_PREFIX:<domain name>'.

In the response dict, the xlator will send the per domain count as

values for each of these keys.

Changes in AFR:

Replaced afr_selfheal_locked_inspect() with afr_lockless_inspect(). Logic has

been added to make the latter behave same as the former, thus not

breaking the current heal info output behaviour.

> Upstream patch: https://review.gluster.org/#/c/glusterfs/+/23771/

> fixes: bz#1774011

> Change-Id: Ie9e83c162aa77f44a39c2ba7115de558120ada4d

BUG: 1721355

Change-Id: I8ed4b504880b19e00068312efd90cd0706787404

Signed-off-by: Ravishankar N <ravishankar@redhat.com>

Reviewed-on: https://code.engineering.redhat.com/gerrit/202490

Tested-by: RHGS Build Bot <nigelb@redhat.com>

Reviewed-by: Karthik Subrahmanya <ksubrahm@redhat.com>

Reviewed-by: Sunil Kumar Heggodu Gopala Acharya <sheggodu@redhat.com>

---

 heal/src/glfs-heal.c                           |  17 +-

 libglusterfs/src/glusterfs/glusterfs.h         |   2 +

 xlators/cluster/afr/src/afr-common.c           | 367 +++++++++++--------------

 xlators/cluster/afr/src/afr-self-heal-common.c |  43 ++-

 xlators/cluster/afr/src/afr-self-heal.h        |   3 +-

 xlators/features/locks/src/common.h            |   4 +

 xlators/features/locks/src/locks.h             |   8 +

 xlators/features/locks/src/posix.c             | 117 +++++++-

 8 files changed, 338 insertions(+), 223 deletions(-)

diff --git a/heal/src/glfs-heal.c b/heal/src/glfs-heal.c

index 125b12c..5af9e31 100644

--- a/heal/src/glfs-heal.c

+++ b/heal/src/glfs-heal.c

@@ -775,7 +775,8 @@ static int

 glfsh_process_entries(xlator_t *xl, fd_t *fd, gf_dirent_t *entries,

                       uint64_t *offset, num_entries_t *num_entries,

                       print_status glfsh_print_status,

-                      gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode)

+                      gf_boolean_t ignore_dirty, glfsh_fail_mode_t mode,

+                      dict_t *xattr_req)

 {

     gf_dirent_t *entry = NULL;

     gf_dirent_t *tmp = NULL;

@@ -807,7 +808,7 @@ glfsh_process_entries(xlator_t *xl, fd_t *fd, gf_dirent_t *entries,

         gf_uuid_parse(entry->d_name, gfid);

         gf_uuid_copy(loc.gfid, gfid);

-        ret = syncop_getxattr(this, &loc, &dict, GF_HEAL_INFO, NULL, NULL);

+        ret = syncop_getxattr(this, &loc, &dict, GF_HEAL_INFO, xattr_req, NULL);

         if (ret) {

             if ((mode != GLFSH_MODE_CONTINUE_ON_ERROR) && (ret == -ENOTCONN))

                 goto out;

@@ -876,19 +877,19 @@ glfsh_crawl_directory(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,

         if (heal_op == GF_SHD_OP_INDEX_SUMMARY) {

             ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,

                                         num_entries, glfsh_print_heal_status,

-                                        ignore, mode);

+                                        ignore, mode, xattr_req);

             if (ret < 0)

                 goto out;

         } else if (heal_op == GF_SHD_OP_SPLIT_BRAIN_FILES) {

             ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,

                                         num_entries, glfsh_print_spb_status,

-                                        ignore, mode);

+                                        ignore, mode, xattr_req);

             if (ret < 0)

                 goto out;

         } else if (heal_op == GF_SHD_OP_HEAL_SUMMARY) {

             ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,

                                         num_entries, glfsh_print_summary_status,

-                                        ignore, mode);

+                                        ignore, mode, xattr_req);

             if (ret < 0)

                 goto out;

         } else if (heal_op == GF_SHD_OP_SBRAIN_HEAL_FROM_BRICK) {

@@ -897,7 +898,7 @@ glfsh_crawl_directory(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,

         } else if (heal_op == GF_SHD_OP_GRANULAR_ENTRY_HEAL_ENABLE) {

             ret = glfsh_process_entries(readdir_xl, fd, &entries, &offset,

                                         num_entries, glfsh_heal_status_boolean,

-                                        ignore, mode);

+                                        ignore, mode, xattr_req);

             if (ret < 0)

                 goto out;

         }

@@ -951,6 +952,10 @@ glfsh_print_pending_heals_type(glfs_t *fs, xlator_t *top_subvol, loc_t *rootloc,

     int32_t op_errno = 0;

     gf_boolean_t ignore = _gf_false;

+    ret = dict_set_str(xattr_req, "index-vgfid", vgfid);

+    if (ret)

+        return ret;

+

     if (!strcmp(vgfid, GF_XATTROP_DIRTY_GFID))

         ignore = _gf_true;

diff --git a/libglusterfs/src/glusterfs/glusterfs.h b/libglusterfs/src/glusterfs/glusterfs.h

index 3b594c0..177a020 100644

--- a/libglusterfs/src/glusterfs/glusterfs.h

+++ b/libglusterfs/src/glusterfs/glusterfs.h

@@ -217,6 +217,8 @@ enum gf_internal_fop_indicator {

 #define GLUSTERFS_POSIXLK_COUNT "glusterfs.posixlk-count"

 #define GLUSTERFS_PARENT_ENTRYLK "glusterfs.parent-entrylk"

 #define GLUSTERFS_INODELK_DOM_COUNT "glusterfs.inodelk-dom-count"

+#define GLUSTERFS_INODELK_DOM_PREFIX "glusterfs.inodelk-dom-prefix"

+#define GLUSTERFS_MULTIPLE_DOM_LK_CNT_REQUESTS "glusterfs.multi-dom-lk-cnt-req"

 #define GFID_TO_PATH_KEY "glusterfs.gfid2path"

 #define GF_XATTR_STIME_PATTERN "trusted.glusterfs.*.stime"

 #define GF_XATTR_XTIME_PATTERN "trusted.glusterfs.*.xtime"

diff --git a/xlators/cluster/afr/src/afr-common.c b/xlators/cluster/afr/src/afr-common.c

index 59710aa..c355ec5 100644

--- a/xlators/cluster/afr/src/afr-common.c

+++ b/xlators/cluster/afr/src/afr-common.c

@@ -5908,259 +5908,218 @@ out:

     return _gf_true;

 }

-int

-afr_selfheal_locked_metadata_inspect(call_frame_t *frame, xlator_t *this,

-                                     inode_t *inode, gf_boolean_t *msh,

-                                     unsigned char *pending)

+static dict_t *

+afr_set_heal_info(char *status)

 {

+    dict_t *dict = NULL;

     int ret = -1;

-    unsigned char *locked_on = NULL;

-    unsigned char *sources = NULL;

-    unsigned char *sinks = NULL;

-    unsigned char *healed_sinks = NULL;

-    unsigned char *undid_pending = NULL;

-    struct afr_reply *locked_replies = NULL;

-

-    afr_private_t *priv = this->private;

-    locked_on = alloca0(priv->child_count);

-    sources = alloca0(priv->child_count);

-    sinks = alloca0(priv->child_count);

-    healed_sinks = alloca0(priv->child_count);

-    undid_pending = alloca0(priv->child_count);

+    dict = dict_new();

+    if (!dict) {

+        ret = -ENOMEM;

+        goto out;

+    }

-    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);

+    ret = dict_set_dynstr_sizen(dict, "heal-info", status);

+    if (ret)

+        gf_msg("", GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,

+               "Failed to set heal-info key to "

+               "%s",

+               status);

+out:

+    /* Any error other than EINVAL, dict_set_dynstr frees status */

+    if (ret == -ENOMEM || ret == -EINVAL) {

+        GF_FREE(status);

+    }

-    ret = afr_selfheal_inodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,

-                               locked_on);

-    {

-        if (ret == 0) {

-            /* Not a single lock */

-            ret = -afr_final_errno(frame->local, priv);

-            if (ret == 0)

-                ret = -ENOTCONN; /* all invalid responses */

-            goto out;

-        }

-        ret = __afr_selfheal_metadata_prepare(

-            frame, this, inode, locked_on, sources, sinks, healed_sinks,

-            undid_pending, locked_replies, pending);

-        *msh = afr_decide_heal_info(priv, sources, ret);

+    if (ret && dict) {

+        dict_unref(dict);

+        dict = NULL;

     }

-    afr_selfheal_uninodelk(frame, this, inode, this->name, LLONG_MAX - 1, 0,

-                           locked_on);

-out:

-    if (locked_replies)

-        afr_replies_wipe(locked_replies, priv->child_count);

-    return ret;

+    return dict;

 }

-int

-afr_selfheal_locked_data_inspect(call_frame_t *frame, xlator_t *this, fd_t *fd,

-                                 gf_boolean_t *dsh, unsigned char *pflag)

+static gf_boolean_t

+afr_is_dirty_count_non_unary_for_txn(xlator_t *this, struct afr_reply *replies,

+                                     afr_transaction_type type)

 {

-    int ret = -1;

-    unsigned char *data_lock = NULL;

-    unsigned char *sources = NULL;

-    unsigned char *sinks = NULL;

-    unsigned char *healed_sinks = NULL;

-    unsigned char *undid_pending = NULL;

-    afr_private_t *priv = NULL;

-    struct afr_reply *locked_replies = NULL;

-    inode_t *inode = fd->inode;

+    afr_private_t *priv = this->private;

+    int *dirty = alloca0(priv->child_count * sizeof(int));

+    int i = 0;

-    priv = this->private;

-    data_lock = alloca0(priv->child_count);

-    sources = alloca0(priv->child_count);

-    sinks = alloca0(priv->child_count);

-    healed_sinks = alloca0(priv->child_count);

-    undid_pending = alloca0(priv->child_count);

+    afr_selfheal_extract_xattr(this, replies, type, dirty, NULL);

+    for (i = 0; i < priv->child_count; i++) {

+        if (dirty[i] > 1)

+            return _gf_true;

+    }

-    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);

+    return _gf_false;

+}

-    ret = afr_selfheal_inodelk(frame, this, inode, this->name, 0, 0, data_lock);

-    {

-        if (ret == 0) {

-            ret = -afr_final_errno(frame->local, priv);

-            if (ret == 0)

-                ret = -ENOTCONN; /* all invalid responses */

-            goto out;

-        }

-        ret = __afr_selfheal_data_prepare(frame, this, inode, data_lock,

-                                          sources, sinks, healed_sinks,

-                                          undid_pending, locked_replies, pflag);

-        *dsh = afr_decide_heal_info(priv, sources, ret);

+static gf_boolean_t

+afr_is_dirty_count_non_unary(xlator_t *this, struct afr_reply *replies,

+                             ia_type_t ia_type)

+{

+    gf_boolean_t data_chk = _gf_false;

+    gf_boolean_t mdata_chk = _gf_false;

+    gf_boolean_t entry_chk = _gf_false;

+

+    switch (ia_type) {

+        case IA_IFDIR:

+            mdata_chk = _gf_true;

+            entry_chk = _gf_true;

+            break;

+        case IA_IFREG:

+            mdata_chk = _gf_true;

+            data_chk = _gf_true;

+            break;

+        default:

+            /*IA_IFBLK, IA_IFCHR, IA_IFLNK, IA_IFIFO, IA_IFSOCK*/

+            mdata_chk = _gf_true;

+            break;

     }

-    afr_selfheal_uninodelk(frame, this, inode, this->name, 0, 0, data_lock);

-out:

-    if (locked_replies)

-        afr_replies_wipe(locked_replies, priv->child_count);

-    return ret;

+

+    if (data_chk && afr_is_dirty_count_non_unary_for_txn(

+                        this, replies, AFR_DATA_TRANSACTION)) {

+        return _gf_true;

+    } else if (mdata_chk && afr_is_dirty_count_non_unary_for_txn(

+                                this, replies, AFR_METADATA_TRANSACTION)) {

+        return _gf_true;

+    } else if (entry_chk && afr_is_dirty_count_non_unary_for_txn(

+                                this, replies, AFR_ENTRY_TRANSACTION)) {

+        return _gf_true;

+    }

+

+    return _gf_false;

 }

-int

-afr_selfheal_locked_entry_inspect(call_frame_t *frame, xlator_t *this,

-                                  inode_t *inode, gf_boolean_t *esh,

-                                  unsigned char *pflag)

+static int

+afr_update_heal_status(xlator_t *this, struct afr_reply *replies,

+                       char *index_vgfid, ia_type_t ia_type, gf_boolean_t *esh,

+                       gf_boolean_t *dsh, gf_boolean_t *msh)

 {

     int ret = -1;

-    int source = -1;

+    GF_UNUSED int ret1 = 0;

+    int i = 0;

+    int io_domain_lk_count = 0;

+    int shd_domain_lk_count = 0;

     afr_private_t *priv = NULL;

-    unsigned char *locked_on = NULL;

-    unsigned char *data_lock = NULL;

-    unsigned char *sources = NULL;

-    unsigned char *sinks = NULL;

-    unsigned char *healed_sinks = NULL;

-    struct afr_reply *locked_replies = NULL;

-    gf_boolean_t granular_locks = _gf_false;

+    char *key1 = NULL;

+    char *key2 = NULL;

     priv = this->private;

-    granular_locks = priv->granular_locks; /*Assign to local variable so that

-                                             reconfigure doesn't change this

-                                             value between locking and unlocking

-                                             below*/

-    locked_on = alloca0(priv->child_count);

-    data_lock = alloca0(priv->child_count);

-    sources = alloca0(priv->child_count);

-    sinks = alloca0(priv->child_count);

-    healed_sinks = alloca0(priv->child_count);

-

-    locked_replies = alloca0(sizeof(*locked_replies) * priv->child_count);

+    key1 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +

+                   strlen(this->name));

+    key2 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +

+                   strlen(priv->sh_domain));

+    sprintf(key1, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, this->name);

+    sprintf(key2, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, priv->sh_domain);

-    if (!granular_locks) {

-        ret = afr_selfheal_tryentrylk(frame, this, inode, priv->sh_domain, NULL,

-                                      locked_on);

-    }

-    {

-        if (!granular_locks && ret == 0) {

-            ret = -afr_final_errno(frame->local, priv);

-            if (ret == 0)

-                ret = -ENOTCONN; /* all invalid responses */

-            goto out;

+    for (i = 0; i < priv->child_count; i++) {

+        if ((replies[i].valid != 1) || (replies[i].op_ret != 0))

+            continue;

+        if (!io_domain_lk_count) {

+            ret1 = dict_get_int32(replies[i].xdata, key1, &io_domain_lk_count);

         }

+        if (!shd_domain_lk_count) {

+            ret1 = dict_get_int32(replies[i].xdata, key2, &shd_domain_lk_count);

+        }

+    }

-        ret = afr_selfheal_entrylk(frame, this, inode, this->name, NULL,

-                                   data_lock);

-        {

-            if (ret == 0) {

-                ret = -afr_final_errno(frame->local, priv);

-                if (ret == 0)

-                    ret = -ENOTCONN;

-                /* all invalid responses */

-                goto unlock;

-            }

-            ret = __afr_selfheal_entry_prepare(frame, this, inode, data_lock,

-                                               sources, sinks, healed_sinks,

-                                               locked_replies, &source, pflag);

-            if ((ret == 0) && (*pflag & PFLAG_SBRAIN))

-                ret = -EIO;

-            *esh = afr_decide_heal_info(priv, sources, ret);

+    if (!strcmp(index_vgfid, GF_XATTROP_INDEX_GFID)) {

+        if (shd_domain_lk_count) {

+            ret = -EAGAIN; /*For 'possibly-healing'. */

+        } else {

+            ret = 0; /*needs heal. Just set a non -ve value so that it is

+                       assumed as the source index.*/

+        }

+    } else if (!strcmp(index_vgfid, GF_XATTROP_DIRTY_GFID)) {

+        if ((afr_is_dirty_count_non_unary(this, replies, ia_type)) ||

+            (!io_domain_lk_count)) {

+            /* Needs heal. */

+            ret = 0;

+        } else {

+            /* No heal needed. */

+            *dsh = *esh = *msh = 0;

         }

-        afr_selfheal_unentrylk(frame, this, inode, this->name, NULL, data_lock,

-                               NULL);

     }

-unlock:

-    if (!granular_locks)

-        afr_selfheal_unentrylk(frame, this, inode, priv->sh_domain, NULL,

-                               locked_on, NULL);

-out:

-    if (locked_replies)

-        afr_replies_wipe(locked_replies, priv->child_count);

     return ret;

 }

+/*return EIO, EAGAIN or pending*/

 int

-afr_selfheal_locked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,

-                            inode_t **inode, gf_boolean_t *entry_selfheal,

-                            gf_boolean_t *data_selfheal,

-                            gf_boolean_t *metadata_selfheal,

-                            unsigned char *pending)

-

+afr_lockless_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,

+                     inode_t **inode, char *index_vgfid,

+                     gf_boolean_t *entry_selfheal, gf_boolean_t *data_selfheal,

+                     gf_boolean_t *metadata_selfheal, unsigned char *pending)

 {

     int ret = -1;

-    fd_t *fd = NULL;

+    int i = 0;

+    afr_private_t *priv = NULL;

+    struct afr_reply *replies = NULL;

     gf_boolean_t dsh = _gf_false;

     gf_boolean_t msh = _gf_false;

     gf_boolean_t esh = _gf_false;

+    unsigned char *sources = NULL;

+    unsigned char *sinks = NULL;

+    unsigned char *valid_on = NULL;

+    uint64_t *witness = NULL;

+

+    priv = this->private;

+    replies = alloca0(sizeof(*replies) * priv->child_count);

+    sources = alloca0(sizeof(*sources) * priv->child_count);

+    sinks = alloca0(sizeof(*sinks) * priv->child_count);

+    witness = alloca0(sizeof(*witness) * priv->child_count);

+    valid_on = alloca0(sizeof(*valid_on) * priv->child_count);

     ret = afr_selfheal_unlocked_inspect(frame, this, gfid, inode, &dsh, &msh,

-                                        &esh;;

+                                        &esh, replies);

     if (ret)

         goto out;

-

-    /* For every heal type hold locks and check if it indeed needs heal */

-

-    /* Heal-info does an open() on the file being examined so that the

-     * current eager-lock holding client, if present, at some point sees

-     * open-fd count being > 1 and releases the eager-lock so that heal-info

-     * doesn't remain blocked forever until IO completes.

-     */

-    if ((*inode)->ia_type == IA_IFREG) {

-        ret = afr_selfheal_data_open(this, *inode, &fd;;

-        if (ret < 0) {

-            gf_msg_debug(this->name, -ret, "%s: Failed to open",

-                         uuid_utoa((*inode)->gfid));

-            goto out;

+    for (i = 0; i < priv->child_count; i++) {

+        if (replies[i].valid && replies[i].op_ret == 0) {

+            valid_on[i] = 1;

         }

     }

-

     if (msh) {

-        ret = afr_selfheal_locked_metadata_inspect(frame, this, *inode, &msh,

-                                                   pending);

-        if (ret == -EIO)

+        ret = afr_selfheal_find_direction(frame, this, replies,

+                                          AFR_METADATA_TRANSACTION, valid_on,

+                                          sources, sinks, witness, pending);

+        if (*pending & PFLAG_SBRAIN)

+            ret = -EIO;

+        if (ret)

             goto out;

     }

-

     if (dsh) {

-        ret = afr_selfheal_locked_data_inspect(frame, this, fd, &dsh, pending);

-        if (ret == -EIO || (ret == -EAGAIN))

+        ret = afr_selfheal_find_direction(frame, this, replies,

+                                          AFR_DATA_TRANSACTION, valid_on,

+                                          sources, sinks, witness, pending);

+        if (*pending & PFLAG_SBRAIN)

+            ret = -EIO;

+        if (ret)

             goto out;

     }

-

     if (esh) {

-        ret = afr_selfheal_locked_entry_inspect(frame, this, *inode, &esh,

-                                                pending);

+        ret = afr_selfheal_find_direction(frame, this, replies,

+                                          AFR_ENTRY_TRANSACTION, valid_on,

+                                          sources, sinks, witness, pending);

+        if (*pending & PFLAG_SBRAIN)

+            ret = -EIO;

+        if (ret)

+            goto out;

     }

+    ret = afr_update_heal_status(this, replies, index_vgfid, (*inode)->ia_type,

+                                 &esh, &dsh, &msh;;

 out:

     *data_selfheal = dsh;

     *entry_selfheal = esh;

     *metadata_selfheal = msh;

-    if (fd)

-        fd_unref(fd);

+    if (replies)

+        afr_replies_wipe(replies, priv->child_count);

     return ret;

 }

-static dict_t *

-afr_set_heal_info(char *status)

-{

-    dict_t *dict = NULL;

-    int ret = -1;

-

-    dict = dict_new();

-    if (!dict) {

-        ret = -ENOMEM;

-        goto out;

-    }

-

-    ret = dict_set_dynstr_sizen(dict, "heal-info", status);

-    if (ret)

-        gf_msg("", GF_LOG_WARNING, -ret, AFR_MSG_DICT_SET_FAILED,

-               "Failed to set heal-info key to "

-               "%s",

-               status);

-out:

-    /* Any error other than EINVAL, dict_set_dynstr frees status */

-    if (ret == -ENOMEM || ret == -EINVAL) {

-        GF_FREE(status);

-    }

-

-    if (ret && dict) {

-        dict_unref(dict);

-        dict = NULL;

-    }

-    return dict;

-}

-

 int

 afr_get_heal_info(call_frame_t *frame, xlator_t *this, loc_t *loc)

 {

@@ -6174,10 +6133,18 @@ afr_get_heal_info(call_frame_t *frame, xlator_t *this, loc_t *loc)

     inode_t *inode = NULL;

     char *substr = NULL;

     char *status = NULL;

+    afr_local_t *local = NULL;

+    char *index_vgfid = NULL;

+

+    local = frame->local;

+    if (dict_get_str(local->xdata_req, "index-vgfid", &index_vgfid)) {

+        ret = -1;

+        goto out;

+    }

-    ret = afr_selfheal_locked_inspect(frame, this, loc->gfid, &inode,

-                                      &entry_selfheal, &data_selfheal,

-                                      &metadata_selfheal, &pending);

+    ret = afr_lockless_inspect(frame, this, loc->gfid, &inode, index_vgfid,

+                               &entry_selfheal, &data_selfheal,

+                               &metadata_selfheal, &pending);

     if (ret == -ENOMEM) {

         ret = -1;

diff --git a/xlators/cluster/afr/src/afr-self-heal-common.c b/xlators/cluster/afr/src/afr-self-heal-common.c

index d942ccf..1608f75 100644

--- a/xlators/cluster/afr/src/afr-self-heal-common.c

+++ b/xlators/cluster/afr/src/afr-self-heal-common.c

@@ -1827,6 +1827,37 @@ afr_selfheal_unlocked_lookup_on(call_frame_t *frame, inode_t *parent,

     return inode;

 }

+static int

+afr_set_multi_dom_lock_count_request(xlator_t *this, dict_t *dict)

+{

+    int ret = 0;

+    afr_private_t *priv = NULL;

+    char *key1 = NULL;

+    char *key2 = NULL;

+

+    priv = this->private;

+    key1 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +

+                   strlen(this->name));

+    key2 = alloca0(strlen(GLUSTERFS_INODELK_DOM_PREFIX) + 2 +

+                   strlen(priv->sh_domain));

+

+    ret = dict_set_uint32(dict, GLUSTERFS_MULTIPLE_DOM_LK_CNT_REQUESTS, 1);

+    if (ret)

+        return ret;

+

+    sprintf(key1, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, this->name);

+    ret = dict_set_uint32(dict, key1, 1);

+    if (ret)

+        return ret;

+

+    sprintf(key2, "%s:%s", GLUSTERFS_INODELK_DOM_PREFIX, priv->sh_domain);

+    ret = dict_set_uint32(dict, key2, 1);

+    if (ret)

+        return ret;

+

+    return 0;

+}

+

 int

 afr_selfheal_unlocked_discover_on(call_frame_t *frame, inode_t *inode,

                                   uuid_t gfid, struct afr_reply *replies,

@@ -1851,6 +1882,11 @@ afr_selfheal_unlocked_discover_on(call_frame_t *frame, inode_t *inode,

         return -ENOMEM;

     }

+    if (afr_set_multi_dom_lock_count_request(frame->this, xattr_req)) {

+        dict_unref(xattr_req);

+        return -1;

+    }

+

     loc.inode = inode_ref(inode);

     gf_uuid_copy(loc.gfid, gfid);

@@ -2241,7 +2277,8 @@ int

 afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,

                               inode_t **link_inode, gf_boolean_t *data_selfheal,

                               gf_boolean_t *metadata_selfheal,

-                              gf_boolean_t *entry_selfheal)

+                              gf_boolean_t *entry_selfheal,

+                              struct afr_reply *replies_dst)

 {

     afr_private_t *priv = NULL;

     inode_t *inode = NULL;

@@ -2377,6 +2414,8 @@ afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,

     ret = 0;

 out:

+    if (replies && replies_dst)

+        afr_replies_copy(replies_dst, replies, priv->child_count);

     if (inode)

         inode_unref(inode);

     if (replies)

@@ -2493,7 +2532,7 @@ afr_selfheal_do(call_frame_t *frame, xlator_t *this, uuid_t gfid)

     ret = afr_selfheal_unlocked_inspect(frame, this, gfid, &inode,

                                         &data_selfheal, &metadata_selfheal,

-                                        &entry_selfheal);

+                                        &entry_selfheal, NULL);

     if (ret)

         goto out;

diff --git a/xlators/cluster/afr/src/afr-self-heal.h b/xlators/cluster/afr/src/afr-self-heal.h

index f7ecf5d..b39af02 100644

--- a/xlators/cluster/afr/src/afr-self-heal.h

+++ b/xlators/cluster/afr/src/afr-self-heal.h

@@ -327,7 +327,8 @@ int

 afr_selfheal_unlocked_inspect(call_frame_t *frame, xlator_t *this, uuid_t gfid,

                               inode_t **link_inode, gf_boolean_t *data_selfheal,

                               gf_boolean_t *metadata_selfheal,

-                              gf_boolean_t *entry_selfheal);

+                              gf_boolean_t *entry_selfheal,

+                              struct afr_reply *replies);

 int

 afr_selfheal_do(call_frame_t *frame, xlator_t *this, uuid_t gfid);

diff --git a/xlators/features/locks/src/common.h b/xlators/features/locks/src/common.h

index 3a74967..ea86b96 100644

--- a/xlators/features/locks/src/common.h

+++ b/xlators/features/locks/src/common.h

@@ -45,6 +45,10 @@

                 fd_unref(__local->fd);                                         \

             if (__local->inode)                                                \

                 inode_unref(__local->inode);                                   \

+            if (__local->xdata) {                                              \

+                dict_unref(__local->xdata);                                    \

+                __local->xdata = NULL;                                         \

+            }                                                                  \

             mem_put(__local);                                                  \

         }                                                                      \

     } while (0)

diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h

index b817960..aa267de 100644

--- a/xlators/features/locks/src/locks.h

+++ b/xlators/features/locks/src/locks.h

@@ -239,6 +239,7 @@ typedef struct {

     gf_boolean_t inodelk_count_req;

     gf_boolean_t posixlk_count_req;

     gf_boolean_t parent_entrylk_req;

+    gf_boolean_t multiple_dom_lk_requests;

     int update_mlock_enforced_flag;

 } pl_local_t;

@@ -260,6 +261,13 @@ typedef struct _locks_ctx {

     struct list_head metalk_list;

 } pl_ctx_t;

+typedef struct _multi_dom_lk_data {

+    xlator_t *this;

+    inode_t *inode;

+    dict_t *xdata_rsp;

+    gf_boolean_t keep_max;

+} multi_dom_lk_data;

+

 typedef enum { DECREMENT, INCREMENT } pl_count_op_t;

 pl_ctx_t *

diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c

index 4592240..9a14c64 100644

--- a/xlators/features/locks/src/posix.c

+++ b/xlators/features/locks/src/posix.c

@@ -150,13 +150,20 @@ fetch_pathinfo(xlator_t *, inode_t *, int32_t *, char **);

 gf_boolean_t

 pl_has_xdata_requests(dict_t *xdata)

 {

-    static char *reqs[] = {GLUSTERFS_ENTRYLK_COUNT,     GLUSTERFS_INODELK_COUNT,

-                           GLUSTERFS_INODELK_DOM_COUNT, GLUSTERFS_POSIXLK_COUNT,

-                           GLUSTERFS_PARENT_ENTRYLK,    NULL};

-    static int reqs_size[] = {

-        SLEN(GLUSTERFS_ENTRYLK_COUNT),     SLEN(GLUSTERFS_INODELK_COUNT),

-        SLEN(GLUSTERFS_INODELK_DOM_COUNT), SLEN(GLUSTERFS_POSIXLK_COUNT),

-        SLEN(GLUSTERFS_PARENT_ENTRYLK),    0};

+    static char *reqs[] = {GLUSTERFS_ENTRYLK_COUNT,

+                           GLUSTERFS_INODELK_COUNT,

+                           GLUSTERFS_INODELK_DOM_COUNT,

+                           GLUSTERFS_POSIXLK_COUNT,