all: fix warnings on non 64-bits architectures

When compiling in other architectures there appear many warnings. Some
of them are actual problems that prevent gluster to work correctly on
those architectures.

Change-Id: Icdc7107a2bc2da662903c51910beddb84bdf03c0
fixes: bz#1632717
Signed-off-by: Xavi Hernandez <xhernandez@redhat.com>

11 files changed, 81 insertions, 71 deletions

diff --git a/xlators/cluster/ec/src/ec-combine.c b/xlators/cluster/ec/src/ec-combine.c
index 2e5111b38f8..454c2c72c95 100644
--- a/xlators/cluster/ec/src/ec-combine.c
+++ b/xlators/cluster/ec/src/ec-combine.c
@@ -174,8 +174,11 @@ ec_iatt_combine(ec_fop_data_t *fop, struct iatt *dst, struct iatt *src,
         }
         if (failed) {
             gf_msg(fop->xl->name, GF_LOG_WARNING, 0, EC_MSG_IATT_COMBINE_FAIL,
-                   "Failed to combine iatt (inode: %lu-%lu, links: %u-%u, "
-                   "uid: %u-%u, gid: %u-%u, rdev: %lu-%lu, size: %lu-%lu, "
+                   "Failed to combine iatt (inode: %" PRIu64 "-%" PRIu64
+                   ", "
+                   "links: %u-%u, uid: %u-%u, gid: %u-%u, "
+                   "rdev: %" PRIu64 "-%" PRIu64 ", size: %" PRIu64 "-%" PRIu64
+                   ", "
                    "mode: %o-%o)",
                    dst[i].ia_ino, src[i].ia_ino, dst[i].ia_nlink,
                    src[i].ia_nlink, dst[i].ia_uid, src[i].ia_uid, dst[i].ia_gid,
diff --git a/xlators/cluster/ec/src/ec-common.c b/xlators/cluster/ec/src/ec-common.c
index 0eee0a3363f..737f7fda882 100644
--- a/xlators/cluster/ec/src/ec-common.c
+++ b/xlators/cluster/ec/src/ec-common.c
@@ -132,22 +132,23 @@ out:
     loc_wipe(&loc);
 }
 
-off_t
-ec_range_end_get(off_t fl_start, size_t fl_size)
-{
-    off_t fl_end = 0;
-    switch (fl_size) {
-        case 0:
-            return fl_start;
-        case LLONG_MAX: /*Infinity*/
-            return LLONG_MAX;
-        default:
-            fl_end = fl_start + fl_size - 1;
-            if (fl_end < 0) /*over-flow*/
-                return LLONG_MAX;
-            else
-                return fl_end;
+static off_t
+ec_range_end_get(off_t fl_start, uint64_t fl_size)
+{
+    if (fl_size > 0) {
+        if (fl_size >= EC_RANGE_FULL) {
+            /* Infinity */
+            fl_start = LLONG_MAX;
+        } else {
+            fl_start += fl_size - 1;
+            if (fl_start < 0) {
+                /* Overflow */
+                fl_start = LLONG_MAX;
+            }
+        }
     }
+
+    return fl_start;
 }
 
 static gf_boolean_t
@@ -648,7 +649,7 @@ ec_child_select(ec_fop_data_t *fop)
     if ((fop->mask & ~ec->xl_up) != 0) {
         gf_msg(fop->xl->name, GF_LOG_WARNING, 0, EC_MSG_OP_EXEC_UNAVAIL,
                "Executing operation with "
-               "some subvolumes unavailable. (%lX). %s ",
+               "some subvolumes unavailable. (%" PRIXPTR "). %s ",
                fop->mask & ~ec->xl_up, ec_msg_str(fop));
         fop->mask &= ec->xl_up;
     }
@@ -870,7 +871,7 @@ ec_lock_allocate(ec_fop_data_t *fop, loc_t *loc)
 
     lock = mem_get0(ec->lock_pool);
     if (lock != NULL) {
-        lock->good_mask = -1ULL;
+        lock->good_mask = UINTPTR_MAX;
         INIT_LIST_HEAD(&lock->owners);
         INIT_LIST_HEAD(&lock->waiting);
         INIT_LIST_HEAD(&lock->frozen);
@@ -903,9 +904,9 @@ ec_lock_compare(ec_lock_t *lock1, ec_lock_t *lock2)
     return gf_uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
 }
 
-void
+static void
 ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock, uint32_t flags, loc_t *base,
-               off_t fl_start, size_t fl_size)
+               off_t fl_start, uint64_t fl_size)
 {
     ec_lock_link_t *link;
 
@@ -945,9 +946,9 @@ ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock, uint32_t flags, loc_t *base,
     lock->refs_pending++;
 }
 
-void
+static void
 ec_lock_prepare_inode_internal(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
-                               loc_t *base, off_t fl_start, size_t fl_size)
+                               loc_t *base, off_t fl_start, uint64_t fl_size)
 {
     ec_lock_t *lock = NULL;
     ec_inode_t *ctx;
@@ -1019,7 +1020,7 @@ unlock:
 
 void
 ec_lock_prepare_inode(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
-                      off_t fl_start, size_t fl_size)
+                      off_t fl_start, uint64_t fl_size)
 {
     ec_lock_prepare_inode_internal(fop, loc, flags, NULL, fl_start, fl_size);
 }
