libglusterfs-event-epoll: structure logging

convert gf_msg() to gf_smsg()

Change-Id: Idf5bfc826b0c9f1a2674eea2a2e6164f30806b00
Updates: #657
Signed-off-by: yatipadia <ypadia@redhat.com>

4 files changed, 114 insertions, 109 deletions

diff --git a/libglusterfs/src/event-epoll.c b/libglusterfs/src/event-epoll.c
index bfe2648a920..fb4fb845b40 100644
--- a/libglusterfs/src/event-epoll.c
+++ b/libglusterfs/src/event-epoll.c
@@ -296,9 +296,8 @@ event_pool_new_epoll(int count, int eventthreadcount)
     epfd = epoll_create(count);
 
     if (epfd == -1) {
-        gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_CREATE_FAILED,
-               "epoll fd creation "
-               "failed");
+        gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_CREATE_FAILED,
+                NULL);
         GF_FREE(event_pool->reg);
         GF_FREE(event_pool);
         event_pool = NULL;
@@ -332,8 +331,8 @@ __slot_update_events(struct event_slot_epoll *slot, int poll_in, int poll_out)
             /* do nothing */
             break;
         default:
-            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
-                   "invalid poll_in value %d", poll_in);
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                    "value=%d", poll_in, NULL);
             break;
     }
 
@@ -348,8 +347,8 @@ __slot_update_events(struct event_slot_epoll *slot, int poll_in, int poll_out)
             /* do nothing */
             break;
         default:
-            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
-                   "invalid poll_out value %d", poll_out);
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                    "value=%d", poll_out, NULL);
             break;
     }
 }
@@ -390,8 +389,8 @@ event_register_epoll(struct event_pool *event_pool, int fd,
 
     idx = event_slot_alloc(event_pool, fd, notify_poller_death, &slot);
     if (idx == -1) {
-        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-               "could not find slot for fd=%d", fd);
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                NULL);
         return -1;
     }
 
@@ -426,10 +425,8 @@ event_register_epoll(struct event_pool *event_pool, int fd,
     UNLOCK(&slot->lock);
 
     if (ret == -1) {
-        gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_ADD_FAILED,
-               "failed to add fd(=%d) to "
-               "epoll fd(=%d)",
-               fd, event_pool->fd);
+        gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_ADD_FAILED,
+                "fd=%d", fd, "epoll_fd=%d", event_pool->fd, NULL);
         event_slot_unref(event_pool, slot, idx);
         idx = -1;
     }
@@ -458,8 +455,8 @@ event_unregister_epoll_common(struct event_pool *event_pool, int fd, int idx,
 
     slot = event_slot_get(event_pool, idx);
     if (!slot) {
-        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-               "could not find slot for fd=%d idx=%d", fd, idx);
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
         return -1;
     }
 
@@ -470,10 +467,8 @@ event_unregister_epoll_common(struct event_pool *event_pool, int fd, int idx,
         ret = epoll_ctl(event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
 
         if (ret == -1) {
-            gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_DEL_FAILED,
-                   "fail to del "
-                   "fd(=%d) from epoll fd(=%d)",
-                   fd, event_pool->fd);
+            gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_DEL_FAILED,
+                    "fd=%d", fd, "epoll_fd=%d", event_pool->fd, NULL);
             goto unlock;
         }
 
@@ -525,8 +520,8 @@ event_select_on_epoll(struct event_pool *event_pool, int fd, int idx,
 
     slot = event_slot_get(event_pool, idx);
     if (!slot) {
-        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-               "could not find slot for fd=%d idx=%d", fd, idx);
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
         return -1;
     }
 
@@ -557,10 +552,8 @@ event_select_on_epoll(struct event_pool *event_pool, int fd, int idx,
 
         ret = epoll_ctl(event_pool->fd, EPOLL_CTL_MOD, fd, &epoll_event);
         if (ret == -1) {
-            gf_msg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_MODIFY_FAILED,
-                   "failed to "
-                   "modify fd(=%d) events to %d",
-                   fd, epoll_event.events);
+            gf_smsg("epoll", GF_LOG_ERROR, errno, LG_MSG_EPOLL_FD_MODIFY_FAILED,
+                    "fd=%d", fd, "events=%d", epoll_event.events, NULL);
         }
     }
 unlock:
@@ -595,8 +588,8 @@ event_dispatch_epoll_handler(struct event_pool *event_pool,
 
     slot = event_slot_get(event_pool, idx);
     if (!slot) {
-        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-               "could not find slot for idx=%d", idx);
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "idx=%d", idx,
+                NULL);
         return -1;
     }
 
