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 strpadcpy(char *buf, int buf_size, const char *str, char pad)
33 int len = qemu_strnlen(str, buf_size);
34 memcpy(buf, str, len);
35 memset(buf + len, pad, buf_size - len);
38 void pstrcpy(char *buf, int buf_size, const char *str)
48 if (c == 0 || q >= buf + buf_size - 1)
55 /* strcat and truncate. */
56 char *pstrcat(char *buf, int buf_size, const char *s)
61 pstrcpy(buf + len, buf_size - len, s);
65 int strstart(const char *str, const char *val, const char **ptr)
81 int stristart(const char *str, const char *val, const char **ptr)
87 if (qemu_toupper(*p) != qemu_toupper(*q))
97 /* XXX: use host strnlen if available ? */
98 int qemu_strnlen(const char *s, int max_len)
102 for(i = 0; i < max_len; i++) {
110 time_t mktimegm(struct tm *tm)
113 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
118 t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
120 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
126 return 32 - clz32(i);
130 * Make sure data goes on disk, but if possible do not bother to
131 * write out the inode just for timestamp updates.
133 * Unfortunately even in 2009 many operating systems do not support
134 * fdatasync and have to fall back to fsync.
136 int qemu_fdatasync(int fd)
138 #ifdef CONFIG_FDATASYNC
139 return fdatasync(fd);
147 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
149 qiov->iov = g_malloc(alloc_hint * sizeof(struct iovec));
151 qiov->nalloc = alloc_hint;
155 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
163 for (i = 0; i < niov; i++)
164 qiov->size += iov[i].iov_len;
167 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
169 assert(qiov->nalloc != -1);
171 if (qiov->niov == qiov->nalloc) {
172 qiov->nalloc = 2 * qiov->nalloc + 1;
173 qiov->iov = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
175 qiov->iov[qiov->niov].iov_base = base;
176 qiov->iov[qiov->niov].iov_len = len;
182 * Concatenates (partial) iovecs from src to the end of dst.
183 * It starts copying after skipping `soffset' bytes at the
184 * beginning of src and adds individual vectors from src to
185 * dst copies up to `sbytes' bytes total, or up to the end
186 * of src if it comes first. This way, it is okay to specify
187 * very large value for `sbytes' to indicate "up to the end
189 * Only vector pointers are processed, not the actual data buffers.
191 void qemu_iovec_concat(QEMUIOVector *dst,
192 QEMUIOVector *src, size_t soffset, size_t sbytes)
196 struct iovec *siov = src->iov;
197 assert(dst->nalloc != -1);
198 assert(src->size >= soffset);
199 for (i = 0, done = 0; done < sbytes && i < src->niov; i++) {
200 if (soffset < siov[i].iov_len) {
201 size_t len = MIN(siov[i].iov_len - soffset, sbytes - done);
202 qemu_iovec_add(dst, siov[i].iov_base + soffset, len);
206 soffset -= siov[i].iov_len;
212 void qemu_iovec_destroy(QEMUIOVector *qiov)
214 assert(qiov->nalloc != -1);
216 qemu_iovec_reset(qiov);
222 void qemu_iovec_reset(QEMUIOVector *qiov)
224 assert(qiov->nalloc != -1);
230 size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,
231 void *buf, size_t bytes)
233 return iov_to_buf(qiov->iov, qiov->niov, offset, buf, bytes);
236 size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
237 const void *buf, size_t bytes)
239 return iov_from_buf(qiov->iov, qiov->niov, offset, buf, bytes);
242 size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
243 int fillc, size_t bytes)
245 return iov_memset(qiov->iov, qiov->niov, offset, fillc, bytes);
249 * Checks if a buffer is all zeroes
251 * Attention! The len must be a multiple of 4 * sizeof(long) due to
252 * restriction of optimizations in this function.
254 bool buffer_is_zero(const void *buf, size_t len)
257 * Use long as the biggest available internal data type that fits into the
258 * CPU register and unroll the loop to smooth out the effect of memory
264 const long * const data = buf;
266 assert(len % (4 * sizeof(long)) == 0);
269 for (i = 0; i < len; i += 4) {
275 if (d0 || d1 || d2 || d3) {
284 /* Sets a specific flag */
285 int fcntl_setfl(int fd, int flag)
289 flags = fcntl(fd, F_GETFL);
293 if (fcntl(fd, F_SETFL, flags | flag) == -1)
300 static int64_t suffix_mul(char suffix, int64_t unit)
302 switch (qemu_toupper(suffix)) {
303 case STRTOSZ_DEFSUFFIX_B:
305 case STRTOSZ_DEFSUFFIX_KB:
307 case STRTOSZ_DEFSUFFIX_MB:
309 case STRTOSZ_DEFSUFFIX_GB:
310 return unit * unit * unit;
311 case STRTOSZ_DEFSUFFIX_TB:
312 return unit * unit * unit * unit;
318 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
319 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
320 * in *end, if not NULL. Return -1 on error.
322 int64_t strtosz_suffix_unit(const char *nptr, char **end,
323 const char default_suffix, int64_t unit)
328 int mul_required = 0;
329 double val, mul, integral, fraction;
332 val = strtod(nptr, &endptr);
333 if (isnan(val) || endptr == nptr || errno != 0) {
336 fraction = modf(val, &integral);
341 mul = suffix_mul(c, unit);
345 mul = suffix_mul(default_suffix, unit);
348 if (mul == 1 && mul_required) {
351 if ((val * mul >= INT64_MAX) || val < 0) {
364 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
366 return strtosz_suffix_unit(nptr, end, default_suffix, 1024);
369 int64_t strtosz(const char *nptr, char **end)
371 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
374 int qemu_parse_fd(const char *param)
379 fd = strtol(param, &endptr, 10);
380 if (*endptr || (fd == 0 && param == endptr)) {