mem-pool,stack,store,syncop,timer/libglusterfs : Porting to a new logging framework

        Backport of http://review.gluster.org/10827

Cherry picked from 2b9b3ef3b646989bbc0412dca187b3f5fcad3283
>Change-Id: Idd3dcaf7eeea5207b3a5210676ce3df64153197f
>BUG: 1194640
>Signed-off-by: Mohamed Ashiq <ashiq333@gmail.com>
>Reviewed-on: http://review.gluster.org/10827
>Reviewed-by: Pranith Kumar Karampuri <pkarampu@redhat.com>
>Tested-by: NetBSD Build System <jenkins@build.gluster.org>

Change-Id: Idd3dcaf7eeea5207b3a5210676ce3df64153197f
BUG: 1217722
Signed-off-by: Mohamed Ashiq <ashiq333@gmail.com>
Reviewed-on: http://review.gluster.org/11478
Tested-by: NetBSD Build System <jenkins@build.gluster.org>
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>

9 files changed, 201 insertions, 155 deletions

diff --git a/libglusterfs/src/client_t.c b/libglusterfs/src/client_t.c
index a66be21a012..c6997c0b7b0 100644
--- a/libglusterfs/src/client_t.c
+++ b/libglusterfs/src/client_t.c
@@ -601,7 +601,7 @@ clienttable_dump (clienttable_t *clienttable, char *prefix)
         {
                 if (ret) {
                         gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_GAIN_FAILED,
+                                LG_MSG_LOCK_FAILED,
                                 "Unable to acquire lock");
                         return;
                 }
@@ -699,7 +699,7 @@ gf_client_dump_fdtables_to_dict (xlator_t *this, dict_t *dict)
         {
                 if (ret) {
                         gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_GAIN_FAILED,
+                                LG_MSG_LOCK_FAILED,
                                 "Unable to acquire lock");
                         return -1;
                 }
@@ -742,7 +742,7 @@ gf_client_dump_fdtables (xlator_t *this)
         {
                 if (ret) {
                         gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_GAIN_FAILED,
+                                LG_MSG_LOCK_FAILED,
                                 "Unable to acquire lock");
                         return -1;
                 }
@@ -808,7 +808,7 @@ gf_client_dump_inodes_to_dict (xlator_t *this, dict_t *dict)
         {
                 if (ret) {
                         gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_GAIN_FAILED,
+                                LG_MSG_LOCK_FAILED,
                                 "Unable to acquire lock");
                         return -1;
                 }
