From 830a3dc46438b1cf18bcd35cca05c164e77180f1 Mon Sep 17 00:00:00 2001 From: yatipadia Date: Mon, 25 Nov 2019 19:57:09 +0530 Subject: api-glfs-fops: structure logging Convert gf_msg() to gf_smsg() Change-Id: Iceb40d60a75106c7b4b0a2487b611f7376bccc46 Updates: #657 Signed-off-by: yatipadia --- api/src/gfapi-messages.h | 95 ++++++++++++++++++++++++- api/src/glfs-fops.c | 93 +++++++++++------------- api/src/glfs-handleops.c | 38 +++++----- api/src/glfs-master.c | 12 ++-- api/src/glfs-mgmt.c | 182 ++++++++++++++++++++--------------------------- api/src/glfs-resolve.c | 121 +++++++++++++++---------------- api/src/glfs.c | 75 ++++++++----------- 7 files changed, 330 insertions(+), 286 deletions(-) (limited to 'api') 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; } -- cgit