static int
glusterd_handle_post_validate_fn (rpcsvc_request_t *req)
{
int32_t ret = -1;
gd1_mgmt_v3_post_val_req op_req = {{0},};
xlator_t *this = NULL;
char *op_errstr = NULL;
dict_t *dict = NULL;
dict_t *rsp_dict = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &op_req,
(xdrproc_t)xdr_gd1_mgmt_v3_post_val_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to decode post validation "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
if (glusterd_peerinfo_find_by_uuid (op_req.uuid) == NULL) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (op_req.uuid));
ret = -1;
goto out;
}
dict = dict_new ();
if (!dict)
goto out;
ret = dict_unserialize (op_req.dict.dict_val,
op_req.dict.dict_len, &dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
rsp_dict = dict_new ();
if (!rsp_dict) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to get new dictionary");
return -1;
}
ret = gd_mgmt_v3_post_validate_fn (op_req.op, op_req.op_ret, dict,
&op_errstr, rsp_dict);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Post Validation failed on operation %s",
gd_op_list[op_req.op]);
}
ret = glusterd_mgmt_v3_post_validate_send_resp (req, op_req.op,
ret, op_errstr,
rsp_dict);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to send Post Validation "
"response for operation %s",
gd_op_list[op_req.op]);
goto out;
}
out:
if (op_errstr && (strcmp (op_errstr, "")))
GF_FREE (op_errstr);
free (op_req.dict.dict_val);
if (dict)
dict_unref (dict);
if (rsp_dict)
dict_unref (rsp_dict);
/* Return 0 from handler to avoid double deletion of req obj */
return 0;
}
static int
glusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req)
{
gd1_mgmt_v3_unlock_req lock_req = {{0},};
int32_t ret = -1;
glusterd_op_lock_ctx_t *ctx = NULL;
xlator_t *this = NULL;
gf_boolean_t is_synctasked = _gf_false;
gf_boolean_t free_ctx = _gf_false;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &lock_req,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR, "Failed to decode unlock "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
gf_log (this->name, GF_LOG_DEBUG, "Received volume unlock req "
"from uuid: %s", uuid_utoa (lock_req.uuid));
if (glusterd_peerinfo_find_by_uuid (lock_req.uuid) == NULL) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (lock_req.uuid));
ret = -1;
goto out;
}
ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);
if (!ctx) {
ret = -1;
goto out;
}
gf_uuid_copy (ctx->uuid, lock_req.uuid);
ctx->req = req;
ctx->dict = dict_new ();
if (!ctx->dict) {
ret = -1;
goto out;
}
ret = dict_unserialize (lock_req.dict.dict_val,
lock_req.dict.dict_len, &ctx->dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
is_synctasked = dict_get_str_boolean (ctx->dict,
"is_synctasked", _gf_false);
if (is_synctasked) {
ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to release mgmt_v3_locks");
/* Ignore the return code, as it shouldn't be propagated
* from the handler function so as to avoid double
* deletion of the req
*/
ret = 0;
}
/* The above function does not take ownership of ctx.
* Therefore we need to free the ctx explicitly. */
free_ctx = _gf_true;
}
else {
/* Shouldn't ignore the return code here, and it should
* be propagated from the handler function as in failure
* case it doesn't delete the req object
*/
ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,
ctx);
if (ret)
gf_log (this->name, GF_LOG_ERROR,
"Failed to release mgmt_v3_locks");
}
out:
if (ctx && (ret || free_ctx)) {
if (ctx->dict)
dict_unref (ctx->dict);
GF_FREE (ctx);
}
free (lock_req.dict.dict_val);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
static int
glusterd_handle_brick_op_fn (rpcsvc_request_t *req)
{
int32_t ret = -1;
gd1_mgmt_v3_brick_op_req op_req = {{0},};
xlator_t *this = NULL;
char *op_errstr = NULL;
dict_t *dict = NULL;
dict_t *rsp_dict = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &op_req,
(xdrproc_t)xdr_gd1_mgmt_v3_brick_op_req);
if (ret < 0) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_REQ_DECODE_FAIL, "Failed to decode brick op "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
if (glusterd_peerinfo_find_by_uuid (op_req.uuid) == NULL) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_PEER_NOT_FOUND, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (op_req.uuid));
ret = -1;
goto out;
}
dict = dict_new ();
if (!dict)
goto out;
ret = dict_unserialize (op_req.dict.dict_val,
op_req.dict.dict_len, &dict);
if (ret) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_DICT_UNSERIALIZE_FAIL,
"failed to unserialize the dictionary");
goto out;
}
rsp_dict = dict_new ();
if (!rsp_dict) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_DICT_CREATE_FAIL,
"Failed to get new dictionary");
return -1;
}
ret = gd_mgmt_v3_brick_op_fn (op_req.op, dict, &op_errstr,
rsp_dict);
if (ret) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_BRICK_OP_FAIL,
"Brick Op failed on operation %s",
gd_op_list[op_req.op]);
}
ret = glusterd_mgmt_v3_brick_op_send_resp (req, op_req.op,
ret, op_errstr,
rsp_dict);
if (ret) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_PRE_VALD_RESP_FAIL,
"Failed to send brick op "
"response for operation %s",
gd_op_list[op_req.op]);
goto out;
}
out:
if (op_errstr && (strcmp (op_errstr, "")))
GF_FREE (op_errstr);
free (op_req.dict.dict_val);
if (dict)
dict_unref (dict);
if (rsp_dict)
dict_unref (rsp_dict);
/* Return 0 from handler to avoid double deletion of req obj */
return 0;
}