@@ -870,7 +870,7 @@ gf_client_dump_inodes (xlator_t *this)
         {
                 if (ret) {
                         gf_msg ("client_t", GF_LOG_WARNING, 0,
-                                LG_MSG_LOCK_GAIN_FAILED,
+                                LG_MSG_LOCK_FAILED,
                                 "Unable to acquire lock");
                         goto out;
                 }
diff --git a/libglusterfs/src/libglusterfs-messages.h b/libglusterfs/src/libglusterfs-messages.h
index 8b8af36ad3c..25cca8bac3e 100644
--- a/libglusterfs/src/libglusterfs-messages.h
+++ b/libglusterfs/src/libglusterfs-messages.h
@@ -145,7 +145,7 @@
  * @recommendedaction
  *
  */
-#define LG_MSG_LOCK_GAIN_FAILED                           (GLFS_LG_BASE + 14)
+#define LG_MSG_LOCK_FAILED                               (GLFS_LG_BASE + 14)
 
 /*!
  * @messageid
@@ -153,7 +153,7 @@
  * @recommendedaction
  *
  */
-#define LG_MSG_LOCK_RELEASE_FAILED                        (GLFS_LG_BASE + 15)
+#define LG_MSG_UNLOCK_FAILED                             (GLFS_LG_BASE + 15)
 
 /*!
  * @messageid
@@ -1198,7 +1198,7 @@
  *
  */
 
-#define LG_MSG_SWAP_FAILED                               (GLFS_LG_BASE + 137)
+#define LG_MSG_SWAPCONTEXT_FAILED                        (GLFS_LG_BASE + 137)
 
 /*!
  * @messageid
diff --git a/libglusterfs/src/mem-pool.c b/libglusterfs/src/mem-pool.c
index 7d95364c4b2..1ed1aba6c2d 100644
--- a/libglusterfs/src/mem-pool.c
+++ b/libglusterfs/src/mem-pool.c
@@ -25,6 +25,7 @@
 #define GLUSTERFS_ENV_MEM_ACCT_STR  "GLUSTERFS_DISABLE_MEM_ACCT"
 
 #include "unittest/unittest.h"
+#include "libglusterfs-messages.h"
 
 void
 gf_mem_acct_enable_set (void *data)
@@ -350,7 +351,8 @@ mem_pool_new_fn (unsigned long sizeof_type,
         glusterfs_ctx_t  *ctx = NULL;
 
         if (!sizeof_type || !count) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
         padded_sizeof_type = sizeof_type + GF_MEM_POOL_PAD_BOUNDARY;
@@ -411,7 +413,8 @@ mem_get0 (struct mem_pool *mem_pool)
         void             *ptr = NULL;
 
         if (!mem_pool) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
 
@@ -432,7 +435,8 @@ mem_get (struct mem_pool *mem_pool)
         struct mem_pool **pool_ptr = NULL;
 
         if (!mem_pool) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
 
@@ -503,7 +507,8 @@ static int
 __is_member (struct mem_pool *pool, void *ptr)
 {
         if (!pool || !ptr) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return -1;
         }
 
@@ -528,21 +533,24 @@ mem_put (void *ptr)
         struct mem_pool *pool = NULL;
 
         if (!ptr) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return;
         }
 
         list = head = mem_pool_ptr2chunkhead (ptr);
         tmp = mem_pool_from_ptr (head);
         if (!tmp) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR,
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, 0,
+                                  LG_MSG_PTR_HEADER_CORRUPTED,
                                   "ptr header is corrupted");
                 return;
         }
 
         pool = *tmp;
         if (!pool) {
-                gf_log_callingfn ("mem-pool", GF_LOG_ERROR,
+                gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, 0,
+                                  LG_MSG_MEMPOOL_PTR_NULL,
                                   "mem-pool ptr is NULL");
                 return;
         }
@@ -555,9 +563,12 @@ mem_put (void *ptr)
                         in_use = (head + GF_MEM_POOL_LIST_BOUNDARY +
                                   GF_MEM_POOL_PTR);
                         if (!is_mem_chunk_in_use(in_use)) {
-                                gf_log_callingfn ("mem-pool", GF_LOG_CRITICAL,
-                                                  "mem_put called on freed ptr %p of mem "
-                                                  "pool %p", ptr, pool);
+                                gf_msg_callingfn ("mem-pool", GF_LOG_CRITICAL,
+                                                  0,
+                                                  LG_MSG_MEMPOOL_INVALID_FREE,
+                                                  "mem_put called on freed ptr"
+                                                  " %p of mem pool %p", ptr,
+                                                  pool);
                                 break;
                         }
                         pool->hot_count--;
@@ -600,8 +611,9 @@ mem_pool_destroy (struct mem_pool *pool)
         if (!pool)
                 return;
 
-        gf_log (THIS->name, GF_LOG_INFO, "size=%lu max=%d total=%"PRIu64,
-                pool->padded_sizeof_type, pool->max_alloc, pool->alloc_count);
+        gf_msg (THIS->name, GF_LOG_INFO, 0, LG_MSG_MEM_POOL_DESTROY, "size=%lu "
+                "max=%d total=%"PRIu64, pool->padded_sizeof_type,
+                pool->max_alloc, pool->alloc_count);
 
         list_del (&pool->global_list);
 
diff --git a/libglusterfs/src/stack.c b/libglusterfs/src/stack.c
index 2488cc7f0ba..6977814ec69 100644
--- a/libglusterfs/src/stack.c
+++ b/libglusterfs/src/stack.c
@@ -10,6 +10,7 @@
 
 #include "statedump.h"
 #include "stack.h"
+#include "libglusterfs-messages.h"
 
 call_frame_t *
 create_frame (xlator_t *xl, call_pool_t *pool)
@@ -44,8 +45,9 @@ create_frame (xlator_t *xl, call_pool_t *pool)
 
         if (stack->ctx->measure_latency) {
                 if (gettimeofday (&stack->tv, NULL) == -1)
-                        gf_log ("stack", GF_LOG_ERROR, "gettimeofday () failed."
-                                " (%s)", strerror (errno));
+                        gf_msg ("stack", GF_LOG_ERROR, errno,
+                                LG_MSG_GETTIMEOFDAY_FAILED,
+                                "gettimeofday () failed");
                 memcpy (&frame->begin, &stack->tv, sizeof (stack->tv));
         }
 
@@ -388,8 +390,9 @@ gf_proc_dump_pending_frames_to_dict (call_pool_t *call_pool, dict_t *dict)
 
         ret = TRY_LOCK (&call_pool->lock);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_WARNING, "Unable to dump call pool"
-                        " to dict. errno: %d", errno);
+                gf_msg (THIS->name, GF_LOG_WARNING, errno,
+                        LG_MSG_LOCK_FAILURE, "Unable to dump call "
+                        "pool to dict.");
                 return;
         }
 
diff --git a/libglusterfs/src/stack.h b/libglusterfs/src/stack.h
index c3a4f79bbec..21f9d1739f0 100644
--- a/libglusterfs/src/stack.h
+++ b/libglusterfs/src/stack.h
@@ -37,6 +37,7 @@ typedef struct call_pool call_pool_t;
 #include "globals.h"
 #include "lkowner.h"
 #include "client_t.h"
+#include "libglusterfs-messages.h"
 
 #define NFS_PID 1
 #define LOW_PRIO_PROC_PID -1
@@ -241,7 +242,6 @@ STACK_RESET (call_stack_t *stack)
                                                                         \
                 _new = mem_get0 (frame->root->pool->frame_mem_pool);    \
                 if (!_new) {                                            \
-                        gf_log ("stack", GF_LOG_ERROR, "alloc failed"); \
                         break;                                          \
                 }                                                       \
                 typeof(fn##_cbk) tmp_cbk = rfn;                         \
@@ -292,7 +292,6 @@ STACK_RESET (call_stack_t *stack)
                                                                         \
                 _new = mem_get0 (frame->root->pool->frame_mem_pool);    \
                 if (!_new) {                                            \
-                        gf_log ("stack", GF_LOG_ERROR, "alloc failed"); \
                         break;                                          \
                 }                                                       \
                 typeof(fn##_cbk) tmp_cbk = rfn;                         \
@@ -328,7 +327,8 @@ STACK_RESET (call_stack_t *stack)
                 call_frame_t *_parent = NULL;                           \
                 xlator_t     *old_THIS = NULL;                          \
                 if (!frame) {                                           \
-                        gf_log ("stack", GF_LOG_CRITICAL, "!frame");    \
+                        gf_msg ("stack", GF_LOG_CRITICAL, 0,            \
+                                LG_MSG_FRAME_ERROR, "!frame");          \
                         break;                                          \
                 }                                                       \
                 fn = frame->ret;                                        \
@@ -357,7 +357,8 @@ STACK_RESET (call_stack_t *stack)
                 xlator_t     *old_THIS = NULL;                          \
                                                                         \
                 if (!frame) {                                           \
-                        gf_log ("stack", GF_LOG_CRITICAL, "!frame");    \
+                        gf_msg ("stack", GF_LOG_CRITICAL, 0,            \
+                                LG_MSG_FRAME_ERROR, "!frame");          \
                         break;                                          \
                 }                                                       \
                 fn = (fop_##op##_cbk_t )frame->ret;                     \
@@ -461,8 +462,9 @@ copy_frame (call_frame_t *frame)
 
         if (newstack->ctx->measure_latency) {
                 if (gettimeofday (&newstack->tv, NULL) == -1)
-                        gf_log ("stack", GF_LOG_ERROR, "gettimeofday () failed."
-                                " (%s)", strerror (errno));
+                        gf_msg ("stack", GF_LOG_ERROR, errno,
+                                LG_MSG_GETTIMEOFDAY_FAILED,
+                                "gettimeofday () failed.");
                 memcpy (&newframe->begin, &newstack->tv,
                         sizeof (newstack->tv));
         }
diff --git a/libglusterfs/src/store.c b/libglusterfs/src/store.c
index 351741f4297..08479776c96 100644
--- a/libglusterfs/src/store.c
+++ b/libglusterfs/src/store.c
@@ -20,7 +20,7 @@
 #include "store.h"
 #include "dict.h"
 #include "xlator.h"
-
+#include "libglusterfs-messages.h"
 int32_t
 gf_store_mkdir (char *path)
 {
@@ -29,8 +29,8 @@ gf_store_mkdir (char *path)
         ret = mkdir (path, 0777);
 
         if ((-1 == ret) && (EEXIST != errno)) {
-                gf_log ("", GF_LOG_ERROR, "mkdir() failed on path %s,"
-                        "errno: %s", path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, "mkdir()"
+                        " failed on path %s.", path);
         } else {
                 ret = 0;
         }
@@ -49,8 +49,9 @@ gf_store_handle_create_on_absence (gf_store_handle_t **shandle,
                 ret = gf_store_handle_new (path, shandle);
 
                 if (ret) {
-                        gf_log ("", GF_LOG_ERROR, "Unable to create store"
-                                " handle for path: %s", path);
+                        gf_msg ("", GF_LOG_ERROR, 0,
+                                LG_MSG_STORE_HANDLE_CREATE_FAILED, "Unable to"
+                                " create store handle for path: %s", path);
                 }
         }
         return ret;
@@ -67,8 +68,8 @@ gf_store_mkstemp (gf_store_handle_t *shandle)
         snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
         shandle->tmp_fd = open (tmppath, O_RDWR | O_CREAT | O_TRUNC, 0600);
         if (shandle->tmp_fd < 0) {
-                gf_log ("", GF_LOG_ERROR, "Failed to open %s, error: %s",
-                        tmppath, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to open %s.", tmppath);
         }
 out:
         return shandle->tmp_fd;
@@ -92,15 +93,15 @@ gf_store_sync_direntry (char *path)
         pdir = dirname (dir);
         dirfd = open (pdir, O_RDONLY);
         if (dirfd == -1) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to open directory "
-                        "%s, due to %s", pdir, strerror (errno));
+                gf_msg (this->name, GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                        "Failed to open directory %s.", pdir);
                 goto out;
         }
 
         ret = fsync (dirfd);
         if (ret) {
-                gf_log (this->name, GF_LOG_ERROR, "Failed to fsync %s, due to "
-                        "%s", pdir, strerror (errno));
+                gf_msg (this->name, GF_LOG_ERROR, errno,
+                        LG_MSG_DIR_OP_FAILED, "Failed to fsync %s.", pdir);
                 goto out;
         }
 
@@ -109,8 +110,8 @@ out:
         if (dirfd >= 0) {
                 ret = close (dirfd);
                 if (ret) {
-                        gf_log (this->name, GF_LOG_ERROR, "Failed to close "
-                                "%s, due to %s", pdir, strerror (errno));
+                        gf_msg (this->name, GF_LOG_ERROR, errno,
+                                LG_MSG_DIR_OP_FAILED, "Failed to close %s", pdir);
                 }
         }
 
@@ -131,15 +132,16 @@ gf_store_rename_tmppath (gf_store_handle_t *shandle)
 
         ret = fsync (shandle->tmp_fd);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to fsync %s, "
-                        "error: %s", shandle->path, strerror (errno));
+                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to fsync %s", shandle->path);
                 goto out;
         }
         snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
         ret = rename (tmppath, shandle->path);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to rename %s to %s, "
-                        "error: %s", tmppath, shandle->path, strerror (errno));
+                gf_msg (THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to rename %s to %s", tmppath,
+                        shandle->path);
                 goto out;
         }
 
@@ -164,8 +166,9 @@ gf_store_unlink_tmppath (gf_store_handle_t *shandle)
         snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
         ret = unlink (tmppath);
         if (ret && (errno != ENOENT)) {
-                gf_log ("", GF_LOG_ERROR, "Failed to mv %s to %s, error: %s",
-                        tmppath, shandle->path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to mv %s to %s", tmppath,
+                        shandle->path);
         } else {
                 ret = 0;
         }
@@ -248,8 +251,8 @@ gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
                 lseek (handle->fd, 0, SEEK_SET);
 
         if (handle->fd == -1) {
-                gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
-                        handle->path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Unable to open file %s", handle->path);
                 goto out;
         }
         if (!handle->read)
@@ -258,15 +261,15 @@ gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
                 fseek (handle->read, 0, SEEK_SET);
 
         if (!handle->read) {
-                gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",
-                        handle->path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Unable to open file %s", handle->path);
                 goto out;
         }
 
         ret = fstat (handle->fd, &st);
         if (ret < 0) {
-                gf_log ("", GF_LOG_WARNING, "stat on file %s failed",
-                        handle->path);
+                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                        "stat on file %s failed", handle->path);
                 ret = -1;
                 store_errno = GD_STORE_STAT_FAILED;
                 goto out;
@@ -292,16 +295,16 @@ gf_store_retrieve_value (gf_store_handle_t *handle, char *key, char **value)
                                                   &iter_key, &iter_val,
                                                   &store_errno);
                 if (ret < 0) {
-                        gf_log ("", GF_LOG_TRACE, "error while reading key "
-                                "'%s': %s", key,
-                                gf_store_strerror (store_errno));
+                        gf_msg_trace ("", 0, "error while reading key '%s': "
+                                      "%s", key,
+                                      gf_store_strerror (store_errno));
                         goto out;
                 }
 
-                gf_log ("", GF_LOG_TRACE, "key %s read", iter_key);
+                gf_msg_trace ("", 0, "key %s read", iter_key);
 
                 if (!strcmp (key, iter_key)) {
-                        gf_log ("", GF_LOG_DEBUG, "key %s found", key);
+                        gf_msg_debug ("", 0, "key %s found", key);
                         ret = 0;
                         if (iter_val)
                                 *value = gf_strdup (iter_val);
@@ -341,25 +344,25 @@ gf_store_save_value (int fd, char *key, char *value)
 
         fp = fdopen (dup_fd, "a+");
         if (fp == NULL) {
-                gf_log ("", GF_LOG_WARNING, "fdopen failed.");
+                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED, "fdopen "
+                        "failed.");
                 ret = -1;
                 goto out;
         }
 
         ret = fprintf (fp, "%s=%s\n", key, value);
         if (ret < 0) {
-                gf_log ("", GF_LOG_WARNING, "Unable to store key: %s,"
-                        "value: %s, error: %s", key, value,
-                        strerror (errno));
+                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                        "Unable to store key: %s, value: %s.",
+                        key, value);
                 ret = -1;
                 goto out;
         }
 
         ret = fflush (fp);
         if (feof (fp)) {
-                gf_log ("", GF_LOG_WARNING,
-                        "fflush failed, error: %s",
-                        strerror (errno));
+                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                        "fflush failed.");
                 ret = -1;
                 goto out;
         }
@@ -369,7 +372,7 @@ out:
         if (fp)
                 fclose (fp);
 
-        gf_log ("", GF_LOG_DEBUG, "returning: %d", ret);
+        gf_msg_debug ("", 0, "returning: %d", ret);
         return ret;
 }
 
@@ -391,8 +394,8 @@ gf_store_handle_new (const char *path, gf_store_handle_t **handle)
 
         fd = open (path, O_RDWR | O_CREAT | O_APPEND, 0600);
         if (fd < 0) {
-                gf_log ("", GF_LOG_ERROR, "Failed to open file: %s, error: %s",
-                        path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to open file: %s.", path);
                 goto out;
         }
 
@@ -415,7 +418,7 @@ out:
                 GF_FREE (shandle);
         }
 
-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);
+        gf_msg_debug ("", 0, "Returning %d", ret);
         return ret;
 }
 
@@ -427,14 +430,13 @@ gf_store_handle_retrieve (char *path, gf_store_handle_t **handle)
 
         ret = stat (path, &statbuf);
         if (ret) {
-                gf_log ("", GF_LOG_ERROR, "Path corresponding to "
-                        "%s, returned error: (%s)",
-                        path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_PATH_NOT_FOUND, "Path "
+                        "corresponding to %s.", path);
                 goto out;
         }
         ret =  gf_store_handle_new (path, handle);
 out:
-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);
+        gf_msg_debug ("", 0, "Returning %d", ret);
         return ret;
 }
 
@@ -455,7 +457,7 @@ gf_store_handle_destroy (gf_store_handle_t *handle)
         ret = 0;
 
 out:
-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);
+        gf_msg_debug ("", 0, "Returning %d", ret);
 
         return ret;
 }
@@ -472,8 +474,8 @@ gf_store_iter_new (gf_store_handle_t  *shandle, gf_store_iter_t  **iter)
 
         fp = fopen (shandle->path, "r");
         if (!fp) {
-                gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %d",
-                        shandle->path, errno);
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Unable to open file %s", shandle->path);
                 goto out;
         }
 
@@ -496,7 +498,7 @@ out:
 
         GF_FREE (tmp_iter);
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
+        gf_msg_debug ("", 0, "Returning with %d", ret);
         return ret;
 }
 
@@ -511,19 +513,21 @@ gf_store_validate_key_value (char *storepath, char *key, char *val,
 
         if ((key == NULL) && (val == NULL)) {
                 ret = -1;
-                gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
-                        "Invalid key and value (null) in %s", storepath);
+                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
+                        "store may be corrupted, Invalid key and value (null)"
+                        " in %s", storepath);
                 *op_errno = GD_STORE_KEY_VALUE_NULL;
         } else if (key == NULL) {
                 ret = -1;
-                gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
-                        "Invalid key (null) in %s", storepath);
+                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
+                        "store may be corrupted, Invalid key (null) in %s",
+                        storepath);
                 *op_errno = GD_STORE_KEY_NULL;
         } else if (val == NULL) {
                 ret = -1;
-                gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
-                        "Invalid value (null) for key %s in %s", key,
-                        storepath);
+                gf_msg ("", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "Glusterd "
+                        "store may be corrupted, Invalid value (null) for key"
+                        " %s in %s", key, storepath);
                 *op_errno = GD_STORE_VALUE_NULL;
         } else {
                 ret = 0;
@@ -550,7 +554,8 @@ gf_store_iter_get_next (gf_store_iter_t *iter, char  **key, char **value,
 
         ret = stat (iter->filepath, &st);
         if (ret < 0) {
-                gf_log ("", GF_LOG_WARNING, "stat on file failed");
+                gf_msg ("", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                        "stat on file failed");
                 ret = -1;
                 store_errno = GD_STORE_STAT_FAILED;
                 goto out;
@@ -605,7 +610,7 @@ out:
         if (op_errno)
                 *op_errno = store_errno;
 
-        gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret);
+        gf_msg_debug ("", 0, "Returning with %d", ret);
         return ret;
 }
 
@@ -646,8 +651,9 @@ gf_store_iter_destroy (gf_store_iter_t *iter)
          * being NULL*/
         ret = fclose (iter->file);
         if (ret)
-                gf_log ("", GF_LOG_ERROR, "Unable to close file: %s, ret: %d, "
-                        "errno: %d" ,iter->filepath, ret, errno);
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "Unable"
+                        " to close file: %s, ret: %d" ,
+                        iter->filepath, ret);
 
         GF_FREE (iter);
         return ret;
