features/locks : Improves debuggability of inode/entry locks.

Prints, in the statedump, the information about the mount that
performed the inode/entry lk.

For the entrylks that are granted after a blocked state, the
blocked time is not printed. A patch for that will be sent
later.

Change-Id: Ib0c1ed21fa9328b435f96b590dd343f59814a08d
BUG: 915629
Signed-off-by: Anuradha Talur <atalur@redhat.com>
Reviewed-on: http://review.gluster.org/5712
Reviewed-by: Pranith Kumar Karampuri <pkarampu@redhat.com>
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

7 files changed, 126 insertions, 41 deletions

diff --git a/xlators/features/locks/src/clear.c b/xlators/features/locks/src/clear.c
index 5790a99ce28..124b9ad0feb 100644
--- a/xlators/features/locks/src/clear.c
+++ b/xlators/features/locks/src/clear.c
@@ -339,6 +339,7 @@ blkd:
                                    -1, EAGAIN);
                 STACK_UNWIND_STRICT (entrylk, elock->frame, -1, EAGAIN, NULL);
                 GF_FREE ((char *) elock->basename);
+                GF_FREE (elock->connection_id);
                 GF_FREE (elock);
         }
 
@@ -379,8 +380,8 @@ out:
 
 int
 clrlk_clear_lks_in_all_domains (xlator_t *this, pl_inode_t *pl_inode,
-                          clrlk_args *args, int *blkd, int *granted,
-                          int *op_errno)
+                                clrlk_args *args, int *blkd, int *granted,
+                                int *op_errno)
 {
         pl_dom_list_t   *dom            = NULL;
         int             ret             = -1;
diff --git a/xlators/features/locks/src/common.h b/xlators/features/locks/src/common.h
index 2e1cd7ac1b1..4fbac5935fd 100644
--- a/xlators/features/locks/src/common.h
+++ b/xlators/features/locks/src/common.h
@@ -14,12 +14,14 @@
 /*dump locks format strings */
 #define RANGE_FMT               "type=%s, whence=%hd, start=%llu, len=%llu"
 #define ENTRY_FMT               "type=%s on basename=%s"
-#define DUMP_GEN_FMT            "pid = %llu, owner=%s, transport=%p, "
+#define DUMP_GEN_FMT            "pid = %llu, owner=%s, transport=%p"
 #define GRNTD_AT                "granted at %s"
 #define BLKD_AT                 "blocked at %s"
-#define DUMP_BLKD_FMT           DUMP_GEN_FMT", "BLKD_AT
-#define DUMP_GRNTD_FMT          DUMP_GEN_FMT", "GRNTD_AT
-#define DUMP_BLKD_GRNTD_FMT     DUMP_GEN_FMT", "BLKD_AT", "GRNTD_AT
+#define CONN_ID                 "connection-id=%s"
+#define DUMP_BLKD_FMT           DUMP_GEN_FMT", "CONN_ID", "BLKD_AT
+#define DUMP_GRNTD_FMT          DUMP_GEN_FMT", "CONN_ID", "GRNTD_AT
+#define DUMP_BLKD_GRNTD_FMT     DUMP_GEN_FMT", "CONN_ID", "BLKD_AT", "GRNTD_AT
+
 #define ENTRY_BLKD_FMT          ENTRY_FMT", "DUMP_BLKD_FMT
 #define ENTRY_GRNTD_FMT         ENTRY_FMT", "DUMP_GRNTD_FMT
 #define ENTRY_BLKD_GRNTD_FMT    ENTRY_FMT", "DUMP_BLKD_GRNTD_FMT
@@ -63,7 +65,8 @@ pl_dom_list_t *
 get_domain (pl_inode_t *pl_inode, const char *volume);
 
 void
-grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode, pl_dom_list_t *dom);
+grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode,
+                           pl_dom_list_t *dom);
 
 void
 __delete_inode_lock (pl_inode_lock_t *lock);
diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c
index d934a8b94e1..6b649437e4a 100644
--- a/xlators/features/locks/src/entrylk.c
+++ b/xlators/features/locks/src/entrylk.c
@@ -305,7 +305,8 @@ __find_most_matching_lock (pl_dom_list_t *dom, const char *basename)
 
 int
 __lock_name (pl_inode_t *pinode, const char *basename, entrylk_type type,
-             call_frame_t *frame, pl_dom_list_t *dom, xlator_t *this, int nonblock)
+             call_frame_t *frame, pl_dom_list_t *dom, xlator_t *this,
+             int nonblock, char *conn_id)
 {
         pl_entry_lock_t *lock       = NULL;
         pl_entry_lock_t *conf       = NULL;
@@ -327,10 +328,15 @@ __lock_name (pl_inode_t *pinode, const char *basename, entrylk_type type,
         lock->this    = this;
         lock->trans   = trans;
 
+        if (conn_id) {
+                lock->connection_id = gf_strdup (conn_id);
+        }
+
         conf = __lock_grantable (dom, basename, type);
         if (conf) {
                 ret = -EAGAIN;
                 if (nonblock){
+                        GF_FREE (lock->connection_id);
                         GF_FREE ((char *)lock->basename);
                         GF_FREE (lock);
                         goto out;
@@ -350,6 +356,7 @@ __lock_name (pl_inode_t *pinode, const char *basename, entrylk_type type,
         if ( __blocked_lock_conflict (dom, basename, type) && !(__owner_has_lock (dom, lock))) {
                 ret = -EAGAIN;
                 if (nonblock) {
+                        GF_FREE (lock->connection_id);
                         GF_FREE ((char *) lock->basename);
                         GF_FREE (lock);
                         goto out;
@@ -480,13 +487,15 @@ __grant_blocked_entry_locks (xlator_t *this, pl_inode_t *pl_inode,
                         pl_inode, bl->basename);
 
                 bl_ret = __lock_name (pl_inode, bl->basename, bl->type,
-                                      bl->frame, dom, bl->this, 0);
+                                      bl->frame, dom, bl->this, 0,
+                                      bl->connection_id);
 
                 if (bl_ret == 0) {
                         list_add (&bl->blocked_locks, granted);
                 } else {
                         gf_log (this->name, GF_LOG_DEBUG,
                                 "should never happen");
+                        GF_FREE (bl->connection_id);
                         GF_FREE ((char *)bl->basename);
                         GF_FREE (bl);
                 }
@@ -507,7 +516,8 @@ grant_blocked_entry_locks (xlator_t *this, pl_inode_t *pl_inode,
 
         pthread_mutex_lock (&pl_inode->mutex);
         {
-                __grant_blocked_entry_locks (this, pl_inode, dom, &granted_list);
+                __grant_blocked_entry_locks (this, pl_inode, dom,
+                                             &granted_list);
         }
         pthread_mutex_unlock (&pl_inode->mutex);
 
@@ -520,11 +530,13 @@ grant_blocked_entry_locks (xlator_t *this, pl_inode_t *pl_inode,
 
                 STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0, NULL);
 
+                GF_FREE (lock->connection_id);
 		GF_FREE ((char *)lock->basename);
 		GF_FREE (lock);
         }
 
         GF_FREE ((char *)unlocked->basename);
+        GF_FREE (unlocked->connection_id);
         GF_FREE (unlocked);
 
         return;
@@ -576,6 +588,7 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
                                 "{transport=%p}",trans);
 
                         GF_FREE ((char *)lock->basename);
+                        GF_FREE (lock->connection_id);
                         GF_FREE (lock);
                 }
 
@@ -591,6 +604,7 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
                 STACK_UNWIND_STRICT (entrylk, lock->frame, -1, EAGAIN, NULL);
 
                 GF_FREE ((char *)lock->basename);
+                GF_FREE (lock->connection_id);
                 GF_FREE (lock);
 
         }
@@ -601,6 +615,7 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
                 STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0, NULL);
 
                 GF_FREE ((char *)lock->basename);
+                GF_FREE (lock->connection_id);
                 GF_FREE (lock);
         }
 
@@ -611,7 +626,9 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
 int
 pl_common_entrylk (call_frame_t *frame, xlator_t *this,
                    const char *volume, inode_t *inode, const char *basename,
-                   entrylk_cmd cmd, entrylk_type type, loc_t *loc, fd_t *fd)
+                   entrylk_cmd cmd, entrylk_type type, loc_t *loc, fd_t *fd,
+                   dict_t *xdata)
+
 {
         int32_t  op_ret   = -1;
         int32_t  op_errno = 0;
@@ -624,6 +641,11 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this,
         char             unwind   = 1;
 
         pl_dom_list_t          *dom = NULL;
+        char            *conn_id  = NULL;
+        GF_UNUSED int    dict_ret = -1;
+
+        if (xdata)
+                dict_ret = dict_get_str (xdata, "connection-id", &conn_id);
 
         pinode = pl_inode_get (this, inode);
         if (!pinode) {
@@ -650,7 +672,8 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this,
                 gf_log (this->name, GF_LOG_TRACE,
                         "Releasing locks for transport %p", transport);
 
-                release_entry_locks_for_transport (this, pinode, dom, transport);
+                release_entry_locks_for_transport (this, pinode, dom,
+                                                   transport);
                 op_ret = 0;
 
                 goto out;
@@ -661,7 +684,7 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this,
                 pthread_mutex_lock (&pinode->mutex);
                 {
                         ret = __lock_name (pinode, basename, type,
-                                           frame, dom, this, 0);
+                                           frame, dom, this, 0, conn_id);
                 }
                 pthread_mutex_unlock (&pinode->mutex);
 
@@ -686,7 +709,7 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this,
                 pthread_mutex_lock (&pinode->mutex);
                 {
                         ret = __lock_name (pinode, basename, type,
-                                           frame, dom, this, 1);
+                                           frame, dom, this, 1, conn_id);
                 }
                 pthread_mutex_unlock (&pinode->mutex);
 
