blob: 4c3dc9c16aab4ab59d7551fc41431e418587540c [file] [log] [blame]
/*
* Copyright (c) 2021 Nutanix Inc. All rights reserved.
*
* Authors: Thanos Makatos <thanos@nutanix.com>
* Swapnil Ingle <swapnil.ingle@nutanix.com>
* Felipe Franciosi <felipe@nutanix.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Nutanix nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*/
#include <sys/param.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "tran_pipe.h"
typedef struct {
int in_fd;
int out_fd;
} tran_pipe_t;
static int
tran_pipe_send_iovec(int fd, uint16_t msg_id, bool is_reply,
enum vfio_user_command cmd,
struct iovec *iovecs, size_t nr_iovecs, int err)
{
struct vfio_user_header hdr = { .msg_id = msg_id };
ssize_t ret;
if (nr_iovecs == 0) {
iovecs = alloca(sizeof(*iovecs));
nr_iovecs = 1;
}
if (is_reply) {
hdr.flags |= VFIO_USER_F_TYPE_REPLY;
hdr.cmd = cmd;
if (err != 0) {
hdr.flags |= VFIO_USER_F_ERROR;
hdr.error_no = err;
}
} else {
hdr.cmd = cmd;
hdr.flags |= VFIO_USER_F_TYPE_COMMAND;
}
iovecs[0].iov_base = &hdr;
iovecs[0].iov_len = sizeof(hdr);
ret = writev(fd, iovecs, nr_iovecs);
/* Quieten static analysis. */
iovecs[0].iov_base = NULL;
iovecs[0].iov_len = 0;
if (ret == -1) {
/* Treat a failed write due to EPIPE the same as a short write. */
if (errno == EPIPE) {
return ERROR_INT(ECONNRESET);
}
return -1;
} else if (ret < (ssize_t)hdr.msg_size) {
return ERROR_INT(ECONNRESET);
}
return 0;
}
static int
tran_pipe_get_msg(void *data, size_t len, int fd)
{
ssize_t ret;
ret = read(fd, data, len);
if (ret == -1) {
return -1;
} else if (ret == 0) {
return ERROR_INT(ENOMSG);
} else if ((size_t)ret < len) {
return ERROR_INT(ECONNRESET);
}
return ret;
}
/*
* Receive a vfio-user message. If "len" is set to non-zero, the message should
* include data of that length, which is stored in the pre-allocated "data"
* pointer.
*/
static int
tran_pipe_recv(int fd, struct vfio_user_header *hdr, bool is_reply,
uint16_t *msg_id, void *data, size_t *len)
{
int ret;
/* FIXME if ret == -1 then fcntl can overwrite recv's errno */
ret = tran_pipe_get_msg(hdr, sizeof(*hdr), fd);
if (ret < 0) {
return ret;
}
if (is_reply) {
if (msg_id != NULL && hdr->msg_id != *msg_id) {
return ERROR_INT(EPROTO);
}
if ((hdr->flags & VFIO_USER_F_TYPE_MASK) != VFIO_USER_F_TYPE_REPLY) {
return ERROR_INT(EINVAL);
}
if (hdr->flags & VFIO_USER_F_ERROR) {
if (hdr->error_no <= 0) {
hdr->error_no = EINVAL;
}
return ERROR_INT(hdr->error_no);
}
} else {
if ((hdr->flags & VFIO_USER_F_TYPE_MASK) != VFIO_USER_F_TYPE_COMMAND) {
return ERROR_INT(EINVAL);
}
if (msg_id != NULL) {
*msg_id = hdr->msg_id;
}
}
if (hdr->msg_size < sizeof(*hdr) || hdr->msg_size > SERVER_MAX_MSG_SIZE) {
return ERROR_INT(EINVAL);
}
if (len != NULL && *len > 0 && hdr->msg_size > sizeof(*hdr)) {
ret = read(fd, data, MIN(hdr->msg_size - sizeof(*hdr), *len));
if (ret < 0) {
return -1;
} else if (ret == 0) {
return ERROR_INT(ENOMSG);
} else if (*len != (size_t)ret) {
return ERROR_INT(ECONNRESET);
}
*len = ret;
}
return 0;
}
/*
* Like tran_pipe_recv(), but will automatically allocate reply data.
*/
static int
tran_pipe_recv_alloc(int fd, struct vfio_user_header *hdr, bool is_reply,
uint16_t *msg_id, void **datap, size_t *lenp)
{
void *data;
size_t len;
int ret;
ret = tran_pipe_recv(fd, hdr, is_reply, msg_id, NULL, NULL);
if (ret != 0) {
return ret;
}
assert(hdr->msg_size >= sizeof(*hdr));
assert(hdr->msg_size <= SERVER_MAX_MSG_SIZE);
len = hdr->msg_size - sizeof(*hdr);
if (len == 0) {
*datap = NULL;
*lenp = 0;
return 0;
}
data = calloc(1, len);
if (data == NULL) {
return -1;
}
ret = read(fd, data, len);
if (ret < 0) {
ret = errno;
free(data);
return ERROR_INT(ret);
} else if (ret == 0) {
free(data);
return ERROR_INT(ENOMSG);
} else if (len != (size_t)ret) {
free(data);
return ERROR_INT(ECONNRESET);
}
*datap = data;
*lenp = len;
return 0;
}
/*
* FIXME: all these send/recv handlers need to be made robust against async
* messages.
*/
static int
tran_pipe_msg_iovec(tran_pipe_t *tp, uint16_t msg_id,
enum vfio_user_command cmd,
struct iovec *iovecs, size_t nr_iovecs,
struct vfio_user_header *hdr,
void *recv_data, size_t recv_len)
{
int ret = tran_pipe_send_iovec(tp->out_fd, msg_id, false, cmd, iovecs,
nr_iovecs, 0);
if (ret < 0) {
return ret;
}
if (hdr == NULL) {
hdr = alloca(sizeof(*hdr));
}
return tran_pipe_recv(tp->in_fd, hdr, true, &msg_id, recv_data, &recv_len);
}
static int
tran_pipe_init(vfu_ctx_t *vfu_ctx)
{
tran_pipe_t *tp = NULL;
assert(vfu_ctx != NULL);
tp = calloc(1, sizeof(tran_pipe_t));
if (tp == NULL) {
return -1;
}
tp->in_fd = -1;
tp->out_fd = -1;
vfu_ctx->tran_data = tp;
return 0;
}
static int
tran_pipe_get_poll_fd(vfu_ctx_t *vfu_ctx)
{
tran_pipe_t *tp = vfu_ctx->tran_data;
return tp->in_fd;
}
static int
tran_pipe_attach(vfu_ctx_t *vfu_ctx)
{
tran_pipe_t *tp;
int ret;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
tp = vfu_ctx->tran_data;
tp->in_fd = STDIN_FILENO;
tp->out_fd = STDOUT_FILENO;
ret = tran_negotiate(vfu_ctx, NULL);
if (ret < 0) {
ret = errno;
tp->in_fd = -1;
tp->out_fd = -1;
return ERROR_INT(ret);
}
return 0;
}
static int
tran_pipe_get_request_header(vfu_ctx_t *vfu_ctx, struct vfio_user_header *hdr,
int *fds UNUSED, size_t *nr_fds)
{
tran_pipe_t *tp;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
tp = vfu_ctx->tran_data;
*nr_fds = 0;
return tran_pipe_get_msg(hdr, sizeof(*hdr), tp->in_fd);
}
static int
tran_pipe_recv_body(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)
{
tran_pipe_t *tp;
int ret;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
assert(msg != NULL);
tp = vfu_ctx->tran_data;
assert(msg->in.iov.iov_len <= SERVER_MAX_MSG_SIZE);
msg->in.iov.iov_base = malloc(msg->in.iov.iov_len);
if (msg->in.iov.iov_base == NULL) {
return -1;
}
ret = read(tp->in_fd, msg->in.iov.iov_base, msg->in.iov.iov_len);
if (ret < 0) {
ret = errno;
free(msg->in.iov.iov_base);
msg->in.iov.iov_base = NULL;
return ERROR_INT(ret);
} else if (ret == 0) {
free(msg->in.iov.iov_base);
msg->in.iov.iov_base = NULL;
return ERROR_INT(ENOMSG);
} else if (ret != (int)msg->in.iov.iov_len) {
vfu_log(vfu_ctx, LOG_ERR, "msg%#hx: short read: expected=%zu, actual=%d",
msg->hdr.msg_id, msg->in.iov.iov_len, ret);
free(msg->in.iov.iov_base);
msg->in.iov.iov_base = NULL;
return ERROR_INT(EINVAL);
}
return 0;
}
static int
tran_pipe_recv_msg(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)
{
tran_pipe_t *tp;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
assert(msg != NULL);
tp = vfu_ctx->tran_data;
if (tp->in_fd == -1) {
vfu_log(vfu_ctx, LOG_ERR, "%s: not connected", __func__);
return ERROR_INT(ENOTCONN);
}
return tran_pipe_recv_alloc(tp->in_fd, &msg->hdr, false, NULL,
&msg->in.iov.iov_base, &msg->in.iov.iov_len);
}
static int
tran_pipe_reply(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg, int err)
{
struct iovec *iovecs;
size_t nr_iovecs;
tran_pipe_t *tp;
int ret;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
assert(msg != NULL);
tp = vfu_ctx->tran_data;
/* First iovec entry is for msg header. */
nr_iovecs = (msg->nr_out_iovecs != 0) ? (msg->nr_out_iovecs + 1) : 2;
iovecs = calloc(nr_iovecs, sizeof(*iovecs));
if (iovecs == NULL) {
return -1;
}
if (msg->out_iovecs != NULL) {
memcpy(iovecs + 1, msg->out_iovecs,
msg->nr_out_iovecs * sizeof(*iovecs));
} else {
iovecs[1].iov_base = msg->out.iov.iov_base;
iovecs[1].iov_len = msg->out.iov.iov_len;
}
ret = tran_pipe_send_iovec(tp->out_fd, msg->hdr.msg_id, true, msg->hdr.cmd,
iovecs, nr_iovecs, err);
free(iovecs);
return ret;
}
static int
tran_pipe_send_msg(vfu_ctx_t *vfu_ctx, uint16_t msg_id,
enum vfio_user_command cmd,
void *send_data, size_t send_len,
struct vfio_user_header *hdr,
void *recv_data, size_t recv_len)
{
/* [0] is for the header. */
struct iovec iovecs[2] = {
[1] = {
.iov_base = send_data,
.iov_len = send_len
}
};
tran_pipe_t *tp;
assert(vfu_ctx != NULL);
assert(vfu_ctx->tran_data != NULL);
tp = vfu_ctx->tran_data;
return tran_pipe_msg_iovec(tp, msg_id, cmd, iovecs, ARRAY_SIZE(iovecs),
hdr, recv_data, recv_len);
}
static void
tran_pipe_detach(vfu_ctx_t *vfu_ctx)
{
assert(vfu_ctx != NULL);
}
static void
tran_pipe_fini(vfu_ctx_t *vfu_ctx)
{
assert(vfu_ctx != NULL);
free(vfu_ctx->tran_data);
vfu_ctx->tran_data = NULL;
}
struct transport_ops tran_pipe_ops = {
.init = tran_pipe_init,
.get_poll_fd = tran_pipe_get_poll_fd,
.attach = tran_pipe_attach,
.get_request_header = tran_pipe_get_request_header,
.recv_body = tran_pipe_recv_body,
.reply = tran_pipe_reply,
.recv_msg = tran_pipe_recv_msg,
.send_msg = tran_pipe_send_msg,
.detach = tran_pipe_detach,
.fini = tran_pipe_fini
};
/* ex: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: */