@@ -685,15 +691,15 @@ gf_store_lock (gf_store_handle_t *sh)
 
         sh->fd = open (sh->path, O_RDWR);
         if (sh->fd == -1) {
-                gf_log ("", GF_LOG_ERROR, "Failed to open '%s': %s", sh->path,
-                        strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
+                        "Failed to open '%s'", sh->path);
                 return -1;
         }
 
         ret = lockf (sh->fd, F_LOCK, 0);
         if (ret)
-                gf_log ("", GF_LOG_ERROR, "Failed to gain lock on '%s': %s",
-                        sh->path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_LOCK_FAILED,
+                        "Failed to gain lock on '%s'", sh->path);
         else
                 /* sh->locked is protected by the lockf(sh->fd) above */
                 sh->locked = F_LOCK;
@@ -711,8 +717,8 @@ gf_store_unlock (gf_store_handle_t *sh)
 
         /* does not matter if this fails, locks are released on close anyway */
         if (lockf (sh->fd, F_ULOCK, 0) == -1)
-                gf_log ("", GF_LOG_ERROR, "Failed to release lock on '%s': %s",
-                        sh->path, strerror (errno));
+                gf_msg ("", GF_LOG_ERROR, errno, LG_MSG_UNLOCK_FAILED,
+                        "Failed to release lock on '%s'", sh->path);
 
         close (sh->fd);
 }
