libglusterfs/common-utils: structure logging

changes all the gf_msg() to gf_smgs()

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

2 files changed, 130 insertions, 122 deletions

diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c
index 5814eb90e21..585952d7641 100644
--- a/libglusterfs/src/common-utils.c
+++ b/libglusterfs/src/common-utils.c
@@ -302,8 +302,7 @@ mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks)
         dir[i] = '\0';
         ret = sys_mkdir(dir, mode);
         if (ret && errno != EEXIST) {
-            gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-                   "Failed due to reason");
+            gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED, NULL);
             goto out;
         }
 
@@ -314,10 +313,8 @@ mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks)
 
             if (S_ISLNK(stbuf.st_mode)) {
                 ret = -1;
-                gf_msg("", GF_LOG_ERROR, 0, LG_MSG_DIR_IS_SYMLINK,
-                       "%s is a "
-                       "symlink",
-                       dir);
+                gf_smsg("", GF_LOG_ERROR, 0, LG_MSG_DIR_IS_SYMLINK, "dir=%s",
+                        dir, NULL);
                 goto out;
             }
         }
@@ -330,10 +327,10 @@ mkdir_p(char *path, mode_t mode, gf_boolean_t allow_symlinks)
         if (ret == 0)
             errno = 0;
         ret = -1;
-        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
-               "Failed"
-               " to create directory, possibly some of the components"
-               " were not directories");
+        gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_DIR_OP_FAILED,
+                "possibly some of the components"
+                " were not directories",
+                NULL);
         goto out;
     }
 
@@ -406,10 +403,8 @@ gf_rev_dns_lookup(const char *ip)
     /* Get the FQDN */
     ret = gf_get_hostname_from_ip((char *)ip, &fqdn);
     if (ret != 0) {
-        gf_msg("resolver", GF_LOG_INFO, errno, LG_MSG_RESOLVE_HOSTNAME_FAILED,
-               "could not resolve "
-               "hostname for %s",
-               ip);
+        gf_smsg("resolver", GF_LOG_INFO, errno, LG_MSG_RESOLVE_HOSTNAME_FAILED,
+                "hostname=%s", ip, NULL);
     }
 out:
     return fqdn;
@@ -498,9 +493,8 @@ gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
         }
         if ((ret = getaddrinfo(hostname, port_str, &hints, &cache->first)) !=
             0) {
-            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
-                   "getaddrinfo failed (family:%d) (%s)", family,
-                   gai_strerror(ret));
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+                    "family=%d", family, "ret=%s", gai_strerror(ret), NULL);
 
             GF_FREE(*dnscache);
             *dnscache = NULL;
@@ -517,10 +511,8 @@ gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
                           cache->next->ai_addrlen, host, sizeof(host), service,
                           sizeof(service), NI_NUMERICHOST);
         if (ret != 0) {
-            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
-                   "getnameinfo failed"
-                   " (%s)",
-                   gai_strerror(ret));
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
             goto err;
         }
 
@@ -539,10 +531,8 @@ gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache,
                           cache->next->ai_addrlen, host, sizeof(host), service,
                           sizeof(service), NI_NUMERICHOST);
         if (ret != 0) {
-            gf_msg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
-                   "getnameinfo failed"
-                   " (%s)",
-                   gai_strerror(ret));
+            gf_smsg("resolver", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
             goto err;
         }
 
@@ -2103,8 +2093,8 @@ get_checksum_for_path(char *path, uint32_t *checksum, int op_version)
     fd = open(path, O_RDWR);
 
     if (fd == -1) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_ERROR,
-               "Unable to open %s", path);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_PATH_OPEN_FAILED,
+                "path=%s", path, NULL);
         goto out;
     }
 
@@ -2137,8 +2127,8 @@ get_file_mtime(const char *path, time_t *stamp)
 
     ret = sys_stat(path, &f_stat);
     if (ret < 0) {
-        gf_msg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
-               "failed to stat %s", path);
+        gf_smsg(THIS->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+                "path=%s", path, NULL);
         goto out;
     }
 
