api-glfs-fops: structure logging

Convert gf_msg() to gf_smsg()

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

7 files changed, 330 insertions, 286 deletions

diff --git a/api/src/gfapi-messages.h b/api/src/gfapi-messages.h
index 68d12427aea..b9223940416 100644
--- a/api/src/gfapi-messages.h
+++ b/api/src/gfapi-messages.h
@@ -49,6 +49,99 @@ GLFS_MSGID(API, API_MSG_MEM_ACCT_INIT_FAILED, API_MSG_MASTER_XLATOR_INIT_FAILED,
            API_MSG_INODE_LINK_FAILED, API_MSG_STATEDUMP_FAILED,
            API_MSG_XREADDIRP_R_FAILED, API_MSG_LOCK_INSERT_MERGE_FAILED,
            API_MSG_SETTING_LOCK_TYPE_FAILED, API_MSG_INODE_FIND_FAILED,
-           API_MSG_FDCTX_SET_FAILED, API_MSG_UPCALL_SYNCOP_FAILED);
+           API_MSG_FDCTX_SET_FAILED, API_MSG_UPCALL_SYNCOP_FAILED,
+           API_MSG_INVALID_ARG, API_MSG_UPCALL_EVENT_NULL_RECEIVED,
+           API_MSG_FLAGS_HANDLE, API_MSG_FDCREATE_FAILED_ON_GRAPH,
+           API_MSG_TRANS_RDMA_DEP, API_MSG_TRANS_NOT_SUPPORTED,
+           API_MSG_FS_NOT_INIT, API_MSG_INVALID_SYSRQ,
+           API_MSG_DECODE_XDR_FAILED, API_MSG_NULL, API_MSG_CALL_NOT_SUCCESSFUL,
+           API_MSG_CALL_NOT_VALID, API_MSG_UNABLE_TO_DEL,
+           API_MSG_REMOTE_HOST_DISCONN, API_MSG_HANDLE_NOT_SET);
 
+#define API_MSG_ALLOC_FAILED_STR "Upcall allocation failed"
+#define API_MSG_LOCK_INSERT_MERGE_FAILED_STR                                   \
+    "Lock insertion and splitting/merging failed"
+#define API_MSG_SETTING_LOCK_TYPE_FAILED_STR "Setting lock type failed"
+
+#define API_MSG_INVALID_ARG_STR "Invalid"
+#define API_MSG_INVALID_ENTRY_STR "Upcall entry validation failed"
+#define API_MSG_INODE_FIND_FAILED_STR "Unable to find inode entry"
+#define API_MSG_CREATE_HANDLE_FAILED_STR "handle creation failed"
+#define API_MSG_UPCALL_EVENT_NULL_RECEIVED_STR                                 \
+    "Upcall_EVENT_NULL received. Skipping it"
+#define API_MSG_UPCALL_SYNCOP_FAILED_STR "Synctask for upcall failed"
+#define API_MSG_FDCREATE_FAILED_STR "Allocating anonymous fd failed"
+#define API_MSG_XREADDIRP_R_FAILED_STR "glfs_x_readdirp_r failed"
+#define API_MSG_FDCTX_SET_FAILED_STR "Setting fd ctx failed"
+#define API_MSG_FLAGS_HANDLE_STR "arg not set. Flags handled are"
+#define API_MSG_INODE_REFRESH_FAILED_STR "inode refresh failed"
+#define API_MSG_INODE_LINK_FAILED_STR "inode linking failed"
+#define API_MSG_GET_CWD_FAILED_STR "Failed to get cwd"
+#define API_MSG_FGETXATTR_FAILED_STR "fgetxattr failed"
+#define API_MSG_LOCKINFO_KEY_MISSING_STR "missing lockinfo key"
+#define API_MSG_FSYNC_FAILED_STR "fsync() failed"
+#define API_MSG_FDCREATE_FAILED_ON_GRAPH_STR "fd_create failed on graph"
+#define API_MSG_INODE_PATH_FAILED_STR "inode_path failed"
+#define API_MSG_SYNCOP_OPEN_FAILED_STR "syncop_open failed"
+#define API_MSG_LOCK_MIGRATE_FAILED_STR "lock migration failed on graph"
+#define API_MSG_OPENFD_SKIPPED_STR "skipping openfd in graph"
+#define API_MSG_FIRST_LOOKUP_GRAPH_FAILED_STR "first lookup on graph failed"
+#define API_MSG_CWD_GRAPH_REF_FAILED_STR "cwd refresh of graph failed"
+#define API_MSG_SWITCHED_GRAPH_STR "switched to graph"
+#define API_MSG_FSETXATTR_FAILED_STR "fsetxattr failed"
+#define API_MSG_MEM_ACCT_INIT_FAILED_STR "Memory accounting init failed"
+#define API_MSG_MASTER_XLATOR_INIT_FAILED_STR                                  \
+    "master xlator for initialization failed"
+#define API_MSG_GFAPI_XLATOR_INIT_FAILED_STR                                   \
+    "failed to initialize gfapi translator"
+#define API_MSG_VOLFILE_OPEN_FAILED_STR "volume file open failed"
+#define API_MSG_VOL_SPEC_FILE_ERROR_STR "Cannot reach volume specification file"
+#define API_MSG_TRANS_RDMA_DEP_STR                                             \
+    "transport RDMA is deprecated, falling back to tcp"
+#define API_MSG_TRANS_NOT_SUPPORTED_STR                                        \
+    "transport is not supported, possible values tcp|unix"
+#define API_MSG_GLFS_FSOBJ_NULL_STR "fs is NULL"
+#define API_MSG_FS_NOT_INIT_STR "fs is not properly initialized"
+#define API_MSG_FSMUTEX_LOCK_FAILED_STR                                        \
+    "pthread lock on glfs mutex, returned error"
+#define API_MSG_FSMUTEX_UNLOCK_FAILED_STR                                      \
+    "pthread unlock on glfs mutex, returned error"
+#define API_MSG_COND_WAIT_FAILED_STR "cond wait failed"
+#define API_MSG_INVALID_SYSRQ_STR "not a valid sysrq"
+#define API_MSG_GRAPH_CONSTRUCT_FAILED_STR "failed to construct the graph"
+#define API_MSG_API_XLATOR_ERROR_STR                                           \
+    "api master xlator cannot be specified in volume file"
+#define API_MSG_STATEDUMP_FAILED_STR "statedump failed"
+#define API_MSG_DECODE_XDR_FAILED_STR                                          \
+    "Failed to decode xdr response for GF_CBK_STATEDUMP"
+#define API_MSG_NULL_STR "NULL"
+#define API_MSG_XDR_PAYLOAD_FAILED_STR "failed to create XDR payload"
+#define API_MSG_CALL_NOT_SUCCESSFUL_STR                                        \
+    "GET_VOLUME_INFO RPC call is not successful"
+#define API_MSG_XDR_RESPONSE_DECODE_FAILED_STR                                 \
+    "Failed to decode xdr response for GET_VOLUME_INFO"
+#define API_MSG_CALL_NOT_VALID_STR                                             \
+    "Response received for GET_VOLUME_INFO RPC is not valid"
+#define API_MSG_GET_VOLINFO_CBK_FAILED_STR                                     \
+    "In GET_VOLUME_INFO cbk, received error"
+#define API_MSG_FETCH_VOLUUID_FAILED_STR "Unable to fetch volume UUID"
+#define API_MSG_INSUFF_SIZE_STR "Insufficient size passed"
+#define API_MSG_FRAME_CREAT_FAILED_STR "failed to create the frame"
+#define API_MSG_DICT_SET_FAILED_STR "failed to set"
+#define API_MSG_XDR_DECODE_FAILED_STR "XDR decoding error"
+#define API_MSG_GET_VOLFILE_FAILED_STR "failed to get the volume file"
+#define API_MSG_VOLFILE_INFO_STR "No change in volfile, continuing"
+#define API_MSG_UNABLE_TO_DEL_STR "unable to delete file"
+#define API_MSG_WRONG_OPVERSION_STR                                            \
+    "Server is operating at an op-version which is not supported"
+#define API_MSG_DICT_SERIALIZE_FAILED_STR "Failed to serialize dictionary"
+#define API_MSG_REMOTE_HOST_CONN_FAILED_STR "Failed to connect to remote-host"
+#define API_MSG_REMOTE_HOST_DISCONN_STR "disconnected from remote-host"
+#define API_MSG_VOLFILE_SERVER_EXHAUST_STR "Exhausted all volfile servers"
+#define API_MSG_VOLFILE_CONNECTING_STR "connecting to next volfile server"
+#define API_MSG_CREATE_RPC_CLIENT_FAILED_STR "failed to create rpc clnt"
+#define API_MSG_REG_NOTIFY_FUNC_FAILED_STR "failed to register notify function"
+#define API_MSG_REG_CBK_FUNC_FAILED_STR "failed to register callback function"
+#define API_MSG_NEW_GRAPH_STR "New graph coming up"
+#define API_MSG_HANDLE_NOT_SET_STR "handle not set. Flags handled for xstat are"
 #endif /* !_GFAPI_MESSAGES_H__ */