@@ -604,20 +597,17 @@ event_dispatch_epoll_handler(struct event_pool *event_pool,
     {
         fd = slot->fd;
         if (fd == -1) {
-            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_STALE_FD_FOUND,
-                   "stale fd found on "
-                   "idx=%d, gen=%d, events=%d, slot->gen=%d",
-                   idx, gen, event->events, slot->gen);
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_STALE_FD_FOUND, "idx=%d",
+                    idx, "gen=%d", gen, "events=%d", event->events,
+                    "slot->gen=%d", slot->gen, NULL);
             /* fd got unregistered in another thread */
             goto pre_unlock;
         }
 
         if (gen != slot->gen) {
-            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_GENERATION_MISMATCH,
-                   "generation "
-                   "mismatch on idx=%d, gen=%d, slot->gen=%d, "
-                   "slot->fd=%d",
-                   idx, gen, slot->gen, slot->fd);
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_GENERATION_MISMATCH,
+                    "idx=%d", idx, "gen=%d", gen, "slot->gen=%d", slot->gen,
+                    "slot->fd=%d", slot->fd, NULL);
             /* slot was re-used and therefore is another fd! */
             goto pre_unlock;
         }
@@ -676,10 +666,8 @@ event_dispatch_epoll_worker(void *data)
 
     GF_VALIDATE_OR_GOTO("event", event_pool, out);
 
-    gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD,
-           "Started"
-           " thread with index %d",
-           myindex - 1);
+    gf_smsg("epoll", GF_LOG_INFO, 0, LG_MSG_STARTED_EPOLL_THREAD, "index=%d",
+            myindex - 1, NULL);
 
     pthread_mutex_lock(&event_pool->mutex);
     {
@@ -743,8 +731,8 @@ event_dispatch_epoll_worker(void *data)
                 }
                 pthread_mutex_unlock(&event_pool->mutex);
 
-                gf_msg("epoll", GF_LOG_INFO, 0, LG_MSG_EXITED_EPOLL_THREAD,
-                       "Exited thread with index %d", myindex);
+                gf_smsg("epoll", GF_LOG_INFO, 0, LG_MSG_EXITED_EPOLL_THREAD,
+                        "index=%d", myindex, NULL);
 
                 goto out;
             }
@@ -762,8 +750,8 @@ event_dispatch_epoll_worker(void *data)
 
         ret = event_dispatch_epoll_handler(event_pool, &event);
         if (ret) {
-            gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_EXITED_EPOLL_THREAD,
-                   "Failed to dispatch handler");
+            gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_DISPATCH_HANDLER_FAILED,
+                    NULL);
         }
     }
 out:
@@ -827,9 +815,8 @@ event_dispatch_epoll(struct event_pool *event_pool)
                 if (i != 0)
                     pthread_detach(event_pool->pollers[i]);
             } else {
-                gf_msg("epoll", GF_LOG_WARNING, 0,
-                       LG_MSG_START_EPOLL_THREAD_FAILED,
-                       "Failed to start thread for index %d", i);
+                gf_smsg("epoll", GF_LOG_WARNING, 0,
+                        LG_MSG_START_EPOLL_THREAD_FAILED, "index=%d", i, NULL);
                 if (i == 0) {
                     GF_FREE(ev_data);
                     break;
@@ -922,11 +909,9 @@ event_reconfigure_threads_epoll(struct event_pool *event_pool, int value)
                                            event_dispatch_epoll_worker, ev_data,
                                            "epoll%03hx", i & 0x3ff);
                     if (ret) {
-                        gf_msg("epoll", GF_LOG_WARNING, 0,
-                               LG_MSG_START_EPOLL_THREAD_FAILED,
-                               "Failed to start thread"
-                               " for index %d",
-                               i);
+                        gf_smsg("epoll", GF_LOG_WARNING, 0,
+                                LG_MSG_START_EPOLL_THREAD_FAILED, "index=%d", i,
+                                NULL);
                         GF_FREE(ev_data);
                     } else {
                         pthread_detach(t_id);
@@ -989,8 +974,8 @@ event_handled_epoll(struct event_pool *event_pool, int fd, int idx, int gen)
 
     slot = event_slot_get(event_pool, idx);
     if (!slot) {
-        gf_msg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND,
-               "could not find slot for fd=%d idx=%d", fd, idx);
+        gf_smsg("epoll", GF_LOG_ERROR, 0, LG_MSG_SLOT_NOT_FOUND, "fd=%d", fd,
+                "idx=%d", idx, NULL);
         return -1;
     }
 
diff --git a/libglusterfs/src/event-poll.c b/libglusterfs/src/event-poll.c
index 14dc5e3180c..2cba963f096 100644
--- a/libglusterfs/src/event-poll.c
+++ b/libglusterfs/src/event-poll.c
@@ -48,10 +48,8 @@ __flush_fd(int fd, int idx, int gen, void *data, int poll_in, int poll_out,
     do {
         ret = sys_read(fd, buf, 64);
         if (ret == -1 && errno != EAGAIN) {
-            gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-                   "read on %d returned "
-                   "error",
-                   fd);
+            gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_READ_FILE_FAILED,
+                    "fd=%d", fd, NULL);
         }
     } while (ret == 64);
 
