From dab6b91c987cd2cfcd0c26114780cee5845190d4 Mon Sep 17 00:00:00 2001

From: Nandaja Varma <nandaja.varma@gmail.com>

Date: Fri, 13 Mar 2015 16:55:17 +0530

Subject: [PATCH 088/101] rebalance,store,glusterd/glusterd: porting to new logging framework

cherry-picked from commit 25f28a9c23b1adf665a982c2f5157bf13361521b

>Change-Id: I231b79e3414e60fe67cde577dd585cce83c8bfad

>BUG: 1194640

>Signed-off-by: Nandaja Varma <nandaja.varma@gmail.com>

>Reviewed-on: http://review.gluster.org/9877

>Tested-by: Gluster Build System <jenkins@build.gluster.com>

>Reviewed-by: Sachin Pandit <spandit@redhat.com>

>Tested-by: NetBSD Build System <jenkins@build.gluster.org>

>Reviewed-by: Atin Mukherjee <amukherj@redhat.com>

Change-Id: I231b79e3414e60fe67cde577dd585cce83c8bfad

BUG: 1231771

Signed-off-by: Nandaja Varma <nvarma@redhat.com>

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

Reviewed-by: Atin Mukherjee <amukherj@redhat.com>

Tested-by: Atin Mukherjee <amukherj@redhat.com>

---

 xlators/mgmt/glusterd/src/glusterd-rebalance.c |  102 +++--

 xlators/mgmt/glusterd/src/glusterd-store.c     |  552 +++++++++++++++---------

 xlators/mgmt/glusterd/src/glusterd.c           |  208 ++++++---

 3 files changed, 538 insertions(+), 324 deletions(-)

diff --git a/xlators/mgmt/glusterd/src/glusterd-rebalance.c b/xlators/mgmt/glusterd/src/glusterd-rebalance.c

index 0367df3..4fd95c2 100644

--- a/xlators/mgmt/glusterd/src/glusterd-rebalance.c

+++ b/xlators/mgmt/glusterd/src/glusterd-rebalance.c

