andy/glusterfs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libgfapi : port gfapi to new logging framework

Browse Source 
Change-Id: Iaa0a92f82b9a0a26eda1a8d72b3b66ce66fab443
BUG: 1194640
Signed-off-by: Humble Devassy Chirammal <hchiramm@redhat.com>
Reviewed-on: http://review.gluster.org/9918
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: jiffin tony Thottan <jthottan@redhat.com>
Reviewed-by: Raghavendra Talur <rtalur@redhat.com>
Reviewed-by: soumya k <skoduri@redhat.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>
This commit is contained in:
Humble Devassy Chirammal 2015-04-25 12:44:15 +05:30 committed by Niels de Vos
parent 315364b78c
commit 8986a47c54
7 changed files with 254 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/src/Makefile.am
View File

@ -1,5 +1,5 @@
lib_LTLIBRARIES = libgfapi.la
noinst_HEADERS = glfs-mem-types.h glfs-internal.h
noinst_HEADERS = glfs-mem-types.h glfs-internal.h gfapi-messages.h
libgfapi_HEADERS = glfs.h glfs-handles.h
libgfapidir = $(includedir)/glusterfs/api

102
api/src/gfapi-messages.h Normal file
View File

@ -0,0 +1,102 @@
/*
* Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
* This file is part of GlusterFS.
*
* This file is licensed to you under your choice of the GNU Lesser
* General Public License, version 3 or any later version (LGPLv3 or
* later), or the GNU General Public License, version 2 (GPLv2), in all
* cases as published by the Free Software Foundation.
* */
#ifndef _GFAPI_MESSAGES_H__
#define _GFAPI_MESSAGES_H_
#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif
#include "glfs-message-id.h"
/*! \file gfapi-messages.h
* \brief libgfapi log-message IDs and their descriptions
*/
/* NOTE: Rules for message additions
* 1) Each instance of a message is _better_ left with a unique message ID, even
* if the message format is the same. Reasoning is that, if the message
* format needs to change in one instance, the other instances are not
* impacted or the new change does not change the ID of the instance being
* modified.
* 2) Addition of a message,
* - Should increment the GLFS_NUM_MESSAGES
* - Append to the list of messages defined, towards the end
* - Retain macro naming as glfs_msg_X (for redability across developers)
* NOTE: Rules for message format modifications
* 3) Check acorss the code if the message ID macro in question is reused
* anywhere. If reused then then the modifications should ensure correctness
* everywhere, or needs a new message ID as (1) above was not adhered to. If
* not used anywhere, proceed with the required modification.
* NOTE: Rules for message deletion
* 4) Check (3) and if used anywhere else, then cannot be deleted. If not used
* anywhere, then can be deleted, but will leave a hole by design, as
* addition rules specify modification to the end of the list and not filling
* holes.
*/
#define GLFS_GFAPI_BASE GLFS_MSGID_COMP_API
#define GLFS_NUM_MESSAGES 45
#define GLFS_MSGID_END (GLFS_GFAPI_BASE + GLFS_NUM_MESSAGESi + 1)
/* Messages with message IDs */
#define glfs_msg_start_x GLFS_GFAPI_BASE, "Invalid: Start of messages"
/*------------*/
#define API_MSG_MEM_ACCT_INIT_FAILED (GLFS_GFAPI_BASE + 1)
#define API_MSG_MASTER_XLATOR_INIT_FAILED (GLFS_GFAPI_BASE + 2)
#define API_MSG_GFAPI_XLATOR_INIT_FAILED (GLFS_GFAPI_BASE + 3)
#define API_MSG_VOLFILE_OPEN_FAILED (GLFS_GFAPI_BASE + 4)
#define API_MSG_VOL_SPEC_FILE_ERROR (GLFS_GFAPI_BASE + 5)
#define API_MSG_GLFS_FSOBJ_NULL (GLFS_GFAPI_BASE + 6)
#define API_MSG_INVALID_ENTRY (GLFS_GFAPI_BASE + 7)
#define API_MSG_FSMUTEX_LOCK_FAILED (GLFS_GFAPI_BASE + 8)
#define API_MSG_COND_WAIT_FAILED (GLFS_GFAPI_BASE + 9)
#define API_MSG_FSMUTEX_UNLOCK_FAILED (GLFS_GFAPI_BASE + 10)
#define API_MSG_INODE_REFRESH_FAILED (GLFS_GFAPI_BASE + 11)
#define API_MSG_GRAPH_CONSTRUCT_FAILED (GLFS_GFAPI_BASE + 12)
#define API_MSG_FUSE_XLATOR_ERROR (GLFS_GFAPI_BASE + 13)
#define API_MSG_XDR_PAYLOAD_FAILED (GLFS_GFAPI_BASE + 14)
#define API_MSG_GET_VOLINFO_CBK_FAILED (GLFS_GFAPI_BASE + 15)
#define API_MSG_FETCH_VOLUUID_FAILED (GLFS_GFAPI_BASE + 16)
#define API_MSG_INSUFF_SIZE (GLFS_GFAPI_BASE + 17)
#define API_MSG_FRAME_CREAT_FAILED (GLFS_GFAPI_BASE + 18)
#define API_MSG_DICT_SET_FAILED (GLFS_GFAPI_BASE + 19)
#define API_MSG_XDR_DECODE_FAILED (GLFS_GFAPI_BASE + 20)
#define API_MSG_GET_VOLFILE_FAILED (GLFS_GFAPI_BASE + 21)
#define API_MSG_WRONG_OPVERSION (GLFS_GFAPI_BASE + 22)
#define API_MSG_DICT_SERIALIZE_FAILED (GLFS_GFAPI_BASE + 23)
#define API_MSG_REMOTE_HOST_CONN_FAILED (GLFS_GFAPI_BASE + 24)
#define API_MSG_VOLFILE_SERVER_EXHAUST (GLFS_GFAPI_BASE + 25)
#define API_MSG_CREATE_RPC_CLIENT_FAILED (GLFS_GFAPI_BASE + 26)
#define API_MSG_REG_NOTIFY_FUNC_FAILED (GLFS_GFAPI_BASE + 27)
#define API_MSG_REG_CBK_FUNC_FAILED (GLFS_GFAPI_BASE + 28)
#define API_MSG_GET_CWD_FAILED (GLFS_GFAPI_BASE + 29)
#define API_MSG_FGETXATTR_FAILED (GLFS_GFAPI_BASE + 30)
#define API_MSG_LOCKINFO_KEY_MISSING (GLFS_GFAPI_BASE + 31)
#define API_MSG_FSETXATTR_FAILED (GLFS_GFAPI_BASE + 32)
#define API_MSG_FSYNC_FAILED (GLFS_GFAPI_BASE + 33)
#define API_MSG_FDCREATE_FAILED (GLFS_GFAPI_BASE + 34)
#define API_MSG_INODE_PATH_FAILED (GLFS_GFAPI_BASE + 35)
#define API_MSG_SYNCOP_OPEN_FAILED (GLFS_GFAPI_BASE + 36)
#define API_MSG_LOCK_MIGRATE_FAILED (GLFS_GFAPI_BASE + 37)
#define API_MSG_OPENFD_SKIPPED (GLFS_GFAPI_BASE + 38)
#define API_MSG_FIRST_LOOKUP_GRAPH_FAILED (GLFS_GFAPI_BASE + 39)
#define API_MSG_CWD_GRAPH_REF_FAILED (GLFS_GFAPI_BASE + 40)
#define API_MSG_SWITCHED_GRAPH (GLFS_GFAPI_BASE + 41)
#define API_MSG_XDR_RESPONSE_DECODE_FAILED (GLFS_GFAPI_BASE + 42)
#define API_MSG_VOLFILE_INFO (GLFS_GFAPI_BASE + 43)
#define API_MSG_VOLFILE_CONNECTING (GLFS_GFAPI_BASE + 44)
#define API_MSG_NEW_GRAPH (GLFS_GFAPI_BASE + 45)
/*------------*/
#define glfs_msg_end_x GLFS_MSGID_END, "Invalid: End of messages"
#endif /* !_GFAPI_MESSAGES_H_ */