@@ -111,8 +109,7 @@ event_pool_new_poll(int count, int eventthreadcount)
     ret = pipe(event_pool->breaker);
 
     if (ret == -1) {
-        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED,
-               "pipe creation failed");
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_PIPE_CREATE_FAILED, NULL);
         GF_FREE(event_pool->reg);
         GF_FREE(event_pool);
         return NULL;
@@ -120,8 +117,7 @@ event_pool_new_poll(int count, int eventthreadcount)
 
     ret = fcntl(event_pool->breaker[0], F_SETFL, O_NONBLOCK);
     if (ret == -1) {
-        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-               "could not set pipe to non blocking mode");
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED, NULL);
         sys_close(event_pool->breaker[0]);
         sys_close(event_pool->breaker[1]);
         event_pool->breaker[0] = event_pool->breaker[1] = -1;
@@ -133,8 +129,7 @@ event_pool_new_poll(int count, int eventthreadcount)
 
     ret = fcntl(event_pool->breaker[1], F_SETFL, O_NONBLOCK);
     if (ret == -1) {
-        gf_msg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED,
-               "could not set pipe to non blocking mode");
+        gf_smsg("poll", GF_LOG_ERROR, errno, LG_MSG_SET_PIPE_FAILED, NULL);
 
         sys_close(event_pool->breaker[0]);
         sys_close(event_pool->breaker[1]);
@@ -148,8 +143,7 @@ event_pool_new_poll(int count, int eventthreadcount)
     ret = event_register_poll(event_pool, event_pool->breaker[0], __flush_fd,
                               NULL, 1, 0, 0);
     if (ret == -1) {
-        gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED,
-               "could not register pipe fd with poll event loop");
+        gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_REGISTER_PIPE_FAILED, NULL);
         sys_close(event_pool->breaker[0]);
         sys_close(event_pool->breaker[1]);
         event_pool->breaker[0] = event_pool->breaker[1] = -1;
@@ -160,11 +154,8 @@ event_pool_new_poll(int count, int eventthreadcount)
     }
 
     if (eventthreadcount > 1) {
-        gf_msg("poll", GF_LOG_INFO, 0, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
-               "Currently poll "
-               "does not use multiple event processing threads, "
-               "thread count (%d) ignored",
-               eventthreadcount);
+        gf_smsg("poll", GF_LOG_INFO, 0, LG_MSG_POLL_IGNORE_MULTIPLE_THREADS,
+                "count=%d", eventthreadcount, NULL);
     }
 
     /* although, eventhreadcount for poll implementation is always
@@ -215,8 +206,8 @@ event_register_poll(struct event_pool *event_pool, int fd,
                 /* do nothing */
                 break;
             default:
-                gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
-                       "invalid poll_in value %d", poll_in);
+                gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_IN,
+                        "value=%d", poll_in, NULL);
                 break;
         }
 
@@ -231,8 +222,8 @@ event_register_poll(struct event_pool *event_pool, int fd,
                 /* do nothing */
                 break;
             default:
-                gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
-                       "invalid poll_out value %d", poll_out);
+                gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INVALID_POLL_OUT,
+                        "value=%d", poll_out, NULL);
                 break;
         }
 
@@ -257,8 +248,8 @@ event_unregister_poll(struct event_pool *event_pool, int fd, int idx_hint)
         idx = __event_getindex(event_pool, fd, idx_hint);
 
         if (idx == -1) {
-            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                   "index not found for fd=%d (idx_hint=%d)", fd, idx_hint);
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    fd, "idx_hint=%d", idx_hint, NULL);
             errno = ENOENT;
             goto unlock;
         }
@@ -298,8 +289,8 @@ event_select_on_poll(struct event_pool *event_pool, int fd, int idx_hint,
         idx = __event_getindex(event_pool, fd, idx_hint);
 
         if (idx == -1) {
-            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                   "index not found for fd=%d (idx_hint=%d)", fd, idx_hint);
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    fd, "idx_hint=%d", idx_hint, NULL);
             errno = ENOENT;
             goto unlock;
         }