@@ -2197,14 +2187,14 @@ gf_is_ip_in_net(const char *network, const char *ip_str)
     /* Convert IP address to a long */
     ret = inet_pton(family, ip_str, &ip_buf);
     if (ret < 0)
-        gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
-               "inet_pton() failed");
+        gf_smsg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+                NULL);
 
     /* Convert network IP address to a long */
     ret = inet_pton(family, net_ip, &net_ip_buf);
     if (ret < 0) {
-        gf_msg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
-               "inet_pton() failed");
+        gf_smsg("common-utils", GF_LOG_ERROR, errno, LG_MSG_INET_PTON_FAILED,
+                NULL);
         goto out;
     }
 
@@ -2784,8 +2774,8 @@ gf_boolean_t
 gf_sock_union_equal_addr(union gf_sock_union *a, union gf_sock_union *b)
 {
     if (!a || !b) {
-        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-               "Invalid arguments to gf_sock_union_equal_addr");
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
+                "gf_sock_union_equal_addr", NULL);
         return _gf_false;
     }
 
@@ -3013,8 +3003,8 @@ gf_roundup_power_of_two(int32_t nr)
     int32_t result = 1;
 
     if (nr < 0) {
-        gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
-               "negative number passed");
+        gf_smsg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+                NULL);
         result = -1;
         goto out;
     }
@@ -3037,8 +3027,8 @@ gf_roundup_next_power_of_two(int32_t nr)
     int32_t result = 1;
 
     if (nr < 0) {
-        gf_msg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
-               "negative number passed");
+        gf_smsg("common-utils", GF_LOG_WARNING, 0, LG_MSG_NEGATIVE_NUM_PASSED,
+                NULL);
         result = -1;
         goto out;
     }
@@ -3212,8 +3202,7 @@ gf_canonicalize_path(char *path)
 
 out:
     if (ret)
-        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR,
-               "Path manipulation failed");
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_PATH_ERROR, NULL);
 
     GF_FREE(tmppath);
 
@@ -3267,19 +3256,15 @@ gf_get_reserved_ports()
          * continue with older method of using any of the available
          * port? For now 2nd option is considered.
          */
-        gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-               "could not open the file "
-               "/proc/sys/net/ipv4/ip_local_reserved_ports for "
-               "getting reserved ports info");
+        gf_smsg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                " /proc/sys/net/ipv4/ip_local_reserved_ports", NULL);
         goto out;
     }
 
     ret = sys_read(proc_fd, buffer, sizeof(buffer) - 1);
     if (ret < 0) {
-        gf_msg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
-               "could not read the file %s for"
-               " getting reserved ports info",
-               proc_file);
+        gf_smsg("glusterfs", GF_LOG_WARNING, errno, LG_MSG_FILE_OP_FAILED,
+                "file=%s", proc_file, NULL);
         goto out;
     }
 
@@ -3307,10 +3292,8 @@ gf_process_reserved_ports(unsigned char *ports, uint32_t ceiling)
 
     ports_info = gf_get_reserved_ports();
     if (!ports_info) {
-        gf_msg("glusterfs", GF_LOG_WARNING, 0, LG_MSG_RESERVED_PORTS_ERROR,
-               "Not able to get reserved"
-               " ports, hence there is a possibility that glusterfs "
-               "may consume reserved port");
+        gf_smsg("glusterfs", GF_LOG_WARNING, 0, LG_MSG_RESERVED_PORTS_ERROR,
+                NULL);
         goto out;
     }
 
@@ -3347,8 +3330,8 @@ gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling)
             blocked_port[strlen(blocked_port) - 1] = '\0';
         if (gf_string2int32(blocked_port, &tmp_port1) == 0) {
             if (tmp_port1 > GF_PORT_MAX || tmp_port1 < 0) {
-                gf_msg("glusterfs-socket", GF_LOG_WARNING, 0,
-                       LG_MSG_INVALID_PORT, "invalid port %d", tmp_port1);
+                gf_smsg("glusterfs-socket", GF_LOG_WARNING, 0,
+                        LG_MSG_INVALID_PORT, "port=%d", tmp_port1, NULL);
                 result = _gf_true;
                 goto out;
             } else {
@@ -3359,10 +3342,8 @@ gf_ports_reserved(char *blocked_port, unsigned char *ports, uint32_t ceiling)
                 BIT_SET(ports, tmp_port1);
             }
         } else {
-            gf_msg("glusterfs-socket", GF_LOG_WARNING, 0, LG_MSG_INVALID_PORT,
-                   "%s is not a valid port "
-                   "identifier",
-                   blocked_port);
+            gf_smsg("glusterfs-socket", GF_LOG_WARNING, 0, LG_MSG_INVALID_PORT,
+                    "port=%s", blocked_port, NULL);
             result = _gf_true;
             goto out;
         }
