int32_t ida_buffer_add_buffer(ida_local_t * local, ida_buffer_t * buffers, uint32_t size) { struct iobuf * buffer; buffer = iobuf_get(local->xl->ctx->iobuf_pool); if (unlikely(buffer == NULL)) { goto failed; } if (unlikely(iobuf_pagesize(buffer) < size)) { gf_log(local->xl->name, GF_LOG_ERROR, "Insufficient space in buffer"); goto failed_buffer; } if (iobref_add(buffers->buffers, buffer) != 0) { goto failed_buffer; } return 0; failed_buffer: iobuf_unref(buffer); 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; 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; }
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; }