@@ -55,7 +55,7 @@ glusterd_defrag_start_validate (glusterd_volinfo_t *volinfo, char *op_errstr,

         /* Check only if operation is not remove-brick */

         if ((GD_OP_REMOVE_BRICK != op) &&

             !gd_is_remove_brick_committed (volinfo)) {

-                gf_log (this->name, GF_LOG_DEBUG, "A remove-brick task on "

+                gf_msg_debug (this->name, 0, "A remove-brick task on "

                         "volume %s is not yet committed", volinfo->volname);

                 snprintf (op_errstr, len, "A remove-brick task on volume %s is"

                           " not yet committed. Either commit or stop the "

@@ -64,7 +64,7 @@ glusterd_defrag_start_validate (glusterd_volinfo_t *volinfo, char *op_errstr,

         }

         if (glusterd_is_defrag_on (volinfo)) {

-                gf_log (this->name, GF_LOG_DEBUG,

+                gf_msg_debug (this->name, 0,

                         "rebalance on volume %s already started",

                         volinfo->volname);

                 snprintf (op_errstr, len, "Rebalance on %s is already started",

@@ -74,7 +74,7 @@ glusterd_defrag_start_validate (glusterd_volinfo_t *volinfo, char *op_errstr,

         ret = 0;

 out:

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

+        gf_msg_debug (this->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -123,7 +123,7 @@ __glusterd_defrag_notify (struct rpc_clnt *rpc, void *mydata,

                 }

                 UNLOCK (&defrag->lock);

-               gf_log ("", GF_LOG_DEBUG, "%s got RPC_CLNT_CONNECT",

+               gf_msg_debug (this->name, 0, "%s got RPC_CLNT_CONNECT",

                         rpc->conn.name);

                break;

         }

@@ -165,7 +165,7 @@ __glusterd_defrag_notify (struct rpc_clnt *rpc, void *mydata,

                 glusterd_volinfo_unref (volinfo);

                 break;

         default:

-                gf_log ("", GF_LOG_TRACE,

+                gf_msg_trace (this->name, 0,

                         "got some other RPC event %d", event);

                 ret = 0;

                 break;

@@ -234,7 +234,8 @@ glusterd_handle_defrag_start (glusterd_volinfo_t *volinfo, char *op_errstr,

         GLUSTERD_GET_DEFRAG_DIR (defrag_path, volinfo, priv);

         ret = mkdir_p (defrag_path, 0777, _gf_true);

         if (ret) {

-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to create "

+                gf_msg (THIS->name, GF_LOG_ERROR, errno,

+                        GD_MSG_CREATE_DIR_FAILED, "Failed to create "

                         "directory %s", defrag_path);

                 goto out;

         }

@@ -296,7 +297,7 @@ glusterd_handle_defrag_start (glusterd_volinfo_t *volinfo, char *op_errstr,

         ret = runner_run_nowait (&runner);

         if (ret) {

-                gf_log ("glusterd", GF_LOG_DEBUG, "rebalance command failed");

+                gf_msg_debug ("glusterd", 0, "rebalance command failed");

                 goto out;

         }

@@ -310,7 +311,7 @@ glusterd_handle_defrag_start (glusterd_volinfo_t *volinfo, char *op_errstr,

                 defrag->cbk_fn = cbk;

 out:

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

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

         return ret;

 }

@@ -352,7 +353,8 @@ glusterd_rebalance_rpc_create (glusterd_volinfo_t *volinfo,

                  * with the older path

                  */

                 if (ret && (errno == ENOENT)) {

-                        gf_log (this->name, GF_LOG_WARNING, "Rebalance sockfile "

+                        gf_msg (this->name, GF_LOG_WARNING, errno,

+                                GD_MSG_FILE_OP_FAILED, "Rebalance sockfile "

                                 "%s does not exist. Trying old path.",

                                 sockfile);

                         GLUSTERD_GET_DEFRAG_SOCK_FILE_OLD (sockfile, volinfo,

@@ -400,14 +402,16 @@ glusterd_rebalance_cmd_validate (int cmd, char *volname,

         int ret = -1;

         if (glusterd_volinfo_find(volname, volinfo)) {

-                gf_log ("glusterd", GF_LOG_ERROR, "Received rebalance on invalid"

+                gf_msg ("glusterd", GF_LOG_ERROR, EINVAL,

+                        GD_MSG_VOL_NOT_FOUND, "Received rebalance on invalid"

                         " volname %s", volname);

                 snprintf (op_errstr, len, "Volume %s does not exist",

                           volname);

                 goto out;

         }

         if ((*volinfo)->brick_count <= (*volinfo)->dist_leaf_count) {

-                gf_log ("glusterd", GF_LOG_ERROR, "Volume %s is not a "

+                gf_msg ("glusterd", GF_LOG_ERROR, 0,

+                        GD_MSG_VOL_NOT_DISTRIBUTE, "Volume %s is not a "

                 "distribute type or contains only 1 brick", volname);

                 snprintf (op_errstr, len, "Volume %s is not a distribute "

                           "volume or contains only 1 brick.\n"

@@ -416,7 +420,8 @@ glusterd_rebalance_cmd_validate (int cmd, char *volname,

         }

         if ((*volinfo)->status != GLUSTERD_STATUS_STARTED) {

-                gf_log ("glusterd", GF_LOG_ERROR, "Received rebalance on stopped"

+                gf_msg ("glusterd", GF_LOG_ERROR, 0,

+                        GD_MSG_VOL_STOPPED, "Received rebalance on stopped"

                         " volname %s", volname);

                 snprintf (op_errstr, len, "Volume %s needs to "

                           "be started to perform rebalance", volname);

@@ -435,7 +440,7 @@ glusterd_rebalance_cmd_validate (int cmd, char *volname,

         ret = 0;

 out:

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

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

         return ret;

 }

@@ -473,7 +478,8 @@ __glusterd_handle_defrag_volume (rpcsvc_request_t *req)

                                         cli_req.dict.dict_len,

                                         &dict);

                 if (ret < 0) {

-                        gf_log (this->name, GF_LOG_ERROR, "failed to "

+                        gf_msg (this->name, GF_LOG_ERROR, 0,

+                                GD_MSG_DICT_UNSERIALIZE_FAIL, "failed to "

                                 "unserialize req-buffer to dictionary");

                         snprintf (msg, sizeof (msg), "Unable to decode the "

                                   "command");

@@ -484,14 +490,16 @@ __glusterd_handle_defrag_volume (rpcsvc_request_t *req)

         ret = dict_get_str (dict, "volname", &volname);

         if (ret) {

                 snprintf (msg, sizeof (msg), "Failed to get volume name");

-                gf_log (this->name, GF_LOG_ERROR, "%s", msg);

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_DICT_GET_FAILED, "%s", msg);

                 goto out;

         }

         ret = dict_get_int32 (dict, "rebalance-command", (int32_t*)&cmd);

         if (ret) {

                 snprintf (msg, sizeof (msg), "Failed to get command");

-                gf_log (this->name, GF_LOG_ERROR, "%s", msg);

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_DICT_GET_FAILED, "%s", msg);

                 goto out;

         }

@@ -581,20 +589,20 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

         ret = dict_get_str (dict, "volname", &volname);

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "volname not found");

+                gf_msg_debug (this->name, 0, "volname not found");

                 goto out;

         }

         ret = dict_get_int32 (dict, "rebalance-command", &cmd);

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "cmd not found");

+                gf_msg_debug (this->name, 0, "cmd not found");

                 goto out;

         }

         ret = glusterd_rebalance_cmd_validate (cmd, volname, &volinfo,

                                                msg, sizeof (msg));

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "failed to validate");

+                gf_msg_debug (this->name, 0, "failed to validate");

                 goto out;

         }

         switch (cmd) {

@@ -626,7 +634,8 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

                         op_ctx = glusterd_op_get_ctx ();

                         if (!op_ctx) {

                                 ret = -1;

-                                gf_log (this->name, GF_LOG_ERROR,

+                                gf_msg (this->name, GF_LOG_ERROR, 0,

+                                        GD_MSG_OPCTX_GET_FAIL,

                                         "Failed to get op_ctx");

                                 goto out;

                         }

@@ -634,7 +643,8 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

                         ret = glusterd_generate_and_set_task_id

                                 (op_ctx, GF_REBALANCE_TID_KEY);

                         if (ret) {

-                                gf_log (this->name, GF_LOG_ERROR,

+                                gf_msg (this->name, GF_LOG_ERROR, 0,

+                                        GD_MSG_TASKID_GEN_FAIL,

                                         "Failed to generate task-id");

                                 goto out;

                         }

@@ -644,7 +654,8 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

                         if (ret) {

                                 snprintf (msg, sizeof (msg),

                                           "Missing rebalance-id");

-                                gf_log (this->name, GF_LOG_WARNING, "%s", msg);

+                                gf_msg (this->name, GF_LOG_WARNING, 0,

+                                        GD_MSG_REBALANCE_ID_MISSING, "%s", msg);

                                 ret = 0;

                         }

                 }

@@ -652,7 +663,7 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

                                                       sizeof (msg),

                                                       GD_OP_REBALANCE);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_DEBUG,

+                        gf_msg_debug (this->name, 0,

                                         "start validate failed");

                         goto out;

                 }

@@ -662,10 +673,11 @@ glusterd_op_stage_rebalance (dict_t *dict, char **op_errstr)

         case GF_DEFRAG_CMD_STOP_DETACH_TIER:

                 ret = dict_get_str (dict, "cmd-str", &cmd_str);

                 if (ret) {

-                     gf_log (this->name, GF_LOG_ERROR, "Failed to get "

-                             "command string");

-                     ret = -1;

-                     goto out;

+                        gf_msg (this->name, GF_LOG_ERROR, 0,

+                                GD_MSG_DICT_GET_FAILED, "Failed to get "

+                                "command string");

+                        ret = -1;

+                        goto out;

                 }

                 if ((strstr(cmd_str, "rebalance") != NULL) &&

                     (volinfo->rebal.op != GD_OP_REBALANCE)) {

@@ -736,13 +748,13 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

         ret = dict_get_str (dict, "volname", &volname);

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "volname not given");

+                gf_msg_debug (this->name, 0, "volname not given");

                 goto out;

         }

         ret = dict_get_int32 (dict, "rebalance-command", &cmd);

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "command not given");

+                gf_msg_debug (this->name, 0, "command not given");

                 goto out;

         }

@@ -750,7 +762,7 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

         ret = glusterd_rebalance_cmd_validate (cmd, volname, &volinfo,

                                                msg, sizeof (msg));

         if (ret) {

-                gf_log (this->name, GF_LOG_DEBUG, "cmd validate failed");

+                gf_msg_debug (this->name, 0, "cmd validate failed");

                 goto out;

         }

@@ -763,7 +775,8 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

                 if (!gf_uuid_is_null (volinfo->rebal.rebalance_id)) {

                         ctx = glusterd_op_get_ctx ();

                         if (!ctx) {

-                                gf_log (this->name, GF_LOG_ERROR,

+                                gf_msg (this->name, GF_LOG_ERROR, 0,

+                                        GD_MSG_OPCTX_GET_FAIL,

                                         "Failed to get op_ctx");

                                 ret = -1;

                                 goto out;

@@ -778,7 +791,8 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

                                         (volinfo->rebal.rebalance_id, ctx,

                                          GF_REBALANCE_TID_KEY);

                         if (ret) {

-                                gf_log (this->name, GF_LOG_ERROR,

+                                gf_msg (this->name, GF_LOG_ERROR, 0,

+                                        GD_MSG_TASKID_GEN_FAIL,

                                         "Failed to set task-id");

                                 goto out;

                         }

@@ -798,7 +812,7 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

                 ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_DEBUG, "Missing rebalance "

+                        gf_msg_debug (this->name, 0, "Missing rebalance "

                                 "id");

                         ret = 0;

                 } else {

@@ -848,7 +862,8 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

                 ret = glusterd_create_volfiles_and_notify_services (volinfo);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_WARNING,

+                        gf_msg (this->name, GF_LOG_WARNING, 0,

+                                GD_MSG_VOLFILE_CREATE_FAIL,

                                 "failed to create volfiles");

                         goto out;

                 }

@@ -856,7 +871,8 @@ glusterd_op_rebalance (dict_t *dict, char **op_errstr, dict_t *rsp_dict)

                 ret = glusterd_store_volinfo (volinfo,

                                              GLUSTERD_VOLINFO_VER_AC_INCREMENT);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_WARNING,

+                        gf_msg (this->name, GF_LOG_WARNING, 0,

+                                GD_MSG_VOLINFO_SET_FAIL,

                                 "failed to store volinfo");

                         goto out;

                 }

@@ -894,7 +910,8 @@ glusterd_defrag_event_notify_handle (dict_t *dict)

         ret = dict_get_str (dict, "volname", &volname);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR, "Failed to get volname");

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_DICT_GET_FAILED, "Failed to get volname");

                 return ret;

         }

@@ -907,8 +924,9 @@ glusterd_defrag_event_notify_handle (dict_t *dict)

                 }

                 volname = volname_ptr + 1;

         } else {

-                gf_log (this->name, GF_LOG_ERROR,

-                        "volname received (%s) is not prefixed with rebalance.",

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_NO_REBALANCE_PFX_IN_VOLNAME,

+                        "volname recieved (%s) is not prefixed with rebalance.",

                         volname);

                 ret = -1;

                 goto out;

@@ -916,7 +934,9 @@ glusterd_defrag_event_notify_handle (dict_t *dict)

         ret = glusterd_volinfo_find (volname, &volinfo);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR, "Failed to get volinfo for %s"

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_VOLINFO_GET_FAIL,

+                        "Failed to get volinfo for %s"

                         , volname);

                 return ret;

         }

@@ -924,7 +944,9 @@ glusterd_defrag_event_notify_handle (dict_t *dict)

         ret = glusterd_defrag_volume_status_update (volinfo, dict);

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "Failed to update status");

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_DEFRAG_STATUS_UPDATE_FAIL,

+                        "Failed to update status");

 out:

         return ret;

diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c

index ae87e9a..d790c6f 100644

--- a/xlators/mgmt/glusterd/src/glusterd-store.c

+++ b/xlators/mgmt/glusterd/src/glusterd-store.c

@@ -38,6 +38,7 @@

 #include "store.h"

 #include "glusterd-store.h"

 #include "glusterd-snapshot-utils.h"

+#include "glusterd-messages.h"

 #include "rpc-clnt.h"

 #include "common-utils.h"

@@ -170,19 +171,22 @@ glusterd_store_is_valid_brickpath (char *volname, char *brick)

         ret = glusterd_brickinfo_new_from_brick (brick, &brickinfo);

         if (ret) {

-                gf_log (this->name, GF_LOG_WARNING, "Failed to create brick "

+                gf_msg (this->name, GF_LOG_WARNING, 0,

+                        GD_MSG_BRICK_CREATION_FAIL, "Failed to create brick "

                         "info for brick %s", brick);

                 ret = 0;

                 goto out;

         }

         ret = glusterd_volinfo_new (&volinfo);

         if (ret) {

-                gf_log (this->name, GF_LOG_WARNING, "Failed to create volinfo");

+                gf_msg (this->name, GF_LOG_WARNING, 0,

+                        GD_MSG_VOLFILE_CREATE_FAIL, "Failed to create volinfo");

                 ret = 0;

                 goto out;

         }

         if (volname_len >= sizeof (volinfo->volname)) {

-                gf_log (this->name, GF_LOG_WARNING, "volume name too long");

+                gf_msg (this->name, GF_LOG_WARNING, 0,

+                        GD_MSG_NAME_TOO_LONG, "volume name too long");

                 ret = 0;

                 goto out;

         }

@@ -332,7 +336,8 @@ gd_store_brick_snap_details_write (int fd, glusterd_brickinfo_t *brickinfo)

                 ret = gf_store_save_value (fd,

                                 GLUSTERD_STORE_KEY_BRICK_FSTYPE, value);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_ERROR, "Failed to save "

+                        gf_msg (this->name, GF_LOG_ERROR, 0,

+                                GD_MSG_FS_LABEL_UPDATE_FAIL, "Failed to save "

                                 "brick fs type of brick %s", brickinfo->path);

                         goto out;

                 }

@@ -343,7 +348,8 @@ gd_store_brick_snap_details_write (int fd, glusterd_brickinfo_t *brickinfo)

                 ret = gf_store_save_value (fd,

                                 GLUSTERD_STORE_KEY_BRICK_MNTOPTS, value);

                 if (ret) {

-                        gf_log (this->name, GF_LOG_ERROR, "Failed to save "

+                        gf_msg (this->name, GF_LOG_ERROR, 0,

+                                GD_MSG_BRK_MOUNTOPTS_FAIL, "Failed to save "

                                 "brick mnt opts of brick %s", brickinfo->path);

                         goto out;

                 }

@@ -405,7 +411,7 @@ glusterd_store_brickinfo_write (int fd, glusterd_brickinfo_t *brickinfo)

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_VGNAME,

                                          brickinfo->vg);

 out:

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

+        gf_msg_debug (THIS->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -425,11 +431,13 @@ glusterd_store_snapd_write (int fd, glusterd_volinfo_t *volinfo)

         snprintf (value, sizeof(value), "%d", volinfo->snapd.port);

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_SNAPD_PORT, value);

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "failed to store the snapd "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_SNAPD_PORT_STORE_FAIL,

+                        "failed to store the snapd "

                         "port of volume %s", volinfo->volname);

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

+        gf_msg_debug (this->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -453,7 +461,7 @@ glusterd_store_perform_brick_store (glusterd_brickinfo_t *brickinfo)

 out:

         if (ret && (fd > 0))

                 gf_store_unlink_tmppath (brickinfo->shandle);

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

+        gf_msg_debug (THIS->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -471,7 +479,8 @@ glusterd_store_perform_snapd_store (glusterd_volinfo_t *volinfo)

         fd = gf_store_mkstemp (volinfo->snapd.handle);

         if (fd <= 0) {

-                gf_log (this->name, GF_LOG_ERROR, "failed to create the "

+                gf_msg (this->name, GF_LOG_ERROR, errno,

+                        GD_MSG_FILE_OP_FAILED, "failed to create the "

                         "temporary file for the snapd store handle of volume "

                         "%s", volinfo->volname);

                 goto out;

@@ -479,7 +488,9 @@ glusterd_store_perform_snapd_store (glusterd_volinfo_t *volinfo)

         ret = glusterd_store_snapd_write (fd, volinfo);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR, "failed to write snapd port "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_SNAPD_PORT_STORE_FAIL,

+                        "failed to write snapd port "

                         "info to store handle (volume: %s", volinfo->volname);

                 goto out;

         }

@@ -489,7 +500,7 @@ glusterd_store_perform_snapd_store (glusterd_volinfo_t *volinfo)

 out:

         if (ret && (fd > 0))

                 gf_store_unlink_tmppath (volinfo->snapd.handle);

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

+        gf_msg_debug (THIS->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -519,7 +530,7 @@ glusterd_store_brickinfo (glusterd_volinfo_t *volinfo,

         ret = glusterd_store_perform_brick_store (brickinfo);

 out:

-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning with %d", ret);

+        gf_msg_debug (THIS->name, 0, "Returning with %d", ret);

         return ret;

 }

@@ -536,21 +547,25 @@ glusterd_store_snapd_info (glusterd_volinfo_t *volinfo)

         ret = glusterd_store_create_snapd_shandle_on_absence (volinfo);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR, "failed to create store "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_STORE_HANDLE_CREATE_FAIL,

+                        "failed to create store "

                         "handle for snapd (volume: %s)", volinfo->volname);

                 goto out;

         }

         ret = glusterd_store_perform_snapd_store (volinfo);

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "failed to store snapd info "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_SNAPD_INFO_STORE_FAIL,

+                        "failed to store snapd info "

                         "of the volume %s", volinfo->volname);

 out:

         if (ret)

                 gf_store_unlink_tmppath (volinfo->snapd.handle);

-        gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret);

+        gf_msg_debug (this->name, 0, "Returning with %d", ret);

         return ret;

 }

@@ -589,8 +604,8 @@ glusterd_store_delete_brick (glusterd_brickinfo_t *brickinfo, char *delete_path)

         ret = unlink (brickpath);

         if ((ret < 0) && (errno != ENOENT)) {

-                gf_log (this->name, GF_LOG_DEBUG, "Unlink failed on %s, "

-                        "reason: %s", brickpath, strerror(errno));

+                gf_msg_debug (this->name, 0, "Unlink failed on %s",

+                              brickpath);

                 ret = -1;

                 goto out;

         } else {

@@ -602,7 +617,7 @@ out:

                 gf_store_handle_destroy (brickinfo->shandle);

                 brickinfo->shandle = NULL;

         }

-        gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret);

+        gf_msg_debug (this->name, 0, "Returning with %d", ret);

         return ret;

 }

@@ -644,8 +659,8 @@ glusterd_store_remove_bricks (glusterd_volinfo_t *volinfo, char *delete_path)

                           brickdir, entry->d_name);

                 ret = unlink (path);

                 if (ret && errno != ENOENT) {

-                        gf_log (this->name, GF_LOG_DEBUG, "Unable to unlink %s, "

-                                "reason: %s", path, strerror(errno));

+                        gf_msg_debug (this->name, 0, "Unable to unlink %s",

+                                      path);

                 }

                 GF_FOR_EACH_ENTRY_IN_DIR (entry, dir);

         }

@@ -655,7 +670,7 @@ glusterd_store_remove_bricks (glusterd_volinfo_t *volinfo, char *delete_path)

         ret = rmdir (brickdir);

 out:

-        gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret);

