core: change lk-owner as a 1k buffer

so, NLM can send the lk-owner field directly to the locks translators,
while doing the same effort, also enabled sending maximum of 500 aux gid
over protocol.

Change-Id: I87c2514392748416f7ffe21d5154faad2e413969
Signed-off-by: Amar Tumballi <amar@gluster.com>
BUG: 767229
Reviewed-on: http://review.gluster.com/779
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@gluster.com>

8 files changed, 138 insertions, 137 deletions

diff --git a/xlators/features/locks/src/common.c b/xlators/features/locks/src/common.c
index f6b9c331575..0bc7baa3011 100644
--- a/xlators/features/locks/src/common.c
+++ b/xlators/features/locks/src/common.c
@@ -143,9 +143,9 @@ __pl_inode_is_empty (pl_inode_t *pl_inode)
 void
 pl_print_locker (char *str, int size, xlator_t *this, call_frame_t *frame)
 {
-        snprintf (str, size, "Pid=%llu, lk-owner=%llu, Transport=%p, Frame=%llu",
+        snprintf (str, size, "Pid=%llu, lk-owner=%s, Transport=%p, Frame=%llu",
                   (unsigned long long) frame->root->pid,
-                  (unsigned long long) frame->root->lk_owner,
+                  lkowner_utoa (&frame->root->lk_owner),
                   (void *)frame->root->trans,
                   (unsigned long long) frame->root->unique);
 }
@@ -187,7 +187,7 @@ pl_print_lockee (char *str, int size, fd_t *fd, loc_t *loc)
 
 void
 pl_print_lock (char *str, int size, int cmd,
-               struct gf_flock *flock, uint64_t owner)
+               struct gf_flock *flock, gf_lkowner_t *owner)
 {
         char *cmd_str = NULL;
         char *type_str = NULL;
@@ -235,11 +235,11 @@ pl_print_lock (char *str, int size, int cmd,
         }
 
         snprintf (str, size, "lock=FCNTL, cmd=%s, type=%s, "
-                  "start=%llu, len=%llu, pid=%llu, lk-owner=%llu",
+                  "start=%llu, len=%llu, pid=%llu, lk-owner=%s",
                   cmd_str, type_str, (unsigned long long) flock->l_start,
                   (unsigned long long) flock->l_len,
                   (unsigned long long) flock->l_pid,
-                  (unsigned long long) owner);
+                  lkowner_utoa (owner));
 }
 
 
@@ -262,7 +262,7 @@ pl_trace_in (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc,
         if (domain)
                 pl_print_inodelk (pl_lock, 256, cmd, flock, domain);
         else
-                pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner);
+                pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner);
 
         gf_log (this->name, GF_LOG_INFO,
                 "[REQUEST] Locker = {%s} Lockee = {%s} Lock = {%s}",
@@ -312,7 +312,7 @@ pl_trace_out (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc,
         if (domain)
                 pl_print_inodelk (pl_lock, 256, cmd, flock, domain);
         else
-                pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner);
+                pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner);
 
         pl_print_verdict (verdict, 32, op_ret, op_errno);
 
