From 658994a4914d8134c4c9f5a9273706c46d88360d Mon Sep 17 00:00:00 2001

From: Mohamed Ashiq <ashiq333@gmail.com>

Date: Tue, 19 May 2015 15:46:01 +0530

Subject: [PATCH 180/190] mem-pool,stack,store,syncop,timer/libglusterfs : Porting to a new logging framework

Change-Id: Idd3dcaf7eeea5207b3a5210676ce3df64153197f

BUG: 1231792

Signed-off-by: Mohamed Ashiq Liyazudeen <mliyazud@redhat.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>

Reviewed-on: https://code.engineering.redhat.com/gerrit/51751

Tested-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

---

 libglusterfs/src/client_t.c              |   10 +-

 libglusterfs/src/libglusterfs-messages.h |    6 +-

 libglusterfs/src/mem-pool.c              |   36 +++++---

 libglusterfs/src/stack.c                 |   11 ++-

 libglusterfs/src/stack.h                 |   14 ++--

 libglusterfs/src/store.c                 |  139 ++++++++++++++++--------------

 libglusterfs/src/syncop-utils.c          |   21 +++--

 libglusterfs/src/syncop.c                |   91 +++++++++++---------

 libglusterfs/src/timer.c                 |   29 ++++--

 9 files changed, 202 insertions(+), 155 deletions(-)

diff --git a/libglusterfs/src/client_t.c b/libglusterfs/src/client_t.c

index b7462fc..035658f 100644

--- a/libglusterfs/src/client_t.c

+++ b/libglusterfs/src/client_t.c

@@ -595,7 +595,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;

                 }

@@ -693,7 +693,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;

                 }

@@ -736,7 +736,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;

                 }

@@ -802,7 +802,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;

                 }

@@ -864,7 +864,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 8b8af36..25cca8b 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 7d95364..1ed1aba 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 a7fb951..12d5759 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"

 static inline

 int call_frames_count (call_frame_t *call_frame)

@@ -46,8 +47,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 (&stack->frames.begin, &stack->tv, sizeof (stack->tv));

         }

@@ -399,8 +401,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 f2d2ef9..38ca3ee 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

@@ -233,7 +234,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;                         \

@@ -288,7 +288,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;                     \

@@ -435,8 +436,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 (&newstack->frames.begin, &newstack->tv,

                         sizeof (newstack->tv));

         }

diff --git a/libglusterfs/src/store.c b/libglusterfs/src/store.c

index 351741f..7c8b29d 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,9 @@ 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 +133,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 +167,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 +252,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 +262,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 +296,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 +345,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 +373,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 +395,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 +419,7 @@ out:

                 GF_FREE (shandle);

         }

-        gf_log ("", GF_LOG_DEBUG, "Returning %d", ret);

+        gf_msg_debug ("", 0, "Returning %d", ret);

         return ret;

 }

@@ -427,14 +431,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 +458,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 +475,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 +499,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 +514,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 +555,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 +611,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 +652,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 +692,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 +718,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 349fa92..8ab6bef 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",