+        gf_msg_debug (this->name, 0, "Returning with %d", ret);

         return ret;

 }

@@ -685,13 +700,15 @@ _storeslaves (dict_t *this, char *key, data_t *value, void *data)

         if (!value || !value->data)

                 return -1;

-        gf_log (xl->name, GF_LOG_DEBUG, "Storing in volinfo:key= %s, val=%s",

+        gf_msg_debug (xl->name, 0, "Storing in volinfo:key= %s, val=%s",

                 key, value->data);

         ret = gf_store_save_value (shandle->fd, key, (char*)value->data);

         if (ret) {

-                gf_log (xl->name, GF_LOG_ERROR, "Unable to write into store"

-                                " handle for path: %s", shandle->path);

+                gf_msg (xl->name, GF_LOG_ERROR, 0,

+                        GD_MSG_STORE_HANDLE_WRITE_FAIL,

+                        "Unable to write into store"

+                        " handle for path: %s", shandle->path);

                 return -1;

         }

         return 0;

@@ -732,18 +749,20 @@ int _storeopts (dict_t *this, char *key, data_t *value, void *data)

         }

         if (1 == exists) {

-                gf_log (xl->name, GF_LOG_DEBUG, "Storing in volinfo:key= %s, "

+                gf_msg_debug (xl->name, 0, "Storing in volinfo:key= %s, "

                         "val=%s", key, value->data);

         } else {

-                gf_log (xl->name, GF_LOG_DEBUG, "Discarding:key= %s, val=%s",

+                gf_msg_debug (xl->name, 0, "Discarding:key= %s, val=%s",

                         key, value->data);

                 return 0;

         }

         ret = gf_store_save_value (shandle->fd, key, (char*)value->data);

         if (ret) {

-                gf_log (xl->name, GF_LOG_ERROR, "Unable to write into store"

+                gf_msg (xl->name, GF_LOG_ERROR, 0,

+                        GD_MSG_STORE_HANDLE_WRITE_FAIL,

+                        "Unable to write into store"

                         " handle for path: %s", shandle->path);

                 return -1;

         }

@@ -779,7 +798,8 @@ glusterd_volume_write_snap_details (int fd, glusterd_volinfo_t *volinfo)

         snprintf (buf, sizeof (buf), "%s", volinfo->parent_volname);

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_PARENT_VOLNAME, buf);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR, "Failed to store "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_STORE_FAIL, "Failed to store "

                         GLUSTERD_STORE_KEY_PARENT_VOLNAME);

                 goto out;

         }