@@ -742,10 +765,11 @@ out:
 int
 pl_entrylk (call_frame_t *frame, xlator_t *this,
             const char *volume, loc_t *loc, const char *basename,
-            entrylk_cmd cmd, entrylk_type type)
+            entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
 
-        pl_common_entrylk (frame, this, volume, loc->inode, basename, cmd, type, loc, NULL);
+        pl_common_entrylk (frame, this, volume, loc->inode, basename, cmd,
+                           type, loc, NULL, xdata);
 
         return 0;
 }
@@ -760,10 +784,11 @@ pl_entrylk (call_frame_t *frame, xlator_t *this,
 int
 pl_fentrylk (call_frame_t *frame, xlator_t *this,
              const char *volume, fd_t *fd, const char *basename,
-             entrylk_cmd cmd, entrylk_type type)
+             entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
 
-        pl_common_entrylk (frame, this, volume, fd->inode, basename, cmd, type, NULL, fd);
+        pl_common_entrylk (frame, this, volume, fd->inode, basename, cmd,
+                           type, NULL, fd, xdata);
 
         return 0;
 }
diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c
index 2fd8b6c293b..7b5c170337e 100644
--- a/xlators/features/locks/src/inodelk.c
+++ b/xlators/features/locks/src/inodelk.c
@@ -39,8 +39,10 @@ inline void
 __pl_inodelk_unref (pl_inode_lock_t *lock)
 {
         lock->ref--;
-        if (!lock->ref)
+        if (!lock->ref) {
+                GF_FREE (lock->connection_id);
                 GF_FREE (lock);
+        }
 }
 
 /* Check if 2 inodelks are conflicting on type. Only 2 shared locks don't conflict */
@@ -333,7 +335,8 @@ __grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode,
 
 /* Grant all inodelks blocked on a lock */
 void
-grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode, pl_dom_list_t *dom)
+grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode,
+                           pl_dom_list_t *dom)
 {
         struct list_head granted;
         pl_inode_lock_t *lock;
@@ -516,7 +519,8 @@ out:
 /* Create a new inode_lock_t */
 pl_inode_lock_t *
 new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
-                gf_lkowner_t *owner, const char *volume)
+                call_frame_t *frame, xlator_t *this, const char *volume,
+                char *conn_id)
 
 {
         pl_inode_lock_t *lock = NULL;
@@ -538,7 +542,13 @@ new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
         lock->transport  = transport;
         lock->client_pid = client_pid;
         lock->volume     = volume;
-        lock->owner      = *owner;
+        lock->owner      = frame->root->lk_owner;
+        lock->frame      = frame;
+        lock->this       = this;
+
+        if (conn_id) {
+                lock->connection_id = gf_strdup (conn_id);
+        }
 
         INIT_LIST_HEAD (&lock->list);
         INIT_LIST_HEAD (&lock->blocked_locks);
@@ -582,11 +592,12 @@ _pl_convert_volume_for_special_range (struct gf_flock *flock,
 int
 pl_common_inodelk (call_frame_t *frame, xlator_t *this,
                    const char *volume, inode_t *inode, int32_t cmd,
-                   struct gf_flock *flock, loc_t *loc, fd_t *fd)
+                   struct gf_flock *flock, loc_t *loc, fd_t *fd, dict_t *xdata)
 {
         int32_t           op_ret     = -1;
         int32_t           op_errno   = 0;
         int               ret        = -1;
+        GF_UNUSED int     dict_ret   = -1;
         int               can_block  = 0;
         pid_t             client_pid = -1;
         void *            transport  = NULL;
@@ -595,6 +606,10 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
         pl_dom_list_t *   dom        = NULL;
         char             *res        = NULL;
         char             *res1       = NULL;
+        char             *conn_id     = NULL;
+
+        if (xdata)
+                dict_ret = dict_get_str (xdata, "connection-id", &conn_id);
 
         VALIDATE_OR_GOTO (frame, out);
         VALIDATE_OR_GOTO (inode, unwind);
@@ -650,7 +665,7 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
         }
 
         reqlock = new_inode_lock (flock, transport, client_pid,
-                                  &frame->root->lk_owner, volume);
+                                  frame, this, volume, conn_id);
 
         if (!reqlock) {
                 op_ret = -1;
@@ -658,14 +673,10 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
                 goto unwind;
         }
 