diff --git a/api/src/glfs-fops.c b/api/src/glfs-fops.c
index 7d73e97822d..603f37afb09 100644
--- a/api/src/glfs-fops.c
+++ b/api/src/glfs-fops.c
@@ -119,8 +119,8 @@ glfs_get_upcall_cache_invalidation(struct gf_upcall *to_up_data,
     ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
 
     if (!ca_data) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -154,8 +154,8 @@ glfs_get_upcall_lease(struct gf_upcall *to_up_data,
     ca_data = GF_CALLOC(1, sizeof(*ca_data), glfs_mt_upcall_entry_t);
 
     if (!ca_data) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -5336,11 +5336,9 @@ glfs_lock_common(struct glfs_fd *glfd, int cmd, struct flock *flock,
     if (ret == 0 && (cmd == F_SETLK || cmd == F_SETLKW)) {
         ret = fd_lk_insert_and_merge(fd, cmd, &saved_flock);
         if (ret) {
-            gf_msg(THIS->name, GF_LOG_ERROR, 0,
-                   API_MSG_LOCK_INSERT_MERGE_FAILED,
-                   "Lock insertion and splitting/merging failed "
-                   "on gfid %s",
-                   uuid_utoa(fd->inode->gfid));
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0,
+                    API_MSG_LOCK_INSERT_MERGE_FAILED, "gfid=%s",
+                    uuid_utoa(fd->inode->gfid), NULL);
             ret = 0;
         }
     }
@@ -5379,9 +5377,8 @@ pub_glfs_file_lock(struct glfs_fd *glfd, int cmd, struct flock *flock,
          * GLFS_LK_MANDATORY */
         ret = dict_set_uint32(xdata_in, GF_LOCK_MODE, GF_LK_MANDATORY);
         if (ret) {
-            gf_msg(THIS->name, GF_LOG_ERROR, 0,
-                   API_MSG_SETTING_LOCK_TYPE_FAILED,
-                   "Setting lock type failed");
+            gf_smsg(THIS->name, GF_LOG_ERROR, 0,
+                    API_MSG_SETTING_LOCK_TYPE_FAILED, NULL);
             ret = -1;
             errno = ENOMEM;
             goto out;
@@ -5422,8 +5419,8 @@ pub_glfs_fd_set_lkowner(struct glfs_fd *glfd, void *data, int len)
 
     if ((len <= 0) || (len > GFAPI_MAX_LOCK_OWNER_LEN)) {
         errno = EINVAL;
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-               "Invalid lk_owner len (%d)", len);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "lk_owner len=%d", len, NULL);
         goto out;
     }
 
@@ -5507,8 +5504,8 @@ glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
     u_list = GF_CALLOC(1, sizeof(*u_list), glfs_mt_upcall_entry_t);
 
     if (!u_list) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -5530,8 +5527,7 @@ glfs_enqueue_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
     }
 
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY,
-               "Upcall entry validation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, NULL);
         goto out;
     }
 
@@ -5601,9 +5597,9 @@ glfs_recall_lease_fd(struct glfs *fs, struct gf_upcall *up_data)
     inode = inode_find(subvol->itable, up_data->gfid);
     if (!inode) {
         ret = -1;
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INODE_FIND_FAILED,
-               "Unable to find inode entry for gfid:%s graph id:%d",
-               uuid_utoa(up_data->gfid), subvol->graph->id);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INODE_FIND_FAILED,
+                "gfid=%s", uuid_utoa(up_data->gfid), "graph_id=%d",
+                subvol->graph->id, NULL);
         goto out;
     }
 
@@ -5681,8 +5677,8 @@ glfs_recall_lease_upcall(struct glfs *fs, struct glfs_upcall *up_arg,
          * the handle and hence will no more be interested in
          * the upcall for this particular gfid.
          */
-        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
-               "handle creation of %s failed", uuid_utoa(up_data->gfid));
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "gfid=%s", uuid_utoa(up_data->gfid), NULL);
         errno = ESTALE;
         goto out;
     }