@@ -1048,14 +1049,14 @@ ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
         base = NULL;
     }
 
-    ec_lock_prepare_inode_internal(fop, &tmp, flags, base, 0, LLONG_MAX);
+    ec_lock_prepare_inode_internal(fop, &tmp, flags, base, 0, EC_RANGE_FULL);
 
     loc_wipe(&tmp);
 }
 
 void
 ec_lock_prepare_fd(ec_fop_data_t *fop, fd_t *fd, uint32_t flags, off_t fl_start,
-                   size_t fl_size)
+                   uint64_t fl_size)
 {
     loc_t loc;
     int32_t err;
diff --git a/xlators/cluster/ec/src/ec-common.h b/xlators/cluster/ec/src/ec-common.h
index bea0c045a47..bf41c0086f8 100644
--- a/xlators/cluster/ec/src/ec-common.h
+++ b/xlators/cluster/ec/src/ec-common.h
@@ -95,6 +95,9 @@ enum _ec_xattrop_flags {
 #define EC_STATE_HEAL_POST_INODELK_UNLOCK 217
 #define EC_STATE_HEAL_DISPATCH 218
 
+/* Value to cover the full range of a file */
+#define EC_RANGE_FULL ((uint64_t)LLONG_MAX + 1)
+
 gf_boolean_t
 ec_dispatch_one_retry(ec_fop_data_t *fop, ec_cbk_data_t **cbk);
 void
@@ -120,13 +123,13 @@ ec_cbk_set_error(ec_cbk_data_t *cbk, int32_t error, gf_boolean_t ro);
 
 void
 ec_lock_prepare_inode(ec_fop_data_t *fop, loc_t *loc, uint32_t flags,
-                      off_t fl_start, size_t fl_size);
+                      off_t fl_start, uint64_t fl_size);
 void
 ec_lock_prepare_parent_inode(ec_fop_data_t *fop, loc_t *loc, loc_t *base,
                              uint32_t flags);
 void
 ec_lock_prepare_fd(ec_fop_data_t *fop, fd_t *fd, uint32_t flags, off_t fl_start,
-                   size_t fl_size);
+                   uint64_t fl_size);
 void
 ec_lock(ec_fop_data_t *fop);
 void
diff --git a/xlators/cluster/ec/src/ec-dir-read.c b/xlators/cluster/ec/src/ec-dir-read.c
index 8db92b9d92d..ec4cefb1e78 100644
--- a/xlators/cluster/ec/src/ec-dir-read.c
+++ b/xlators/cluster/ec/src/ec-dir-read.c
@@ -142,7 +142,7 @@ ec_manager_opendir(ec_fop_data_t *fop, int32_t state)
 
         case EC_STATE_LOCK:
             ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                  LLONG_MAX);
+                                  EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -427,7 +427,8 @@ ec_manager_readdir(ec_fop_data_t *fop, int32_t state)
                 }
                 fop->mask &= 1ULL << idx;
             } else {
-                ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, LLONG_MAX);
+                ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0,
+                                   EC_RANGE_FULL);
                 ec_lock(fop);
             }
 
diff --git a/xlators/cluster/ec/src/ec-generic.c b/xlators/cluster/ec/src/ec-generic.c
index d12481bdc18..89e72540916 100644
--- a/xlators/cluster/ec/src/ec-generic.c
+++ b/xlators/cluster/ec/src/ec-generic.c
@@ -83,7 +83,7 @@ ec_manager_flush(ec_fop_data_t *fop, int32_t state)
     switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_fd(fop, fop->fd, 0, 0, LLONG_MAX);
+            ec_lock_prepare_fd(fop, fop->fd, 0, 0, EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -289,7 +289,7 @@ ec_manager_fsync(ec_fop_data_t *fop, int32_t state)
     switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, LLONG_MAX);
