Commit 3e80bf93 authored by Michael Tokarev's avatar Michael Tokarev
Browse files

rename qemu_sendv to iov_send, change proto and move declarations to iov.h 



Rename arguments and use size_t for sizes instead of int,
from
 int
 qemu_sendv(int sockfd, struct iovec *iov,
            int len, int iov_offset)
to
 ssize_t
 iov_send(int sockfd, struct iovec *iov,
          size_t offset, size_t bytes)

The main motivation was to make it clear that length
and offset are in _bytes_, not in iov elements: it was
very confusing before, because all standard functions
which deals with iovecs expects number of iovs, not
bytes, even the fact that struct iovec has iov_len and
iov_ prefix does not help.  With "bytes" and "offset",
especially since they're now size_t, it is much more
explicit.  Also change the return type to be ssize_t
instead of int.

This also changes it to match other iov-related functons,
but not _quite_: there's still no argument indicating
where iovec ends, ie, no iov_cnt parameter as used
in iov_size() and friends.  If will be added in subsequent
patch/rewrite.

All callers of qemu_sendv() and qemu_recvv() and
related, like qemu_co_sendv() and qemu_co_recvv(),
were checked to verify that it is safe to use unsigned
datatype instead of int.

Note that the order of arguments is changed to: offset
and bytes (len and iov_offset) are swapped with each
other.  This is to make them consistent with very similar
functions from qemu_iovec family, where offset always
follows qiov, to mean the place in it to start from.

Signed-off-by: default avatarMichael Tokarev <mjt@tls.msk.ru>
parent d5e6b161

cutils.c

+13 −28
Original line number Diff line number Diff line
@@ -376,43 +376,28 @@ int qemu_parse_fd(const char *param) 
    return fd;

}



/*

 * Send/recv data with iovec buffers

 *

 * This function send/recv data from/to the iovec buffer directly.

 * The first `offset' bytes in the iovec buffer are skipped and next

 * `len' bytes are used.

 *

 * For example,

 *

 *   do_sendv_recvv(sockfd, iov, len, offset, 1);

 *

 * is equal to

 *

 *   char *buf = malloc(size);

 *   iov_to_buf(iov, iovcnt, buf, offset, size);

 *   send(sockfd, buf, size, 0);

 *   free(buf);

 */

static int do_sendv_recvv(int sockfd, struct iovec *iov, int len, int offset,

static ssize_t do_sendv_recvv(int sockfd, struct iovec *iov,

                          size_t offset, size_t bytes,

                          int do_sendv)

{

    int ret, diff, iovlen;

    int iovlen;

    ssize_t ret;

    size_t diff;

    struct iovec *last_iov;



    /* last_iov is inclusive, so count from one.  */

    iovlen = 1;

    last_iov = iov;

    len += offset;

    bytes += offset;



    while (last_iov->iov_len < len) {

        len -= last_iov->iov_len;

    while (last_iov->iov_len < bytes) {

        bytes -= last_iov->iov_len;



        last_iov++;

        iovlen++;

    }



    diff = last_iov->iov_len - len;

    diff = last_iov->iov_len - bytes;

    last_iov->iov_len -= diff;



    while (iov->iov_len <= offset) {
@@ -474,13 +459,13 @@ static int do_sendv_recvv(int sockfd, struct iovec *iov, int len, int offset, 
    return ret;

}



int qemu_recvv(int sockfd, struct iovec *iov, int len, int iov_offset)

ssize_t iov_recv(int sockfd, struct iovec *iov, size_t offset, size_t bytes)

{

    return do_sendv_recvv(sockfd, iov, len, iov_offset, 0);

    return do_sendv_recvv(sockfd, iov, offset, bytes, 0);

}



int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset)

ssize_t iov_send(int sockfd, struct iovec *iov, size_t offset, size_t bytes)

{

    return do_sendv_recvv(sockfd, iov, len, iov_offset, 1);

    return do_sendv_recvv(sockfd, iov, offset, bytes, 1);

}

iov.h

+18 −0
Original line number Diff line number Diff line
@@ -54,6 +54,24 @@ size_t iov_to_buf(const struct iovec *iov, const unsigned int iov_cnt, 
size_t iov_memset(const struct iovec *iov, const unsigned int iov_cnt,

                  size_t offset, int fillc, size_t bytes);



/*

 * Send/recv data from/to iovec buffers directly

 *

 * `offset' bytes in the beginning of iovec buffer are skipped and

 * next `bytes' bytes are used, which must be within data of iovec.

 *

 *   r = iov_send(sockfd, iov, offset, bytes);

 *

 * is logically equivalent to

 *

 *   char *buf = malloc(bytes);

 *   iov_to_buf(iov, iovcnt, offset, buf, bytes);

 *   r = send(sockfd, buf, bytes, 0);

 *   free(buf);

 */

ssize_t iov_recv(int sockfd, struct iovec *iov, size_t offset, size_t bytes);

ssize_t iov_send(int sockfd, struct iovec *iov, size_t offset, size_t bytes);



/**

 * Produce a text hexdump of iovec `iov' with `iov_cnt' number of elements

 * in file `fp', prefixing each line with `prefix' and processing not more

qemu-common.h

+0 −3
Original line number Diff line number Diff line
@@ -205,9 +205,6 @@ int qemu_pipe(int pipefd[2]); 
#define qemu_recv(sockfd, buf, len, flags) recv(sockfd, buf, len, flags)

#endif



int qemu_recvv(int sockfd, struct iovec *iov, int len, int iov_offset);

int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset);



/* Error handling.  */



void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);

qemu-coroutine-io.c

+3 −2
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include "qemu-common.h"

#include "qemu_socket.h"

#include "qemu-coroutine.h"

#include "iov.h"



int coroutine_fn qemu_co_recvv(int sockfd, struct iovec *iov,

                               int len, int iov_offset)
@@ -32,7 +33,7 @@ int coroutine_fn qemu_co_recvv(int sockfd, struct iovec *iov, 
    int total = 0;

    int ret;

    while (len) {

        ret = qemu_recvv(sockfd, iov, len, iov_offset + total);

        ret = iov_recv(sockfd, iov, iov_offset + total, len);

        if (ret < 0) {

            if (errno == EAGAIN) {

                qemu_coroutine_yield();
@@ -58,7 +59,7 @@ int coroutine_fn qemu_co_sendv(int sockfd, struct iovec *iov, 
    int total = 0;

    int ret;

    while (len) {

        ret = qemu_sendv(sockfd, iov, len, iov_offset + total);

        ret = iov_send(sockfd, iov, iov_offset + total, len);

        if (ret < 0) {

            if (errno == EAGAIN) {

                qemu_coroutine_yield();