@@ -5771,8 +5767,8 @@ glfs_cbk_upcall_syncop(void *opaque)
     up_arg = GLFS_CALLOC(1, sizeof(struct gf_upcall), glfs_release_upcall,
                          glfs_mt_upcall_entry_t);
     if (!up_arg) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -5794,14 +5790,13 @@ glfs_cbk_upcall_syncop(void *opaque)
      * send upcall then
      */
     if (up_arg->reason == GLFS_UPCALL_EVENT_NULL) {
-        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_INVALID_ENTRY,
-               "Upcall_EVENT_NULL received. Skipping it.");
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                API_MSG_UPCALL_EVENT_NULL_RECEIVED, NULL);
         ret = 0;
         GLFS_FREE(up_arg);
         goto out;
     } else if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY,
-               "Upcall entry validation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ENTRY, NULL);
         goto out;
     }
 
@@ -5827,8 +5822,8 @@ gf_copy_cache_invalidation(struct gf_upcall_cache_invalidation *src)
                     glfs_mt_upcall_entry_t);
 
     if (!dst) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -5858,8 +5853,8 @@ gf_copy_recall_lease(struct gf_upcall_recall_lease *src)
                     glfs_mt_upcall_entry_t);
 
     if (!dst) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-               "Upcall entry allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED, "entry",
+                NULL);
         goto out;
     }
 
@@ -5887,8 +5882,8 @@ upcall_syncop_args_init(struct glfs *fs, struct gf_upcall *upcall_data)
     args = GF_CALLOC(1, sizeof(struct upcall_syncop_args),
                      glfs_mt_upcall_entry_t);
     if (!args) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
-               "Upcall syncop args allocation failed.");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_ALLOC_FAILED,
+                "syncop args", NULL);
         goto out;
     }
 
@@ -5956,9 +5951,9 @@ glfs_cbk_upcall_data(struct glfs *fs, struct gf_upcall *upcall_data)
                        glfs_upcall_syncop_cbk, NULL, args);
     /* should we retry incase of failure? */
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, API_MSG_UPCALL_SYNCOP_FAILED,
-               "Synctak for Upcall event_type(%d) and gfid(%s) failed",
-               upcall_data->event_type, (char *)(upcall_data->gfid));
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_UPCALL_SYNCOP_FAILED,
+                "event_type=%d", upcall_data->event_type, "gfid=%s",
+                (char *)(upcall_data->gfid), NULL);
         upcall_syncop_args_free(args);
     }
 
@@ -6086,8 +6081,7 @@ glfs_anonymous_pwritev(struct glfs *fs, struct glfs_object *object,
     fd = fd_anonymous(inode);
     if (!fd) {
         ret = -1;
-        gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-               "Allocating anonymous fd failed");
+        gf_smsg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, NULL);
         errno = ENOMEM;
         goto out;
     }
@@ -6185,8 +6179,7 @@ glfs_anonymous_preadv(struct glfs *fs, struct glfs_object *object,
     fd = fd_anonymous(inode);
     if (!fd) {
         ret = -1;
-        gf_msg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED,
-               "Allocating anonymous fd failed");
+        gf_smsg("gfapi", GF_LOG_ERROR, ENOMEM, API_MSG_FDCREATE_FAILED, NULL);
         errno = ENOMEM;
         goto out;
     }
@@ -6329,8 +6322,8 @@ out:
     GF_REF_PUT(glfd);
 
     if (ret < 0) {
-        gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED,
-               "glfs_x_readdirp_r failed - reason (%s)", strerror(errno));
+        gf_smsg(THIS->name, GF_LOG_WARNING, errno, API_MSG_XREADDIRP_R_FAILED,
+                "reason=%s", strerror(errno), NULL);
 
         if (xstat)
             GLFS_FREE(xstat);
@@ -6351,10 +6344,10 @@ pub_glfs_xreaddirplus_get_stat(struct glfs_xreaddirp_stat *xstat)
     GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_stat", xstat, out);
 
     if (!xstat->flags_handled & GFAPI_XREADDIRP_STAT)
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-               "GFAPI_XREADDIRP_STAT is not set. Flags"
-               "handled for xstat(%p) are (%x)",
-               xstat, xstat->flags_handled);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_FLAGS_HANDLE,
+                "GFAPI_XREADDIRP_STAT"
+                "xstat=%p",
+                xstat, "handles=%x", xstat->flags_handled, NULL);
     return &xstat->st;
 
 out:
@@ -6460,8 +6453,8 @@ pub_glfs_lease(struct glfs_fd *glfd, struct glfs_lease *lease,
     if (ret == 0) {
         ret = fd_ctx_set(glfd->fd, subvol, (uint64_t)(long)glfd);
         if (ret) {
-            gf_msg(subvol->name, GF_LOG_ERROR, ENOMEM, API_MSG_FDCTX_SET_FAILED,
-                   "Setting fd ctx failed for fd(%p)", glfd->fd);
+            gf_smsg(subvol->name, GF_LOG_ERROR, ENOMEM,
+                    API_MSG_FDCTX_SET_FAILED, "fd=%p", glfd->fd, NULL);
             goto out;
         }
         glfd->cbk = fn;
diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c
index cdf368379d6..cdac07124a5 100644
--- a/api/src/glfs-handleops.c
+++ b/api/src/glfs-handleops.c
@@ -1495,9 +1495,9 @@ pub_glfs_h_create_from_handle(struct glfs *fs, unsigned char *handle, int len,
     ret = syncop_lookup(subvol, &loc, &iatt, 0, 0, 0);
     DECODE_SYNCOP_ERR(ret);
     if (ret) {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno,
-               API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s",
-               uuid_utoa(loc.gfid), strerror(errno));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s", uuid_utoa(loc.gfid),
+                "error=%s", strerror(errno), NULL);
         goto out;
     }
 
@@ -1508,8 +1508,8 @@ pub_glfs_h_create_from_handle(struct glfs *fs, unsigned char *handle, int len,
         }
         inode_lookup(newinode);
     } else {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
-               "inode linking of %s failed", uuid_utoa(loc.gfid));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa(loc.gfid), NULL);
         goto out;
     }
 
@@ -2097,8 +2097,8 @@ glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
          * the handle and hence will no more be interested in
          * the upcall for this particular gfid.
          */
-        gf_msg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
-               "handle creation of %s failed", uuid_utoa(upcall_data->gfid));
+        gf_smsg(THIS->name, GF_LOG_DEBUG, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "gfid=%s", uuid_utoa(upcall_data->gfid), NULL);
         errno = ESTALE;
         goto out;
     }
@@ -2121,9 +2121,9 @@ glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
         p_object = glfs_h_find_handle(fs, ca_data->p_stat.ia_gfid,
                                       GFAPI_HANDLE_LENGTH);
         if (!p_object) {
-            gf_msg(THIS->name, GF_LOG_DEBUG, errno,
-                   API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed",
-                   uuid_utoa(ca_data->p_stat.ia_gfid));
+            gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                    API_MSG_CREATE_HANDLE_FAILED, "gfid=%s",
+                    uuid_utoa(ca_data->p_stat.ia_gfid), NULL);
             errno = ESTALE;
             goto out;
         }