@@ -3464,10 +3445,8 @@ gf_get_hostname_from_ip(char *client_ip, char **hostname)
     ret = getnameinfo(client_sockaddr, addr_sz, client_hostname,
                       sizeof(client_hostname), NULL, 0, 0);
     if (ret) {
-        gf_msg("common-utils", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
-               "Could not lookup hostname "
-               "of %s : %s",
-               client_ip, gai_strerror(ret));
+        gf_smsg("common-utils", GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                "ip=%s", client_ip, "ret=%s", gai_strerror(ret), NULL);
         ret = -1;
         goto out;
     }
@@ -3496,8 +3475,8 @@ gf_interface_search(char *ip)
     ret = getifaddrs(&ifaddr);
 
     if (ret != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED,
-               "getifaddrs() failed: %s\n", gai_strerror(ret));
+        gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETIFADDRS_FAILED, "ret=%s",
+                gai_strerror(ret), NULL);
         goto out;
     }
 
@@ -3521,10 +3500,8 @@ gf_interface_search(char *ip)
                           host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
 
         if (ret != 0) {
-            gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
-                   "getnameinfo() "
-                   "failed: %s\n",
-                   gai_strerror(ret));
+            gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETNAMEINFO_FAILED,
+                    "ret=%s", gai_strerror(ret), NULL);
             goto out;
         }
 
@@ -3574,14 +3551,12 @@ get_ip_from_addrinfo(struct addrinfo *addr, char **ip)
             break;
 
         default:
-            gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
-                   "Invalid family");
+            gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY, NULL);
             return NULL;
     }
 
     if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) {
-        gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED,
-               "String conversion failed");
+        gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_CONVERSION_FAILED, NULL);
         return NULL;
     }
 
@@ -3616,10 +3591,9 @@ gf_is_loopback_localhost(const struct sockaddr *sa, char *hostname)
 
         default:
             if (hostname)
-                gf_msg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
-                       "unknown "
-                       "address family %d for %s",
-                       sa->sa_family, hostname);
+                gf_smsg("glusterd", GF_LOG_ERROR, 0, LG_MSG_INVALID_FAMILY,
+                        "family=%d", sa->sa_family, "hostname=%s", hostname,
+                        NULL);
             break;
     }
 
@@ -3649,8 +3623,8 @@ gf_is_local_addr(char *hostname)
     ret = getaddrinfo(hostname, NULL, &hints, &result);
 
     if (ret != 0) {
-        gf_msg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
-               "error in getaddrinfo: %s\n", gai_strerror(ret));
+        gf_smsg(this->name, GF_LOG_ERROR, 0, LG_MSG_GETADDRINFO_FAILED,
+                "ret=%s", gai_strerror(ret), NULL);
         goto out;
     }
 
@@ -3698,15 +3672,15 @@ gf_is_same_address(char *name1, char *name2)
 
     gai_err = getaddrinfo(name1, NULL, &hints, &addr1);
     if (gai_err != 0) {
-        gf_msg(name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-               "error in getaddrinfo: %s\n", gai_strerror(gai_err));
+        gf_smsg(name1, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, "error=%s",
+                gai_strerror(gai_err), NULL);
         goto out;
     }
 
     gai_err = getaddrinfo(name2, NULL, &hints, &addr2);
     if (gai_err != 0) {
-        gf_msg(name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED,
-               "error in getaddrinfo: %s\n", gai_strerror(gai_err));
+        gf_smsg(name2, GF_LOG_WARNING, 0, LG_MSG_GETADDRINFO_FAILED, "error=%s",
+                gai_strerror(gai_err), NULL);
         goto out;
     }
 