diff --git a/libglusterfs/src/syncop-utils.c b/libglusterfs/src/syncop-utils.c
index 349fa92d64f..8ab6befe652 100644
--- a/libglusterfs/src/syncop-utils.c
+++ b/libglusterfs/src/syncop-utils.c
@@ -15,6 +15,7 @@
 
 #include "syncop.h"
 #include "common-utils.h"
+#include "libglusterfs-messages.h"
 
 int
 syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
@@ -27,9 +28,9 @@ syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
 
         dirfd = fd_create (loc->inode, pid);
         if (!dirfd) {
-                gf_log (subvol->name, GF_LOG_ERROR,
-                        "fd_create of %s failed: %s",
-                        uuid_utoa (loc->gfid), strerror(errno));
+                gf_msg (subvol->name, GF_LOG_ERROR, errno,
+                        LG_MSG_FD_CREATE_FAILED, "fd_create of %s",
+                        uuid_utoa (loc->gfid));
                 ret = -errno;
                 goto out;
         }
@@ -49,18 +50,18 @@ syncop_dirfd (xlator_t *subvol, loc_t *loc, fd_t **fd, int pid)
                 fd_unref (dirfd);
                 dirfd = fd_anonymous (loc->inode);
                 if (!dirfd) {
-                        gf_log(subvol->name, GF_LOG_ERROR,
-                               "fd_anonymous of %s failed: %s",
-                               uuid_utoa (loc->gfid), strerror(errno));
+                        gf_msg (subvol->name, GF_LOG_ERROR, errno,
+                                LG_MSG_FD_ANONYMOUS_FAILED, "fd_anonymous of "
+                                "%s", uuid_utoa (loc->gfid));
                         ret = -errno;
                         goto out;
                 }
                 ret = 0;
 #else /* GF_LINUX_HOST_OS */
                 fd_unref (dirfd);