@@ -2137,9 +2137,9 @@ glfs_h_poll_cache_invalidation(struct glfs *fs, struct glfs_upcall *up_arg,
         oldp_object = glfs_h_find_handle(fs, ca_data->oldp_stat.ia_gfid,
                                          GFAPI_HANDLE_LENGTH);
         if (!oldp_object) {
-            gf_msg(THIS->name, GF_LOG_DEBUG, errno,
-                   API_MSG_CREATE_HANDLE_FAILED, "handle creation of %s failed",
-                   uuid_utoa(ca_data->oldp_stat.ia_gfid));
+            gf_smsg(THIS->name, GF_LOG_DEBUG, errno,
+                    API_MSG_CREATE_HANDLE_FAILED, "gfid=%s",
+                    uuid_utoa(ca_data->oldp_stat.ia_gfid), NULL);
             errno = ESTALE;
             /* By the time we receive upcall old parent_dir may
              * have got removed. We still need to send upcall
@@ -2588,9 +2588,8 @@ pub_glfs_object_copy(struct glfs_object *src)
     object = GF_CALLOC(1, sizeof(struct glfs_object), glfs_mt_glfs_object_t);
     if (object == NULL) {
         errno = ENOMEM;
-        gf_msg(THIS->name, GF_LOG_WARNING, errno, API_MSG_CREATE_HANDLE_FAILED,
-               "glfs_dup_object for gfid-%s failed",
-               uuid_utoa(src->inode->gfid));
+        gf_smsg(THIS->name, GF_LOG_WARNING, errno, API_MSG_CREATE_HANDLE_FAILED,
+                "glfs_dup_object gfid=%s", uuid_utoa(src->inode->gfid), NULL);
         return NULL;
     }
 
@@ -2608,10 +2607,9 @@ pub_glfs_xreaddirplus_get_object(struct glfs_xreaddirp_stat *xstat)
     GF_VALIDATE_OR_GOTO("glfs_xreaddirplus_get_object", xstat, out);
 
     if (!(xstat->flags_handled & GFAPI_XREADDIRP_HANDLE))
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-               "GFAPI_XREADDIRP_HANDLE is not set. Flags"
-               "handled for xstat(%p) are (%x)",
-               xstat, xstat->flags_handled);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_HANDLE_NOT_SET,
+                "GFAPI_XREADDIRP_HANDLE xstat=%p", xstat, "handle=%x",
+                xstat->flags_handled, NULL);
 
     return xstat->object;
 
diff --git a/api/src/glfs-master.c b/api/src/glfs-master.c
index 4bc69d1f3d8..100dcc16cc0 100644
--- a/api/src/glfs-master.c
+++ b/api/src/glfs-master.c
@@ -75,9 +75,10 @@ notify(xlator_t *this, int event, void *data, ...)
 
     switch (event) {
         case GF_EVENT_GRAPH_NEW:
-            gf_msg(this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
-                   "New graph %s (%d) coming up",
-                   uuid_utoa((unsigned char *)graph->graph_uuid), graph->id);
+            gf_smsg(this->name, GF_LOG_INFO, 0, API_MSG_NEW_GRAPH,
+                    "graph-uuid=%s",
+                    uuid_utoa((unsigned char *)graph->graph_uuid), "id=%d",
+                    graph->id, NULL);
             break;
         case GF_EVENT_CHILD_UP:
             pthread_mutex_lock(&fs->mutex);
@@ -120,9 +121,8 @@ mem_acct_init(xlator_t *this)
 
     ret = xlator_mem_acct_init(this, glfs_mt_end + 1);
     if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
-               "Failed to initialise "
-               "memory accounting");
+        gf_smsg(this->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+                NULL);
         return ret;
     }
 
diff --git a/api/src/glfs-mgmt.c b/api/src/glfs-mgmt.c
index 83eb6e788bf..ddb506039da 100644
--- a/api/src/glfs-mgmt.c
+++ b/api/src/glfs-mgmt.c
@@ -46,16 +46,15 @@ glfs_process_volfp(struct glfs *fs, FILE *fp)
     ctx = fs->ctx;
     graph = glusterfs_graph_construct(fp);
     if (!graph) {
-        gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_GRAPH_CONSTRUCT_FAILED,
-               "failed to construct the graph");
+        gf_smsg("glfs", GF_LOG_ERROR, errno, API_MSG_GRAPH_CONSTRUCT_FAILED,
+                NULL);
         goto out;
     }
 
     for (trav = graph->first; trav; trav = trav->next) {
         if (strcmp(trav->type, "mount/api") == 0) {
-            gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_API_XLATOR_ERROR,
-                   "api master xlator cannot be specified "
-                   "in volume file");
+            gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_API_XLATOR_ERROR,
+                    NULL);
             goto out;
         }
     }
@@ -120,32 +119,28 @@ mgmt_cbk_statedump(struct rpc_clnt *rpc, void *mydata, void *data)
 
     this = mydata;
     if (!this) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
-               "NULL mydata");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "mydata", NULL);
         errno = EINVAL;
         goto out;
     }
 
     fs = this->private;
     if (!fs) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
-               "NULL glfs");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "glfs", NULL);
         errno = EINVAL;
         goto out;
     }
 
     iov = (struct iovec *)data;
     if (!iov) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
-               "NULL iovec data");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_NULL, "iovec data", NULL);
         errno = EINVAL;
         goto out;
     }
 
     ret = xdr_to_generic(*iov, &target_pid, (xdrproc_t)xdr_gf_statedump);
     if (ret < 0) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_STATEDUMP_FAILED,
-               "Failed to decode xdr response for GF_CBK_STATEDUMP");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_DECODE_XDR_FAILED, NULL);
         goto out;
     }
 
@@ -156,8 +151,7 @@ mgmt_cbk_statedump(struct rpc_clnt *rpc, void *mydata, void *data)
 
         ret = glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
         if (ret < 0) {
-            gf_msg("glfs", GF_LOG_INFO, 0, API_MSG_STATEDUMP_FAILED,
-                   "statedump failed");
+            gf_smsg("glfs", GF_LOG_INFO, 0, API_MSG_STATEDUMP_FAILED, NULL);
         }
     }
 out:
@@ -230,8 +224,8 @@ mgmt_submit_request(void *req, call_frame_t *frame, glusterfs_ctx_t *ctx,
         /* Create the xdr payload */
         ret = xdr_serialize_generic(iov, req, xdrproc);
         if (ret == -1) {
-            gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_XDR_PAYLOAD_FAILED,
-                   "failed to create XDR payload");
+            gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_XDR_PAYLOAD_FAILED,
+                    NULL);
             goto out;
         }
         iov.iov_len = ret;