@@ -361,10 +352,8 @@ event_dispatch_poll_handler(struct event_pool *event_pool, struct pollfd *ufds,
         idx = __event_getindex(event_pool, ufds[i].fd, i);
 
         if (idx == -1) {
-            gf_msg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND,
-                   "index not found for "
-                   "fd=%d (idx_hint=%d)",
-                   ufds[i].fd, i);
+            gf_smsg("poll", GF_LOG_ERROR, 0, LG_MSG_INDEX_NOT_FOUND, "fd=%d",
+                    ufds[i].fd, "idx_hint=%d", i, NULL);
             goto unlock;
         }
 
diff --git a/libglusterfs/src/glusterfs/libglusterfs-messages.h b/libglusterfs/src/glusterfs/libglusterfs-messages.h
index 11de9fdb0d8..441f1bbafa3 100644
--- a/libglusterfs/src/glusterfs/libglusterfs-messages.h
+++ b/libglusterfs/src/glusterfs/libglusterfs-messages.h
@@ -115,8 +115,43 @@ GLFS_MSGID(
     LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED, LG_MSG_DUPLICATE_ENTRY,
     LG_MSG_THREAD_NAME_TOO_LONG, LG_MSG_SET_THREAD_FAILED,
     LG_MSG_THREAD_CREATE_FAILED, LG_MSG_FILE_DELETE_FAILED, LG_MSG_WRONG_VALUE,
-    LG_MSG_PATH_OPEN_FAILED);
+    LG_MSG_PATH_OPEN_FAILED, LG_MSG_DISPATCH_HANDLER_FAILED,
+    LG_MSG_READ_FILE_FAILED, LG_MSG_ENTRIES_NOT_PROVIDED,
+    LG_MSG_ENTRIES_PROVIDED);
 
+#define LG_MSG_EPOLL_FD_CREATE_FAILED_STR "epoll fd creation failed"
+#define LG_MSG_INVALID_POLL_IN_STR "invalid poll_in value"
+#define LG_MSG_INVALID_POLL_OUT_STR "invalid poll_out value"
+#define LG_MSG_SLOT_NOT_FOUND_STR "could not find slot"
+#define LG_MSG_EPOLL_FD_ADD_FAILED_STR "failed to add fd to epoll"
+#define LG_MSG_EPOLL_FD_DEL_FAILED_STR "fail to delete fd to epoll"
+#define LG_MSG_EPOLL_FD_MODIFY_FAILED_STR "failed to modify fd events"
+#define LG_MSG_STALE_FD_FOUND_STR "stale fd found"
+#define LG_MSG_GENERATION_MISMATCH_STR "generation mismatch"
+#define LG_MSG_STARTED_EPOLL_THREAD_STR "Started thread with index"
+#define LG_MSG_EXITED_EPOLL_THREAD_STR "Exited thread"
+#define LG_MSG_DISPATCH_HANDLER_FAILED_STR "Failed to dispatch handler"
+#define LG_MSG_START_EPOLL_THREAD_FAILED_STR "Failed to start thread"
+#define LG_MSG_PIPE_CREATE_FAILED_STR "pipe creation failed"
+#define LG_MSG_SET_PIPE_FAILED_STR "could not set pipe to non blocking mode"
+#define LG_MSG_REGISTER_PIPE_FAILED_STR                                        \
+    "could not register pipe fd with poll event loop"
+#define LG_MSG_POLL_IGNORE_MULTIPLE_THREADS_STR                                \
+    "Currently poll does not use multiple event processing threads, count "    \
+    "ignored"
+#define LG_MSG_INDEX_NOT_FOUND_STR "index not found"
+#define LG_MSG_READ_FILE_FAILED_STR "read on file returned error"
+#define LG_MSG_RB_TABLE_CREATE_FAILED_STR "Failed to create rb table bucket"
+#define LG_MSG_HASH_FUNC_ERROR_STR "Hash function not given"
+#define LG_MSG_ENTRIES_NOT_PROVIDED_STR                                        \
+    "Both mem-pool and expected entries not provided"
+#define LG_MSG_ENTRIES_PROVIDED_STR                                            \
+    "Both mem-pool and expected entries are provided"
+#define LG_MSG_RBTHASH_INIT_BUCKET_FAILED_STR "failed to init buckets"
+#define LG_MSG_RBTHASH_GET_ENTRY_FAILED_STR "Failed to get entry from mem-pool"
+#define LG_MSG_RBTHASH_GET_BUCKET_FAILED_STR "Failed to get bucket"
+#define LG_MSG_RBTHASH_INSERT_FAILED_STR "Failed to insert entry"
+#define LG_MSG_RBTHASH_INIT_ENTRY_FAILED_STR "Failed to init entry"
 #define LG_MSG_FILE_STAT_FAILED_STR "failed to stat"
 #define LG_MSG_INET_PTON_FAILED_STR "inet_pton() failed"
 #define LG_MSG_INVALID_ENTRY_STR "Invalid arguments"
