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 void pstrcpy(char *buf
, int buf_size
, const char *str
)
38 if (c
== 0 || q
>= buf
+ buf_size
- 1)
45 /* strcat and truncate. */
46 char *pstrcat(char *buf
, int buf_size
, const char *s
)
51 pstrcpy(buf
+ len
, buf_size
- len
, s
);
55 int strstart(const char *str
, const char *val
, const char **ptr
)
71 int stristart(const char *str
, const char *val
, const char **ptr
)
77 if (qemu_toupper(*p
) != qemu_toupper(*q
))
87 /* XXX: use host strnlen if available ? */
88 int qemu_strnlen(const char *s
, int max_len
)
92 for(i
= 0; i
< max_len
; i
++) {
100 time_t mktimegm(struct tm
*tm
)
103 int y
= tm
->tm_year
+ 1900, m
= tm
->tm_mon
+ 1, d
= tm
->tm_mday
;
108 t
= 86400 * (d
+ (153 * m
- 457) / 5 + 365 * y
+ y
/ 4 - y
/ 100 +
110 t
+= 3600 * tm
->tm_hour
+ 60 * tm
->tm_min
+ tm
->tm_sec
;
116 return 32 - clz32(i
);
120 * Make sure data goes on disk, but if possible do not bother to
121 * write out the inode just for timestamp updates.
123 * Unfortunately even in 2009 many operating systems do not support
124 * fdatasync and have to fall back to fsync.
126 int qemu_fdatasync(int fd
)
128 #ifdef CONFIG_FDATASYNC
129 return fdatasync(fd
);
137 void qemu_iovec_init(QEMUIOVector
*qiov
, int alloc_hint
)
139 qiov
->iov
= qemu_malloc(alloc_hint
* sizeof(struct iovec
));
141 qiov
->nalloc
= alloc_hint
;
145 void qemu_iovec_init_external(QEMUIOVector
*qiov
, struct iovec
*iov
, int niov
)
153 for (i
= 0; i
< niov
; i
++)
154 qiov
->size
+= iov
[i
].iov_len
;
157 void qemu_iovec_add(QEMUIOVector
*qiov
, void *base
, size_t len
)
159 assert(qiov
->nalloc
!= -1);
161 if (qiov
->niov
== qiov
->nalloc
) {
162 qiov
->nalloc
= 2 * qiov
->nalloc
+ 1;
163 qiov
->iov
= qemu_realloc(qiov
->iov
, qiov
->nalloc
* sizeof(struct iovec
));
165 qiov
->iov
[qiov
->niov
].iov_base
= base
;
166 qiov
->iov
[qiov
->niov
].iov_len
= len
;
172 * Copies iovecs from src to the end of dst. It starts copying after skipping
173 * the given number of bytes in src and copies until src is completely copied
174 * or the total size of the copied iovec reaches size.The size of the last
175 * copied iovec is changed in order to fit the specified total size if it isn't
176 * a perfect fit already.
178 void qemu_iovec_copy(QEMUIOVector
*dst
, QEMUIOVector
*src
, uint64_t skip
,
186 assert(dst
->nalloc
!= -1);
189 for (i
= 0; (i
< src
->niov
) && (done
!= size
); i
++) {
190 if (skip
>= src
->iov
[i
].iov_len
) {
191 /* Skip the whole iov */
192 skip
-= src
->iov
[i
].iov_len
;
195 /* Skip only part (or nothing) of the iov */
196 iov_base
= (uint8_t*) src
->iov
[i
].iov_base
+ skip
;
197 iov_len
= src
->iov
[i
].iov_len
- skip
;
201 if (done
+ iov_len
> size
) {
202 qemu_iovec_add(dst
, iov_base
, size
- done
);
205 qemu_iovec_add(dst
, iov_base
, iov_len
);
211 void qemu_iovec_concat(QEMUIOVector
*dst
, QEMUIOVector
*src
, size_t size
)
213 qemu_iovec_copy(dst
, src
, 0, size
);
216 void qemu_iovec_destroy(QEMUIOVector
*qiov
)
218 assert(qiov
->nalloc
!= -1);
220 qemu_free(qiov
->iov
);
223 void qemu_iovec_reset(QEMUIOVector
*qiov
)
225 assert(qiov
->nalloc
!= -1);
231 void qemu_iovec_to_buffer(QEMUIOVector
*qiov
, void *buf
)
233 uint8_t *p
= (uint8_t *)buf
;
236 for (i
= 0; i
< qiov
->niov
; ++i
) {
237 memcpy(p
, qiov
->iov
[i
].iov_base
, qiov
->iov
[i
].iov_len
);
238 p
+= qiov
->iov
[i
].iov_len
;
243 * No dma flushing needed here, as the aio code will call dma_bdrv_cb()
244 * on completion as well, which will result in a call to
245 * dma_bdrv_unmap() which will do the flushing ....
247 void qemu_iovec_from_buffer(QEMUIOVector
*qiov
, const void *buf
, size_t count
)
249 const uint8_t *p
= (const uint8_t *)buf
;
253 for (i
= 0; i
< qiov
->niov
&& count
; ++i
) {
255 if (copy
> qiov
->iov
[i
].iov_len
)
256 copy
= qiov
->iov
[i
].iov_len
;
257 memcpy(qiov
->iov
[i
].iov_base
, p
, copy
);
263 void qemu_iovec_memset(QEMUIOVector
*qiov
, int c
, size_t count
)
268 for (i
= 0; i
< qiov
->niov
&& count
; ++i
) {
269 n
= MIN(count
, qiov
->iov
[i
].iov_len
);
270 memset(qiov
->iov
[i
].iov_base
, c
, n
);
276 /* Sets a specific flag */
277 int fcntl_setfl(int fd
, int flag
)
281 flags
= fcntl(fd
, F_GETFL
);
285 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
293 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
294 * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
295 * is MB. End pointer will be returned in *end, if not NULL. A valid
296 * value must be terminated by whitespace, ',' or '\0'. Return -1 on
299 ssize_t
strtosz_suffix(const char *nptr
, char **end
, const char default_suffix
)
303 int mul_required
= 0;
304 double val
, mul
, integral
, fraction
;
307 val
= strtod(nptr
, &endptr
);
308 if (isnan(val
) || endptr
== nptr
|| errno
!= 0) {
311 integral
= modf(val
, &fraction
);
316 * Any whitespace character is fine for terminating the number,
317 * in addition we accept ',' to handle strings where the size is
318 * part of a multi token argument.
322 if (isspace(c
) || c
== '\0' || c
== ',') {
324 if (default_suffix
) {
362 * If not terminated by whitespace, ',', or \0, increment endptr
363 * to point to next character, then check that we are terminated
364 * by an appropriate separating character, ie. whitespace, ',', or
365 * \0. If not, we are seeing trailing garbage, thus fail.
369 if (!isspace(*endptr
) && *endptr
!= ',' && *endptr
!= 0) {
373 if ((val
* mul
>= ~(size_t)0) || val
< 0) {
386 ssize_t
strtosz(const char *nptr
, char **end
)
388 return strtosz_suffix(nptr
, end
, STRTOSZ_DEFSUFFIX_MB
);