-        reqlock->frame = frame;
-        reqlock->this  = this;
 
         switch (cmd) {
         case F_SETLKW:
                 can_block = 1;
-                reqlock->frame = frame;
-                reqlock->this  = this;
 
                 /* fall through */
 
@@ -712,20 +723,24 @@ out:
 
 int
 pl_inodelk (call_frame_t *frame, xlator_t *this,
-            const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock)
+            const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock,
+            dict_t *xdata)
 {
 
-        pl_common_inodelk (frame, this, volume, loc->inode, cmd, flock, loc, NULL);
+        pl_common_inodelk (frame, this, volume, loc->inode, cmd, flock, loc, NULL,
+                           xdata);
 
         return 0;
 }
 
 int
 pl_finodelk (call_frame_t *frame, xlator_t *this,
-             const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *flock)
+             const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *flock,
+             dict_t *xdata)
 {
 
-        pl_common_inodelk (frame, this, volume, fd->inode, cmd, flock, NULL, fd);
+        pl_common_inodelk (frame, this, volume, fd->inode, cmd, flock, NULL, fd,
+                           xdata);
 
         return 0;
 
diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h
index 43b67476042..5bd0b05e05f 100644
--- a/xlators/features/locks/src/locks.h
+++ b/xlators/features/locks/src/locks.h
@@ -78,6 +78,8 @@ struct __pl_inode_lock {
         void              *transport;     /* to identify client node */
         gf_lkowner_t       owner;
         pid_t              client_pid;    /* pid of client process */
+
+        char              *connection_id; /* stores the client connection id */
 };
 typedef struct __pl_inode_lock pl_inode_lock_t;
 
@@ -115,7 +117,9 @@ struct __entry_lock {
 
         void             *trans;
         gf_lkowner_t      owner;
-        pid_t             client_pid;    /* pid of client process */
+	pid_t             client_pid;    /* pid of client process */
+
+        char             *connection_id; /* stores the client connection id */
 };
 typedef struct __entry_lock pl_entry_lock_t;
 
diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c
index ec670cda82e..0d6f32fa328 100644
--- a/xlators/features/locks/src/posix.c
+++ b/xlators/features/locks/src/posix.c
@@ -1764,6 +1764,7 @@ pl_forget (xlator_t *this,
                                         list_del_init (&entry_l->domain_list);
 
                                         GF_FREE ((char *)entry_l->basename);
+                                        GF_FREE (entry_l->connection_id);
                                         GF_FREE (entry_l);
                                 }
 
@@ -1797,6 +1798,7 @@ pl_forget (xlator_t *this,
 
                 STACK_UNWIND_STRICT (entrylk, entry_l->frame, -1, 0, NULL);
                 GF_FREE ((char *)entry_l->basename);
+                GF_FREE (entry_l->connection_id);
                 GF_FREE (entry_l);
 
         }
@@ -2161,8 +2163,8 @@ out:
 
 void
 pl_dump_lock (char *str, int size, struct gf_flock *flock,
-              gf_lkowner_t *owner, void *trans, time_t *granted_time,
-              time_t *blkd_time, gf_boolean_t active)
+              gf_lkowner_t *owner, void *trans, char *conn_id,
+              time_t *granted_time, time_t *blkd_time, gf_boolean_t active)
 {
         char  *type_str    = NULL;
         char   granted[32] = {0,};
@@ -2190,7 +2192,7 @@ pl_dump_lock (char *str, int size, struct gf_flock *flock,
                                   (unsigned long long) flock->l_start,
                                   (unsigned long long) flock->l_len,
                                   (unsigned long long) flock->l_pid,
-                                  lkowner_utoa (owner), trans,
+                                  lkowner_utoa (owner), trans, conn_id,
                                   ctime_r (granted_time, granted));
                 } else {
                         snprintf (str, size, RANGE_BLKD_GRNTD_FMT,
@@ -2198,7 +2200,7 @@ pl_dump_lock (char *str, int size, struct gf_flock *flock,
                                   (unsigned long long) flock->l_start,
                                   (unsigned long long) flock->l_len,
                                   (unsigned long long) flock->l_pid,
-                                  lkowner_utoa (owner), trans,
+                                  lkowner_utoa (owner), trans, conn_id,
                                   ctime_r (blkd_time, blocked),
                                   ctime_r (granted_time, granted));
                 }
@@ -2209,7 +2211,7 @@ pl_dump_lock (char *str, int size, struct gf_flock *flock,
                           (unsigned long long) flock->l_start,
                           (unsigned long long) flock->l_len,
                           (unsigned long long) flock->l_pid,
-                          lkowner_utoa (owner), trans,
+                          lkowner_utoa (owner), trans, conn_id,
                           ctime_r (blkd_time, blocked));
         }
 
@@ -2247,6 +2249,7 @@ __dump_entrylks (pl_inode_t *pl_inode)
                                           "ENTRYLK_WRLCK", lock->basename,
                                           (unsigned long long) lock->client_pid,
                                           lkowner_utoa (&lock->owner), lock->trans,
+                                          lock->connection_id,
                                           ctime_r (&lock->granted_time.tv_sec, granted));
                         } else {
                                 snprintf (tmp, 256, ENTRY_BLKD_GRNTD_FMT,
@@ -2254,6 +2257,7 @@ __dump_entrylks (pl_inode_t *pl_inode)
                                           "ENTRYLK_WRLCK", lock->basename,
                                           (unsigned long long) lock->client_pid,
                                           lkowner_utoa (&lock->owner), lock->trans,
+                                          lock->connection_id,
                                           ctime_r (&lock->blkd_time.tv_sec, blocked),
                                           ctime_r (&lock->granted_time.tv_sec, granted));
                         }
@@ -2273,6 +2277,7 @@ __dump_entrylks (pl_inode_t *pl_inode)
                                   "ENTRYLK_WRLCK", lock->basename,
                                   (unsigned long long) lock->client_pid,
                                   lkowner_utoa (&lock->owner), lock->trans,