@@ -3844,8 +3818,8 @@ gf_set_volfile_server_common(cmd_args_t *cmd_args, const char *host,
              !strcmp(tmp->transport, server->transport) &&
              (tmp->port == server->port))) {
             /* Duplicate option given, log and ignore */
-            gf_msg("gluster", GF_LOG_INFO, EEXIST, LG_MSG_INVALID_ENTRY,
-                   "duplicate entry for volfile-server");
+            gf_smsg("gluster", GF_LOG_INFO, EEXIST, LG_MSG_DUPLICATE_ENTRY,
+                    NULL);
             ret = 0;
             goto out;
         }
@@ -4023,15 +3997,14 @@ gf_thread_set_vname(pthread_t thread, const char *name, va_list args)
                     sizeof(thread_name) - sizeof(GF_THREAD_NAME_PREFIX) + 1,
                     name, args);
     if (ret < 0) {
-        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED,
-               "Failed to compose thread name ('%s')", name);
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED,
+                "name=%s", name, NULL);
         return;
     }
 
     if (ret >= sizeof(thread_name)) {
-        gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_PTHREAD_NAMING_FAILED,
-               "Thread name is too long. It has been truncated ('%s')",
-               thread_name);
+        gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_THREAD_NAME_TOO_LONG,
+                "name=%s", thread_name, NULL);
     }
 
 #ifdef GF_LINUX_HOST_OS
@@ -4045,8 +4018,8 @@ gf_thread_set_vname(pthread_t thread, const char *name, va_list args)
     ret = ENOSYS;
 #endif
     if (ret != 0) {
-        gf_msg(THIS->name, GF_LOG_WARNING, ret, LG_MSG_PTHREAD_NAMING_FAILED,
-               "Could not set thread name: %s", thread_name);
+        gf_smsg(THIS->name, GF_LOG_WARNING, ret, LG_MSG_SET_THREAD_FAILED,
+                "name=%s", thread_name, NULL);
     }
 }
 
@@ -4081,8 +4054,8 @@ gf_thread_vcreate(pthread_t *thread, const pthread_attr_t *attr,
 
     ret = pthread_create(thread, attr, start_routine, arg);
     if (ret != 0) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_FAILED,
-               "Thread creation failed");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_THREAD_CREATE_FAILED,
+                NULL);
         ret = -1;
     } else if (name != NULL) {
         gf_thread_set_vname(*thread, name, args);
@@ -4118,8 +4091,8 @@ gf_thread_create_detached(pthread_t *thread, void *(*start_routine)(void *),
 
     ret = pthread_attr_init(&attr);
     if (ret) {
-        gf_msg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED,
-               "Thread attribute initialization failed");
+        gf_smsg(THIS->name, GF_LOG_ERROR, ret, LG_MSG_PTHREAD_ATTR_INIT_FAILED,
+                NULL);
         return -1;
     }
 
@@ -4141,8 +4114,7 @@ gf_skip_header_section(int fd, int header_len)
 
     ret = sys_lseek(fd, header_len, SEEK_SET);
     if (ret == (off_t)-1) {
-        gf_msg("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED,
-               "Failed to skip header section");
+        gf_smsg("", GF_LOG_ERROR, 0, LG_MSG_SKIP_HEADER_FAILED, NULL);
     } else {
         ret = 0;
     }
@@ -4192,8 +4164,8 @@ gf_is_service_running(char *pidfile, int *pid)
 
     ret = fscanf(file, "%d", pid);
     if (ret <= 0) {
-        gf_msg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED,
-               "Unable to read pidfile: %s", pidfile);
+        gf_smsg("", GF_LOG_ERROR, errno, LG_MSG_FILE_OP_FAILED, "pidfile=%s",
+                pidfile, NULL);
         *pid = -1;
         running = _gf_false;
         goto out;
@@ -4267,10 +4239,10 @@ gf_check_log_format(const char *value)
         log_format = gf_logformat_withmsgid;
 
     if (log_format == -1)
-        gf_msg(
-            THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-            "Invalid log-format. possible values are " GF_LOG_FORMAT_NO_MSG_ID
-            "|" GF_LOG_FORMAT_WITH_MSG_ID);
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+                "possible_values=" GF_LOG_FORMAT_NO_MSG_ID
+                "|" GF_LOG_FORMAT_WITH_MSG_ID,
+                NULL);
 
     return log_format;
 }