+            ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -484,7 +484,7 @@ ec_manager_fsyncdir(ec_fop_data_t *fop, int32_t state)
     switch (state) {
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
-            ec_lock_prepare_fd(fop, fop->fd, 0, 0, LLONG_MAX);
+            ec_lock_prepare_fd(fop, fop->fd, 0, 0, EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -1182,9 +1182,10 @@ ec_manager_xattrop(ec_fop_data_t *fop, int32_t state)
         case EC_STATE_LOCK:
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0], EC_UPDATE_META, 0,
-                                      LLONG_MAX);
+                                      EC_RANGE_FULL);
             } else {
-                ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META, 0, LLONG_MAX);
+                ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META, 0,
+                                   EC_RANGE_FULL);
             }
             ec_lock(fop);
 
diff --git a/xlators/cluster/ec/src/ec-heal.c b/xlators/cluster/ec/src/ec-heal.c
index 229c0683d91..9eb5b856932 100644
--- a/xlators/cluster/ec/src/ec-heal.c
+++ b/xlators/cluster/ec/src/ec-heal.c
@@ -332,7 +332,7 @@ ec_fheal(call_frame_t *frame, xlator_t *this, uintptr_t target, int32_t minimum,
     ec_fd_t *ctx = ec_fd_get(fd, this);
 
     if (ctx != NULL) {
-        gf_msg_trace("ec", 0, "FHEAL ctx: flags=%X, open=%lX", ctx->flags,
+        gf_msg_trace("ec", 0, "FHEAL ctx: flags=%X, open=%" PRIXPTR, ctx->flags,
                      ctx->open);
         ec_heal(frame, this, target, minimum, func, data, &ctx->loc, partial,
                 xdata);
@@ -2484,7 +2484,7 @@ ec_heal_do(xlator_t *this, void *data, loc_t *loc, int32_t partial)
         if (ret == 0) {
             gf_msg_debug(this->name, 0,
                          "%s: name heal "
-                         "successful on %lX",
+                         "successful on %" PRIXPTR,
                          loc->path,
                          ec_char_array_to_mask(participants, ec->nodes));
         } else {
diff --git a/xlators/cluster/ec/src/ec-inode-read.c b/xlators/cluster/ec/src/ec-inode-read.c
index 7a8b174bbed..c02d5401439 100644
--- a/xlators/cluster/ec/src/ec-inode-read.c
+++ b/xlators/cluster/ec/src/ec-inode-read.c
@@ -74,7 +74,7 @@ ec_manager_access(ec_fop_data_t *fop, int32_t state)
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                  LLONG_MAX);
+                                  EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -301,10 +301,10 @@ ec_manager_getxattr(ec_fop_data_t *fop, int32_t state)
                          SLEN(GF_XATTR_CLRLK_CMD)) != 0)) {
                 if (fop->fd == NULL) {
                     ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                          LLONG_MAX);
+                                          EC_RANGE_FULL);
                 } else {
                     ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0,
-                                       LLONG_MAX);
+                                       EC_RANGE_FULL);
                 }
                 ec_lock(fop);
             }
@@ -1008,7 +1008,7 @@ ec_manager_readlink(ec_fop_data_t *fop, int32_t state)
         case EC_STATE_INIT:
         case EC_STATE_LOCK:
             ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                  LLONG_MAX);
+                                  EC_RANGE_FULL);
             ec_lock(fop);
             return EC_STATE_DISPATCH;
 
@@ -1131,7 +1131,7 @@ ec_readv_rebuild(ec_t *ec, ec_fop_data_t *fop, ec_cbk_data_t *cbk)
     ec_cbk_data_t *ans = NULL;
     struct iobref *iobref = NULL;
     void *ptr;
-    size_t fsize = 0, size = 0, max = 0;
+    uint64_t fsize = 0, size = 0, max = 0;
     int32_t pos, err = -ENOMEM;
 
     if (cbk->op_ret < 0) {
@@ -1536,7 +1536,7 @@ int32_t
 ec_manager_seek(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk;
-    size_t size;
+    uint64_t size;
 
     switch (state) {
         case EC_STATE_INIT:
@@ -1548,7 +1548,7 @@ ec_manager_seek(ec_fop_data_t *fop, int32_t state)
 
         case EC_STATE_LOCK:
             ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, fop->offset,
-                               LLONG_MAX);
+                               EC_RANGE_FULL);
             ec_lock(fop);
 
             return EC_STATE_DISPATCH;
@@ -1764,9 +1764,10 @@ ec_manager_stat(ec_fop_data_t *fop, int32_t state)
         case EC_STATE_LOCK:
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0], EC_QUERY_INFO, 0,
-                                      LLONG_MAX);
+                                      EC_RANGE_FULL);
             } else {
-                ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0, LLONG_MAX);
+                ec_lock_prepare_fd(fop, fop->fd, EC_QUERY_INFO, 0,
+                                   EC_RANGE_FULL);
             }
             ec_lock(fop);
 