+                                  lock->connection_id,
                                   ctime_r (&lock->blkd_time.tv_sec, blocked));
 
                         gf_proc_dump_write(key, tmp);
@@ -2323,7 +2328,7 @@ __dump_inodelks (pl_inode_t *pl_inode)
                         SET_FLOCK_PID (&lock->user_flock, lock);
                         pl_dump_lock (tmp, 256, &lock->user_flock,
                                       &lock->owner,
-                                      lock->transport,
+                                      lock->transport, lock->connection_id,
                                       &lock->granted_time.tv_sec,
                                       &lock->blkd_time.tv_sec,
                                       _gf_true);
@@ -2340,7 +2345,7 @@ __dump_inodelks (pl_inode_t *pl_inode)
                         SET_FLOCK_PID (&lock->user_flock, lock);
                         pl_dump_lock (tmp, 256, &lock->user_flock,
                                       &lock->owner,
-                                      lock->transport,
+                                      lock->transport, lock->connection_id,
                                       0, &lock->blkd_time.tv_sec,
                                       _gf_false);
                         gf_proc_dump_write(key, tmp);
@@ -2381,7 +2386,7 @@ __dump_posixlks (pl_inode_t *pl_inode)
                                      count,
                                      lock->blocked ? "BLOCKED" : "ACTIVE");
               pl_dump_lock (tmp, 256, &lock->user_flock,
-                            &lock->owner, lock->transport,
+                            &lock->owner, lock->transport, NULL,
                             &lock->granted_time.tv_sec, &lock->blkd_time.tv_sec,
                             (lock->blocked)? _gf_false: _gf_true);
               gf_proc_dump_write(key, tmp);
diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c
index 9a0c777e5e7..f0a896131f9 100644
--- a/xlators/protocol/server/src/server-rpc-fops.c
+++ b/xlators/protocol/server/src/server-rpc-fops.c
@@ -2206,6 +2206,7 @@ err:
 int
 server_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
 {
+        GF_UNUSED  int  ret   = -1;
         server_state_t *state = NULL;
 
         state = CALL_STATE (frame);
@@ -2213,6 +2214,13 @@ server_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
         if (state->resolve.op_ret != 0)
                 goto err;
 
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    state->client->server_ctx.client_uid);
+
         STACK_WIND (frame, server_fentrylk_cbk, bound_xl,
                     bound_xl->fops->fentrylk,
                     state->volume, state->fd, state->name,
@@ -2229,6 +2237,7 @@ err:
 int
 server_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
 {
+        GF_UNUSED int   ret   = -1;
         server_state_t *state = NULL;
 
         state = CALL_STATE (frame);
@@ -2236,6 +2245,13 @@ server_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
         if (state->resolve.op_ret != 0)
                 goto err;
 
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    state->client->server_ctx.client_uid);
+
         STACK_WIND (frame, server_entrylk_cbk,
                     bound_xl, bound_xl->fops->entrylk,
                     state->volume, &state->loc, state->name,
@@ -2251,6 +2267,7 @@ err:
 int
 server_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
 {
+        GF_UNUSED int   ret   = -1;
         server_state_t *state = NULL;
 
         state = CALL_STATE (frame);
@@ -2258,6 +2275,13 @@ server_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
         if (state->resolve.op_ret != 0)
                 goto err;
 
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    state->client->server_ctx.client_uid);
+
         STACK_WIND (frame, server_finodelk_cbk, bound_xl,
                     bound_xl->fops->finodelk, state->volume, state->fd,
                     state->cmd, &state->flock, state->xdata);
@@ -2273,6 +2297,7 @@ err:
 int
 server_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
 {
+        GF_UNUSED int   ret   = -1;
         server_state_t *state = NULL;
 
         state = CALL_STATE (frame);
@@ -2280,6 +2305,13 @@ server_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
         if (state->resolve.op_ret != 0)
                 goto err;
 
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    state->client->server_ctx.client_uid);
+
         STACK_WIND (frame, server_inodelk_cbk, bound_xl,
                     bound_xl->fops->inodelk, state->volume, &state->loc,
                     state->cmd, &state->flock, state->xdata);