diff --git a/libglusterfs/src/rbthash.c b/libglusterfs/src/rbthash.c
index ae2e158d61e..c90b5a21f44 100644
--- a/libglusterfs/src/rbthash.c
+++ b/libglusterfs/src/rbthash.c
@@ -56,9 +56,8 @@ __rbthash_init_buckets(rbthash_table_t *tbl, int buckets)
         tbl->buckets[i].bucket = rb_create(
             (rb_comparison_func *)rbthash_comparator, tbl, NULL);
         if (!tbl->buckets[i].bucket) {
-            gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RB_TABLE_CREATE_FAILED,
-                   "Failed to "
-                   "create rb table bucket");
+            gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RB_TABLE_CREATE_FAILED,
+                    NULL);
             ret = -1;
             goto err;
         }
@@ -88,20 +87,17 @@ rbthash_table_init(glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
     int ret = -1;
 
     if (!hfunc) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR,
-               "Hash function not given");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_HASH_FUNC_ERROR, NULL);
         return NULL;
     }
 
     if (!entrypool && !expected_entries) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-               "Both mem-pool and expected entries not provided");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_ENTRIES_NOT_PROVIDED, NULL);
         return NULL;
     }
 
     if (entrypool && expected_entries) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-               "Both mem-pool and expected entries are provided");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_ENTRIES_PROVIDED, NULL);
         return NULL;
     }
 
@@ -132,8 +128,8 @@ rbthash_table_init(glusterfs_ctx_t *ctx, int buckets, rbt_hasher_t hfunc,
     ret = __rbthash_init_buckets(newtab, buckets);
 
     if (ret == -1) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
-               "Failed to init buckets");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_BUCKET_FAILED,
+                NULL);
         if (newtab->pool_alloced)
             mem_pool_destroy(newtab->entrypool);
     } else {
@@ -170,8 +166,8 @@ rbthash_init_entry(rbthash_table_t *tbl, void *data, void *key, int keylen)
 
     entry = mem_get(tbl->entrypool);
     if (!entry) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_ENTRY_FAILED,
-               "Failed to get entry from mem-pool");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_ENTRY_FAILED,
+                NULL);
         goto ret;
     }
 
@@ -243,8 +239,8 @@ rbthash_insert_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
 
     bucket = rbthash_entry_bucket(tbl, entry);
     if (!bucket) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-               "Failed to get bucket");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
         goto err;
     }
 
@@ -253,8 +249,8 @@ rbthash_insert_entry(rbthash_table_t *tbl, rbthash_entry_t *entry)
     {
         if (!rb_probe(bucket->bucket, (void *)entry)) {
             UNLOCK(&bucket->bucketlock);
-            gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
-                   "Failed to insert entry");
+            gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+                    NULL);
             ret = -1;
             goto err;
         }
@@ -276,16 +272,16 @@ rbthash_insert(rbthash_table_t *tbl, void *data, void *key, int keylen)
 
     entry = rbthash_init_entry(tbl, data, key, keylen);
     if (!entry) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
-               "Failed to init entry");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INIT_ENTRY_FAILED,
+                NULL);
         goto err;
     }
 
     ret = rbthash_insert_entry(tbl, entry);
 
     if (ret == -1) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
-               "Failed to insert entry");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_INSERT_FAILED,
+                NULL);
         rbthash_deinit_entry(tbl, entry);
         goto err;
     }
@@ -331,8 +327,8 @@ rbthash_get(rbthash_table_t *tbl, void *key, int keylen)
 
     bucket = rbthash_key_bucket(tbl, key, keylen);
     if (!bucket) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_GET_BUCKET_FAILED,
-               "Failed to get bucket");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
         return NULL;
     }
 
@@ -365,8 +361,8 @@ rbthash_remove(rbthash_table_t *tbl, void *key, int keylen)
 
     bucket = rbthash_key_bucket(tbl, key, keylen);
     if (!bucket) {
-        gf_msg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
-               "Failed to get bucket");
+        gf_smsg(GF_RBTHASH, GF_LOG_ERROR, 0, LG_MSG_RBTHASH_GET_BUCKET_FAILED,
+                NULL);
         return NULL;
     }