2010-04-27 20:34:05 +08:00
|
|
|
/*
|
|
|
|
* Helpers for getting linearized buffers from iov / filling buffers into iovs
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2007, 2008
|
|
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* Author(s):
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
* Amit Shah <amit.shah@redhat.com>
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
* Michael Tokarev <mjt@tls.msk.ru>
|
2010-04-27 20:34:05 +08:00
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
2012-01-14 00:44:23 +08:00
|
|
|
*
|
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2010-04-27 20:34:05 +08:00
|
|
|
*/
|
|
|
|
|
2016-01-30 01:49:55 +08:00
|
|
|
#include "qemu/osdep.h"
|
2016-03-09 17:52:44 +08:00
|
|
|
#include "qemu-common.h"
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/iov.h"
|
2014-02-24 01:02:07 +08:00
|
|
|
#include "qemu/sockets.h"
|
2012-03-14 15:18:54 +08:00
|
|
|
|
2015-12-22 19:03:33 +08:00
|
|
|
size_t iov_from_buf_full(const struct iovec *iov, unsigned int iov_cnt,
|
|
|
|
size_t offset, const void *buf, size_t bytes)
|
2010-04-27 20:34:05 +08:00
|
|
|
{
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
size_t done;
|
2010-04-27 20:34:05 +08:00
|
|
|
unsigned int i;
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
for (i = 0, done = 0; (offset || done < bytes) && i < iov_cnt; i++) {
|
|
|
|
if (offset < iov[i].iov_len) {
|
|
|
|
size_t len = MIN(iov[i].iov_len - offset, bytes - done);
|
|
|
|
memcpy(iov[i].iov_base + offset, buf + done, len);
|
|
|
|
done += len;
|
|
|
|
offset = 0;
|
|
|
|
} else {
|
|
|
|
offset -= iov[i].iov_len;
|
2011-07-11 21:02:23 +08:00
|
|
|
}
|
2010-04-27 20:34:05 +08:00
|
|
|
}
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
assert(offset == 0);
|
|
|
|
return done;
|
2010-04-27 20:34:05 +08:00
|
|
|
}
|
2010-04-27 20:34:06 +08:00
|
|
|
|
2015-12-22 19:03:33 +08:00
|
|
|
size_t iov_to_buf_full(const struct iovec *iov, const unsigned int iov_cnt,
|
|
|
|
size_t offset, void *buf, size_t bytes)
|
2010-04-27 20:34:06 +08:00
|
|
|
{
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
size_t done;
|
2010-04-27 20:34:06 +08:00
|
|
|
unsigned int i;
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
for (i = 0, done = 0; (offset || done < bytes) && i < iov_cnt; i++) {
|
|
|
|
if (offset < iov[i].iov_len) {
|
|
|
|
size_t len = MIN(iov[i].iov_len - offset, bytes - done);
|
|
|
|
memcpy(buf + done, iov[i].iov_base + offset, len);
|
|
|
|
done += len;
|
|
|
|
offset = 0;
|
|
|
|
} else {
|
|
|
|
offset -= iov[i].iov_len;
|
2010-04-27 20:34:06 +08:00
|
|
|
}
|
2011-07-13 21:16:08 +08:00
|
|
|
}
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
assert(offset == 0);
|
|
|
|
return done;
|
2011-07-13 21:16:08 +08:00
|
|
|
}
|
|
|
|
|
change iov_* function prototypes to be more appropriate
Reorder arguments to be more natural, readable and
consistent with other iov_* functions, and change
argument names, from:
iov_from_buf(iov, iov_cnt, buf, iov_off, size)
to
iov_from_buf(iov, iov_cnt, offset, buf, bytes)
The result becomes natural English:
copy data to this `iov' vector with `iov_cnt'
elements starting at byte offset `offset'
from memory buffer `buf', processing `bytes'
bytes max.
(Try to read the original prototype this way).
Also change iov_clear() to more general iov_memset()
(it uses memset() internally anyway).
While at it, add comments to the header file
describing what the routines actually does.
The patch only renames argumens in the header, but
keeps old names in the implementation. The next
patch will touch actual code to match.
Now, it might look wrong to pay so much attention
to so small things. But we've so many badly designed
interfaces already so the whole thing becomes rather
confusing or error prone. One example of this is
previous commit and small discussion which emerged
from it, with an outcome that the utility functions
like these aren't well-understdandable, leading to
strange usage cases. That's why I paid quite some
attention to this set of functions and a few
others in subsequent patches.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-11 22:05:12 +08:00
|
|
|
size_t iov_memset(const struct iovec *iov, const unsigned int iov_cnt,
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
size_t offset, int fillc, size_t bytes)
|
2011-07-13 21:16:08 +08:00
|
|
|
{
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
size_t done;
|
2011-07-13 21:16:08 +08:00
|
|
|
unsigned int i;
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
for (i = 0, done = 0; (offset || done < bytes) && i < iov_cnt; i++) {
|
|
|
|
if (offset < iov[i].iov_len) {
|
|
|
|
size_t len = MIN(iov[i].iov_len - offset, bytes - done);
|
|
|
|
memset(iov[i].iov_base + offset, fillc, len);
|
|
|
|
done += len;
|
|
|
|
offset = 0;
|
|
|
|
} else {
|
|
|
|
offset -= iov[i].iov_len;
|
2011-07-13 21:16:08 +08:00
|
|
|
}
|
2010-04-27 20:34:06 +08:00
|
|
|
}
|
rewrite iov_* functions
This changes implementations of all iov_*
functions, completing the previous step.
All iov_* functions now ensure that this offset
argument is within the iovec (using assertion),
but lets to specify `bytes' value larger than
actual length of the iovec - in this case they
stops at the actual end of iovec. It is also
suggested to use convinient `-1' value as `bytes'
to mean just this -- "up to the end".
There's one very minor semantic change here: new
requiriment is that `offset' points to inside of
iovec. This is checked just at the end of functions
(assert()), it does not actually need to be enforced,
but using any of these functions with offset pointing
past the end of iovec is wrong anyway.
Note: the new code in iov.c uses arithmetic with
void pointers. I thought this is not supported
everywhere and is a GCC extension (indeed, the C
standard does not define void arithmetic). However,
the original code already use void arith in
iov_from_buf() function:
(memcpy(..., buf + buf_off,...)
which apparently works well so far (it is this
way in qemu 1.0). So I left it this way and used
it in other places.
While at it, add a unit-test file test-iov.c,
to check various corner cases with iov_from_buf(),
iov_to_buf() and iov_memset().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-08 00:08:19 +08:00
|
|
|
assert(offset == 0);
|
|
|
|
return done;
|
2010-04-27 20:34:06 +08:00
|
|
|
}
|
|
|
|
|
2011-07-11 21:02:23 +08:00
|
|
|
size_t iov_size(const struct iovec *iov, const unsigned int iov_cnt)
|
2010-04-27 20:34:06 +08:00
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
len = 0;
|
2011-07-11 21:02:23 +08:00
|
|
|
for (i = 0; i < iov_cnt; i++) {
|
2010-04-27 20:34:06 +08:00
|
|
|
len += iov[i].iov_len;
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
2011-07-12 19:35:10 +08:00
|
|
|
|
2012-03-14 15:18:54 +08:00
|
|
|
/* helper function for iov_send_recv() */
|
|
|
|
static ssize_t
|
|
|
|
do_send_recv(int sockfd, struct iovec *iov, unsigned iov_cnt, bool do_send)
|
|
|
|
{
|
2013-04-21 18:01:06 +08:00
|
|
|
#ifdef CONFIG_POSIX
|
2012-03-14 15:18:54 +08:00
|
|
|
ssize_t ret;
|
|
|
|
struct msghdr msg;
|
|
|
|
memset(&msg, 0, sizeof(msg));
|
|
|
|
msg.msg_iov = iov;
|
|
|
|
msg.msg_iovlen = iov_cnt;
|
|
|
|
do {
|
|
|
|
ret = do_send
|
|
|
|
? sendmsg(sockfd, &msg, 0)
|
|
|
|
: recvmsg(sockfd, &msg, 0);
|
|
|
|
} while (ret < 0 && errno == EINTR);
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
/* else send piece-by-piece */
|
|
|
|
/*XXX Note: windows has WSASend() and WSARecv() */
|
2012-07-11 13:09:05 +08:00
|
|
|
unsigned i = 0;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
while (i < iov_cnt) {
|
2012-03-14 15:18:54 +08:00
|
|
|
ssize_t r = do_send
|
|
|
|
? send(sockfd, iov[i].iov_base, iov[i].iov_len, 0)
|
|
|
|
: recv(sockfd, iov[i].iov_base, iov[i].iov_len, 0);
|
|
|
|
if (r > 0) {
|
|
|
|
ret += r;
|
|
|
|
} else if (!r) {
|
|
|
|
break;
|
|
|
|
} else if (errno == EINTR) {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* else it is some "other" error,
|
|
|
|
* only return if there was no data processed. */
|
|
|
|
if (ret == 0) {
|
2012-07-11 13:09:05 +08:00
|
|
|
ret = -1;
|
2012-03-14 15:18:54 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2012-07-11 13:09:05 +08:00
|
|
|
i++;
|
2012-03-14 15:18:54 +08:00
|
|
|
}
|
2012-07-11 13:09:05 +08:00
|
|
|
return ret;
|
2012-03-14 15:18:54 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-05-21 09:50:10 +08:00
|
|
|
ssize_t iov_send_recv(int sockfd, const struct iovec *_iov, unsigned iov_cnt,
|
2012-03-14 15:18:54 +08:00
|
|
|
size_t offset, size_t bytes,
|
|
|
|
bool do_send)
|
|
|
|
{
|
2013-03-28 00:36:31 +08:00
|
|
|
ssize_t total = 0;
|
2012-03-14 15:18:54 +08:00
|
|
|
ssize_t ret;
|
2013-03-28 00:36:29 +08:00
|
|
|
size_t orig_len, tail;
|
2013-03-28 00:36:30 +08:00
|
|
|
unsigned niov;
|
2015-05-21 09:50:10 +08:00
|
|
|
struct iovec *local_iov, *iov;
|
|
|
|
|
|
|
|
if (bytes <= 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_iov = g_new0(struct iovec, iov_cnt);
|
|
|
|
iov_copy(local_iov, iov_cnt, _iov, iov_cnt, offset, bytes);
|
|
|
|
offset = 0;
|
|
|
|
iov = local_iov;
|
2013-03-28 00:36:29 +08:00
|
|
|
|
2013-03-28 00:36:31 +08:00
|
|
|
while (bytes > 0) {
|
|
|
|
/* Find the start position, skipping `offset' bytes:
|
|
|
|
* first, skip all full-sized vector elements, */
|
|
|
|
for (niov = 0; niov < iov_cnt && offset >= iov[niov].iov_len; ++niov) {
|
|
|
|
offset -= iov[niov].iov_len;
|
|
|
|
}
|
2013-03-28 00:36:28 +08:00
|
|
|
|
2013-03-28 00:36:31 +08:00
|
|
|
/* niov == iov_cnt would only be valid if bytes == 0, which
|
|
|
|
* we already ruled out in the loop condition. */
|
2013-03-28 00:36:30 +08:00
|
|
|
assert(niov < iov_cnt);
|
2013-03-28 00:36:31 +08:00
|
|
|
iov += niov;
|
|
|
|
iov_cnt -= niov;
|
|
|
|
|
|
|
|
if (offset) {
|
|
|
|
/* second, skip `offset' bytes from the (now) first element,
|
|
|
|
* undo it on exit */
|
|
|
|
iov[0].iov_base += offset;
|
|
|
|
iov[0].iov_len -= offset;
|
|
|
|
}
|
|
|
|
/* Find the end position skipping `bytes' bytes: */
|
|
|
|
/* first, skip all full-sized elements */
|
|
|
|
tail = bytes;
|
|
|
|
for (niov = 0; niov < iov_cnt && iov[niov].iov_len <= tail; ++niov) {
|
|
|
|
tail -= iov[niov].iov_len;
|
|
|
|
}
|
|
|
|
if (tail) {
|
|
|
|
/* second, fixup the last element, and remember the original
|
|
|
|
* length */
|
|
|
|
assert(niov < iov_cnt);
|
|
|
|
assert(iov[niov].iov_len > tail);
|
|
|
|
orig_len = iov[niov].iov_len;
|
|
|
|
iov[niov++].iov_len = tail;
|
2013-09-14 17:11:36 +08:00
|
|
|
ret = do_send_recv(sockfd, iov, niov, do_send);
|
|
|
|
/* Undo the changes above before checking for errors */
|
2013-03-28 00:36:31 +08:00
|
|
|
iov[niov-1].iov_len = orig_len;
|
2013-09-14 17:11:36 +08:00
|
|
|
} else {
|
|
|
|
ret = do_send_recv(sockfd, iov, niov, do_send);
|
2013-03-28 00:36:31 +08:00
|
|
|
}
|
|
|
|
if (offset) {
|
|
|
|
iov[0].iov_base -= offset;
|
|
|
|
iov[0].iov_len += offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
assert(errno != EINTR);
|
2015-05-21 09:50:10 +08:00
|
|
|
g_free(local_iov);
|
2013-03-28 00:36:31 +08:00
|
|
|
if (errno == EAGAIN && total > 0) {
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-23 16:30:12 +08:00
|
|
|
if (ret == 0 && !do_send) {
|
|
|
|
/* recv returns 0 when the peer has performed an orderly
|
|
|
|
* shutdown. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-03-28 00:36:31 +08:00
|
|
|
/* Prepare for the next iteration */
|
|
|
|
offset += ret;
|
|
|
|
total += ret;
|
|
|
|
bytes -= ret;
|
2012-03-14 15:18:54 +08:00
|
|
|
}
|
|
|
|
|
2015-05-21 09:50:10 +08:00
|
|
|
g_free(local_iov);
|
2013-03-28 00:36:31 +08:00
|
|
|
return total;
|
2012-03-14 15:18:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-12 19:35:10 +08:00
|
|
|
void iov_hexdump(const struct iovec *iov, const unsigned int iov_cnt,
|
|
|
|
FILE *fp, const char *prefix, size_t limit)
|
|
|
|
{
|
2013-03-16 00:41:58 +08:00
|
|
|
int v;
|
|
|
|
size_t size = 0;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
for (v = 0; v < iov_cnt; v++) {
|
|
|
|
size += iov[v].iov_len;
|
2011-07-12 19:35:10 +08:00
|
|
|
}
|
2013-03-16 00:41:58 +08:00
|
|
|
size = size > limit ? limit : size;
|
|
|
|
buf = g_malloc(size);
|
|
|
|
iov_to_buf(iov, iov_cnt, 0, buf, size);
|
2013-05-16 23:32:28 +08:00
|
|
|
qemu_hexdump(buf, fp, prefix, size);
|
2013-03-16 00:41:58 +08:00
|
|
|
g_free(buf);
|
2011-07-12 19:35:10 +08:00
|
|
|
}
|
2012-10-24 20:58:39 +08:00
|
|
|
|
2012-09-24 19:02:52 +08:00
|
|
|
unsigned iov_copy(struct iovec *dst_iov, unsigned int dst_iov_cnt,
|
|
|
|
const struct iovec *iov, unsigned int iov_cnt,
|
|
|
|
size_t offset, size_t bytes)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
unsigned int i, j;
|
|
|
|
for (i = 0, j = 0; i < iov_cnt && j < dst_iov_cnt && bytes; i++) {
|
|
|
|
if (offset >= iov[i].iov_len) {
|
|
|
|
offset -= iov[i].iov_len;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
len = MIN(bytes, iov[i].iov_len - offset);
|
|
|
|
|
|
|
|
dst_iov[j].iov_base = iov[i].iov_base + offset;
|
|
|
|
dst_iov[j].iov_len = len;
|
|
|
|
j++;
|
|
|
|
bytes -= len;
|
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
assert(offset == 0);
|
|
|
|
return j;
|
|
|
|
}
|
2012-10-31 17:42:51 +08:00
|
|
|
|
2012-10-24 20:58:39 +08:00
|
|
|
/* io vectors */
|
|
|
|
|
|
|
|
void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
|
|
|
|
{
|
2014-12-04 22:00:03 +08:00
|
|
|
qiov->iov = g_new(struct iovec, alloc_hint);
|
2012-10-24 20:58:39 +08:00
|
|
|
qiov->niov = 0;
|
|
|
|
qiov->nalloc = alloc_hint;
|
|
|
|
qiov->size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
qiov->iov = iov;
|
|
|
|
qiov->niov = niov;
|
|
|
|
qiov->nalloc = -1;
|
|
|
|
qiov->size = 0;
|
|
|
|
for (i = 0; i < niov; i++)
|
|
|
|
qiov->size += iov[i].iov_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
|
|
|
|
{
|
|
|
|
assert(qiov->nalloc != -1);
|
|
|
|
|
|
|
|
if (qiov->niov == qiov->nalloc) {
|
|
|
|
qiov->nalloc = 2 * qiov->nalloc + 1;
|
2014-12-04 22:00:03 +08:00
|
|
|
qiov->iov = g_renew(struct iovec, qiov->iov, qiov->nalloc);
|
2012-10-24 20:58:39 +08:00
|
|
|
}
|
|
|
|
qiov->iov[qiov->niov].iov_base = base;
|
|
|
|
qiov->iov[qiov->niov].iov_len = len;
|
|
|
|
qiov->size += len;
|
|
|
|
++qiov->niov;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-11-22 23:06:06 +08:00
|
|
|
* Concatenates (partial) iovecs from src_iov to the end of dst.
|
2012-10-24 20:58:39 +08:00
|
|
|
* It starts copying after skipping `soffset' bytes at the
|
|
|
|
* beginning of src and adds individual vectors from src to
|
|
|
|
* dst copies up to `sbytes' bytes total, or up to the end
|
2012-11-22 23:06:06 +08:00
|
|
|
* of src_iov if it comes first. This way, it is okay to specify
|
2012-10-24 20:58:39 +08:00
|
|
|
* very large value for `sbytes' to indicate "up to the end
|
|
|
|
* of src".
|
|
|
|
* Only vector pointers are processed, not the actual data buffers.
|
|
|
|
*/
|
2014-06-10 22:21:28 +08:00
|
|
|
size_t qemu_iovec_concat_iov(QEMUIOVector *dst,
|
|
|
|
struct iovec *src_iov, unsigned int src_cnt,
|
|
|
|
size_t soffset, size_t sbytes)
|
2012-10-24 20:58:39 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t done;
|
2013-02-05 13:57:45 +08:00
|
|
|
|
|
|
|
if (!sbytes) {
|
2014-06-10 22:21:28 +08:00
|
|
|
return 0;
|
2013-02-05 13:57:45 +08:00
|
|
|
}
|
2012-10-24 20:58:39 +08:00
|
|
|
assert(dst->nalloc != -1);
|
2012-11-22 23:06:06 +08:00
|
|
|
for (i = 0, done = 0; done < sbytes && i < src_cnt; i++) {
|
|
|
|
if (soffset < src_iov[i].iov_len) {
|
|
|
|
size_t len = MIN(src_iov[i].iov_len - soffset, sbytes - done);
|
|
|
|
qemu_iovec_add(dst, src_iov[i].iov_base + soffset, len);
|
2012-10-24 20:58:39 +08:00
|
|
|
done += len;
|
|
|
|
soffset = 0;
|
|
|
|
} else {
|
2012-11-22 23:06:06 +08:00
|
|
|
soffset -= src_iov[i].iov_len;
|
2012-10-24 20:58:39 +08:00
|
|
|
}
|
|
|
|
}
|
2012-11-22 23:06:06 +08:00
|
|
|
assert(soffset == 0); /* offset beyond end of src */
|
2014-06-10 22:21:28 +08:00
|
|
|
|
|
|
|
return done;
|
2012-11-22 23:06:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Concatenates (partial) iovecs from src to the end of dst.
|
|
|
|
* It starts copying after skipping `soffset' bytes at the
|
|
|
|
* beginning of src and adds individual vectors from src to
|
|
|
|
* dst copies up to `sbytes' bytes total, or up to the end
|
|
|
|
* of src if it comes first. This way, it is okay to specify
|
|
|
|
* very large value for `sbytes' to indicate "up to the end
|
|
|
|
* of src".
|
|
|
|
* Only vector pointers are processed, not the actual data buffers.
|
|
|
|
*/
|
|
|
|
void qemu_iovec_concat(QEMUIOVector *dst,
|
|
|
|
QEMUIOVector *src, size_t soffset, size_t sbytes)
|
|
|
|
{
|
|
|
|
qemu_iovec_concat_iov(dst, src->iov, src->niov, soffset, sbytes);
|
2012-10-24 20:58:39 +08:00
|
|
|
}
|
|
|
|
|
2014-05-18 06:58:17 +08:00
|
|
|
/*
|
|
|
|
* Check if the contents of the iovecs are all zero
|
|
|
|
*/
|
|
|
|
bool qemu_iovec_is_zero(QEMUIOVector *qiov)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < qiov->niov; i++) {
|
|
|
|
size_t offs = QEMU_ALIGN_DOWN(qiov->iov[i].iov_len, 4 * sizeof(long));
|
|
|
|
uint8_t *ptr = qiov->iov[i].iov_base;
|
|
|
|
if (offs && !buffer_is_zero(qiov->iov[i].iov_base, offs)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
for (; offs < qiov->iov[i].iov_len; offs++) {
|
|
|
|
if (ptr[offs]) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-10-24 20:58:39 +08:00
|
|
|
void qemu_iovec_destroy(QEMUIOVector *qiov)
|
|
|
|
{
|
|
|
|
assert(qiov->nalloc != -1);
|
|
|
|
|
|
|
|
qemu_iovec_reset(qiov);
|
|
|
|
g_free(qiov->iov);
|
|
|
|
qiov->nalloc = 0;
|
|
|
|
qiov->iov = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_iovec_reset(QEMUIOVector *qiov)
|
|
|
|
{
|
|
|
|
assert(qiov->nalloc != -1);
|
|
|
|
|
|
|
|
qiov->niov = 0;
|
|
|
|
qiov->size = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,
|
|
|
|
void *buf, size_t bytes)
|
|
|
|
{
|
|
|
|
return iov_to_buf(qiov->iov, qiov->niov, offset, buf, bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
|
|
|
|
const void *buf, size_t bytes)
|
|
|
|
{
|
|
|
|
return iov_from_buf(qiov->iov, qiov->niov, offset, buf, bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
|
|
|
|
int fillc, size_t bytes)
|
|
|
|
{
|
|
|
|
return iov_memset(qiov->iov, qiov->niov, offset, fillc, bytes);
|
|
|
|
}
|
2012-11-22 00:41:10 +08:00
|
|
|
|
2014-02-22 05:21:13 +08:00
|
|
|
/**
|
|
|
|
* Check that I/O vector contents are identical
|
|
|
|
*
|
|
|
|
* The IO vectors must have the same structure (same length of all parts).
|
|
|
|
* A typical usage is to compare vectors created with qemu_iovec_clone().
|
|
|
|
*
|
|
|
|
* @a: I/O vector
|
|
|
|
* @b: I/O vector
|
|
|
|
* @ret: Offset to first mismatching byte or -1 if match
|
|
|
|
*/
|
|
|
|
ssize_t qemu_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
ssize_t offset = 0;
|
|
|
|
|
|
|
|
assert(a->niov == b->niov);
|
|
|
|
for (i = 0; i < a->niov; i++) {
|
|
|
|
size_t len = 0;
|
|
|
|
uint8_t *p = (uint8_t *)a->iov[i].iov_base;
|
|
|
|
uint8_t *q = (uint8_t *)b->iov[i].iov_base;
|
|
|
|
|
|
|
|
assert(a->iov[i].iov_len == b->iov[i].iov_len);
|
|
|
|
while (len < a->iov[i].iov_len && *p++ == *q++) {
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += len;
|
|
|
|
|
|
|
|
if (len != a->iov[i].iov_len) {
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int src_index;
|
|
|
|
struct iovec *src_iov;
|
|
|
|
void *dest_base;
|
|
|
|
} IOVectorSortElem;
|
|
|
|
|
|
|
|
static int sortelem_cmp_src_base(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const IOVectorSortElem *elem_a = a;
|
|
|
|
const IOVectorSortElem *elem_b = b;
|
|
|
|
|
|
|
|
/* Don't overflow */
|
|
|
|
if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
|
|
|
|
return -1;
|
|
|
|
} else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sortelem_cmp_src_index(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const IOVectorSortElem *elem_a = a;
|
|
|
|
const IOVectorSortElem *elem_b = b;
|
|
|
|
|
|
|
|
return elem_a->src_index - elem_b->src_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy contents of I/O vector
|
|
|
|
*
|
|
|
|
* The relative relationships of overlapping iovecs are preserved. This is
|
|
|
|
* necessary to ensure identical semantics in the cloned I/O vector.
|
|
|
|
*/
|
|
|
|
void qemu_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src, void *buf)
|
|
|
|
{
|
|
|
|
IOVectorSortElem sortelems[src->niov];
|
|
|
|
void *last_end;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Sort by source iovecs by base address */
|
|
|
|
for (i = 0; i < src->niov; i++) {
|
|
|
|
sortelems[i].src_index = i;
|
|
|
|
sortelems[i].src_iov = &src->iov[i];
|
|
|
|
}
|
|
|
|
qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);
|
|
|
|
|
|
|
|
/* Allocate buffer space taking into account overlapping iovecs */
|
|
|
|
last_end = NULL;
|
|
|
|
for (i = 0; i < src->niov; i++) {
|
|
|
|
struct iovec *cur = sortelems[i].src_iov;
|
|
|
|
ptrdiff_t rewind = 0;
|
|
|
|
|
|
|
|
/* Detect overlap */
|
|
|
|
if (last_end && last_end > cur->iov_base) {
|
|
|
|
rewind = last_end - cur->iov_base;
|
|
|
|
}
|
|
|
|
|
|
|
|
sortelems[i].dest_base = buf - rewind;
|
|
|
|
buf += cur->iov_len - MIN(rewind, cur->iov_len);
|
|
|
|
last_end = MAX(cur->iov_base + cur->iov_len, last_end);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sort by source iovec index and build destination iovec */
|
|
|
|
qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_index);
|
|
|
|
for (i = 0; i < src->niov; i++) {
|
|
|
|
qemu_iovec_add(dest, sortelems[i].dest_base, src->iov[i].iov_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-22 00:41:10 +08:00
|
|
|
size_t iov_discard_front(struct iovec **iov, unsigned int *iov_cnt,
|
|
|
|
size_t bytes)
|
|
|
|
{
|
|
|
|
size_t total = 0;
|
|
|
|
struct iovec *cur;
|
|
|
|
|
|
|
|
for (cur = *iov; *iov_cnt > 0; cur++) {
|
|
|
|
if (cur->iov_len > bytes) {
|
|
|
|
cur->iov_base += bytes;
|
|
|
|
cur->iov_len -= bytes;
|
|
|
|
total += bytes;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bytes -= cur->iov_len;
|
|
|
|
total += cur->iov_len;
|
|
|
|
*iov_cnt -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*iov = cur;
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t iov_discard_back(struct iovec *iov, unsigned int *iov_cnt,
|
|
|
|
size_t bytes)
|
|
|
|
{
|
|
|
|
size_t total = 0;
|
|
|
|
struct iovec *cur;
|
|
|
|
|
|
|
|
if (*iov_cnt == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur = iov + (*iov_cnt - 1);
|
|
|
|
|
|
|
|
while (*iov_cnt > 0) {
|
|
|
|
if (cur->iov_len > bytes) {
|
|
|
|
cur->iov_len -= bytes;
|
|
|
|
total += bytes;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bytes -= cur->iov_len;
|
|
|
|
total += cur->iov_len;
|
|
|
|
cur--;
|
|
|
|
*iov_cnt -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return total;
|
|
|
|
}
|
2014-07-10 01:17:30 +08:00
|
|
|
|
|
|
|
void qemu_iovec_discard_back(QEMUIOVector *qiov, size_t bytes)
|
|
|
|
{
|
|
|
|
size_t total;
|
|
|
|
unsigned int niov = qiov->niov;
|
|
|
|
|
|
|
|
assert(qiov->size >= bytes);
|
|
|
|
total = iov_discard_back(qiov->iov, &niov, bytes);
|
|
|
|
assert(total == bytes);
|
|
|
|
|
|
|
|
qiov->niov = niov;
|
|
|
|
qiov->size -= bytes;
|
|
|
|
}
|