@@ -4286,9 +4258,9 @@ gf_check_logger(const char *value)
         logger = gf_logger_syslog;
 
     if (logger == -1)
-        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
-               "Invalid logger. possible values are " GF_LOGGER_GLUSTER_LOG
-               "|" GF_LOGGER_SYSLOG);
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_LOG,
+                "possible_values=" GF_LOGGER_GLUSTER_LOG "|" GF_LOGGER_SYSLOG,
+                NULL);
 
     return logger;
 }
@@ -4360,8 +4332,8 @@ gf_set_timestamp(const char *src, const char *dest)
 
     ret = sys_stat(src, &sb);
     if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
-               "stat on %s", src);
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_FILE_STAT_FAILED,
+                "stat=%s", src, NULL);
         goto out;
     }
     /* The granularity is nano seconds if `utimensat()` is available,
@@ -4377,8 +4349,8 @@ gf_set_timestamp(const char *src, const char *dest)
     /* dirfd = 0 is ignored because `dest` is an absolute path. */
     ret = sys_utimensat(AT_FDCWD, dest, new_time, AT_SYMLINK_NOFOLLOW);
     if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMENSAT_FAILED,
-               "utimensat on %s", dest);
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMENSAT_FAILED,
+                "dest=%s", dest, NULL);
     }
 #else
     new_time[0].tv_sec = sb.st_atime;
@@ -4389,8 +4361,8 @@ gf_set_timestamp(const char *src, const char *dest)
 
     ret = sys_utimes(dest, new_time);
     if (ret) {
-        gf_msg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
-               "utimes on %s", dest);
+        gf_smsg(this->name, GF_LOG_ERROR, errno, LG_MSG_UTIMES_FAILED,
+                "dest=%s", dest, NULL);
     }
 #endif
 out:
@@ -4455,8 +4427,8 @@ gf_backtrace_fillframes(char *buf)
      */
     ret = sys_unlink(tmpl);
     if (ret < 0) {
-        gf_msg(THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_OP_FAILED,
-               "Unable to delete temporary file: %s", tmpl);
+        gf_smsg(THIS->name, GF_LOG_INFO, 0, LG_MSG_FILE_DELETE_FAILED,
+                "temporary_file=%s", tmpl, NULL);
     }
 
     /*The most recent two frames are the calling function and
@@ -4516,8 +4488,7 @@ gf_backtrace_save(char *buf)
     if ((0 == gf_backtrace_fillframes(bt)))
         return bt;
 
-    gf_msg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED,
-           "Failed to save the backtrace.");
+    gf_smsg(THIS->name, GF_LOG_WARNING, 0, LG_MSG_BACKTRACE_SAVE_FAILED, NULL);
     return NULL;
 }
 
@@ -4608,16 +4579,16 @@ gf_build_absolute_path(char *current_path, char *relative_path, char **path)
      */
     currentpath_len = strlen(current_path);
     if (current_path[0] != '/' || (currentpath_len > PATH_MAX)) {
-        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-               "Wrong value for current path %s", current_path);
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_WRONG_VALUE,
+                "current-path=%s", current_path, NULL);
         ret = -EINVAL;
         goto err;
     }
 
     relativepath_len = strlen(relative_path);
     if (relative_path[0] == '/' || (relativepath_len > PATH_MAX)) {
-        gf_msg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY,
-               "Wrong value for relative path %s", relative_path);
+        gf_smsg(THIS->name, GF_LOG_ERROR, 0, LG_MSG_WRONG_VALUE,
+                "relative-path=%s", relative_path, NULL);
         ret = -EINVAL;
         goto err;
     }