@@ -275,8 +269,8 @@ mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
     args = frame->local;
 
     if (!ctx) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "NULL context");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_NULL,
+                "context", NULL);
         errno = EINVAL;
         ret = -1;
         goto out;
@@ -285,8 +279,8 @@ mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
     fs = ((xlator_t *)ctx->master)->private;
 
     if (-1 == req->rpc_status) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "GET_VOLUME_INFO RPC call is not successful");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL,
+                API_MSG_CALL_NOT_SUCCESSFUL, NULL);
         errno = EINVAL;
         ret = -1;
         goto out;
@@ -295,9 +289,8 @@ mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
     ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
 
     if (ret < 0) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, 0,
-               API_MSG_XDR_RESPONSE_DECODE_FAILED,
-               "Failed to decode xdr response for GET_VOLUME_INFO");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, 0,
+                API_MSG_XDR_RESPONSE_DECODE_FAILED, NULL);
         goto out;
     }
 
@@ -313,9 +306,8 @@ mgmt_get_volinfo_cbk(struct rpc_req *req, struct iovec *iov, int count,
     }
 
     if (!rsp.dict.dict_len) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "Response received for "
-               "GET_VOLUME_INFO RPC call is not valid");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_CALL_NOT_VALID,
+                NULL);
         ret = -1;
         errno = EINVAL;
         goto out;
@@ -353,11 +345,9 @@ out:
     }
 
     if (ret) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, errno,
-               API_MSG_GET_VOLINFO_CBK_FAILED,
-               "In GET_VOLUME_INFO "
-               "cbk, received error: %s",
-               strerror(errno));
+        gf_smsg(frame->this->name, GF_LOG_ERROR, errno,
+                API_MSG_GET_VOLINFO_CBK_FAILED, "error=%s", strerror(errno),
+                NULL);
     }
 
     if (dict)
@@ -399,9 +389,8 @@ pub_glfs_get_volumeid(struct glfs *fs, char *volid, size_t size)
     glfs_get_volume_info(fs);
 
     if (gf_uuid_is_null(fs->vol_uuid)) {
-        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_FETCH_VOLUUID_FAILED,
-               "Unable to fetch "
-               "volume UUID");
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_FETCH_VOLUUID_FAILED,
+                NULL);
         goto out;
     }
 
@@ -413,8 +402,7 @@ done:
     }
 
     if (size < uuid_size) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE,
-               "Insufficient size passed");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE, NULL);
         errno = ERANGE;
         goto out;
     }
@@ -447,8 +435,7 @@ glfs_get_volume_info(struct glfs *fs)
     ctx = fs->ctx;
     frame = create_frame(THIS, ctx->pool);
     if (!frame) {
-        gf_msg("glfs", GF_LOG_ERROR, ENOMEM, API_MSG_FRAME_CREAT_FAILED,
-               "failed to create the frame");
+        gf_smsg("glfs", GF_LOG_ERROR, ENOMEM, API_MSG_FRAME_CREAT_FAILED, NULL);
         ret = -1;
         goto out;
     }
@@ -504,8 +491,8 @@ glfs_get_volume_info_rpc(call_frame_t *frame, xlator_t *this, struct glfs *fs)
     flags = (int32_t)GF_GET_VOLUME_UUID;  // ctx->flags;
     ret = dict_set_int32(dict, "flags", flags);
     if (ret) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
-               "failed to set flags");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL,
+                API_MSG_DICT_SET_FAILED, "flags", NULL);
         goto out;
     }
 
@@ -575,8 +562,8 @@ glfs_mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
     ctx = frame->this->ctx;
 
     if (!ctx) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "NULL context");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, EINVAL, API_MSG_NULL,
+                "context", NULL);
         errno = EINVAL;
         ret = -1;
         goto out;
@@ -592,16 +579,15 @@ glfs_mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count,
 
     ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
     if (ret < 0) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, 0, API_MSG_XDR_DECODE_FAILED,
-               "XDR decoding error");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, 0, API_MSG_XDR_DECODE_FAILED,
+                NULL);
         ret = -1;
         goto out;
     }
 
     if (-1 == rsp.op_ret) {
-        gf_msg(frame->this->name, GF_LOG_ERROR, rsp.op_errno,
-               API_MSG_GET_VOLFILE_FAILED,
-               "failed to get the 'volume file' from server");
+        gf_smsg(frame->this->name, GF_LOG_ERROR, rsp.op_errno,
+                API_MSG_GET_VOLFILE_FAILED, "from server", NULL);
         ret = -1;
         errno = rsp.op_errno;
         goto out;
@@ -650,8 +636,7 @@ volfile:
     if ((size == fs->oldvollen) &&
         (memcmp(fs->oldvolfile, rsp.spec, size) == 0)) {
         pthread_mutex_unlock(&fs->mutex);
-        gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
-               "No change in volfile, continuing");
+        gf_smsg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO, NULL);
         goto out;
     }
     pthread_mutex_unlock(&fs->mutex);
@@ -668,8 +653,8 @@ volfile:
      */
     ret = sys_unlink(template);
     if (ret < 0) {
-        gf_msg(frame->this->name, GF_LOG_INFO, 0, API_MSG_VOLFILE_INFO,
-               "Unable to delete file: %s", template);
+        gf_smsg(frame->this->name, GF_LOG_INFO, 0, API_MSG_UNABLE_TO_DEL,
+                "template=%s", template, NULL);
         ret = 0;
     }
 
@@ -731,9 +716,7 @@ out:
 
     // Stop if server is running at an unsupported op-version
     if (ENOTSUP == ret) {
-        gf_msg("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION,
-               "Server is operating at an op-version which is not "
-               "supported");
+        gf_smsg("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION, NULL);
         errno = ENOTSUP;
         glfs_init_done(fs, -1);
     }
@@ -742,9 +725,8 @@ out:
         /* Do it only for the first time */
         /* Failed to get the volume file, something wrong,
            restart the process */
-        gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "failed to fetch volume file (key:%s)",
-               ctx->cmd_args.volfile_id);
+        gf_smsg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_GET_VOLFILE_FAILED,
+                "key=%s", ctx->cmd_args.volfile_id, NULL);
         if (!need_retry) {
             if (!errno)
                 errno = EINVAL;
@@ -787,15 +769,15 @@ glfs_volfile_fetch(struct glfs *fs)
     // decision
     ret = dict_set_int32(dict, "min-op-version", GD_OP_VERSION_MIN);
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
-               "Failed to set min-op-version in request dict");
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+                "min-op-version", NULL);
         goto out;
     }
 
     ret = dict_set_int32(dict, "max-op-version", GD_OP_VERSION_MAX);
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
-               "Failed to set max-op-version in request dict");
+        gf_smsg(THIS->name, GF_LOG_ERROR, EINVAL, API_MSG_DICT_SET_FAILED,
+                "max-op-version", NULL);
         goto out;
     }
 