7
api/src/glfs-handleops.c
View File

@ -14,6 +14,7 @@
#include "syncop.h"
#include "glfs.h"
#include "glfs-handles.h"
#include "gfapi-messages.h"
int
glfs_listxattr_process (void *value, size_t size, dict_t *xattr);
@ -1161,7 +1162,8 @@ 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_log (subvol->name, GF_LOG_WARNING,
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));
goto out;
@ -1171,7 +1173,8 @@ pub_glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len,
if (newinode)
inode_lookup (newinode);
else {
gf_log (subvol->name, GF_LOG_WARNING,
gf_msg (subvol->name, GF_LOG_WARNING, EINVAL,
API_MSG_INVALID_ENTRY,
"inode linking of %s failed: %s",
uuid_utoa (loc.gfid), strerror (errno));
errno = EINVAL;

10
api/src/glfs-master.c
View File

@ -25,6 +25,7 @@
#include "glfs-internal.h"
#include "glfs-mem-types.h"
#include "gfapi-messages.h"
int
@ -88,7 +89,8 @@ notify (xlator_t *this, int event, void *data, ...)
switch (event) {
case GF_EVENT_GRAPH_NEW:
gf_log (this->name, GF_LOG_INFO, "New graph %s (%d) coming up",
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);
break;
@ -117,8 +119,7 @@ notify (xlator_t *this, int event, void *data, ...)
glfs_process_upcall_event (fs, data);
break;
default:
gf_log (this->name, GF_LOG_DEBUG,
"got notify event %d", event);
gf_msg_debug (this->name, 0, "got notify event %d", event);
break;
}
@ -136,7 +137,8 @@ mem_acct_init (xlator_t *this)
ret = xlator_mem_acct_init (this, glfs_mt_end + 1);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "Failed to initialise "
gf_msg (this->name, GF_LOG_ERROR, ENOMEM,
API_MSG_MEM_ACCT_INIT_FAILED, "Failed to initialise "
"memory accounting");
return ret;
}

129
api/src/glfs-mgmt.c
View File

@ -40,6 +40,7 @@
#include "glfs-internal.h"
#include "glfs-mem-types.h"
#include "gfapi-messages.h"
int glfs_volfile_fetch (struct glfs *fs);
int32_t glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
@ -56,13 +57,16 @@ glfs_process_volfp (struct glfs *fs, FILE *fp)
ctx = fs->ctx;
graph = glusterfs_graph_construct (fp);
if (!graph) {
gf_log ("glfs", GF_LOG_ERROR, "failed to construct the graph");
gf_msg ("glfs", GF_LOG_ERROR, errno,
API_MSG_GRAPH_CONSTRUCT_FAILED,
"failed to construct the graph");
goto out;
}
for (trav = graph->first; trav; trav = trav->next) {
if (strcmp (trav->type, "mount/fuse") == 0) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, EINVAL,
API_MSG_FUSE_XLATOR_ERROR,
"fuse xlator cannot be specified "
"in volume file");
goto out;
@ -183,7 +187,8 @@ mgmt_submit_request (void *req, call_frame_t *frame,
/* Create the xdr payload */
ret = xdr_serialize_generic (iov, req, xdrproc);
if (ret == -1) {
gf_log (THIS->name, GF_LOG_WARNING,
gf_msg (THIS->name, GF_LOG_WARNING, 0,
API_MSG_XDR_PAYLOAD_FAILED,
"failed to create XDR payload");
goto out;
}
@ -227,7 +232,8 @@ mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
args = frame->local;
if (!ctx) {
gf_log (frame->this->name, GF_LOG_ERROR, "NULL context");
gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY, "NULL context");
errno = EINVAL;
ret = -1;
goto out;
@ -236,7 +242,8 @@ mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
fs = ((xlator_t *)ctx->master)->private;
if (-1 == req->rpc_status) {
gf_log (frame->this->name, GF_LOG_ERROR,
gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY,
"GET_VOLUME_INFO RPC call is not successfull");
errno = EINVAL;
ret = -1;
@ -246,13 +253,14 @@ mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_get_volume_info_rsp);
if (ret < 0) {
gf_log (frame->this->name, GF_LOG_ERROR,
gf_msg (frame->this->name, GF_LOG_ERROR, 0,
API_MSG_XDR_RESPONSE_DECODE_FAILED,
"Failed to decode xdr response for GET_VOLUME_INFO");
goto out;
}
gf_log (frame->this->name, GF_LOG_DEBUG,
"Received resp to GET_VOLUME_INFO RPC: %d", rsp.op_ret);
gf_msg_debug (frame->this->name, 0, "Received resp to GET_VOLUME_INFO "
"RPC: %d", rsp.op_ret);
if (rsp.op_ret == -1) {
errno = rsp.op_errno;
@ -261,8 +269,9 @@ mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
}
if (!rsp.dict.dict_len) {
gf_log (frame->this->name, GF_LOG_ERROR,
"Response received for GET_VOLUME_INFO RPC call is not valid");
gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY, "Response received for "
"GET_VOLUME_INFO RPC call is not valid");
ret = -1;
errno = EINVAL;
goto out;
@ -295,17 +304,17 @@ mgmt_get_volinfo_cbk (struct rpc_req *req, struct iovec *iov,
ret = 0;
out:
if (volume_id_str) {
gf_log (frame->this->name, GF_LOG_DEBUG,
"Volume Id: %s", volume_id_str);
gf_msg_debug (frame->this->name, 0,
"Volume Id: %s", volume_id_str);
pthread_mutex_lock (&fs->mutex);
gf_uuid_parse (volume_id_str, fs->vol_uuid);
pthread_mutex_unlock (&fs->mutex);
}
if (ret) {
gf_log (frame->this->name, GF_LOG_ERROR,
"In GET_VOLUME_INFO cbk, received error: %s",
strerror(errno));
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));
}
if (dict)
@ -317,7 +326,7 @@ out:
if (rsp.op_errstr && *rsp.op_errstr)
free (rsp.op_errstr);
gf_log (frame->this->name, GF_LOG_DEBUG, "Returning: %d", ret);
gf_msg_debug (frame->this->name, 0, "Returning: %d", ret);
__wake (args);
@ -344,18 +353,21 @@ 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_log (THIS->name, GF_LOG_ERROR, "Unable to fetch volume UUID");
gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
API_MSG_FETCH_VOLUUID_FAILED, "Unable to fetch "
"volume UUID");
return -1;
}
done:
if (!volid || !size) {
gf_log (THIS->name, GF_LOG_DEBUG, "volumeid/size is null");
gf_msg_debug (THIS->name, 0, "volumeid/size is null");
return uuid_size;
}
if (size < uuid_size) {
gf_log (THIS->name, GF_LOG_ERROR, "Insufficient size passed");
gf_msg (THIS->name, GF_LOG_ERROR, ERANGE, API_MSG_INSUFF_SIZE,
"Insufficient size passed");
errno = ERANGE;
return -1;
}
@ -378,7 +390,9 @@ glfs_get_volume_info (struct glfs *fs)
ctx = fs->ctx;
frame = create_frame (THIS, ctx->pool);
if (!frame) {
gf_log ("glfs", GF_LOG_ERROR, "failed to create the frame");
gf_msg ("glfs", GF_LOG_ERROR, ENOMEM,
API_MSG_FRAME_CREAT_FAILED,
"failed to create the frame");
ret = -1;
goto out;
}
@ -433,7 +447,8 @@ glfs_get_volume_info_rpc (call_frame_t *frame, xlator_t *this,
flags = (int32_t)GF_GET_VOLUME_UUID; //ctx->flags;
ret = dict_set_int32 (dict, "flags", flags);
if (ret) {
gf_log (frame->this->name, GF_LOG_ERROR, "failed to set flags");
gf_msg (frame->this->name, GF_LOG_ERROR, ENOKEY,
API_MSG_DICT_SET_FAILED, "failed to set flags");
goto out;
}
@ -500,7 +515,8 @@ glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
ctx = frame->this->ctx;
if (!ctx) {
gf_log (frame->this->name, GF_LOG_ERROR, "NULL context");
gf_msg (frame->this->name, GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY, "NULL context");
errno = EINVAL;
ret = -1;
goto out;
@ -516,13 +532,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_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error");
gf_msg (frame->this->name, GF_LOG_ERROR, 0,
API_MSG_XDR_DECODE_FAILED, "XDR decoding error");
ret = -1;
goto out;
}
if (-1 == rsp.op_ret) {
gf_log (frame->this->name, GF_LOG_ERROR,
gf_msg (frame->this->name, GF_LOG_ERROR, rsp.op_errno,
API_MSG_GET_VOLFILE_FAILED,
"failed to get the 'volume file' from server");
ret = -1;
errno = rsp.op_errno;
@ -534,7 +552,8 @@ glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
if ((size == fs->oldvollen) &&
(memcmp (fs->oldvolfile, rsp.spec, size) == 0)) {
gf_log (frame->this->name, GF_LOG_INFO,
gf_msg (frame->this->name, GF_LOG_INFO, 0,
API_MSG_VOLFILE_INFO,
"No change in volfile, continuing");
goto out;
}
@ -563,15 +582,14 @@ glfs_mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count,
ret = glusterfs_volfile_reconfigure (fs->oldvollen, tmpfp, fs->ctx,
fs->oldvolfile);
if (ret == 0) {
gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG,
"No need to re-load volfile, reconfigure done");
gf_msg_debug ("glusterfsd-mgmt", 0, "No need to re-load "
"volfile, reconfigure done");
ret = glusterfs_oldvolfile_update (fs, rsp.spec, size);
goto out;
}
if (ret < 0) {
gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG,
"Reconfigure failed !!");
gf_msg_debug ("glusterfsd-mgmt", 0, "Reconfigure failed !!");
goto out;
}
@ -590,8 +608,9 @@ out:
// Stop if server is running at an unsupported op-version
if (ENOTSUP == ret) {
gf_log ("mgmt", GF_LOG_ERROR, "Server is operating at an "
"op-version which is not supported");
gf_msg ("mgmt", GF_LOG_ERROR, ENOTSUP, API_MSG_WRONG_OPVERSION,
"Server is operating at an op-version which is not "
"supported");
errno = ENOTSUP;
glfs_init_done (fs, -1);
}
@ -600,7 +619,8 @@ out:
/* Do it only for the first time */
/* Failed to get the volume file, something wrong,
restart the process */
gf_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY,
"failed to fetch volume file (key:%s)",
ctx->cmd_args.volfile_id);
if (!need_retry) {
@ -645,22 +665,25 @@ glfs_volfile_fetch (struct glfs *fs)
// decision
ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN);
if (ret) {
gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version"
" in request dict");
gf_msg (THIS->name, GF_LOG_ERROR, ENOKEY,
API_MSG_DICT_SET_FAILED,
"Failed to set min-op-version in request dict");
goto out;
}
ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX);
if (ret) {
gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version"
" in request dict");
gf_msg (THIS->name, GF_LOG_ERROR, ENOKEY,
API_MSG_DICT_SET_FAILED,
"Failed to set max-op-version in request dict");
goto out;
}
ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val,
&req.xdata.xdata_len);
if (ret < 0) {
gf_log (THIS->name, GF_LOG_ERROR,
gf_msg (THIS->name, GF_LOG_ERROR, 0,
API_MSG_DICT_SERIALIZE_FAILED,
"Failed to serialize dictionary");
goto out;
}
@ -696,15 +719,17 @@ mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
switch (event) {
case RPC_CLNT_DISCONNECT:
if (!ctx->active) {
gf_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, errno,
API_MSG_REMOTE_HOST_CONN_FAILED,
"failed to connect with remote-host: %s (%s)",
ctx->cmd_args.volfile_server,
strerror (errno));
server = ctx->cmd_args.curr_server;
if (server->list.next == &ctx->cmd_args.volfile_servers) {
errno = ENOTCONN;
gf_log("glfs-mgmt", GF_LOG_INFO,
"Exhausted all volfile servers");
gf_msg ("glfs-mgmt", GF_LOG_INFO, ENOTCONN,
API_MSG_VOLFILE_SERVER_EXHAUST,
"Exhausted all volfile servers");
glfs_init_done (fs, -1);
break;
}
@ -719,7 +744,8 @@ mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
"remote-port",
server->port);
if (ret != 0) {
gf_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
API_MSG_DICT_SET_FAILED,
"failed to set remote-port: %d",
server->port);
errno = ENOTCONN;
@ -731,7 +757,8 @@ mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
"remote-host",
server->volfile_server);
if (ret != 0) {
gf_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
API_MSG_DICT_SET_FAILED,
"failed to set remote-host: %s",
server->volfile_server);
errno = ENOTCONN;
@ -743,14 +770,16 @@ mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event,
"transport-type",
server->transport);
if (ret != 0) {
gf_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, ENOTCONN,
API_MSG_DICT_SET_FAILED,
"failed to set transport-type: %s",
server->transport);
errno = ENOTCONN;
glfs_init_done (fs, -1);
break;
}
gf_log ("glfs-mgmt", GF_LOG_INFO,
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,
@ -764,7 +793,8 @@ 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_log ("glfs-mgmt", GF_LOG_ERROR,
gf_msg ("glfs-mgmt", GF_LOG_ERROR, EINVAL,
API_MSG_INVALID_ENTRY,
"failed to fetch volume file (key:%s)",
ctx->cmd_args.volfile_id);
errno = EINVAL;
@ -829,21 +859,24 @@ glfs_mgmt_init (struct glfs *fs)
rpc = rpc_clnt_new (options, ctx, THIS->name, 8);
if (!rpc) {
ret = -1;
gf_log (THIS->name, GF_LOG_WARNING,
gf_msg (THIS->name, GF_LOG_WARNING, 0,
API_MSG_CREATE_RPC_CLIENT_FAILED,
"failed to create rpc clnt");
goto out;
}
ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS);
if (ret) {
gf_log (THIS->name, GF_LOG_WARNING,
gf_msg (THIS->name, GF_LOG_WARNING, 0,
API_MSG_REG_NOTIFY_FUNC_FAILED,
"failed to register notify function");
goto out;
}
ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS);
if (ret) {
gf_log (THIS->name, GF_LOG_WARNING,
gf_msg (THIS->name, GF_LOG_WARNING, 0,
API_MSG_REG_CBK_FUNC_FAILED,
"failed to register callback function");
goto out;
}

51
api/src/glfs-resolve.c
View File

@ -29,6 +29,7 @@
#include "common-utils.h"
#include "syncop.h"
#include "call-stub.h"
#include "gfapi-messages.h"
#include "glfs-internal.h"
@ -50,7 +51,7 @@ glfs_first_lookup_safe (xlator_t *subvol)
ret = syncop_lookup (subvol, &loc, 0, 0, 0, 0);
DECODE_SYNCOP_ERR (ret);
gf_log (subvol->name, GF_LOG_DEBUG, "first lookup complete %d", ret);
gf_msg_debug (subvol->name, 0, "first lookup complete %d", ret);
return ret;
}
@ -102,7 +103,8 @@ glfs_refresh_inode_safe (xlator_t *subvol, inode_t *oldinode)
DECODE_SYNCOP_ERR (ret);
if (ret) {
gf_log (subvol->name, GF_LOG_WARNING,
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));
loc_wipe (&loc);
@ -497,7 +499,8 @@ glfs_resolve_path (struct glfs *fs, xlator_t *subvol, const char *origpath,
cwd = glfs_cwd_get (fs);
if (NULL == cwd) {
gf_log (subvol->name, GF_LOG_WARNING, "Failed to get cwd");
gf_msg (subvol->name, GF_LOG_WARNING, EIO,
API_MSG_GET_CWD_FAILED, "Failed to get cwd");
errno = EIO;
goto out;
}
@ -553,7 +556,8 @@ glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
GF_XATTR_LOCKINFO_KEY, NULL, NULL);
DECODE_SYNCOP_ERR (ret);
if (ret < 0) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -562,7 +566,8 @@ glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
}
if (!dict_get (lockinfo, GF_XATTR_LOCKINFO_KEY)) {
gf_log (fs->volname, GF_LOG_WARNING,
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);
@ -572,7 +577,8 @@ glfs_migrate_fd_locks_safe (struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
ret = syncop_fsetxattr (newsubvol, newfd, lockinfo, 0, NULL, NULL);
DECODE_SYNCOP_ERR (ret);
if (ret < 0) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -608,9 +614,9 @@ glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
ret = syncop_fsync (oldsubvol, oldfd, 0, NULL, NULL);
DECODE_SYNCOP_ERR (ret);
if (ret) {
gf_log (fs->volname, GF_LOG_WARNING,
"fsync() failed (%s) on %s graph %s (%d)",
strerror (errno),
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);
}
@ -618,7 +624,8 @@ glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
newinode = glfs_refresh_inode_safe (newsubvol, oldinode);
if (!newinode) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -628,7 +635,8 @@ glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
newfd = fd_create (newinode, getpid());
if (!newfd) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -640,7 +648,8 @@ 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_log (fs->volname, GF_LOG_INFO, "inode_path failed");
gf_msg (fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
"inode_path failed");
goto out;
}
@ -657,7 +666,8 @@ glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
loc_wipe (&loc);
if (ret) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -670,7 +680,8 @@ glfs_migrate_fd_safe (struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
newfd);
if (ret) {
gf_log (fs->volname, GF_LOG_WARNING,
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),
@ -758,7 +769,8 @@ __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_log (fs->volname, GF_LOG_INFO,
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);
@ -789,7 +801,8 @@ __glfs_active_subvol (struct glfs *fs)
ret = __glfs_first_lookup (fs, new_subvol);
if (ret) {
gf_log (fs->volname, GF_LOG_INFO,
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));
@ -801,7 +814,8 @@ __glfs_active_subvol (struct glfs *fs)
if (!new_cwd) {
char buf1[64];
gf_log (fs->volname, GF_LOG_INFO,
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),
@ -824,7 +838,8 @@ __glfs_active_subvol (struct glfs *fs)
inode_unref (new_cwd);
}
gf_log (fs->volname, GF_LOG_INFO, "switched to graph %s (%d)",
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);
return new_subvol;

45
api/src/glfs.c
View File

@ -46,6 +46,7 @@
#include "common-utils.h"
#include "syncop.h"
#include "call-stub.h"
#include "gfapi-messages.h"
#include "glfs.h"
#include "glfs-internal.h"
@ -72,8 +73,9 @@ glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
ret = xlator_mem_acct_init (THIS, glfs_mt_end + 1);
if (ret != 0) {
gf_log (THIS->name, GF_LOG_ERROR,
"Memory accounting init failed");
gf_msg (THIS->name, GF_LOG_ERROR, ENOMEM,
API_MSG_MEM_ACCT_INIT_FAILED,
"Memory accounting init failed");
return ret;
}
@ -198,9 +200,9 @@ create_master (struct glfs *fs)
goto err;
if (xlator_set_type (master, "mount/api") == -1) {
gf_log ("glfs", GF_LOG_ERROR,
"master xlator for %s initialization failed",
fs->volname);
gf_msg ("glfs", GF_LOG_ERROR, 0,
API_MSG_MASTER_XLATOR_INIT_FAILED, "master xlator "
"for %s initialization failed", fs->volname);
goto err;
}
@ -213,7 +215,8 @@ create_master (struct glfs *fs)
ret = xlator_init (master);
if (ret) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, 0,
API_MSG_GFAPI_XLATOR_INIT_FAILED,
"failed to initialize gfapi translator");
goto err;
}
@ -241,15 +244,15 @@ get_volfp (struct glfs *fs)
cmd_args = &fs->ctx->cmd_args;
if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, errno,
API_MSG_VOLFILE_OPEN_FAILED,
"volume file %s open failed: %s",
cmd_args->volfile,
strerror (errno));
return NULL;
}
gf_log ("glfs", GF_LOG_DEBUG,
"loading volume file %s", cmd_args->volfile);
gf_msg_debug ("glfs", 0, "loading volume file %s", cmd_args->volfile);
return specfp;
}
@ -275,7 +278,8 @@ glfs_volumes_init (struct glfs *fs)
fp = get_volfp (fs);
if (!fp) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, ENOENT,
API_MSG_VOL_SPEC_FILE_ERROR,
"Cannot reach volume specification file");
ret = -1;
goto out;
@ -801,7 +805,7 @@ priv_glfs_init_done (struct glfs *fs, int ret)
glfs_init_cbk init_cbk;
if (!fs) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_GLFS_FSOBJ_NULL,
"fs is NULL");
goto out;
}
@ -857,7 +861,7 @@ glfs_init_async (struct glfs *fs, glfs_init_cbk cbk)
int ret = -1;
if (!fs || !fs->ctx) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
"fs is not properly initialized.");
errno = EINVAL;
return ret;
@ -877,7 +881,7 @@ pub_glfs_init (struct glfs *fs)
int ret = -1;
if (!fs || !fs->ctx) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, EINVAL, API_MSG_INVALID_ENTRY,
"fs is not properly initialized.");
errno = EINVAL;
return ret;
@ -1005,7 +1009,7 @@ pub_glfs_fini (struct glfs *fs)
{
/* Do we need to increase countdown? */
if ((!call_pool->cnt) && (!fs->pin_refcnt)) {
gf_log ("glfs", GF_LOG_TRACE,
gf_msg_trace ("glfs", 0,
"call_pool_cnt - %ld,"
"pin_refcnt - %d",
call_pool->cnt, fs->pin_refcnt);
@ -1049,7 +1053,8 @@ pub_glfs_fini (struct glfs *fs)
graph = subvol->graph;
err = pthread_mutex_lock (&fs->mutex);
if (err != 0) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, err,
API_MSG_FSMUTEX_LOCK_FAILED,
"pthread lock on glfs mutex, "
"returned error: (%s)", strerror (err));
goto fail;
@ -1060,7 +1065,8 @@ pub_glfs_fini (struct glfs *fs)
err = pthread_cond_wait (&fs->child_down_cond,
&fs->mutex);
if (err != 0)
gf_log ("glfs", GF_LOG_INFO,
gf_msg ("glfs", GF_LOG_INFO, err,
API_MSG_COND_WAIT_FAILED,
"%s cond wait failed %s",
subvol->name,
strerror (err));
@ -1069,7 +1075,8 @@ pub_glfs_fini (struct glfs *fs)
err = pthread_mutex_unlock (&fs->mutex);
if (err != 0) {
gf_log ("glfs", GF_LOG_ERROR,
gf_msg ("glfs", GF_LOG_ERROR, err,
API_MSG_FSMUTEX_UNLOCK_FAILED,
"pthread unlock on glfs mutex, "
"returned error: (%s)", strerror (err));
goto fail;
@ -1145,13 +1152,13 @@ pub_glfs_get_volfile (struct glfs *fs, void *buf, size_t len)
glfs_lock(fs);
if (len >= fs->oldvollen) {
gf_log ("glfs", GF_LOG_TRACE, "copying %zu to %p", len, buf);
gf_msg_trace ("glfs", 0, "copying %zu to %p", len, buf);
memcpy(buf,fs->oldvolfile,len);
res = len;
}
else {
res = len - fs->oldvollen;
gf_log ("glfs", GF_LOG_TRACE, "buffer is %zd too short", -res);
gf_msg_trace ("glfs", 0, "buffer is %zd too short", -res);
}
glfs_unlock(fs);