-                gf_log (subvol->name, GF_LOG_ERROR,
-                        "opendir of %s failed: %s",
-                        uuid_utoa (loc->gfid), strerror(errno));
+                gf_msg (subvol->name, GF_LOG_ERROR, errno,
+                        LG_MSG_DIR_OP_FAILED, "opendir of %s",
+                        uuid_utoa (loc->gfid));
                 goto out;
 #endif /* GF_LINUX_HOST_OS */
         }
@@ -304,7 +305,7 @@ syncop_is_subvol_local (xlator_t *this, loc_t *loc, gf_boolean_t *is_local)
 
         ret = glusterfs_is_local_pathinfo (pathinfo, is_local);
 
-        gf_log (this->name, GF_LOG_DEBUG, "subvol %s is %slocal",
+        gf_msg_debug (this->name, 0, "subvol %s is %slocal",
                 this->name, is_local ? "" : "not ");
 
 out:
diff --git a/libglusterfs/src/syncop.c b/libglusterfs/src/syncop.c
index c3b0efea7d2..5ee4e2d33d5 100644
--- a/libglusterfs/src/syncop.c
+++ b/libglusterfs/src/syncop.c
@@ -14,6 +14,7 @@
 #endif
 
 #include "syncop.h"
+#include "libglusterfs-messages.h"
 
 int
 syncopctx_setfsuid (void *uid)
@@ -262,20 +263,21 @@ __run (struct synctask *task)
         case SYNCTASK_SUSPEND:
                 break;
         case SYNCTASK_RUN:
-                gf_log (task->xl->name, GF_LOG_DEBUG,
-                        "re-running already running task");
+                gf_msg_debug (task->xl->name, 0, "re-running already running"
+                              " task");
                 env->runcount--;
                 break;
         case SYNCTASK_WAIT:
                 env->waitcount--;
                 break;
         case SYNCTASK_DONE:
-                gf_log (task->xl->name, GF_LOG_WARNING,
-                        "running completed task");
+                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
+                        LG_MSG_COMPLETED_TASK, "running completed task");
 		return;
 	case SYNCTASK_ZOMBIE:
-		gf_log (task->xl->name, GF_LOG_WARNING,
-			"attempted to wake up zombie!!");
+		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
+                        LG_MSG_WAKE_UP_ZOMBIE, "attempted to wake up "
+                        "zombie!!");
 		return;
         }
 
@@ -301,16 +303,19 @@ __wait (struct synctask *task)
                 env->runcount--;
                 break;
         case SYNCTASK_WAIT:
-                gf_log (task->xl->name, GF_LOG_WARNING,
-                        "re-waiting already waiting task");
+                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
+                        LG_MSG_REWAITING_TASK, "re-waiting already waiting "
+                        "task");
                 env->waitcount--;
                 break;
         case SYNCTASK_DONE:
-                gf_log (task->xl->name, GF_LOG_WARNING,
+                gf_msg (task->xl->name, GF_LOG_WARNING, 0,
+                        LG_MSG_COMPLETED_TASK,
                         "running completed task");
                 return;
 	case SYNCTASK_ZOMBIE:
-		gf_log (task->xl->name, GF_LOG_WARNING,
+		gf_msg (task->xl->name, GF_LOG_WARNING, 0,
+                        LG_MSG_SLEEP_ZOMBIE,
 			"attempted to sleep a zombie!!");
 		return;
         }
@@ -336,8 +341,9 @@ synctask_yield (struct synctask *task)
                 (void) gf_backtrace_save (task->btbuf);
         }
         if (swapcontext (&task->ctx, &task->proc->sched) < 0) {
-                gf_log ("syncop", GF_LOG_ERROR,
-                        "swapcontext failed (%s)", strerror (errno));
+                gf_msg ("syncop", GF_LOG_ERROR, errno,
+                        LG_MSG_SWAPCONTEXT_FAILED, "swapcontext failed (%s)",
+                        strerror (errno));
         }
 
         THIS = oldTHIS;