diff --git a/xlators/cluster/ec/src/ec-inode-write.c b/xlators/cluster/ec/src/ec-inode-write.c
index ffdac632683..b915a992a00 100644
--- a/xlators/cluster/ec/src/ec-inode-write.c
+++ b/xlators/cluster/ec/src/ec-inode-write.c
@@ -68,8 +68,8 @@ out:
     return 0;
 }
 
-int32_t
-ec_update_write(ec_fop_data_t *fop, uintptr_t mask, off_t offset, size_t size)
+static int32_t
+ec_update_write(ec_fop_data_t *fop, uintptr_t mask, off_t offset, uint64_t size)
 {
     struct iobref *iobref = NULL;
     struct iobuf *iobuf = NULL;
@@ -219,10 +219,10 @@ ec_manager_xattr(ec_fop_data_t *fop, int32_t state)
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0],
                                       EC_UPDATE_META | EC_QUERY_INFO, 0,
-                                      LLONG_MAX);
+                                      EC_RANGE_FULL);
             } else {
                 ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META | EC_QUERY_INFO,
-                                   0, LLONG_MAX);
+                                   0, EC_RANGE_FULL);
             }
             ec_lock(fop);
 
@@ -455,10 +455,10 @@ ec_manager_setattr(ec_fop_data_t *fop, int32_t state)
             if (fop->fd == NULL) {
                 ec_lock_prepare_inode(fop, &fop->loc[0],
                                       EC_UPDATE_META | EC_QUERY_INFO, 0,
-                                      LLONG_MAX);
+                                      EC_RANGE_FULL);
             } else {
                 ec_lock_prepare_fd(fop, fop->fd, EC_UPDATE_META | EC_QUERY_INFO,
-                                   0, LLONG_MAX);
+                                   0, EC_RANGE_FULL);
             }
             ec_lock(fop);
 
@@ -1101,8 +1101,8 @@ ec_update_discard_write(ec_fop_data_t *fop, uintptr_t mask)
     ec_t *ec = fop->xl->private;
     off_t off_head = 0;
     off_t off_tail = 0;
-    size_t size_head = 0;
-    size_t size_tail = 0;
+    uint64_t size_head = 0;
+    uint64_t size_tail = 0;
     int error = 0;
 
     off_head = fop->offset * ec->fragments - fop->int32;
@@ -1172,7 +1172,7 @@ ec_manager_discard(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk = NULL;
     off_t fl_start = 0;
-    size_t fl_size = 0;
+    uint64_t fl_size = 0;
 
     switch (state) {
         case EC_STATE_INIT:
@@ -1341,7 +1341,7 @@ int32_t
 ec_update_truncate_write(ec_fop_data_t *fop, uintptr_t mask)
 {
     ec_t *ec = fop->xl->private;
-    size_t size = fop->offset * ec->fragments - fop->user_size;
+    uint64_t size = fop->offset * ec->fragments - fop->user_size;
     return ec_update_write(fop, mask, fop->user_size, size);
 }
 
@@ -1420,12 +1420,12 @@ ec_manager_truncate(ec_fop_data_t *fop, int32_t state)
                 ec_lock_prepare_inode(
                     fop, &fop->loc[0],
                     EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
-                    fop->offset, LLONG_MAX);
+                    fop->offset, EC_RANGE_FULL);
             } else {
                 ec_lock_prepare_fd(
                     fop, fop->fd,
                     EC_UPDATE_DATA | EC_UPDATE_META | EC_QUERY_INFO,
-                    fop->offset, LLONG_MAX);
+                    fop->offset, EC_RANGE_FULL);
             }
             ec_lock(fop);
 
@@ -1739,7 +1739,7 @@ ec_writev_merge_tail(call_frame_t *frame, void *cookie, xlator_t *this,
 {
     ec_t *ec = this->private;
     ec_fop_data_t *fop = frame->local;
-    size_t size, base, tmp;
+    uint64_t size, base, tmp;
 
     if (op_ret >= 0) {
         tmp = 0;
@@ -1772,7 +1772,7 @@ ec_writev_merge_head(call_frame_t *frame, void *cookie, xlator_t *this,
 {
     ec_t *ec = this->private;
     ec_fop_data_t *fop = frame->local;
-    size_t size, base;
+    uint64_t size, base;
 
     if (op_ret >= 0) {
         size = fop->head;
@@ -1884,7 +1884,7 @@ out:
 static void
 ec_merge_stripe_head_locked(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 {
-    size_t head, size;
+    uint32_t head, size;
 
     head = fop->head;
     memcpy(fop->vector[0].iov_base, stripe->data, head);
@@ -1900,7 +1900,7 @@ ec_merge_stripe_head_locked(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 static void
 ec_merge_stripe_tail_locked(ec_t *ec, ec_fop_data_t *fop, ec_stripe_t *stripe)
 {
-    size_t head, tail;
+    uint32_t head, tail;
     off_t offset;
 
     offset = fop->user_size + fop->head;
@@ -2117,7 +2117,7 @@ ec_manager_writev(ec_fop_data_t *fop, int32_t state)
     ec_fd_t *ctx = NULL;
     ec_t *ec = fop->xl->private;
     off_t fl_start = 0;
-    size_t fl_size = LLONG_MAX;
+    uint64_t fl_size = LONG_MAX;
 
     switch (state) {
         case EC_STATE_INIT:
@@ -2163,7 +2163,7 @@ ec_manager_writev(ec_fop_data_t *fop, int32_t state)
             cbk = ec_fop_prepare_answer(fop, _gf_false);
             if (cbk != NULL) {
                 ec_t *ec = fop->xl->private;
-                size_t size;
+                uint64_t size;
 
                 ec_iatt_rebuild(fop->xl->private, cbk->iatt, 2, cbk->count);
 
diff --git a/xlators/cluster/ec/src/ec-method.c b/xlators/cluster/ec/src/ec-method.c
index 3aff6b096bd..55faed0b193 100644
--- a/xlators/cluster/ec/src/ec-method.c
+++ b/xlators/cluster/ec/src/ec-method.c
@@ -391,10 +391,10 @@ ec_method_update(xlator_t *xl, ec_matrix_list_t *list, const char *gen)
 }
 
 void
-ec_method_encode(ec_matrix_list_t *list, size_t size, void *in, void **out)
+ec_method_encode(ec_matrix_list_t *list, uint64_t size, void *in, void **out)
 {
     ec_matrix_t *matrix;
-    size_t pos;
+    uint64_t pos;
     uint32_t i;
 
     matrix = list->encode;
@@ -408,11 +408,11 @@ ec_method_encode(ec_matrix_list_t *list, size_t size, void *in, void **out)
 }
 
 int32_t
-ec_method_decode(ec_matrix_list_t *list, size_t size, uintptr_t mask,
+ec_method_decode(ec_matrix_list_t *list, uint64_t size, uintptr_t mask,
                  uint32_t *rows, void **in, void *out)
 {
     ec_matrix_t *matrix;
-    size_t pos;
+    uint64_t pos;
     uint32_t i;
 
     matrix = ec_method_matrix_get(list, mask, rows);
diff --git a/xlators/cluster/ec/src/ec-method.h b/xlators/cluster/ec/src/ec-method.h
index 3d6393bed06..ca33f4ffdce 100644
--- a/xlators/cluster/ec/src/ec-method.h
+++ b/xlators/cluster/ec/src/ec-method.h
@@ -41,10 +41,10 @@ int32_t
 ec_method_update(xlator_t *xl, ec_matrix_list_t *list, const char *gen);
 
 void
-ec_method_encode(ec_matrix_list_t *list, size_t size, void *in, void **out);
+ec_method_encode(ec_matrix_list_t *list, uint64_t size, void *in, void **out);
 
 int32_t
-ec_method_decode(ec_matrix_list_t *list, size_t size, uintptr_t mask,
+ec_method_decode(ec_matrix_list_t *list, uint64_t size, uintptr_t mask,
                  uint32_t *rows, void **in, void *out);
 
 #endif /* __EC_METHOD_H__ */
diff --git a/xlators/cluster/ec/src/ec.c b/xlators/cluster/ec/src/ec.c
index 0350325d6fb..00c374e7ca3 100644
--- a/xlators/cluster/ec/src/ec.c
+++ b/xlators/cluster/ec/src/ec.c
@@ -74,7 +74,7 @@ ec_parse_options(xlator_t *this)
 
     gf_msg_debug("ec", 0,
                  "Initialized with: nodes=%u, fragments=%u, "
-                 "stripe_size=%u, node_mask=%lX",
+                 "stripe_size=%u, node_mask=%" PRIxFAST32,
                  ec->nodes, ec->fragments, ec->stripe_size, ec->node_mask);
 
     error = 0;