blob: f9a7e3689e04605beebabef940f280e1a8fca572 [file] [log] [blame]
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -08001/*
2 * Simple C functions to supplement the C library
3 *
4 * Copyright (c) 2006 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 */
24#include "qemu-common.h"
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -070025#include "host-utils.h"
David 'Digit' Turner795bb192011-05-09 15:20:22 +020026#include <math.h>
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080027
28void pstrcpy(char *buf, int buf_size, const char *str)
29{
30 int c;
31 char *q = buf;
32
33 if (buf_size <= 0)
34 return;
35
36 for(;;) {
37 c = *str++;
38 if (c == 0 || q >= buf + buf_size - 1)
39 break;
40 *q++ = c;
41 }
42 *q = '\0';
43}
44
45/* strcat and truncate. */
46char *pstrcat(char *buf, int buf_size, const char *s)
47{
48 int len;
49 len = strlen(buf);
50 if (len < buf_size)
51 pstrcpy(buf + len, buf_size - len, s);
52 return buf;
53}
54
55int strstart(const char *str, const char *val, const char **ptr)
56{
57 const char *p, *q;
58 p = str;
59 q = val;
60 while (*q != '\0') {
61 if (*p != *q)
62 return 0;
63 p++;
64 q++;
65 }
66 if (ptr)
67 *ptr = p;
68 return 1;
69}
70
71int stristart(const char *str, const char *val, const char **ptr)
72{
73 const char *p, *q;
74 p = str;
75 q = val;
76 while (*q != '\0') {
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -070077 if (qemu_toupper(*p) != qemu_toupper(*q))
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080078 return 0;
79 p++;
80 q++;
81 }
82 if (ptr)
83 *ptr = p;
84 return 1;
85}
86
David 'Digit' Turner92518662010-05-10 23:26:01 -070087/* XXX: use host strnlen if available ? */
88int qemu_strnlen(const char *s, int max_len)
89{
90 int i;
91
92 for(i = 0; i < max_len; i++) {
93 if (s[i] == '\0') {
94 break;
95 }
96 }
97 return i;
98}
99
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800100time_t mktimegm(struct tm *tm)
101{
102 time_t t;
103 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
104 if (m < 3) {
105 m += 12;
106 y--;
107 }
108 t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
109 y / 400 - 719469);
110 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
111 return t;
112}
113
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700114int qemu_fls(int i)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800115{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700116 return 32 - clz32(i);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800117}
118
David 'Digit' Turnerfd3b1a02010-05-10 23:47:54 -0700119/*
120 * Make sure data goes on disk, but if possible do not bother to
121 * write out the inode just for timestamp updates.
122 *
123 * Unfortunately even in 2009 many operating systems do not support
124 * fdatasync and have to fall back to fsync.
125 */
126int qemu_fdatasync(int fd)
127{
128#ifdef CONFIG_FDATASYNC
129 return fdatasync(fd);
130#else
131 return fsync(fd);
132#endif
133}
134
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700135/* io vectors */
136
137void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800138{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700139 qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
140 qiov->niov = 0;
141 qiov->nalloc = alloc_hint;
142 qiov->size = 0;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800143}
144
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700145void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800146{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700147 int i;
148
149 qiov->iov = iov;
150 qiov->niov = niov;
151 qiov->nalloc = -1;
152 qiov->size = 0;
153 for (i = 0; i < niov; i++)
154 qiov->size += iov[i].iov_len;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800155}
156
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700157void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800158{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700159 assert(qiov->nalloc != -1);
160
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));
164 }
165 qiov->iov[qiov->niov].iov_base = base;
166 qiov->iov[qiov->niov].iov_len = len;
167 qiov->size += len;
168 ++qiov->niov;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800169}
170
David 'Digit' Turner92518662010-05-10 23:26:01 -0700171/*
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200172 * 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.
David 'Digit' Turner92518662010-05-10 23:26:01 -0700177 */
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200178void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
179 size_t size)
David 'Digit' Turner92518662010-05-10 23:26:01 -0700180{
181 int i;
182 size_t done;
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200183 void *iov_base;
184 uint64_t iov_len;
David 'Digit' Turner92518662010-05-10 23:26:01 -0700185
186 assert(dst->nalloc != -1);
187
188 done = 0;
189 for (i = 0; (i < src->niov) && (done != size); i++) {
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200190 if (skip >= src->iov[i].iov_len) {
191 /* Skip the whole iov */
192 skip -= src->iov[i].iov_len;
193 continue;
194 } else {
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;
198 skip = 0;
199 }
200
201 if (done + iov_len > size) {
202 qemu_iovec_add(dst, iov_base, size - done);
David 'Digit' Turner92518662010-05-10 23:26:01 -0700203 break;
204 } else {
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200205 qemu_iovec_add(dst, iov_base, iov_len);
David 'Digit' Turner92518662010-05-10 23:26:01 -0700206 }
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200207 done += iov_len;
David 'Digit' Turner92518662010-05-10 23:26:01 -0700208 }
209}
210
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200211void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size)
212{
213 qemu_iovec_copy(dst, src, 0, size);
214}
215
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700216void qemu_iovec_destroy(QEMUIOVector *qiov)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800217{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700218 assert(qiov->nalloc != -1);
219
220 qemu_free(qiov->iov);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800221}
222
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700223void qemu_iovec_reset(QEMUIOVector *qiov)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800224{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700225 assert(qiov->nalloc != -1);
226
227 qiov->niov = 0;
228 qiov->size = 0;
229}
230
231void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
232{
233 uint8_t *p = (uint8_t *)buf;
234 int i;
235
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;
239 }
240}
241
242void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
243{
244 const uint8_t *p = (const uint8_t *)buf;
245 size_t copy;
246 int i;
247
248 for (i = 0; i < qiov->niov && count; ++i) {
249 copy = count;
250 if (copy > qiov->iov[i].iov_len)
251 copy = qiov->iov[i].iov_len;
252 memcpy(qiov->iov[i].iov_base, p, copy);
253 p += copy;
254 count -= copy;
255 }
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800256}
David Turner6a9ef172010-09-09 22:54:36 +0200257
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200258void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count)
259{
260 size_t n;
261 int i;
262
263 for (i = 0; i < qiov->niov && count; ++i) {
264 n = MIN(count, qiov->iov[i].iov_len);
265 memset(qiov->iov[i].iov_base, c, n);
266 count -= n;
267 }
268}
269
270void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
271 size_t skip)
272{
273 int i;
274 size_t done;
275 void *iov_base;
276 uint64_t iov_len;
277
278 done = 0;
279 for (i = 0; (i < qiov->niov) && (done != count); i++) {
280 if (skip >= qiov->iov[i].iov_len) {
281 /* Skip the whole iov */
282 skip -= qiov->iov[i].iov_len;
283 continue;
284 } else {
285 /* Skip only part (or nothing) of the iov */
286 iov_base = (uint8_t*) qiov->iov[i].iov_base + skip;
287 iov_len = qiov->iov[i].iov_len - skip;
288 skip = 0;
289 }
290
291 if (done + iov_len > count) {
292 memset(iov_base, c, count - done);
293 break;
294 } else {
295 memset(iov_base, c, iov_len);
296 }
297 done += iov_len;
298 }
299}
300
David Turner6a9ef172010-09-09 22:54:36 +0200301#ifndef _WIN32
302/* Sets a specific flag */
303int fcntl_setfl(int fd, int flag)
304{
305 int flags;
306
307 flags = fcntl(fd, F_GETFL);
308 if (flags == -1)
309 return -errno;
310
311 if (fcntl(fd, F_SETFL, flags | flag) == -1)
312 return -errno;
313
314 return 0;
315}
316#endif
317
David 'Digit' Turner795bb192011-05-09 15:20:22 +0200318/*
319 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
320 * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
321 * is MB. End pointer will be returned in *end, if not NULL. A valid
322 * value must be terminated by whitespace, ',' or '\0'. Return -1 on
323 * error.
324 */
325int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
326{
327 int64_t retval = -1;
328 char *endptr;
329 unsigned char c, d;
330 int mul_required = 0;
331 double val, mul, integral, fraction;
332
333 errno = 0;
334 val = strtod(nptr, &endptr);
335 if (isnan(val) || endptr == nptr || errno != 0) {
336 goto fail;
337 }
338 fraction = modf(val, &integral);
339 if (fraction != 0) {
340 mul_required = 1;
341 }
342 /*
343 * Any whitespace character is fine for terminating the number,
344 * in addition we accept ',' to handle strings where the size is
345 * part of a multi token argument.
346 */
347 c = *endptr;
348 d = c;
349 if (qemu_isspace(c) || c == '\0' || c == ',') {
350 c = 0;
351 if (default_suffix) {
352 d = default_suffix;
353 } else {
354 d = c;
355 }
356 }
357 switch (qemu_toupper(d)) {
358 case STRTOSZ_DEFSUFFIX_B:
359 mul = 1;
360 if (mul_required) {
361 goto fail;
362 }
363 break;
364 case STRTOSZ_DEFSUFFIX_KB:
365 mul = 1 << 10;
366 break;
367 case 0:
368 if (mul_required) {
369 goto fail;
370 }
371 case STRTOSZ_DEFSUFFIX_MB:
372 mul = 1ULL << 20;
373 break;
374 case STRTOSZ_DEFSUFFIX_GB:
375 mul = 1ULL << 30;
376 break;
377 case STRTOSZ_DEFSUFFIX_TB:
378 mul = 1ULL << 40;
379 break;
380 default:
381 goto fail;
382 }
383 /*
384 * If not terminated by whitespace, ',', or \0, increment endptr
385 * to point to next character, then check that we are terminated
386 * by an appropriate separating character, ie. whitespace, ',', or
387 * \0. If not, we are seeing trailing garbage, thus fail.
388 */
389 if (c != 0) {
390 endptr++;
391 if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) {
392 goto fail;
393 }
394 }
395 if ((val * mul >= INT64_MAX) || val < 0) {
396 goto fail;
397 }
398 retval = val * mul;
399
400fail:
401 if (end) {
402 *end = endptr;
403 }
404
405 return retval;
406}
407
408int64_t strtosz(const char *nptr, char **end)
409{
410 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
411}