@@ -488,16 +494,14 @@ synctask_create (struct syncenv *env, synctask_fn_t fn, synctask_cbk_t cbk,
         INIT_LIST_HEAD (&newtask->waitq);
 
         if (getcontext (&newtask->ctx) < 0) {
-                gf_log ("syncop", GF_LOG_ERROR,
-                        "getcontext failed (%s)",
+                gf_msg ("syncop", GF_LOG_ERROR, errno,
+                        LG_MSG_GETCONTEXT_FAILED, "getcontext failed (%s)",
                         strerror (errno));
                 goto err;
         }
 
         newtask->stack = GF_CALLOC (1, env->stacksize, gf_common_mt_syncstack);
         if (!newtask->stack) {
-                gf_log ("syncop", GF_LOG_ERROR,
-                        "out of memory for stack");
                 goto err;
         }
 
@@ -648,8 +652,8 @@ synctask_switchto (struct synctask *task)
 #endif
 
         if (swapcontext (&task->proc->sched, &task->ctx) < 0) {
-                gf_log ("syncop", GF_LOG_ERROR,
-                        "swapcontext failed (%s)", strerror (errno));
+        gf_msg ("syncop", GF_LOG_ERROR, errno, LG_MSG_SWAPCONTEXT_FAILED,
+                "swapcontext failed");
         }
 
         if (task->state == SYNCTASK_DONE) {
@@ -874,22 +878,25 @@ __synclock_lock (struct synclock *lock)
                 case LOCK_TASK:
                         if (task == lock->owner) {
                                 lock->lock++;
-                                gf_log ("", GF_LOG_TRACE, "Recursive lock called by "
-                                        "sync task.owner= %p,lock=%d", lock->owner, lock->lock);
+                                gf_msg_trace ("", 0, "Recursive lock called by"
+                                              " sync task.owner= %p,lock=%d",
+                                              lock->owner, lock->lock);
                                 return 0;
                         }
                         break;
                 case LOCK_THREAD:
                         if (pthread_self () == lock->owner_tid) {
                                 lock->lock++;
-                                gf_log ("", GF_LOG_TRACE, "Recursive lock called by "
-                                        "thread ,owner=%u lock=%d", (unsigned int) lock->owner_tid,
-                                         lock->lock);
+                                gf_msg_trace ("", 0, "Recursive lock called by"
+                                              " thread ,owner=%u lock=%d",
+                                              (unsigned int) lock->owner_tid,
+                                              lock->lock);
                                 return 0;
                         }
                         break;
                 default:
-                        gf_log ("", GF_LOG_CRITICAL, "unknown lock type");
+                        gf_msg ("", GF_LOG_CRITICAL, 0,
+                                LG_MSG_UNKNOWN_LOCK_TYPE, "unknown lock type");
                         break;
                 }
         }
@@ -974,7 +981,8 @@ __synclock_unlock (synclock_t *lock)
                return -1;
 
         if (lock->lock == 0) {
-                gf_log ("", GF_LOG_CRITICAL, "Unlock called  before lock ");
+                gf_msg ("", GF_LOG_CRITICAL, 0, LG_MSG_UNLOCK_BEFORE_LOCK,
+                        "Unlock called  before lock ");
                 return -1;
         }
         curr = synctask_get ();
@@ -986,23 +994,27 @@ __synclock_unlock (synclock_t *lock)
         case LOCK_TASK:
                 if (curr == lock->owner) {
                         lock->lock--;
-                        gf_log ("", GF_LOG_TRACE, "Unlock success %p, remaining"
-                                " locks=%d", lock->owner, lock->lock);
+                        gf_msg_trace ("", 0, "Unlock success %p, remaining"
+                                      " locks=%d", lock->owner, lock->lock);
                 } else {
-                        gf_log ("", GF_LOG_WARNING, "Unlock called by %p, but"
-                               " lock held by %p", curr, lock->owner);
+                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                                "Unlock called by %p, but lock held by %p",
+                                curr, lock->owner);
                 }
 
                 break;
         case LOCK_THREAD:
                 if (pthread_self () == lock->owner_tid) {
                         lock->lock--;
-                        gf_log ("", GF_LOG_TRACE, "Unlock success %u, remaining"
-                                " locks=%d", (unsigned int)lock->owner_tid, lock->lock);
+                        gf_msg_trace ("", 0, "Unlock success %u, remaining "
+                                      "locks=%d",
+                                      (unsigned int)lock->owner_tid,
+                                      lock->lock);
                 } else {
-                        gf_log ("", GF_LOG_WARNING, "Unlock called by %u, but"
-                                " lock held by %u", (unsigned int) pthread_self(),
-                                 (unsigned int) lock->owner_tid);
+                        gf_msg ("", GF_LOG_WARNING, 0, LG_MSG_LOCK_OWNER_ERROR,
+                                "Unlock called by %u, but lock held by %u",
+                                (unsigned int) pthread_self(),
+                                (unsigned int) lock->owner_tid);
                 }
 
                 break;
