david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

io: add new qio_channel_{readv, writev, read, write}_all functions

Browse Source 
These functions wait until they are able to read / write the full
requested data buffer(s).

Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2017-08-30 14:53:59 +01:00
parent 50ea44f077
commit d4622e5588
3 changed files with 193 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
include/io/channel.h
View File

@ -268,6 +268,58 @@ ssize_t qio_channel_writev_full(QIOChannel *ioc,
size_t nfds,
Error **errp);
/**
* qio_channel_readv_all:
* @ioc: the channel object
* @iov: the array of memory regions to read data into
* @niov: the length of the @iov array
* @errp: pointer to a NULL-initialized error object
*
* Read data from the IO channel, storing it in the
* memory regions referenced by @iov. Each element
* in the @iov will be fully populated with data
* before the next one is used. The @niov parameter
* specifies the total number of elements in @iov.
*
* The function will wait for all requested data
* to be read, yielding from the current coroutine
* if required.
*
* If end-of-file occurs before all requested data
* has been read, an error will be reported.
*
* Returns: 0 if all bytes were read, or -1 on error
*/
int qio_channel_readv_all(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
Error **errp);
/**
* qio_channel_writev_all:
* @ioc: the channel object
* @iov: the array of memory regions to write data from
* @niov: the length of the @iov array
* @errp: pointer to a NULL-initialized error object
*
* Write data to the IO channel, reading it from the
* memory regions referenced by @iov. Each element
* in the @iov will be fully sent, before the next
* one is used. The @niov parameter specifies the
* total number of elements in @iov.
*
* The function will wait for all requested data
* to be written, yielding from the current coroutine
* if required.
*
* Returns: 0 if all bytes were written, or -1 on error
*/
int qio_channel_writev_all(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
Error **erp);
/**
* qio_channel_readv:
* @ioc: the channel object
@ -330,6 +382,44 @@ ssize_t qio_channel_write(QIOChannel *ioc,
size_t buflen,
Error **errp);
/**
* qio_channel_read_all:
* @ioc: the channel object
* @buf: the memory region to read data into
* @buflen: the number of bytes to @buf
* @errp: pointer to a NULL-initialized error object
*
* Reads @buflen bytes into @buf, possibly blocking or (if the
* channel is non-blocking) yielding from the current coroutine
* multiple times until the entire content is read. If end-of-file
* occurs it will return an error rather than a short-read. Otherwise
* behaves as qio_channel_read().
*
* Returns: 0 if all bytes were read, or -1 on error
*/
int qio_channel_read_all(QIOChannel *ioc,
char *buf,
size_t buflen,
Error **errp);
/**
* qio_channel_write_all:
* @ioc: the channel object
* @buf: the memory region to write data into
* @buflen: the number of bytes to @buf
* @errp: pointer to a NULL-initialized error object
*
* Writes @buflen bytes from @buf, possibly blocking or (if the
* channel is non-blocking) yielding from the current coroutine
* multiple times until the entire content is written. Otherwise
* behaves as qio_channel_write().
*
* Returns: 0 if all bytes were written, or -1 on error
*/
int qio_channel_write_all(QIOChannel *ioc,
const char *buf,
size_t buflen,
Error **errp);
/**
* qio_channel_set_blocking:
* @ioc: the channel object

94
io/channel.c
View File

@ -22,6 +22,7 @@
#include "io/channel.h"
#include "qapi/error.h"
#include "qemu/main-loop.h"
#include "qemu/iov.h"
bool qio_channel_has_feature(QIOChannel *ioc,
QIOChannelFeature feature)
@ -85,6 +86,79 @@ ssize_t qio_channel_writev_full(QIOChannel *ioc,
}
int qio_channel_readv_all(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
Error **errp)
{
int ret = -1;
struct iovec *local_iov = g_new(struct iovec, niov);
struct iovec *local_iov_head = local_iov;
unsigned int nlocal_iov = niov;
nlocal_iov = iov_copy(local_iov, nlocal_iov,
iov, niov,
0, iov_size(iov, niov));
while (nlocal_iov > 0) {
ssize_t len;
len = qio_channel_readv(ioc, local_iov, nlocal_iov, errp);
if (len == QIO_CHANNEL_ERR_BLOCK) {
qio_channel_wait(ioc, G_IO_IN);
continue;
} else if (len < 0) {
goto cleanup;
} else if (len == 0) {
error_setg(errp,
"Unexpected end-of-file before all bytes were read");
goto cleanup;
}
iov_discard_front(&local_iov, &nlocal_iov, len);
}
ret = 0;
cleanup:
g_free(local_iov_head);
return ret;
}
int qio_channel_writev_all(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
Error **errp)
{
int ret = -1;
struct iovec *local_iov = g_new(struct iovec, niov);
struct iovec *local_iov_head = local_iov;
unsigned int nlocal_iov = niov;
nlocal_iov = iov_copy(local_iov, nlocal_iov,
iov, niov,
0, iov_size(iov, niov));
while (nlocal_iov > 0) {
ssize_t len;
len = qio_channel_writev(ioc, local_iov, nlocal_iov, errp);
if (len == QIO_CHANNEL_ERR_BLOCK) {
qio_channel_wait(ioc, G_IO_OUT);
continue;
}
if (len < 0) {
goto cleanup;
}
iov_discard_front(&local_iov, &nlocal_iov, len);
}
ret = 0;
cleanup:
g_free(local_iov_head);
return ret;
}
ssize_t qio_channel_readv(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
@ -123,6 +197,26 @@ ssize_t qio_channel_write(QIOChannel *ioc,
}
int qio_channel_read_all(QIOChannel *ioc,
char *buf,
size_t buflen,
Error **errp)
{
struct iovec iov = { .iov_base = buf, .iov_len = buflen };
return qio_channel_readv_all(ioc, &iov, 1, errp);
}
int qio_channel_write_all(QIOChannel *ioc,
const char *buf,
size_t buflen,
Error **errp)
{
struct iovec iov = { .iov_base = (char *)buf, .iov_len = buflen };
return qio_channel_writev_all(ioc, &iov, 1, errp);
}
int qio_channel_set_blocking(QIOChannel *ioc,
bool enabled,
Error **errp)

102
tests/io-channel-helpers.c
View File

@ -21,6 +21,7 @@
#include "qemu/osdep.h"
#include "io-channel-helpers.h"
#include "qapi/error.h"
#include "qemu/iov.h"
struct QIOChannelTest {
QIOChannel *src;
@ -37,77 +38,17 @@ struct QIOChannelTest {
};
static void test_skip_iovec(struct iovec **iov,
size_t *niov,
size_t skip,
struct iovec *old)
{
size_t offset = 0;
size_t i;
for (i = 0; i < *niov; i++) {
if (skip < (*iov)[i].iov_len) {
old->iov_len = (*iov)[i].iov_len;
old->iov_base = (*iov)[i].iov_base;
(*iov)[i].iov_len -= skip;
(*iov)[i].iov_base += skip;
break;
} else {
skip -= (*iov)[i].iov_len;
if (i == 0 && old->iov_base) {
(*iov)[i].iov_len = old->iov_len;
(*iov)[i].iov_base = old->iov_base;
old->iov_len = 0;
old->iov_base = NULL;
}
offset++;
}
}
*iov = *iov + offset;
*niov -= offset;
}
/* This thread sends all data using iovecs */
static gpointer test_io_thread_writer(gpointer opaque)
{
QIOChannelTest *data = opaque;
struct iovec *iov = data->inputv;
size_t niov = data->niov;
struct iovec old = { 0 };
qio_channel_set_blocking(data->src, data->blocking, NULL);
while (niov) {
ssize_t ret;
ret = qio_channel_writev(data->src,
iov,
niov,
&data->writeerr);
if (ret == QIO_CHANNEL_ERR_BLOCK) {
if (data->blocking) {
error_setg(&data->writeerr,
"Unexpected I/O blocking");
break;
} else {
qio_channel_wait(data->src,
G_IO_OUT);
continue;
}
} else if (ret < 0) {
break;
} else if (ret == 0) {
error_setg(&data->writeerr,
"Unexpected zero length write");
break;
}
test_skip_iovec(&iov, &niov, ret, &old);
}
qio_channel_writev_all(data->src,
data->inputv,
data->niov,
&data->writeerr);
return NULL;
}
@ -117,38 +58,13 @@ static gpointer test_io_thread_writer(gpointer opaque)
static gpointer test_io_thread_reader(gpointer opaque)
{
QIOChannelTest *data = opaque;
struct iovec *iov = data->outputv;
size_t niov = data->niov;
struct iovec old = { 0 };
qio_channel_set_blocking(data->dst, data->blocking, NULL);
while (niov) {
ssize_t ret;
ret = qio_channel_readv(data->dst,
iov,
niov,
&data->readerr);
if (ret == QIO_CHANNEL_ERR_BLOCK) {
if (data->blocking) {
error_setg(&data->readerr,
"Unexpected I/O blocking");
break;
} else {
qio_channel_wait(data->dst,
G_IO_IN);
continue;
}
} else if (ret < 0) {
break;
} else if (ret == 0) {
break;
}
test_skip_iovec(&iov, &niov, ret, &old);
}
qio_channel_readv_all(data->dst,
data->outputv,
data->niov,
&data->readerr);
return NULL;
}