@@ -787,7 +807,8 @@ glusterd_volume_write_snap_details (int fd, glusterd_volinfo_t *volinfo)

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP,

                                    uuid_utoa (volinfo->restored_from_snap));

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR,

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_STORE_HANDLE_WRITE_FAIL,

                         "Unable to write restored_from_snap");

                 goto out;

         }

@@ -797,19 +818,23 @@ glusterd_volume_write_snap_details (int fd, glusterd_volinfo_t *volinfo)

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_SNAP_MAX_HARD_LIMIT,

                                    buf);

         if (ret) {

-                gf_log (this->name, GF_LOG_ERROR,

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_HARD_LIMIT_SET_FAIL,

                         "Unable to write snap-max-hard-limit");

                 goto out;

         }

         ret = glusterd_store_snapd_info (volinfo);

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "snapd info store failed "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_SNAPD_INFO_STORE_FAIL, "snapd info store failed "

                         "volume: %s", volinfo->volname);

 out:

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "Failed to write snap details"

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_SNAPINFO_WRITE_FAIL,

+                        "Failed to write snap details"

                         " for volume %s", volinfo->volname);

         return ret;

 }

@@ -988,7 +1013,8 @@ glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo)

 out:

         if (ret)

-                gf_log (this->name, GF_LOG_ERROR, "Unable to write volume "

+                gf_msg (this->name, GF_LOG_ERROR, 0,

+                        GD_MSG_VOL_VALS_WRITE_FAIL, "Unable to write volume "

                         "values for %s", volinfo->volname);

         return ret;

 }