@@ -1250,9 +1262,8 @@ syncop_readdirp_cbk (call_frame_t *frame,
                                 gf_dirent_free (&(args->entries));
                                 break;
                         }
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "adding entry=%s, count=%d",
-                                tmp->d_name, count);
+                        gf_msg_trace (this->name, 0, "adding entry=%s, "
+                                      "count=%d", tmp->d_name, count);
                         list_add_tail (&tmp->list, &(args->entries.list));
                         count++;
                 }
@@ -1326,9 +1337,9 @@ syncop_readdir_cbk (call_frame_t *frame,
                                 gf_dirent_free (&(args->entries));
                                 break;
                         }
-                        gf_log (this->name, GF_LOG_TRACE,
-                                "adding entry=%s, count=%d",
-                                tmp->d_name, count);
+                        gf_msg_trace (this->name, 0, "adding "
+                                      "entry=%s, count=%d", tmp->d_name,
+                                      count);
                         list_add_tail (&tmp->list, &(args->entries.list));
                         count++;
                 }
diff --git a/libglusterfs/src/timer.c b/libglusterfs/src/timer.c
index 0d845cdeb38..8344c9bc5d5 100644
--- a/libglusterfs/src/timer.c
+++ b/libglusterfs/src/timer.c
@@ -18,6 +18,7 @@
 #include "common-utils.h"
 #include "globals.h"
 #include "timespec.h"
+#include "libglusterfs-messages.h"
 
 gf_timer_t *
 gf_timer_call_after (glusterfs_ctx_t *ctx,
@@ -32,7 +33,8 @@ gf_timer_call_after (glusterfs_ctx_t *ctx,
 
         if (ctx == NULL)
         {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
 
@@ -41,14 +43,17 @@ gf_timer_call_after (glusterfs_ctx_t *ctx,
          * when cleanup_started is set after checking for it
          */
         if (ctx->cleanup_started) {
-                gf_log_callingfn ("timer", GF_LOG_INFO, "ctx cleanup started");
+                gf_msg_callingfn ("timer", GF_LOG_INFO, 0,
+                                  LG_MSG_CTX_CLEANUP_STARTED, "ctx cleanup "
+                                  "started");
                 return NULL;
         }
 
         reg = gf_timer_registry_init (ctx);
 
         if (!reg) {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "!reg");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
+                                  LG_MSG_TIMER_REGISTER_ERROR, "!reg");
                 return NULL;
         }
 
@@ -85,7 +90,8 @@ gf_timer_call_stale (gf_timer_registry_t *reg,
 {
         if (reg == NULL || event == NULL)
         {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return 0;
         }
 
@@ -107,13 +113,15 @@ gf_timer_call_cancel (glusterfs_ctx_t *ctx,
 
         if (ctx == NULL || event == NULL)
         {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return 0;
         }
 
         reg = gf_timer_registry_init (ctx);
         if (!reg) {
-                gf_log ("timer", GF_LOG_ERROR, "!reg");
+                gf_msg ("timer", GF_LOG_ERROR, 0, LG_MSG_INIT_TIMER_FAILED,
+                        "!reg");
                 GF_FREE (event);
                 return 0;
         }
@@ -145,13 +153,15 @@ gf_timer_proc (void *ctx)
 
         if (ctx == NULL)
         {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
 
         reg = gf_timer_registry_init (ctx);
         if (!reg) {
-                gf_log ("timer", GF_LOG_ERROR, "!reg");
+                gf_msg ("timer", GF_LOG_ERROR, 0, LG_MSG_INIT_TIMER_FAILED,
+                        "!reg");
                 return NULL;
         }
 
@@ -223,7 +233,8 @@ gf_timer_registry_t *
 gf_timer_registry_init (glusterfs_ctx_t *ctx)
 {
         if (ctx == NULL) {
-                gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
+                gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
+                                  LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }