int
acl3svc_submit_reply (rpcsvc_request_t *req, void *arg, acl3_serializer sfunc)
{
struct iovec outmsg = {0, };
struct iobuf *iob = NULL;
struct nfs3_state *nfs3 = NULL;
int ret = -1;
struct iobref *iobref = NULL;
if (!req)
return -1;
nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req);
if (!nfs3) {
gf_log (GF_ACL, GF_LOG_ERROR, "mount state not found");
goto ret;
}
/* First, get the io buffer into which the reply in arg will
* be serialized.
*/
iob = iobuf_get (nfs3->iobpool);
if (!iob) {
gf_log (GF_ACL, GF_LOG_ERROR, "Failed to get iobuf");
goto ret;
}
iobuf_to_iovec (iob, &outmsg);
/* Use the given serializer to translate the give C structure in arg
* to XDR format which will be written into the buffer in outmsg.
*/
outmsg.iov_len = sfunc (outmsg, arg);
iobref = iobref_new ();
if (iobref == NULL) {
gf_log (GF_ACL, GF_LOG_ERROR, "Failed to get iobref");
goto ret;
}
iobref_add (iobref, iob);
/* Then, submit the message for transmission. */
ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref);
if (ret == -1) {
gf_log (GF_ACL, GF_LOG_ERROR, "Reply submission failed");
goto ret;
}
ret = 0;
ret:
if (iob)
iobuf_unref (iob);
if (iobref)
iobref_unref (iobref);
return ret;
}
int
quotad_aggregator_submit_reply (call_frame_t *frame, rpcsvc_request_t *req,
void *arg, struct iovec *payload,
int payloadcount, struct iobref *iobref,
xdrproc_t xdrproc)
{
struct iobuf *iob = NULL;
int ret = -1;
struct iovec rsp = {0,};
quotad_aggregator_state_t *state = NULL;
char new_iobref = 0;
GF_VALIDATE_OR_GOTO ("server", req, ret);
if (frame) {
state = frame->root->state;
frame->local = NULL;
}
if (!iobref) {
iobref = iobref_new ();
if (!iobref) {
goto ret;
}
new_iobref = 1;
}
iob = quotad_serialize_reply (req, arg, &rsp, xdrproc);
if (!iob) {
gf_msg ("", GF_LOG_ERROR, 0, Q_MSG_DICT_SERIALIZE_FAIL,
"Failed to serialize reply");
goto ret;
}
iobref_add (iobref, iob);
ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount,
iobref);
iobuf_unref (iob);
ret = 0;
ret:
if (state) {
quotad_aggregator_free_state (state);
}
if (frame)
STACK_DESTROY (frame->root);
if (new_iobref) {
iobref_unref (iobref);
}
return ret;
}
void ida_buffer_unassign(ida_buffer_t * dst)
{
if (dst->vectors != NULL)
{
GF_FREE(dst->vectors);
dst->vectors = NULL;
}
if (dst->buffers != NULL)
{
iobref_unref(dst->buffers);
dst->buffers = NULL;
}
}
int32_t ida_buffer_assign(ida_local_t * local, ida_buffer_t * dst, struct iobref * buffers, struct iovec * vectors, uint32_t count)
{
char * ptr;
int32_t i, error;
if (unlikely(count > 1))
{
error = ida_buffer_new(local, dst, iov_length(vectors, count));
if (unlikely(error != 0))
{
return error;
}
ptr = dst->vectors->iov_base;
for (i = 0; i < count; i++)
{
memcpy(ptr, vectors[i].iov_base, vectors[i].iov_len);
ptr += vectors[i].iov_len;
}
}
else
{
SYS_PTR(
&dst->buffers, iobref_ref, (buffers),
ENOMEM,
E(),
RETERR()
);
SYS_PTR(
&dst->vectors, iov_dup, (vectors, count),
ENOMEM,
E(),
GOTO(failed)
);
}
dst->count = 1;
return 0;
failed:
iobref_unref(dst->buffers);
dst->buffers = NULL;
return -ENOMEM;
}
int32_t ida_buffer_new(ida_local_t * local, ida_buffer_t * dst, uint32_t size)
{
struct iobuf * buffer;
dst->buffers = iobref_new();
if (unlikely(dst->buffers == NULL))
{
goto failed;
}
buffer = iobuf_get(local->xl->ctx->iobuf_pool);
if (unlikely(buffer == NULL))
{
goto failed_iobref;
}
if (unlikely(iobuf_pagesize(buffer) < size))
{
gf_log(local->xl->name, GF_LOG_ERROR, "Insufficient space in buffer");
goto failed_buffer;
}
if (iobref_add(dst->buffers, buffer) != 0)
{
goto failed_buffer;
}
dst->vectors = IDA_ALLOC_OR_GOTO(local->xl->name, sizeof(struct iovec), gf_common_mt_iovec, failed_buffer);
dst->vectors->iov_base = buffer->ptr;
dst->vectors->iov_len = size;
dst->count = 1;
iobuf_unref(buffer);
return 0;
failed_buffer:
iobuf_unref(buffer);
failed_iobref:
iobref_unref(dst->buffers);
dst->buffers = NULL;
failed:
return ENOMEM;
}
int
acl3svc_submit_reply (rpcsvc_request_t *req, void *arg, acl3_serializer sfunc)
{
struct iovec outmsg = {0, };
struct iobuf *iob = NULL;
struct nfs3_state *nfs3 = NULL;
int ret = -1;
ssize_t msglen = 0;
struct iobref *iobref = NULL;
if (!req)
return -1;
nfs3 = (struct nfs3_state *)rpcsvc_request_program_private (req);
if (!nfs3) {
gf_msg (GF_ACL, GF_LOG_ERROR, EINVAL,
NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found");
goto ret;
}
/* First, get the io buffer into which the reply in arg will
* be serialized.
*/
iob = iobuf_get (nfs3->iobpool);
if (!iob) {
gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
"Failed to get iobuf");
goto ret;
}
iobuf_to_iovec (iob, &outmsg);
/* Use the given serializer to translate the give C structure in arg
* to XDR format which will be written into the buffer in outmsg.
*/
msglen = sfunc (outmsg, arg);
if (msglen < 0) {
gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_ENCODE_MSG_FAIL,
"Failed to encode message");
goto ret;
}
outmsg.iov_len = msglen;
iobref = iobref_new ();
if (iobref == NULL) {
gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
"Failed to get iobref");
goto ret;
}
ret = iobref_add (iobref, iob);
if (ret) {
gf_msg (GF_ACL, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY,
"Failed to add iob to iobref");
goto ret;
}
/* Then, submit the message for transmission. */
ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref);
if (ret == -1) {
gf_msg (GF_ACL, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL,
"Reply submission failed");
goto ret;
}
ret = 0;
ret:
if (iob)
iobuf_unref (iob);
if (iobref)
iobref_unref (iobref);
return ret;
}
int
rpc_clnt_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brickname)
{
int ret = 0;
pmap_signout_req req = {0, };
call_frame_t *frame = NULL;
cmd_args_t *cmd_args = NULL;
char brick_name[PATH_MAX] = {0,};
struct iovec iov = {0, };
struct iobuf *iobuf = NULL;
struct iobref *iobref = NULL;
ssize_t xdr_size = 0;
frame = create_frame (THIS, ctx->pool);
cmd_args = &ctx->cmd_args;
if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) {
gf_log ("fsd-mgmt", GF_LOG_DEBUG,
"portmapper signout arguments not given");
goto out;
}
if (cmd_args->volfile_server_transport &&
!strcmp(cmd_args->volfile_server_transport, "rdma")) {
snprintf (brick_name, sizeof(brick_name), "%s.rdma",
cmd_args->brick_name);
req.brick = brick_name;
} else {
if (brickname)
req.brick = brickname;
else
req.brick = cmd_args->brick_name;
}
req.port = cmd_args->brick_port;
req.rdma_port = cmd_args->brick_port2;
/* mgmt_submit_request is not available in libglusterfs.
* Need to serialize and submit manually.
*/
iobref = iobref_new ();
if (!iobref) {
goto out;
}
xdr_size = xdr_sizeof ((xdrproc_t)xdr_pmap_signout_req, &req);
iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size);
if (!iobuf) {
goto out;
};
iobref_add (iobref, iobuf);
iov.iov_base = iobuf->ptr;
iov.iov_len = iobuf_pagesize (iobuf);
/* Create the xdr payload */
ret = xdr_serialize_generic (iov, &req,
(xdrproc_t)xdr_pmap_signout_req);
if (ret == -1) {
gf_log (THIS->name, GF_LOG_WARNING,
"failed to create XDR payload");
goto out;
}
iov.iov_len = ret;
ret = rpc_clnt_submit (ctx->mgmt, &clnt_pmap_signout_prog,
GF_PMAP_SIGNOUT, mgmt_pmap_signout_cbk,
&iov, 1,
NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL);
out:
if (iobref)
iobref_unref (iobref);
if (iobuf)
iobuf_unref (iobuf);
return ret;
}
int
bd_aio_readv_complete (struct bd_aio_cb *paiocb, int res, int res2)
{
call_frame_t *frame = NULL;
xlator_t *this = NULL;
struct iobuf *iobuf = NULL;
struct iatt postbuf = {0,};
int op_ret = -1;
int op_errno = 0;
struct iovec iov;
struct iobref *iobref = NULL;
off_t offset = 0;
bd_attr_t *bdatt = NULL;
frame = paiocb->frame;
this = frame->this;
iobuf = paiocb->iobuf;
offset = paiocb->offset;
if (res < 0) {
op_ret = -1;
op_errno = -res;
gf_log (this->name, GF_LOG_ERROR,
"readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)",
paiocb->fd, paiocb->iocb.u.c.nbytes,
(unsigned long long) paiocb->offset,
res, strerror (op_errno));
goto out;
}
bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt);
memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt));
op_ret = res;
op_errno = 0;
iobref = iobref_new ();
if (!iobref) {
op_ret = -1;
op_errno = ENOMEM;
goto out;
}
iobref_add (iobref, iobuf);
iov.iov_base = iobuf_ptr (iobuf);
iov.iov_len = op_ret;
/* Hack to notify higher layers of EOF. */
if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size)
op_errno = ENOENT;
out:
STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &iov, 1,
&postbuf, iobref, NULL);
if (iobuf)
iobuf_unref (iobuf);
if (iobref)
iobref_unref (iobref);
GF_FREE (paiocb);
return 0;
}