diff --git a/libglusterfs/src/glusterfs/libglusterfs-messages.h b/libglusterfs/src/glusterfs/libglusterfs-messages.h
index 7e0eebbe535..a68fd7119ac 100644
--- a/libglusterfs/src/glusterfs/libglusterfs-messages.h
+++ b/libglusterfs/src/glusterfs/libglusterfs-messages.h
@@ -112,6 +112,43 @@ GLFS_MSGID(
     LG_MSG_XXH64_TO_GFID_FAILED, LG_MSG_ASYNC_WARNING, LG_MSG_ASYNC_FAILURE,
     LG_MSG_GRAPH_CLEANUP_FAILED, LG_MSG_GRAPH_SETUP_FAILED,
     LG_MSG_GRAPH_DETACH_STARTED, LG_MSG_GRAPH_ATTACH_FAILED,
-    LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED);
+    LG_MSG_GRAPH_ATTACH_PID_FILE_UPDATED, LG_MSG_DUPLICATE_ENTRY,
+    LG_MSG_THREAD_NAME_TOO_LONG, LG_MSG_SET_THREAD_FAILED,
+    LG_MSG_THREAD_CREATE_FAILED, LG_MSG_FILE_DELETE_FAILED, LG_MSG_WRONG_VALUE,
+    LG_MSG_PATH_OPEN_FAILED);
 
+#define LG_MSG_FILE_STAT_FAILED_STR "failed to stat"
+#define LG_MSG_INET_PTON_FAILED_STR "inet_pton() failed"
+#define LG_MSG_INVALID_ENTRY_STR "Invalid arguments"
+#define LG_MSG_NEGATIVE_NUM_PASSED_STR "negative number passed"
+#define LG_MSG_PATH_ERROR_STR "Path manipulation failed"
+#define LG_MSG_FILE_OP_FAILED_STR "could not open/read file, getting ports info"
+#define LG_MSG_RESERVED_PORTS_ERROR_STR                                        \
+    "Not able to get reserved ports, hence there is a possibility that "       \
+    "glusterfs may consume reserved port"
+#define LG_MSG_INVALID_PORT_STR "invalid port"
+#define LG_MSG_GETNAMEINFO_FAILED_STR "Could not lookup hostname"
+#define LG_MSG_GETIFADDRS_FAILED_STR "getifaddrs() failed"
+#define LG_MSG_INVALID_FAMILY_STR "Invalid family"
+#define LG_MSG_CONVERSION_FAILED_STR "String conversion failed"
+#define LG_MSG_GETADDRINFO_FAILED_STR "error in getaddrinfo"
+#define LG_MSG_DUPLICATE_ENTRY_STR "duplicate entry for volfile-server"
+#define LG_MSG_PTHREAD_NAMING_FAILED_STR "Failed to compose thread name"
+#define LG_MSG_THREAD_NAME_TOO_LONG_STR                                        \
+    "Thread name is too long. It has been truncated"
+#define LG_MSG_SET_THREAD_FAILED_STR "Could not set thread name"
+#define LG_MSG_THREAD_CREATE_FAILED_STR "Thread creation failed"
+#define LG_MSG_PTHREAD_ATTR_INIT_FAILED_STR                                    \
+    "Thread attribute initialization failed"
+#define LG_MSG_SKIP_HEADER_FAILED_STR "Failed to skip header section"
+#define LG_MSG_INVALID_LOG_STR "Invalid log-format"
+#define LG_MSG_UTIMENSAT_FAILED_STR "utimenstat failed"
+#define LG_MSG_UTIMES_FAILED_STR "utimes failed"
+#define LG_MSG_FILE_DELETE_FAILED_STR "Unable to delete file"
+#define LG_MSG_BACKTRACE_SAVE_FAILED_STR "Failed to save the backtrace"
+#define LG_MSG_WRONG_VALUE_STR "wrong value"
+#define LG_MSG_DIR_OP_FAILED_STR "Failed to create directory"
+#define LG_MSG_DIR_IS_SYMLINK_STR "dir is symlink"
+#define LG_MSG_RESOLVE_HOSTNAME_FAILED_STR "couldnot resolve hostname"
+#define LG_MSG_PATH_OPEN_FAILED_STR "Unable to open path"
 #endif /* !_LG_MESSAGES_H_ */