@@ -342,7 +342,7 @@ pl_trace_block (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc,
         if (domain)
                 pl_print_inodelk (pl_lock, 256, cmd, flock, domain);
         else
-                pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner);
+                pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner);
 
         gf_log (this->name, GF_LOG_INFO,
                 "[BLOCKED] Locker = {%s} Lockee = {%s} Lock = {%s}",
@@ -468,7 +468,7 @@ out:
 /* Create a new posix_lock_t */
 posix_lock_t *
 new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
-                uint64_t owner, fd_t *fd)
+                gf_lkowner_t *owner, fd_t *fd)
 {
         posix_lock_t *lock = NULL;
 
@@ -494,7 +494,7 @@ new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
         lock->fd_num     = fd_to_fdnum (fd);
         lock->fd         = fd;
         lock->client_pid = client_pid;
-        lock->owner      = owner;
+        lock->owner      = *owner;
 
         INIT_LIST_HEAD (&lock->list);
 
@@ -569,8 +569,8 @@ int
 same_owner (posix_lock_t *l1, posix_lock_t *l2)
 {
 
-                return ((l1->owner == l2->owner) &&
-                        (l1->transport  == l2->transport));
+        return (is_same_lkowner (&l1->owner, &l2->owner) &&
+                (l1->transport  == l2->transport));
 
 }
 
@@ -889,10 +889,9 @@ __grant_blocked_locks (xlator_t *this, pl_inode_t *pl_inode, struct list_head *g
                         posix_lock_to_flock (l, &conf->user_flock);
 
                         gf_log (this->name, GF_LOG_TRACE,
-                                "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Granted",
+                                "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Granted",
                                 l->fl_type == F_UNLCK ? "Unlock" : "Lock",
-                                l->client_pid,
-                                l->owner,
+                                l->client_pid, lkowner_utoa (&l->owner),
                                 l->user_flock.l_start,
                                 l->user_flock.l_len);
 
@@ -958,7 +957,7 @@ pl_send_prelock_unlock (xlator_t *this, pl_inode_t *pl_inode,
 
 
         unlock_lock = new_posix_lock (&flock, old_lock->transport,
-                                      old_lock->client_pid, old_lock->owner,
+                                      old_lock->client_pid, &old_lock->owner,
                                       old_lock->fd);
         GF_VALIDATE_OR_GOTO (this->name, unlock_lock, out);
         ret = 0;
@@ -1011,19 +1010,19 @@ pl_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock,
 
                 if (__is_lock_grantable (pl_inode, lock)) {
                         gf_log (this->name, GF_LOG_TRACE,
-                                "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => OK",
+                                "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => OK",
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len);
                         __insert_and_merge (pl_inode, lock);
                 } else if (can_block) {
                         gf_log (this->name, GF_LOG_TRACE,
-                                "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked",
+                                "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked",
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len);
                         lock->blocked = 1;
@@ -1031,10 +1030,10 @@ pl_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock,
                         ret = -1;
                 } else {
                         gf_log (this->name, GF_LOG_TRACE,
-                                "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => NOK",
+                                "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => NOK",
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len);
                         errno = EAGAIN;
diff --git a/xlators/features/locks/src/common.h b/xlators/features/locks/src/common.h
index d95e287cb94..0c0dd22e7ca 100644
--- a/xlators/features/locks/src/common.h
+++ b/xlators/features/locks/src/common.h
@@ -20,10 +20,12 @@
 #ifndef __COMMON_H__
 #define __COMMON_H__
 
+#include "lkowner.h"
+
 #define SET_FLOCK_PID(flock, lock) ((flock)->l_pid = lock->client_pid)
 posix_lock_t *
 new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
-                uint64_t owner, fd_t *fd);
+                gf_lkowner_t *owner, fd_t *fd);
 
 pl_inode_t *
 pl_inode_get (xlator_t *this, inode_t *inode);
diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c
index 886a30b0ef2..3e91b9d9467 100644
--- a/xlators/features/locks/src/entrylk.c
+++ b/xlators/features/locks/src/entrylk.c
@@ -35,7 +35,8 @@
 
 static pl_entry_lock_t *
 new_entrylk_lock (pl_inode_t *pinode, const char *basename, entrylk_type type,
-                  void *trans, pid_t client_pid, uint64_t owner, const char *volume)
+                  void *trans, pid_t client_pid, gf_lkowner_t *owner,
+                  const char *volume)
 
 {
         pl_entry_lock_t *newlock = NULL;
@@ -46,12 +47,12 @@ new_entrylk_lock (pl_inode_t *pinode, const char *basename, entrylk_type type,
                 goto out;
         }
 
-        newlock->basename       = basename ? gf_strdup (basename) : NULL;
-        newlock->type           = type;
-        newlock->trans          = trans;
-        newlock->volume         = volume;
-        newlock->client_pid     = client_pid;
-        newlock->owner          = owner;
+        newlock->basename   = basename ? gf_strdup (basename) : NULL;
+        newlock->type       = type;
+        newlock->trans      = trans;
+        newlock->volume     = volume;
+        newlock->client_pid = client_pid;
+        newlock->owner      = *owner;
 
         INIT_LIST_HEAD (&newlock->domain_list);
         INIT_LIST_HEAD (&newlock->blocked_locks);
@@ -81,11 +82,11 @@ names_conflict (const char *n1, const char *n2)
 }
 
 
-static int
+static inline int
 __same_entrylk_owner (pl_entry_lock_t *l1, pl_entry_lock_t *l2)
 {
 
-        return ((l1->owner == l2->owner) &&
+        return (is_same_lkowner (&l1->owner, &l2->owner) &&
                 (l1->trans  == l2->trans));
 }
 
@@ -320,15 +321,13 @@ __lock_name (pl_inode_t *pinode, const char *basename, entrylk_type type,
         pl_entry_lock_t *conf       = NULL;
         void            *trans      = NULL;
         pid_t            client_pid = 0;
-        uint64_t         owner      = 0;
-
-        int ret = -EINVAL;
+        int              ret        = -EINVAL;
 
         trans = frame->root->trans;
         client_pid = frame->root->pid;
-        owner      = frame->root->lk_owner;
 
-        lock = new_entrylk_lock (pinode, basename, type, trans, client_pid, owner, dom->domain);
+        lock = new_entrylk_lock (pinode, basename, type, trans, client_pid,
+                                 &frame->root->lk_owner, dom->domain);
         if (!lock) {
                 ret = -ENOMEM;
                 goto out;
@@ -601,7 +600,6 @@ 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)
 {
-        uint64_t owner    = 0;
         int32_t  op_ret   = -1;
         int32_t  op_errno = 0;
 
@@ -628,10 +626,9 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this,
 
         entrylk_trace_in (this, frame, volume, fd, loc, basename, cmd, type);
 
-        owner     = frame->root->lk_owner;
         transport = frame->root->trans;
 
-        if (owner == 0) {
+        if (frame->root->lk_owner.len == 0) {
                 /*
                   this is a special case that means release
                   all locks from this transport
diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c
index 1db08e05858..5785f1f8e3f 100644
--- a/xlators/features/locks/src/inodelk.c
+++ b/xlators/features/locks/src/inodelk.c
@@ -120,9 +120,10 @@ inodelk_overlap (pl_inode_lock_t *l1, pl_inode_lock_t *l2)
 }
 
 /* Returns true if the 2 inodelks have the same owner */
-static int same_inodelk_owner (pl_inode_lock_t *l1, pl_inode_lock_t *l2)
+static inline int
+same_inodelk_owner (pl_inode_lock_t *l1, pl_inode_lock_t *l2)
 {
-        return ((l1->owner == l2->owner) &&
+        return (is_same_lkowner (&l1->owner, &l2->owner) &&
                 (l1->transport  == l2->transport));
 }
 
@@ -212,10 +213,10 @@ __lock_inodelk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock,
                 list_add_tail (&lock->blocked_locks, &dom->blocked_inodelks);
 
                 gf_log (this->name, GF_LOG_TRACE,
-                        "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked",
+                        "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked",
                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                         lock->client_pid,
-                        lock->owner,
+                        lkowner_utoa (&lock->owner),
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
@@ -234,10 +235,10 @@ __lock_inodelk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock,
                 gf_log (this->name, GF_LOG_TRACE,
                         "Lock is grantable, but blocking to prevent starvation");
                 gf_log (this->name, GF_LOG_TRACE,
-                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Blocked",
+                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Blocked",
                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                         lock->client_pid,
-                        lock->owner,
+                        lkowner_utoa (&lock->owner),
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
@@ -352,10 +353,10 @@ grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode, pl_dom_list_t *
 
         list_for_each_entry_safe (lock, tmp, &granted, blocked_locks) {
                 gf_log (this->name, GF_LOG_TRACE,
-                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Granted",
+                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Granted",
                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                         lock->client_pid,
-                        lock->owner,
+                        lkowner_utoa (&lock->owner),
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
@@ -405,8 +406,9 @@ release_inode_locks_of_transport (xlator_t *this, pl_dom_list_t *dom,
 
                         gf_log (this->name, GF_LOG_DEBUG,
                                 "releasing blocking lock on %s held by "
-                                "{transport=%p, pid=%"PRId64" lk-owner=%"PRIu64"}",
-                                file, trans, (uint64_t) l->client_pid, l->owner);
+                                "{transport=%p, pid=%"PRId64" lk-owner=%s}",
+                                file, trans, (uint64_t) l->client_pid,
+                                lkowner_utoa (&l->owner));
 
                         list_add (&l->blocked_locks, &released);
                         if (path) {
@@ -430,8 +432,9 @@ release_inode_locks_of_transport (xlator_t *this, pl_dom_list_t *dom,
 
                         gf_log (this->name, GF_LOG_DEBUG,
                                 "releasing granted lock on %s held by "
-                                "{transport=%p, pid=%"PRId64" lk-owner=%"PRIu64"}",
-                                file, trans, (uint64_t) l->client_pid, l->owner);
+                                "{transport=%p, pid=%"PRId64" lk-owner=%s}",
+                                file, trans, (uint64_t) l->client_pid,
+                                lkowner_utoa (&l->owner));
                         if (path) {
                                 GF_FREE (path);
                                 path = NULL;
@@ -468,19 +471,19 @@ pl_inode_setlk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock,
                         ret = __lock_inodelk (this, pl_inode, lock, can_block, dom);
                         if (ret == 0)
                                 gf_log (this->name, GF_LOG_TRACE,
-                                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => OK",
+                                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => OK",
                                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                         lock->client_pid,
-                                        lock->owner,
+                                        lkowner_utoa (&lock->owner),
                                         lock->fl_start,
                                         lock->fl_end);
 
                         if (ret == -EAGAIN)
                                 gf_log (this->name, GF_LOG_TRACE,
-                                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => NOK",
+                                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => NOK",
                                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                         lock->client_pid,
-                                        lock->owner,
+                                        lkowner_utoa (&lock->owner),
                                         lock->user_flock.l_start,
                                         lock->user_flock.l_len);
 
@@ -510,7 +513,7 @@ out:
 /* Create a new inode_lock_t */
 pl_inode_lock_t *
 new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
-                uint64_t owner, const char *volume)
+                gf_lkowner_t *owner, const char *volume)
 
 {
         pl_inode_lock_t *lock = NULL;
@@ -531,8 +534,8 @@ new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid,
 
         lock->transport  = transport;
         lock->client_pid = client_pid;
-        lock->owner      = owner;
         lock->volume     = volume;
+        lock->owner      = *owner;
 
         INIT_LIST_HEAD (&lock->list);
         INIT_LIST_HEAD (&lock->blocked_locks);
@@ -546,16 +549,15 @@ 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)
 {
-        int32_t op_ret   = -1;
-        int32_t op_errno = 0;
-        int     ret      = -1;
-        int     can_block = 0;
-        void *                  transport  = NULL;
-        pid_t                   client_pid = -1;
-        uint64_t                owner      = -1;
-        pl_inode_t *            pinode     = NULL;
-        pl_inode_lock_t *       reqlock    = NULL;
-        pl_dom_list_t *                dom           = NULL;
+        int32_t           op_ret     = -1;
+        int32_t           op_errno   = 0;
+        int               ret        = -1;
+        int               can_block  = 0;
+        pid_t             client_pid = -1;
+        void *            transport  = NULL;
+        pl_inode_t *      pinode     = NULL;
+        pl_inode_lock_t * reqlock    = NULL;
+        pl_dom_list_t *   dom        = NULL;
 
         VALIDATE_OR_GOTO (frame, out);
         VALIDATE_OR_GOTO (inode, unwind);
@@ -570,7 +572,6 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
 
         transport  = frame->root->trans;
         client_pid = frame->root->pid;
-        owner      = frame->root->lk_owner;
 
         pinode = pl_inode_get (this, inode);
         if (!pinode) {
@@ -580,7 +581,7 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
 
         dom = get_domain (pinode, volume);
 
-        if (owner == 0) {
+        if (frame->root->lk_owner.len == 0) {
                 /*
                   special case: this means release all locks
                   from this transport
@@ -594,7 +595,8 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this,
                 goto unwind;
         }
 
-        reqlock = new_inode_lock (flock, transport, client_pid, owner, volume);
+        reqlock = new_inode_lock (flock, transport, client_pid,
+                                  &frame->root->lk_owner, volume);
 
         if (!reqlock) {
                 op_ret = -1;
@@ -687,12 +689,12 @@ __get_inodelk_count (xlator_t *this, pl_inode_t *pl_inode)
 
                         gf_log (this->name, GF_LOG_DEBUG,
                                 " XATTR DEBUG"
-                                " domain: %s %s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" "
+                                " domain: %s %s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" "
                                 "state = Active",
                                 dom->domain,
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len);
 
@@ -703,12 +705,12 @@ __get_inodelk_count (xlator_t *this, pl_inode_t *pl_inode)
 
                         gf_log (this->name, GF_LOG_DEBUG,
                                 " XATTR DEBUG"
-                                " domain: %s %s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" "
+                                " domain: %s %s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" "
                                 "state = Blocked",
                                 dom->domain,
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len);
 
diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h
index 476b9a83cd6..0dcbdf97901 100644
--- a/xlators/features/locks/src/locks.h
+++ b/xlators/features/locks/src/locks.h
@@ -30,6 +30,8 @@
 #include "call-stub.h"
 #include "locks-mem-types.h"
 
+#include "lkowner.h"
+
 #define POSIX_LOCKS "posix-locks"
 struct __pl_fd;
 
@@ -55,8 +57,8 @@ struct __posix_lock {
            across nodes */
 
         void              *transport;     /* to identify client node */
+        gf_lkowner_t       owner;
         pid_t              client_pid;    /* pid of client process */
-        uint64_t           owner;         /* lock owner from fuse */
 };
 typedef struct __posix_lock posix_lock_t;
 
@@ -83,8 +85,8 @@ struct __pl_inode_lock {
            across nodes */
 
         void              *transport;     /* to identify client node */
+        gf_lkowner_t       owner;
         pid_t              client_pid;    /* pid of client process */
-        uint64_t           owner;
 };
 typedef struct __pl_inode_lock pl_inode_lock_t;
 
@@ -120,9 +122,9 @@ struct __entry_lock {
         struct timeval     blkd_time;   /*time at which lock was queued into blkd list*/
         struct timeval     granted_time; /*time at which lock was queued into active list*/
 
-        void      *trans;
+        void             *trans;
+        gf_lkowner_t      owner;
         pid_t             client_pid;    /* pid of client process */
-        uint64_t          owner;
 };
 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 59e2199fb4b..0914d16df41 100644
--- a/xlators/features/locks/src/posix.c
+++ b/xlators/features/locks/src/posix.c
@@ -126,7 +126,7 @@ pl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 static int
 truncate_allowed (pl_inode_t *pl_inode,
                   void *transport, pid_t client_pid,
-                  uint64_t owner, off_t offset)
+                  gf_lkowner_t *owner, off_t offset)
 {
         posix_lock_t *l = NULL;
         posix_lock_t  region = {.list = {0, }, };
@@ -136,7 +136,7 @@ truncate_allowed (pl_inode_t *pl_inode,
         region.fl_end     = LLONG_MAX;
         region.transport  = transport;
         region.client_pid = client_pid;
-        region.owner      = owner;
+        region.owner      = *owner;
 
         pthread_mutex_lock (&pl_inode->mutex);
         {
@@ -192,7 +192,7 @@ truncate_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if (priv->mandatory
             && pl_inode->mandatory
             && !truncate_allowed (pl_inode, frame->root->trans,
-                                  frame->root->pid, frame->root->lk_owner,
+                                  frame->root->pid, &frame->root->lk_owner,
                                   local->offset)) {
                 op_ret   = -1;
                 op_errno = EAGAIN;
@@ -324,7 +324,7 @@ delete_locks_of_fd (xlator_t *this, pl_inode_t *pl_inode, fd_t *fd)
 
 static void
 __delete_locks_of_owner (pl_inode_t *pl_inode,
-                         void *transport, uint64_t owner)
+                         void *transport, gf_lkowner_t *owner)
 {
         posix_lock_t *tmp = NULL;
         posix_lock_t *l = NULL;
@@ -332,14 +332,14 @@ __delete_locks_of_owner (pl_inode_t *pl_inode,
         /* TODO: what if it is a blocked lock with pending l->frame */
 
         list_for_each_entry_safe (l, tmp, &pl_inode->ext_list, list) {
-                if ((l->transport == transport)
-                    && (l->owner == owner)) {
+                if ((l->transport == transport) &&
+                    is_same_lkowner (&l->owner, owner)) {
                         gf_log ("posix-locks", GF_LOG_TRACE,
                                 " Flushing lock"
-                                "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" state: %s",
+                                "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" state: %s",
                                 l->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 l->client_pid,
-                                l->owner,
+                                lkowner_utoa (&l->owner),
                                 l->user_flock.l_start,
                                 l->user_flock.l_len,
                                 l->blocked == 1 ? "Blocked" : "Active");
@@ -408,10 +408,7 @@ int
 pl_flush (call_frame_t *frame, xlator_t *this,
           fd_t *fd)
 {
-        pl_inode_t            *pl_inode = NULL;
-        uint64_t              owner     = -1;
-
-        owner = frame->root->lk_owner;
+        pl_inode_t *pl_inode = NULL;
 
         pl_inode = pl_inode_get (this, fd->inode);
 
@@ -423,7 +420,7 @@ pl_flush (call_frame_t *frame, xlator_t *this,
 
         pl_trace_flush (this, frame, fd);
 
-        if (owner == 0) {
+        if (frame->root->lk_owner.len == 0) {
                 /* Handle special case when protocol/server sets lk-owner to zero.
                  * This usually happens due to a client disconnection. Hence, free
                  * all locks opened with this fd.
@@ -437,7 +434,7 @@ pl_flush (call_frame_t *frame, xlator_t *this,
         pthread_mutex_lock (&pl_inode->mutex);
         {
                 __delete_locks_of_owner (pl_inode, frame->root->trans,
-                                         owner);
+                                         &frame->root->lk_owner);
         }
         pthread_mutex_unlock (&pl_inode->mutex);
 
@@ -805,7 +802,7 @@ lock_dup (posix_lock_t *lock)
         posix_lock_t *new_lock = NULL;
 
         new_lock = new_posix_lock (&lock->user_flock, lock->transport,
-                                   lock->client_pid, lock->owner,
+                                   lock->client_pid, &lock->owner,
                                    (fd_t *)lock->fd_num);
         return new_lock;
 }
@@ -964,20 +961,18 @@ int
 pl_lk (call_frame_t *frame, xlator_t *this,
        fd_t *fd, int32_t cmd, struct gf_flock *flock)
 {
-        void                  *transport = NULL;
-        pid_t                  client_pid = 0;
-        uint64_t               owner      = 0;
-        pl_inode_t            *pl_inode = NULL;
-        int                    op_ret = 0;
-        int                    op_errno = 0;
-        int                    can_block = 0;
-        posix_lock_t          *reqlock = NULL;
-        posix_lock_t          *conf = NULL;
-        int                    ret = 0;
+        void         *transport  = NULL;
+        pid_t         client_pid = 0;
+        pl_inode_t   *pl_inode   = NULL;
+        int           op_ret     = 0;
+        int           op_errno   = 0;
+        int           can_block  = 0;
+        posix_lock_t *reqlock    = NULL;
+        posix_lock_t *conf       = NULL;
+        int           ret        = 0;
 
         transport  = frame->root->trans;
         client_pid = frame->root->pid;
-        owner      = frame->root->lk_owner;
 
         if ((flock->l_start < 0) || (flock->l_len < 0)) {
                 op_ret = -1;
@@ -993,7 +988,7 @@ pl_lk (call_frame_t *frame, xlator_t *this,
         }
 
         reqlock = new_posix_lock (flock, transport, client_pid,
-                                  owner, fd);
+                                  &frame->root->lk_owner, fd);
 
         if (!reqlock) {
                 op_ret = -1;
@@ -1327,10 +1322,10 @@ __get_posixlk_count (xlator_t *this, pl_inode_t *pl_inode)
 
                         gf_log (this->name, GF_LOG_DEBUG,
                                 " XATTR DEBUG"
-                                "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" state: %s",
+                                "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" state: %s",
                                 lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                 lock->client_pid,
-                                lock->owner,
+                                lkowner_utoa (&lock->owner),
                                 lock->user_flock.l_start,
                                 lock->user_flock.l_len,
                                 lock->blocked == 1 ? "Blocked" : "Active");
@@ -1504,7 +1499,7 @@ out:
 
 void
 pl_dump_lock (char *str, int size, struct gf_flock *flock,
-              uint64_t owner, void *trans, time_t *granted_time,
+              gf_lkowner_t *owner, void *trans, time_t *granted_time,
               time_t *blkd_time, gf_boolean_t active)
 {
         char *type_str = NULL;
@@ -1526,30 +1521,32 @@ pl_dump_lock (char *str, int size, struct gf_flock *flock,
 
         if (active) {
                 if (blkd_time && *blkd_time == 0) {
-                        snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, "
-                                  "granted at  %s",
+                        snprintf (str, size, "type=%s, start=%llu, len=%llu, "
+                                  "pid=%llu, lk-owner=%s, transport=%p, "
+                                  "granted at %s",
                                   type_str, (unsigned long long) flock->l_start,
                                   (unsigned long long) flock->l_len,
                                   (unsigned long long) flock->l_pid,
-                                  (unsigned long long) owner,
+                                  lkowner_utoa (owner),
                                   trans, ctime (granted_time));
                 } else {
-                        snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, "
+                        snprintf (str, size, "type=%s, start=%llu, len=%llu, "
+                                  "pid=%llu, lk-owner=%s, transport=%p, "
                                   "blocked at %s, granted at  %s",
                                   type_str, (unsigned long long) flock->l_start,
                                   (unsigned long long) flock->l_len,
                                   (unsigned long long) flock->l_pid,
-                                  (unsigned long long) owner,
+                                  lkowner_utoa (owner),
                                   trans, ctime (blkd_time), ctime (granted_time));
                 }
         }
         else {
-                snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, "
-                          "blocked at  %s",
+                snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, "
+                          "lk-owner=%s, transport=%p, blocked at  %s",
                           type_str, (unsigned long long) flock->l_start,
                           (unsigned long long) flock->l_len,
                           (unsigned long long) flock->l_pid,
-                          (unsigned long long) owner,
+                          lkowner_utoa (owner),
                           trans, ctime (blkd_time));
         }
 
@@ -1580,20 +1577,20 @@ __dump_entrylks (pl_inode_t *pl_inode)
                                                "xlator.feature.locks.lock-dump.domain.entrylk",
                                                "entrylk[%d](ACTIVE)", count );
                         if (lock->blkd_time.tv_sec == 0 && lock->blkd_time.tv_usec == 0) {
-                                snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p,"
+                                snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p,"
                                           " granted at %s",
                                           lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" :
                                           "ENTRYLK_WRLCK", lock->basename,
                                           (unsigned long long) lock->client_pid,
-                                          (unsigned long long) lock->owner, lock->trans,
+                                          lkowner_utoa (&lock->owner), lock->trans,
                                           ctime (&lock->granted_time.tv_sec));
                         } else {
-                                snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p,"
+                                snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p,"
                                           " blocked at %s, granted at %s",
                                           lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" :
                                           "ENTRYLK_WRLCK", lock->basename,
                                           (unsigned long long) lock->client_pid,
-                                          (unsigned long long) lock->owner, lock->trans,
+                                          lkowner_utoa (&lock->owner), lock->trans,
                                           ctime (&lock->blkd_time.tv_sec),
                                           ctime (&lock->granted_time.tv_sec));
                         }
@@ -1608,12 +1605,12 @@ __dump_entrylks (pl_inode_t *pl_inode)
                         gf_proc_dump_build_key(key,
                                                "xlator.feature.locks.lock-dump.domain.entrylk",
                                                "entrylk[%d](BLOCKED)", count );
-                        snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p,"
+                        snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p,"
                                   " blocked at %s",
                                   lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" :
                                   "ENTRYLK_WRLCK", lock->basename,
                                   (unsigned long long) lock->client_pid,
-                                  (unsigned long long) lock->owner, lock->trans,
+                                  lkowner_utoa (&lock->owner), lock->trans,
                                   ctime (&lock->blkd_time.tv_sec));
 
                         gf_proc_dump_write(key, tmp);
@@ -1663,7 +1660,8 @@ __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->owner,
+                                      lock->transport,
                                       &lock->granted_time.tv_sec,
                                       &lock->blkd_time.tv_sec,
                                       _gf_true);
@@ -1679,7 +1677,8 @@ __dump_inodelks (pl_inode_t *pl_inode)
                                                "inodelk[%d](BLOCKED)",count );
                         SET_FLOCK_PID (&lock->user_flock, lock);
                         pl_dump_lock (tmp, 256, &lock->user_flock,
-                                      lock->owner, lock->transport,
+                                      &lock->owner,
+                                      lock->transport,
                                       0, &lock->blkd_time.tv_sec,
                                       _gf_false);
                         gf_proc_dump_write(key, tmp);
@@ -1720,7 +1719,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,
                             &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/features/locks/src/reservelk.c b/xlators/features/locks/src/reservelk.c
index 4aac1803d8a..7a75cdea10d 100644
--- a/xlators/features/locks/src/reservelk.c
+++ b/xlators/features/locks/src/reservelk.c
@@ -81,10 +81,10 @@ out:
         return ret_lock;
 }
 
-static int
+static inline int
 __same_owner_reservelk (posix_lock_t *l1, posix_lock_t *l2)
 {
-        return ((l1->owner == l2->owner));
+        return (is_same_lkowner (&l1->owner, &l2->owner));
 
 }
 
@@ -187,10 +187,10 @@ __lock_reservelk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock,
                 list_add_tail (&lock->list, &pl_inode->blocked_reservelks);
 
                 gf_log (this->name, GF_LOG_TRACE,
-                        "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked",
+                        "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked",
                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                         lock->client_pid,
-                        lock->owner,
+                        lkowner_utoa (&lock->owner),
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
@@ -292,10 +292,10 @@ grant_blocked_reserve_locks (xlator_t *this, pl_inode_t *pl_inode)
 
         list_for_each_entry_safe (lock, tmp, &granted, list) {
                 gf_log (this->name, GF_LOG_TRACE,
-                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Granted",
+                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Granted",
                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                         lock->client_pid,
-                        lock->owner,
+                        lkowner_utoa (&lock->owner),
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
@@ -429,18 +429,18 @@ pl_reserve_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock,
                         ret = __lock_reservelk (this, pl_inode, lock, can_block);
                         if (ret < 0)
                                 gf_log (this->name, GF_LOG_TRACE,
-                                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => NOK",
+                                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => NOK",
                                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                         lock->client_pid,
-                                        lock->owner,
+                                        lkowner_utoa (&lock->owner),
                                         lock->user_flock.l_start,
                                         lock->user_flock.l_len);
                         else
                                 gf_log (this->name, GF_LOG_TRACE,
-                                        "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => OK",
+                                        "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => OK",
                                         lock->fl_type == F_UNLCK ? "Unlock" : "Lock",
                                         lock->client_pid,
-                                        lock->owner,
+                                        lkowner_utoa (&lock->owner),
                                         lock->fl_start,
                                         lock->fl_end);
 
diff --git a/xlators/features/marker/src/marker-quota.c b/xlators/features/marker/src/marker-quota.c
index 57e8470d67a..227c4951b35 100644
--- a/xlators/features/marker/src/marker-quota.c
+++ b/xlators/features/marker/src/marker-quota.c
@@ -152,7 +152,7 @@ mq_assign_lk_owner (xlator_t *this, call_frame_t *frame)
         }
         UNLOCK (&conf->lock);
 
-        frame->root->lk_owner = lk_owner;
+        set_lk_owner_from_uint64 (&frame->root->lk_owner, lk_owner);
 
         return;
 }