@@ -807,8 +789,8 @@ glfs_volfile_fetch(struct glfs *fs)
     ret = dict_allocate_and_serialize(dict, &req.xdata.xdata_val,
                                       &req.xdata.xdata_len);
     if (ret < 0) {
-        gf_msg(THIS->name, GF_LOG_ERROR, 0, API_MSG_DICT_SERIALIZE_FAILED,
-               "Failed to serialize dictionary");
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, API_MSG_DICT_SERIALIZE_FAILED,
+                NULL);
         goto out;
     }
 
@@ -855,15 +837,13 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
         case RPC_CLNT_DISCONNECT:
             if (!ctx->active) {
                 if (rpc_trans->connect_failed)
-                    gf_msg("glfs-mgmt", GF_LOG_ERROR, 0,
-                           API_MSG_REMOTE_HOST_CONN_FAILED,
-                           "failed to connect to remote-host: %s",
-                           ctx->cmd_args.volfile_server);
+                    gf_smsg("glfs-mgmt", GF_LOG_ERROR, 0,
+                            API_MSG_REMOTE_HOST_CONN_FAILED, "server=%s",
+                            ctx->cmd_args.volfile_server, NULL);
                 else
-                    gf_msg("glfs-mgmt", GF_LOG_INFO, 0,
-                           API_MSG_REMOTE_HOST_CONN_FAILED,
-                           "disconnected from remote-host: %s",
-                           ctx->cmd_args.volfile_server);
+                    gf_smsg("glfs-mgmt", GF_LOG_INFO, 0,
+                            API_MSG_REMOTE_HOST_CONN_FAILED, "server=%s",
+                            ctx->cmd_args.volfile_server, NULL);
 
                 if (!rpc->disabled) {
                     /*
@@ -878,9 +858,8 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                 server = ctx->cmd_args.curr_server;
                 if (server->list.next == &ctx->cmd_args.volfile_servers) {
                     errno = ENOTCONN;
-                    gf_msg("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
-                           API_MSG_VOLFILE_SERVER_EXHAUST,
-                           "Exhausted all volfile servers");
+                    gf_smsg("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
+                            API_MSG_VOLFILE_SERVER_EXHAUST, NULL);
                     glfs_init_done(fs, -1);
                     break;
                 }
@@ -893,10 +872,9 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                 ret = dict_set_str(rpc_trans->options, "transport-type",
                                    server->transport);
                 if (ret != 0) {
-                    gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                           API_MSG_DICT_SET_FAILED,
-                           "failed to set transport-type: %s",
-                           server->transport);
+                    gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                            API_MSG_DICT_SET_FAILED, "transport-type=%s",
+                            server->transport, NULL);
                     errno = ENOTCONN;
                     glfs_init_done(fs, -1);
                     break;
@@ -907,10 +885,10 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                                        "transport.socket.connect-path",
                                        server->volfile_server);
                     if (ret != 0) {
-                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                               API_MSG_DICT_SET_FAILED,
-                               "failed to set socket.connect-path: %s",
-                               server->volfile_server);
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED,
+                                "socket.connect-path=%s",
+                                server->volfile_server, NULL);
                         errno = ENOTCONN;
                         glfs_init_done(fs, -1);
                         break;
@@ -925,9 +903,9 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                     ret = dict_set_int32(rpc_trans->options, "remote-port",
                                          server->port);
                     if (ret != 0) {
-                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                               API_MSG_DICT_SET_FAILED,
-                               "failed to set remote-port: %d", server->port);
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED, "remote-port=%d",
+                                server->port, NULL);
                         errno = ENOTCONN;
                         glfs_init_done(fs, -1);
                         break;
@@ -936,10 +914,9 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                     ret = dict_set_str(rpc_trans->options, "remote-host",
                                        server->volfile_server);
                     if (ret != 0) {
-                        gf_msg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
-                               API_MSG_DICT_SET_FAILED,
-                               "failed to set remote-host: %s",
-                               server->volfile_server);
+                        gf_smsg("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
+                                API_MSG_DICT_SET_FAILED, "remote-host=%s",
+                                server->volfile_server, NULL);
                         errno = ENOTCONN;
                         glfs_init_done(fs, -1);
                         break;
@@ -952,10 +929,9 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
                              "transport.socket.connect-path");
                 }
 
-                gf_msg("glfs-mgmt", GF_LOG_INFO, 0, API_MSG_VOLFILE_CONNECTING,
-                       "connecting to next volfile server %s"
-                       " at port %d with transport: %s",
-                       server->volfile_server, server->port, server->transport);
+                gf_smsg("glfs-mgmt", GF_LOG_INFO, 0, API_MSG_VOLFILE_CONNECTING,
+                        "server=%s", server->volfile_server, "port=%d",
+                        server->port, "transport=%s", server->transport, NULL);
             }
             break;
         case RPC_CLNT_CONNECT:
@@ -963,9 +939,9 @@ mgmt_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
             if (ret && (ctx->active == NULL)) {
                 /* Do it only for the first time */
                 /* Exit the process.. there are some wrong options */
-                gf_msg("glfs-mgmt", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-                       "failed to fetch volume file (key:%s)",
-                       ctx->cmd_args.volfile_id);
+                gf_smsg("glfs-mgmt", GF_LOG_ERROR, EINVAL,
+                        API_MSG_GET_VOLFILE_FAILED, "key=%s",
+                        ctx->cmd_args.volfile_id, NULL);
                 errno = EINVAL;
                 glfs_init_done(fs, -1);
             }
@@ -1048,22 +1024,22 @@ glfs_mgmt_init(struct glfs *fs)
     rpc = rpc_clnt_new(options, THIS, THIS->name, 8);
     if (!rpc) {
         ret = -1;
-        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_CREATE_RPC_CLIENT_FAILED,
-               "failed to create rpc clnt");
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_CREATE_RPC_CLIENT_FAILED,
+                NULL);
         goto out;
     }
 
     ret = rpc_clnt_register_notify(rpc, mgmt_rpc_notify, THIS);
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_NOTIFY_FUNC_FAILED,
-               "failed to register notify function");
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_NOTIFY_FUNC_FAILED,
+                NULL);
         goto out;
     }
 
     ret = rpcclnt_cbk_program_register(rpc, &mgmt_cbk_prog, THIS);
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_CBK_FUNC_FAILED,
-               "failed to register callback function");
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, API_MSG_REG_CBK_FUNC_FAILED,
+                NULL);
         goto out;
     }
 
