2 * Simple C functions to supplement the C library
4 * Copyright (c) 2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu-common.h"
25 #include "host-utils.h"
28 #include "qemu_socket.h"
31 void pstrcpy(char *buf
, int buf_size
, const char *str
)
41 if (c
== 0 || q
>= buf
+ buf_size
- 1)
48 /* strcat and truncate. */
49 char *pstrcat(char *buf
, int buf_size
, const char *s
)
54 pstrcpy(buf
+ len
, buf_size
- len
, s
);
58 int strstart(const char *str
, const char *val
, const char **ptr
)
74 int stristart(const char *str
, const char *val
, const char **ptr
)
80 if (qemu_toupper(*p
) != qemu_toupper(*q
))
90 /* XXX: use host strnlen if available ? */
91 int qemu_strnlen(const char *s
, int max_len
)
95 for(i
= 0; i
< max_len
; i
++) {
103 time_t mktimegm(struct tm
*tm
)
106 int y
= tm
->tm_year
+ 1900, m
= tm
->tm_mon
+ 1, d
= tm
->tm_mday
;
111 t
= 86400 * (d
+ (153 * m
- 457) / 5 + 365 * y
+ y
/ 4 - y
/ 100 +
113 t
+= 3600 * tm
->tm_hour
+ 60 * tm
->tm_min
+ tm
->tm_sec
;
119 return 32 - clz32(i
);
123 * Make sure data goes on disk, but if possible do not bother to
124 * write out the inode just for timestamp updates.
126 * Unfortunately even in 2009 many operating systems do not support
127 * fdatasync and have to fall back to fsync.
129 int qemu_fdatasync(int fd
)
131 #ifdef CONFIG_FDATASYNC
132 return fdatasync(fd
);
140 void qemu_iovec_init(QEMUIOVector
*qiov
, int alloc_hint
)
142 qiov
->iov
= g_malloc(alloc_hint
* sizeof(struct iovec
));
144 qiov
->nalloc
= alloc_hint
;
148 void qemu_iovec_init_external(QEMUIOVector
*qiov
, struct iovec
*iov
, int niov
)
156 for (i
= 0; i
< niov
; i
++)
157 qiov
->size
+= iov
[i
].iov_len
;
160 void qemu_iovec_add(QEMUIOVector
*qiov
, void *base
, size_t len
)
162 assert(qiov
->nalloc
!= -1);
164 if (qiov
->niov
== qiov
->nalloc
) {
165 qiov
->nalloc
= 2 * qiov
->nalloc
+ 1;
166 qiov
->iov
= g_realloc(qiov
->iov
, qiov
->nalloc
* sizeof(struct iovec
));
168 qiov
->iov
[qiov
->niov
].iov_base
= base
;
169 qiov
->iov
[qiov
->niov
].iov_len
= len
;
175 * Copies iovecs from src to the end of dst. It starts copying after skipping
176 * the given number of bytes in src and copies until src is completely copied
177 * or the total size of the copied iovec reaches size.The size of the last
178 * copied iovec is changed in order to fit the specified total size if it isn't
179 * a perfect fit already.
181 void qemu_iovec_copy(QEMUIOVector
*dst
, QEMUIOVector
*src
, uint64_t skip
,
189 assert(dst
->nalloc
!= -1);
192 for (i
= 0; (i
< src
->niov
) && (done
!= size
); i
++) {
193 if (skip
>= src
->iov
[i
].iov_len
) {
194 /* Skip the whole iov */
195 skip
-= src
->iov
[i
].iov_len
;
198 /* Skip only part (or nothing) of the iov */
199 iov_base
= (uint8_t*) src
->iov
[i
].iov_base
+ skip
;
200 iov_len
= src
->iov
[i
].iov_len
- skip
;
204 if (done
+ iov_len
> size
) {
205 qemu_iovec_add(dst
, iov_base
, size
- done
);
208 qemu_iovec_add(dst
, iov_base
, iov_len
);
214 void qemu_iovec_concat(QEMUIOVector
*dst
, QEMUIOVector
*src
, size_t size
)
216 qemu_iovec_copy(dst
, src
, 0, size
);
219 void qemu_iovec_destroy(QEMUIOVector
*qiov
)
221 assert(qiov
->nalloc
!= -1);
223 qemu_iovec_reset(qiov
);
229 void qemu_iovec_reset(QEMUIOVector
*qiov
)
231 assert(qiov
->nalloc
!= -1);
237 void qemu_iovec_to_buffer(QEMUIOVector
*qiov
, void *buf
)
239 uint8_t *p
= (uint8_t *)buf
;
242 for (i
= 0; i
< qiov
->niov
; ++i
) {
243 memcpy(p
, qiov
->iov
[i
].iov_base
, qiov
->iov
[i
].iov_len
);
244 p
+= qiov
->iov
[i
].iov_len
;
248 size_t qemu_iovec_from_buf(QEMUIOVector
*qiov
, size_t offset
,
249 const void *buf
, size_t bytes
)
251 return iov_from_buf(qiov
->iov
, qiov
->niov
, offset
, buf
, bytes
);
254 size_t qemu_iovec_memset(QEMUIOVector
*qiov
, size_t offset
,
255 int fillc
, size_t bytes
)
257 return iov_memset(qiov
->iov
, qiov
->niov
, offset
, fillc
, bytes
);
261 * Checks if a buffer is all zeroes
263 * Attention! The len must be a multiple of 4 * sizeof(long) due to
264 * restriction of optimizations in this function.
266 bool buffer_is_zero(const void *buf
, size_t len
)
269 * Use long as the biggest available internal data type that fits into the
270 * CPU register and unroll the loop to smooth out the effect of memory
276 const long * const data
= buf
;
278 assert(len
% (4 * sizeof(long)) == 0);
281 for (i
= 0; i
< len
; i
+= 4) {
287 if (d0
|| d1
|| d2
|| d3
) {
296 /* Sets a specific flag */
297 int fcntl_setfl(int fd
, int flag
)
301 flags
= fcntl(fd
, F_GETFL
);
305 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
312 static int64_t suffix_mul(char suffix
, int64_t unit
)
314 switch (qemu_toupper(suffix
)) {
315 case STRTOSZ_DEFSUFFIX_B
:
317 case STRTOSZ_DEFSUFFIX_KB
:
319 case STRTOSZ_DEFSUFFIX_MB
:
321 case STRTOSZ_DEFSUFFIX_GB
:
322 return unit
* unit
* unit
;
323 case STRTOSZ_DEFSUFFIX_TB
:
324 return unit
* unit
* unit
* unit
;
330 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
331 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
332 * in *end, if not NULL. Return -1 on error.
334 int64_t strtosz_suffix_unit(const char *nptr
, char **end
,
335 const char default_suffix
, int64_t unit
)
340 int mul_required
= 0;
341 double val
, mul
, integral
, fraction
;
344 val
= strtod(nptr
, &endptr
);
345 if (isnan(val
) || endptr
== nptr
|| errno
!= 0) {
348 fraction
= modf(val
, &integral
);
353 mul
= suffix_mul(c
, unit
);
357 mul
= suffix_mul(default_suffix
, unit
);
360 if (mul
== 1 && mul_required
) {
363 if ((val
* mul
>= INT64_MAX
) || val
< 0) {
376 int64_t strtosz_suffix(const char *nptr
, char **end
, const char default_suffix
)
378 return strtosz_suffix_unit(nptr
, end
, default_suffix
, 1024);
381 int64_t strtosz(const char *nptr
, char **end
)
383 return strtosz_suffix(nptr
, end
, STRTOSZ_DEFSUFFIX_MB
);
386 int qemu_parse_fd(const char *param
)
391 fd
= strtol(param
, &endptr
, 10);
392 if (*endptr
|| (fd
== 0 && param
== endptr
)) {
399 * Send/recv data with iovec buffers
401 * This function send/recv data from/to the iovec buffer directly.
402 * The first `offset' bytes in the iovec buffer are skipped and next
403 * `len' bytes are used.
407 * do_sendv_recvv(sockfd, iov, len, offset, 1);
411 * char *buf = malloc(size);
412 * iov_to_buf(iov, iovcnt, buf, offset, size);
413 * send(sockfd, buf, size, 0);
416 static int do_sendv_recvv(int sockfd
, struct iovec
*iov
, int len
, int offset
,
419 int ret
, diff
, iovlen
;
420 struct iovec
*last_iov
;
422 /* last_iov is inclusive, so count from one. */
427 while (last_iov
->iov_len
< len
) {
428 len
-= last_iov
->iov_len
;
434 diff
= last_iov
->iov_len
- len
;
435 last_iov
->iov_len
-= diff
;
437 while (iov
->iov_len
<= offset
) {
438 offset
-= iov
->iov_len
;
444 iov
->iov_base
= (char *) iov
->iov_base
+ offset
;
445 iov
->iov_len
-= offset
;
448 #if defined CONFIG_IOVEC && defined CONFIG_POSIX
450 memset(&msg
, 0, sizeof(msg
));
452 msg
.msg_iovlen
= iovlen
;
456 ret
= sendmsg(sockfd
, &msg
, 0);
458 ret
= recvmsg(sockfd
, &msg
, 0);
460 } while (ret
== -1 && errno
== EINTR
);
462 struct iovec
*p
= iov
;
467 rc
= send(sockfd
, p
->iov_base
, p
->iov_len
, 0);
469 rc
= qemu_recv(sockfd
, p
->iov_base
, p
->iov_len
, 0);
472 if (errno
== EINTR
) {
489 /* Undo the changes above */
490 iov
->iov_base
= (char *) iov
->iov_base
- offset
;
491 iov
->iov_len
+= offset
;
492 last_iov
->iov_len
+= diff
;
496 int qemu_recvv(int sockfd
, struct iovec
*iov
, int len
, int iov_offset
)
498 return do_sendv_recvv(sockfd
, iov
, len
, iov_offset
, 0);
501 int qemu_sendv(int sockfd
, struct iovec
*iov
, int len
, int iov_offset
)
503 return do_sendv_recvv(sockfd
, iov
, len
, iov_offset
, 1);