@@ -1018,7 +1044,7 @@ glusterd_store_create_volume_dir (glusterd_volinfo_t *volinfo)

                                        sizeof (voldirpath));

         ret = gf_store_mkdir (voldirpath);

-        gf_log (THIS->name, GF_LOG_DEBUG, "Returning with %d", ret);

+        gf_msg_debug (THIS->name, 0, "Returning with %d", ret);

         return ret;

 }

@@ -1037,7 +1063,8 @@ glusterd_store_create_snap_dir (glusterd_snap_t *snap)

         ret = mkdir_p (snapdirpath, 0755, _gf_true);

         if (ret) {

-                gf_log (THIS->name, GF_LOG_ERROR, "Failed to create snaps dir "

+                gf_msg (THIS->name, GF_LOG_ERROR, errno,

+                        GD_MSG_CREATE_DIR_FAILED, "Failed to create snaps dir "

                         "%s", snapdirpath);

         }

         return ret;

@@ -1063,7 +1090,7 @@ glusterd_store_volinfo_write (int fd, glusterd_volinfo_t *volinfo)

         dict_foreach (volinfo->gsync_slaves, _storeslaves, shandle);

         shandle->fd = 0;

 out:

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

+        gf_msg_debug (THIS->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -1106,7 +1133,7 @@ glusterd_store_snapinfo_write (glusterd_snap_t *snap)

         ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_SNAP_TIMESTAMP, buf);

 out:

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

+        gf_msg_debug (THIS->name, 0, "Returning %d", ret);

         return ret;

 }

@@ -1284,7 +1311,7 @@ glusterd_store_brickinfos (glusterd_volinfo_t *volinfo, int vol_fd)

                 brick_count++;