diff --git a/api/src/glfs-resolve.c b/api/src/glfs-resolve.c
index e03bbecbd8d..4b6f76961ee 100644
--- a/api/src/glfs-resolve.c
+++ b/api/src/glfs-resolve.c
@@ -116,9 +116,9 @@ glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
     DECODE_SYNCOP_ERR(ret);
 
     if (ret) {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno,
-               API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s",
-               uuid_utoa(oldinode->gfid), strerror(errno));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa(oldinode->gfid), "err=%s", strerror(errno), NULL);
         loc_wipe(&loc);
         return NULL;
     }
@@ -129,9 +129,8 @@ glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
             inode_ctx_set(newinode, THIS, &ctx_value);
         inode_lookup(newinode);
     } else {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
-               "inode linking of %s failed",
-               uuid_utoa((unsigned char *)&iatt.ia_gfid));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&iatt.ia_gfid), NULL);
     }
 
     loc_wipe(&loc);
@@ -442,9 +441,8 @@ glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
     inode = inode_link(loc.inode, loc.parent, component, &ciatt);
 
     if (!inode) {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
-               "inode linking of %s failed",
-               uuid_utoa((unsigned char *)&ciatt.ia_gfid));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&ciatt.ia_gfid), NULL);
         goto out;
     } else if (inode == loc.inode)
         inode_ctx_set(inode, THIS, &ctx_value);
@@ -628,8 +626,8 @@ glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath,
 
     cwd = glfs_cwd_get(fs);
     if (NULL == cwd) {
-        gf_msg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
-               "Failed to get cwd");
+        gf_smsg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
+                NULL);
         errno = EIO;
         goto out;
     }
@@ -683,28 +681,27 @@ glfs_migrate_fd_locks_safe(struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
                            NULL, NULL);
     DECODE_SYNCOP_ERR(ret);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
-               "fgetxattr (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(oldfd->inode->gfid, uuid1), strerror(errno),
-               graphid_str(oldsubvol), oldsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(oldsubvol), "id=%d",
+                oldsubvol->graph->id, NULL);
         goto out;
     }
 
     if (!dict_get(lockinfo, GF_XATTR_LOCKINFO_KEY)) {
-        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
-               "missing lockinfo key (%s) on graph %s (%d)",
-               uuid_utoa_r(oldfd->inode->gfid, uuid1), graphid_str(oldsubvol),
-               oldsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id, NULL);
         goto out;
     }
 
     ret = syncop_fsetxattr(newsubvol, newfd, lockinfo, 0, NULL, NULL);
     DECODE_SYNCOP_ERR(ret);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
-               "fsetxattr (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newfd->inode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(newfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 out:
@@ -736,29 +733,31 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
         ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL);
         DECODE_SYNCOP_ERR(ret);
         if (ret) {
-            gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
-                   "fsync() failed "
-                   "(%s) on %s graph %s (%d)",
-                   strerror(errno), uuid_utoa_r(oldfd->inode->gfid, uuid1),
-                   graphid_str(oldsubvol), oldsubvol->graph->id);
+            gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
+                    "err=%s", strerror(errno), "gfid=%s",
+                    uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                    graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id,
+                    NULL);
         }
     }
 
     newinode = glfs_refresh_inode_safe(newsubvol, oldinode, _gf_false);
     if (!newinode) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_INODE_REFRESH_FAILED,
-               "inode (%s) refresh failed (%s) on graph %s (%d)",
-               uuid_utoa_r(oldinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa_r(oldinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
     newfd = fd_create(newinode, getpid());
     if (!newfd) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FDCREATE_FAILED,
-               "fd_create (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_FDCREATE_FAILED_ON_GRAPH, "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
@@ -766,8 +765,7 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
 
     ret = inode_path(oldfd->inode, NULL, (char **)&loc.path);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
-               "inode_path failed");
+        gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED, NULL);
         goto out;
     }
 
@@ -783,21 +781,21 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
     loc_wipe(&loc);
 
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
-               "syncop_open%s (%s) failed (%s) on graph %s (%d)",
-               IA_ISDIR(oldinode->ia_type) ? "dir" : "",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
+                "type=%s", IA_ISDIR(oldinode->ia_type) ? "dir" : "", "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
     ret = glfs_migrate_fd_locks_safe(fs, oldsubvol, oldfd, newsubvol, newfd);
 
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
-               "lock migration (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
+                "gfid=%s", uuid_utoa_r(newinode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
@@ -878,9 +876,9 @@ __glfs_migrate_openfds(struct glfs *fs, xlator_t *subvol)
     list_for_each_entry(glfd, &fs->openfds, openfds)
     {
         if (gf_uuid_is_null(glfd->fd->inode->gfid)) {
-            gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
-                   "skipping openfd %p/%p in graph %s (%d)", glfd, glfd->fd,
-                   graphid_str(subvol), subvol->graph->id);
+            gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
+                    "glfd=%p", glfd, "glfd->fd=%p", glfd->fd, "subvol=%s",
+                    graphid_str(subvol), "id=%d", subvol->graph->id, NULL);
             /* create in progress, defer */
             continue;
         }
@@ -915,10 +913,10 @@ __glfs_active_subvol(struct glfs *fs)
 
     ret = __glfs_first_lookup(fs, new_subvol);
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_INFO, errno,
-               API_MSG_FIRST_LOOKUP_GRAPH_FAILED,
-               "first lookup on graph %s (%d) failed (%s)",
-               graphid_str(new_subvol), new_subvol->graph->id, strerror(errno));
+        gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                API_MSG_FIRST_LOOKUP_GRAPH_FAILED, "subvol=%s",
+                graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                "err=%s", strerror(errno), NULL);
         return NULL;
     }
 
@@ -927,11 +925,11 @@ __glfs_active_subvol(struct glfs *fs)
 
         if (!new_cwd) {
             char buf1[64];
-            gf_msg(fs->volname, GF_LOG_INFO, errno,
-                   API_MSG_CWD_GRAPH_REF_FAILED,
-                   "cwd refresh of %s graph %s (%d) failed (%s)",
-                   uuid_utoa_r(fs->cwd->gfid, buf1), graphid_str(new_subvol),
-                   new_subvol->graph->id, strerror(errno));
+            gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                    API_MSG_CWD_GRAPH_REF_FAILED, "buf=%s",
+                    uuid_utoa_r(fs->cwd->gfid, buf1), "subvol=%s",
+                    graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                    "err=%s", strerror(errno), NULL);
             return NULL;
         }
     }
@@ -952,9 +950,8 @@ __glfs_active_subvol(struct glfs *fs)
         inode_unref(new_cwd);
     }
 
-    gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH,
-           "switched to graph %s (%d)", graphid_str(new_subvol),
-           new_subvol->graph->id);
+    gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH, "subvol=%s",
+            graphid_str(new_subvol), "id=%d", new_subvol->graph->id, NULL);
 
     return new_subvol;
 }
