]>
git.proxmox.com Git - qemu.git/blob - util/iov.c
2 * Helpers for getting linearized buffers from iov / filling buffers into iovs
4 * Copyright IBM, Corp. 2007, 2008
5 * Copyright (C) 2010 Red Hat, Inc.
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Amit Shah <amit.shah@redhat.com>
10 * Michael Tokarev <mjt@tls.msk.ru>
12 * This work is licensed under the terms of the GNU GPL, version 2. See
13 * the COPYING file in the top-level directory.
15 * Contributions after 2012-01-13 are licensed under the terms of the
16 * GNU GPL, version 2 or (at your option) any later version.
23 # include <winsock2.h>
25 # include <sys/types.h>
26 # include <sys/socket.h>
29 size_t iov_from_buf(const struct iovec
*iov
, unsigned int iov_cnt
,
30 size_t offset
, const void *buf
, size_t bytes
)
34 for (i
= 0, done
= 0; (offset
|| done
< bytes
) && i
< iov_cnt
; i
++) {
35 if (offset
< iov
[i
].iov_len
) {
36 size_t len
= MIN(iov
[i
].iov_len
- offset
, bytes
- done
);
37 memcpy(iov
[i
].iov_base
+ offset
, buf
+ done
, len
);
41 offset
-= iov
[i
].iov_len
;
48 size_t iov_to_buf(const struct iovec
*iov
, const unsigned int iov_cnt
,
49 size_t offset
, void *buf
, size_t bytes
)
53 for (i
= 0, done
= 0; (offset
|| done
< bytes
) && i
< iov_cnt
; i
++) {
54 if (offset
< iov
[i
].iov_len
) {
55 size_t len
= MIN(iov
[i
].iov_len
- offset
, bytes
- done
);
56 memcpy(buf
+ done
, iov
[i
].iov_base
+ offset
, len
);
60 offset
-= iov
[i
].iov_len
;
67 size_t iov_memset(const struct iovec
*iov
, const unsigned int iov_cnt
,
68 size_t offset
, int fillc
, size_t bytes
)
72 for (i
= 0, done
= 0; (offset
|| done
< bytes
) && i
< iov_cnt
; i
++) {
73 if (offset
< iov
[i
].iov_len
) {
74 size_t len
= MIN(iov
[i
].iov_len
- offset
, bytes
- done
);
75 memset(iov
[i
].iov_base
+ offset
, fillc
, len
);
79 offset
-= iov
[i
].iov_len
;
86 size_t iov_size(const struct iovec
*iov
, const unsigned int iov_cnt
)
92 for (i
= 0; i
< iov_cnt
; i
++) {
93 len
+= iov
[i
].iov_len
;
98 /* helper function for iov_send_recv() */
100 do_send_recv(int sockfd
, struct iovec
*iov
, unsigned iov_cnt
, bool do_send
)
102 #if defined CONFIG_IOVEC && defined CONFIG_POSIX
105 memset(&msg
, 0, sizeof(msg
));
107 msg
.msg_iovlen
= iov_cnt
;
110 ? sendmsg(sockfd
, &msg
, 0)
111 : recvmsg(sockfd
, &msg
, 0);
112 } while (ret
< 0 && errno
== EINTR
);
115 /* else send piece-by-piece */
116 /*XXX Note: windows has WSASend() and WSARecv() */
119 while (i
< iov_cnt
) {
121 ? send(sockfd
, iov
[i
].iov_base
, iov
[i
].iov_len
, 0)
122 : recv(sockfd
, iov
[i
].iov_base
, iov
[i
].iov_len
, 0);
127 } else if (errno
== EINTR
) {
130 /* else it is some "other" error,
131 * only return if there was no data processed. */
143 ssize_t
iov_send_recv(int sockfd
, struct iovec
*iov
, unsigned iov_cnt
,
144 size_t offset
, size_t bytes
,
148 size_t orig_len
, tail
;
149 unsigned si
, ei
; /* start and end indexes */
152 /* Catch the do-nothing case early, as otherwise we will pass an
153 * empty iovec to sendmsg/recvmsg(), and not all implementations
159 /* Find the start position, skipping `offset' bytes:
160 * first, skip all full-sized vector elements, */
161 for (si
= 0; si
< iov_cnt
&& offset
>= iov
[si
].iov_len
; ++si
) {
162 offset
-= iov
[si
].iov_len
;
165 /* si == iov_cnt would only be valid if bytes == 0, which
166 * we already ruled out above. */
167 assert(si
< iov_cnt
);
172 /* second, skip `offset' bytes from the (now) first element,
174 iov
[0].iov_base
+= offset
;
175 iov
[0].iov_len
-= offset
;
177 /* Find the end position skipping `bytes' bytes: */
178 /* first, skip all full-sized elements */
180 for (ei
= 0; ei
< iov_cnt
&& iov
[ei
].iov_len
<= tail
; ++ei
) {
181 tail
-= iov
[ei
].iov_len
;
184 /* second, fixup the last element, and remember the original
186 assert(ei
< iov_cnt
);
187 assert(iov
[ei
].iov_len
> tail
);
188 orig_len
= iov
[ei
].iov_len
;
189 iov
[ei
++].iov_len
= tail
;
192 ret
= do_send_recv(sockfd
, iov
, ei
, do_send
);
194 /* Undo the changes above */
196 iov
[ei
-1].iov_len
= orig_len
;
199 iov
[0].iov_base
-= offset
;
200 iov
[0].iov_len
+= offset
;
207 void iov_hexdump(const struct iovec
*iov
, const unsigned int iov_cnt
,
208 FILE *fp
, const char *prefix
, size_t limit
)
214 for (v
= 0; v
< iov_cnt
; v
++) {
215 size
+= iov
[v
].iov_len
;
217 size
= size
> limit
? limit
: size
;
218 buf
= g_malloc(size
);
219 iov_to_buf(iov
, iov_cnt
, 0, buf
, size
);
220 hexdump(buf
, fp
, prefix
, size
);
224 unsigned iov_copy(struct iovec
*dst_iov
, unsigned int dst_iov_cnt
,
225 const struct iovec
*iov
, unsigned int iov_cnt
,
226 size_t offset
, size_t bytes
)
230 for (i
= 0, j
= 0; i
< iov_cnt
&& j
< dst_iov_cnt
&& bytes
; i
++) {
231 if (offset
>= iov
[i
].iov_len
) {
232 offset
-= iov
[i
].iov_len
;
235 len
= MIN(bytes
, iov
[i
].iov_len
- offset
);
237 dst_iov
[j
].iov_base
= iov
[i
].iov_base
+ offset
;
238 dst_iov
[j
].iov_len
= len
;
249 void qemu_iovec_init(QEMUIOVector
*qiov
, int alloc_hint
)
251 qiov
->iov
= g_malloc(alloc_hint
* sizeof(struct iovec
));
253 qiov
->nalloc
= alloc_hint
;
257 void qemu_iovec_init_external(QEMUIOVector
*qiov
, struct iovec
*iov
, int niov
)
265 for (i
= 0; i
< niov
; i
++)
266 qiov
->size
+= iov
[i
].iov_len
;
269 void qemu_iovec_add(QEMUIOVector
*qiov
, void *base
, size_t len
)
271 assert(qiov
->nalloc
!= -1);
273 if (qiov
->niov
== qiov
->nalloc
) {
274 qiov
->nalloc
= 2 * qiov
->nalloc
+ 1;
275 qiov
->iov
= g_realloc(qiov
->iov
, qiov
->nalloc
* sizeof(struct iovec
));
277 qiov
->iov
[qiov
->niov
].iov_base
= base
;
278 qiov
->iov
[qiov
->niov
].iov_len
= len
;
284 * Concatenates (partial) iovecs from src_iov to the end of dst.
285 * It starts copying after skipping `soffset' bytes at the
286 * beginning of src and adds individual vectors from src to
287 * dst copies up to `sbytes' bytes total, or up to the end
288 * of src_iov if it comes first. This way, it is okay to specify
289 * very large value for `sbytes' to indicate "up to the end
291 * Only vector pointers are processed, not the actual data buffers.
293 void qemu_iovec_concat_iov(QEMUIOVector
*dst
,
294 struct iovec
*src_iov
, unsigned int src_cnt
,
295 size_t soffset
, size_t sbytes
)
303 assert(dst
->nalloc
!= -1);
304 for (i
= 0, done
= 0; done
< sbytes
&& i
< src_cnt
; i
++) {
305 if (soffset
< src_iov
[i
].iov_len
) {
306 size_t len
= MIN(src_iov
[i
].iov_len
- soffset
, sbytes
- done
);
307 qemu_iovec_add(dst
, src_iov
[i
].iov_base
+ soffset
, len
);
311 soffset
-= src_iov
[i
].iov_len
;
314 assert(soffset
== 0); /* offset beyond end of src */
318 * Concatenates (partial) iovecs from src to the end of dst.
319 * It starts copying after skipping `soffset' bytes at the
320 * beginning of src and adds individual vectors from src to
321 * dst copies up to `sbytes' bytes total, or up to the end
322 * of src if it comes first. This way, it is okay to specify
323 * very large value for `sbytes' to indicate "up to the end
325 * Only vector pointers are processed, not the actual data buffers.
327 void qemu_iovec_concat(QEMUIOVector
*dst
,
328 QEMUIOVector
*src
, size_t soffset
, size_t sbytes
)
330 qemu_iovec_concat_iov(dst
, src
->iov
, src
->niov
, soffset
, sbytes
);
333 void qemu_iovec_destroy(QEMUIOVector
*qiov
)
335 assert(qiov
->nalloc
!= -1);
337 qemu_iovec_reset(qiov
);
343 void qemu_iovec_reset(QEMUIOVector
*qiov
)
345 assert(qiov
->nalloc
!= -1);
351 size_t qemu_iovec_to_buf(QEMUIOVector
*qiov
, size_t offset
,
352 void *buf
, size_t bytes
)
354 return iov_to_buf(qiov
->iov
, qiov
->niov
, offset
, buf
, bytes
);
357 size_t qemu_iovec_from_buf(QEMUIOVector
*qiov
, size_t offset
,
358 const void *buf
, size_t bytes
)
360 return iov_from_buf(qiov
->iov
, qiov
->niov
, offset
, buf
, bytes
);
363 size_t qemu_iovec_memset(QEMUIOVector
*qiov
, size_t offset
,
364 int fillc
, size_t bytes
)
366 return iov_memset(qiov
->iov
, qiov
->niov
, offset
, fillc
, bytes
);
369 size_t iov_discard_front(struct iovec
**iov
, unsigned int *iov_cnt
,
375 for (cur
= *iov
; *iov_cnt
> 0; cur
++) {
376 if (cur
->iov_len
> bytes
) {
377 cur
->iov_base
+= bytes
;
378 cur
->iov_len
-= bytes
;
383 bytes
-= cur
->iov_len
;
384 total
+= cur
->iov_len
;
392 size_t iov_discard_back(struct iovec
*iov
, unsigned int *iov_cnt
,
402 cur
= iov
+ (*iov_cnt
- 1);
404 while (*iov_cnt
> 0) {
405 if (cur
->iov_len
> bytes
) {
406 cur
->iov_len
-= bytes
;
411 bytes
-= cur
->iov_len
;
412 total
+= cur
->iov_len
;