]>
git.proxmox.com Git - mirror_qemu.git/blob - cutils.c
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 * Concatenates (partial) iovecs from src to the end of dst.
176 * It starts copying after skipping `soffset' bytes at the
177 * beginning of src and adds individual vectors from src to
178 * dst copies up to `sbytes' bytes total, or up to the end
179 * of src if it comes first. This way, it is okay to specify
180 * very large value for `sbytes' to indicate "up to the end
182 * Only vector pointers are processed, not the actual data buffers.
184 void qemu_iovec_concat(QEMUIOVector
*dst
,
185 QEMUIOVector
*src
, size_t soffset
, size_t sbytes
)
189 struct iovec
*siov
= src
->iov
;
190 assert(dst
->nalloc
!= -1);
191 assert(src
->size
>= soffset
);
192 for (i
= 0, done
= 0; done
< sbytes
&& i
< src
->niov
; i
++) {
193 if (soffset
< siov
[i
].iov_len
) {
194 size_t len
= MIN(siov
[i
].iov_len
- soffset
, sbytes
- done
);
195 qemu_iovec_add(dst
, siov
[i
].iov_base
+ soffset
, len
);
199 soffset
-= siov
[i
].iov_len
;
205 void qemu_iovec_destroy(QEMUIOVector
*qiov
)
207 assert(qiov
->nalloc
!= -1);
209 qemu_iovec_reset(qiov
);
215 void qemu_iovec_reset(QEMUIOVector
*qiov
)
217 assert(qiov
->nalloc
!= -1);
223 void qemu_iovec_to_buffer(QEMUIOVector
*qiov
, void *buf
)
225 uint8_t *p
= (uint8_t *)buf
;
228 for (i
= 0; i
< qiov
->niov
; ++i
) {
229 memcpy(p
, qiov
->iov
[i
].iov_base
, qiov
->iov
[i
].iov_len
);
230 p
+= qiov
->iov
[i
].iov_len
;
234 size_t qemu_iovec_from_buf(QEMUIOVector
*qiov
, size_t offset
,
235 const void *buf
, size_t bytes
)
237 return iov_from_buf(qiov
->iov
, qiov
->niov
, offset
, buf
, bytes
);
240 size_t qemu_iovec_memset(QEMUIOVector
*qiov
, size_t offset
,
241 int fillc
, size_t bytes
)
243 return iov_memset(qiov
->iov
, qiov
->niov
, offset
, fillc
, bytes
);
247 * Checks if a buffer is all zeroes
249 * Attention! The len must be a multiple of 4 * sizeof(long) due to
250 * restriction of optimizations in this function.
252 bool buffer_is_zero(const void *buf
, size_t len
)
255 * Use long as the biggest available internal data type that fits into the
256 * CPU register and unroll the loop to smooth out the effect of memory
262 const long * const data
= buf
;
264 assert(len
% (4 * sizeof(long)) == 0);
267 for (i
= 0; i
< len
; i
+= 4) {
273 if (d0
|| d1
|| d2
|| d3
) {
282 /* Sets a specific flag */
283 int fcntl_setfl(int fd
, int flag
)
287 flags
= fcntl(fd
, F_GETFL
);
291 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
298 static int64_t suffix_mul(char suffix
, int64_t unit
)
300 switch (qemu_toupper(suffix
)) {
301 case STRTOSZ_DEFSUFFIX_B
:
303 case STRTOSZ_DEFSUFFIX_KB
:
305 case STRTOSZ_DEFSUFFIX_MB
:
307 case STRTOSZ_DEFSUFFIX_GB
:
308 return unit
* unit
* unit
;
309 case STRTOSZ_DEFSUFFIX_TB
:
310 return unit
* unit
* unit
* unit
;
316 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
317 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
318 * in *end, if not NULL. Return -1 on error.
320 int64_t strtosz_suffix_unit(const char *nptr
, char **end
,
321 const char default_suffix
, int64_t unit
)
326 int mul_required
= 0;
327 double val
, mul
, integral
, fraction
;
330 val
= strtod(nptr
, &endptr
);
331 if (isnan(val
) || endptr
== nptr
|| errno
!= 0) {
334 fraction
= modf(val
, &integral
);
339 mul
= suffix_mul(c
, unit
);
343 mul
= suffix_mul(default_suffix
, unit
);
346 if (mul
== 1 && mul_required
) {
349 if ((val
* mul
>= INT64_MAX
) || val
< 0) {
362 int64_t strtosz_suffix(const char *nptr
, char **end
, const char default_suffix
)
364 return strtosz_suffix_unit(nptr
, end
, default_suffix
, 1024);
367 int64_t strtosz(const char *nptr
, char **end
)
369 return strtosz_suffix(nptr
, end
, STRTOSZ_DEFSUFFIX_MB
);
372 int qemu_parse_fd(const char *param
)
377 fd
= strtol(param
, &endptr
, 10);
378 if (*endptr
|| (fd
== 0 && param
== endptr
)) {
385 * Send/recv data with iovec buffers
387 * This function send/recv data from/to the iovec buffer directly.
388 * The first `offset' bytes in the iovec buffer are skipped and next
389 * `len' bytes are used.
393 * do_sendv_recvv(sockfd, iov, len, offset, 1);
397 * char *buf = malloc(size);
398 * iov_to_buf(iov, iovcnt, buf, offset, size);
399 * send(sockfd, buf, size, 0);
402 static int do_sendv_recvv(int sockfd
, struct iovec
*iov
, int len
, int offset
,
405 int ret
, diff
, iovlen
;
406 struct iovec
*last_iov
;
408 /* last_iov is inclusive, so count from one. */
413 while (last_iov
->iov_len
< len
) {
414 len
-= last_iov
->iov_len
;
420 diff
= last_iov
->iov_len
- len
;
421 last_iov
->iov_len
-= diff
;
423 while (iov
->iov_len
<= offset
) {
424 offset
-= iov
->iov_len
;
430 iov
->iov_base
= (char *) iov
->iov_base
+ offset
;
431 iov
->iov_len
-= offset
;
434 #if defined CONFIG_IOVEC && defined CONFIG_POSIX
436 memset(&msg
, 0, sizeof(msg
));
438 msg
.msg_iovlen
= iovlen
;
442 ret
= sendmsg(sockfd
, &msg
, 0);
444 ret
= recvmsg(sockfd
, &msg
, 0);
446 } while (ret
== -1 && errno
== EINTR
);
448 struct iovec
*p
= iov
;
453 rc
= send(sockfd
, p
->iov_base
, p
->iov_len
, 0);
455 rc
= qemu_recv(sockfd
, p
->iov_base
, p
->iov_len
, 0);
458 if (errno
== EINTR
) {
475 /* Undo the changes above */
476 iov
->iov_base
= (char *) iov
->iov_base
- offset
;
477 iov
->iov_len
+= offset
;
478 last_iov
->iov_len
+= diff
;
482 int qemu_recvv(int sockfd
, struct iovec
*iov
, int len
, int iov_offset
)
484 return do_sendv_recvv(sockfd
, iov
, len
, iov_offset
, 0);
487 int qemu_sendv(int sockfd
, struct iovec
*iov
, int len
, int iov_offset
)
489 return do_sendv_recvv(sockfd
, iov
, len
, iov_offset
, 1);