diff --git a/api/src/glfs.c b/api/src/glfs.c
index f83ecbc5ae6..5f683451c21 100644
--- a/api/src/glfs.c
+++ b/api/src/glfs.c
@@ -69,8 +69,8 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 
     ret = xlator_mem_acct_init(THIS, glfs_mt_end + 1);
     if (ret != 0) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
-               "Memory accounting init failed");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,
+                NULL);
         return ret;
     }
 
@@ -189,10 +189,8 @@ create_master(struct glfs *fs)
         goto err;
 
     if (xlator_set_type(master, "mount/api") == -1) {
-        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED,
-               "master xlator "
-               "for %s initialization failed",
-               fs->volname);
+        gf_smsg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED,
+                "name=%s", fs->volname, NULL);
         goto err;
     }
 
@@ -204,8 +202,8 @@ create_master(struct glfs *fs)
 
     ret = xlator_init(master);
     if (ret) {
-        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,
-               "failed to initialize gfapi translator");
+        gf_smsg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,
+                NULL);
         goto err;
     }
 
@@ -231,9 +229,8 @@ get_volfp(struct glfs *fs)
     cmd_args = &fs->ctx->cmd_args;
 
     if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {
-        gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED,
-               "volume file %s open failed: %s", cmd_args->volfile,
-               strerror(errno));
+        gf_smsg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED,
+                "file=%s", cmd_args->volfile, "err=%s", strerror(errno), NULL);
         return NULL;
     }
 
@@ -262,8 +259,8 @@ glfs_volumes_init(struct glfs *fs)
     fp = get_volfp(fs);
 
     if (!fp) {
-        gf_msg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR,
-               "Cannot reach volume specification file");
+        gf_smsg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR,
+                NULL);
         ret = -1;
         goto out;
     }
@@ -422,14 +419,11 @@ pub_glfs_set_volfile_server(struct glfs *fs, const char *transport,
             server_transport = gf_strdup(transport);
         } else if (!strcmp(transport, "rdma")) {
             server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);
-            gf_msg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_INVALID_ENTRY,
-                   "transport RDMA is deprecated, "
-                   "falling back to tcp");
+            gf_smsg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_TRANS_RDMA_DEP,
+                    NULL);
         } else {
-            gf_msg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_INVALID_ENTRY,
-                   "transport %s is not supported, "
-                   "possible values tcp|unix",
-                   transport);
+            gf_smsg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_TRANS_NOT_SUPPORTED,
+                    "transport=%s", transport, NULL);
             goto out;
         }
     } else {
@@ -1059,8 +1053,7 @@ priv_glfs_init_done(struct glfs *fs, int ret)
     glfs_init_cbk init_cbk;
 
     if (!fs) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL,
-               "fs is NULL");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL, NULL);
         goto out;
     }
 
@@ -1113,8 +1106,7 @@ glfs_init_async(struct glfs *fs, glfs_init_cbk cbk)
     int ret = -1;
 
     if (!fs || !fs->ctx) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "fs is not properly initialized.");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_FS_NOT_INIT, NULL);
         errno = EINVAL;
         return ret;
     }
@@ -1134,8 +1126,7 @@ pub_glfs_init(struct glfs *fs)
     DECLARE_OLD_THIS;
 
     if (!fs || !fs->ctx) {
-        gf_msg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
-               "fs is not properly initialized.");
+        gf_smsg("glfs", GF_LOG_ERROR, EINVAL, API_MSG_FS_NOT_INIT, NULL);
         errno = EINVAL;
         return ret;
     }
@@ -1321,10 +1312,8 @@ pub_glfs_fini(struct glfs *fs)
             graph = subvol->graph;
             err = pthread_mutex_lock(&fs->mutex);
             if (err != 0) {
-                gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_LOCK_FAILED,
-                       "pthread lock on glfs mutex, "
-                       "returned error: (%s)",
-                       strerror(err));
+                gf_smsg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_LOCK_FAILED,
+                        "error=%s", strerror(err), NULL);
                 goto fail;
             }
             /* check and wait for CHILD_DOWN for active subvol*/
@@ -1332,19 +1321,17 @@ pub_glfs_fini(struct glfs *fs)
                 while (graph->used) {
                     err = pthread_cond_wait(&fs->child_down_cond, &fs->mutex);
                     if (err != 0)
-                        gf_msg("glfs", GF_LOG_INFO, err,
-                               API_MSG_COND_WAIT_FAILED,
-                               "%s cond wait failed %s", subvol->name,
-                               strerror(err));
+                        gf_smsg("glfs", GF_LOG_INFO, err,
+                                API_MSG_COND_WAIT_FAILED, "name=%s",
+                                subvol->name, "err=%s", strerror(err), NULL);
                 }
             }
 
             err = pthread_mutex_unlock(&fs->mutex);
             if (err != 0) {
-                gf_msg("glfs", GF_LOG_ERROR, err, API_MSG_FSMUTEX_UNLOCK_FAILED,
-                       "pthread unlock on glfs mutex, "
-                       "returned error: (%s)",
-                       strerror(err));
+                gf_smsg("glfs", GF_LOG_ERROR, err,
+                        API_MSG_FSMUTEX_UNLOCK_FAILED, "error=%s",
+                        strerror(err), NULL);
                 goto fail;
             }
         }
@@ -1644,8 +1631,8 @@ pub_glfs_sysrq(struct glfs *fs, char sysrq)
             gf_proc_dump_info(SIGUSR1, ctx);
             break;
         default:
-            gf_msg("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_ENTRY,
-                   "'%c' is not a valid sysrq", sysrq);
+            gf_smsg("glfs", GF_LOG_ERROR, ENOTSUP, API_MSG_INVALID_SYSRQ,
+                    "sysrq=%c", sysrq, NULL);
             errno = ENOTSUP;
             ret = -1;
     }
@@ -1676,8 +1663,8 @@ pub_glfs_upcall_register(struct glfs *fs, uint32_t event_list,
     if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
         errno = EINVAL;
         ret = -1;
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-               "invalid event_list (0x%08x)", event_list);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "event_list=(0x%08x)", event_list, NULL);
         goto out;
     }
 
@@ -1729,8 +1716,8 @@ pub_glfs_upcall_unregister(struct glfs *fs, uint32_t event_list)
     if ((event_list != GLFS_EVENT_ANY) && (event_list & ~up_events)) {
         errno = EINVAL;
         ret = -1;
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_INVALID_ARG,
-               "invalid event_list (0x%08x)", event_list);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, API_MSG_INVALID_ARG,
+                "event_list=(0x%08x)", event_list, NULL);
         goto out;
     }