fix spelling in block sub directory
[qemu/ar7.git] / cutils.c
blob6db6304bb464cb06d4777464eeae204e5a4b84d4
1 /*
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
22 * THE SOFTWARE.
24 #include "qemu-common.h"
25 #include "host-utils.h"
26 #include <math.h>
28 void pstrcpy(char *buf, int buf_size, const char *str)
30 int c;
31 char *q = buf;
33 if (buf_size <= 0)
34 return;
36 for(;;) {
37 c = *str++;
38 if (c == 0 || q >= buf + buf_size - 1)
39 break;
40 *q++ = c;
42 *q = '\0';
45 /* strcat and truncate. */
46 char *pstrcat(char *buf, int buf_size, const char *s)
48 int len;
49 len = strlen(buf);
50 if (len < buf_size)
51 pstrcpy(buf + len, buf_size - len, s);
52 return buf;
55 int strstart(const char *str, const char *val, const char **ptr)
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++;
66 if (ptr)
67 *ptr = p;
68 return 1;
71 int stristart(const char *str, const char *val, const char **ptr)
73 const char *p, *q;
74 p = str;
75 q = val;
76 while (*q != '\0') {
77 if (qemu_toupper(*p) != qemu_toupper(*q))
78 return 0;
79 p++;
80 q++;
82 if (ptr)
83 *ptr = p;
84 return 1;
87 /* XXX: use host strnlen if available ? */
88 int qemu_strnlen(const char *s, int max_len)
90 int i;
92 for(i = 0; i < max_len; i++) {
93 if (s[i] == '\0') {
94 break;
97 return i;
100 time_t mktimegm(struct tm *tm)
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--;
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;
114 int qemu_fls(int i)
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);
130 #else
131 return fsync(fd);
132 #endif
135 /* io vectors */
137 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
139 qiov->iov = g_malloc(alloc_hint * sizeof(struct iovec));
140 qiov->niov = 0;
141 qiov->nalloc = alloc_hint;
142 qiov->size = 0;
145 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
147 int i;
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;
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 = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
165 qiov->iov[qiov->niov].iov_base = base;
166 qiov->iov[qiov->niov].iov_len = len;
167 qiov->size += len;
168 ++qiov->niov;
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,
179 size_t size)
181 int i;
182 size_t done;
183 void *iov_base;
184 uint64_t iov_len;
186 assert(dst->nalloc != -1);
188 done = 0;
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;
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;
201 if (done + iov_len > size) {
202 qemu_iovec_add(dst, iov_base, size - done);
203 break;
204 } else {
205 qemu_iovec_add(dst, iov_base, iov_len);
207 done += 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 g_free(qiov->iov);
223 void qemu_iovec_reset(QEMUIOVector *qiov)
225 assert(qiov->nalloc != -1);
227 qiov->niov = 0;
228 qiov->size = 0;
231 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
233 uint8_t *p = (uint8_t *)buf;
234 int i;
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;
242 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
244 const uint8_t *p = (const uint8_t *)buf;
245 size_t copy;
246 int i;
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;
258 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count)
260 size_t n;
261 int i;
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;
270 void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
271 size_t skip)
273 int i;
274 size_t done;
275 void *iov_base;
276 uint64_t iov_len;
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;
291 if (done + iov_len > count) {
292 memset(iov_base, c, count - done);
293 break;
294 } else {
295 memset(iov_base, c, iov_len);
297 done += iov_len;
301 #ifndef _WIN32
302 /* Sets a specific flag */
303 int fcntl_setfl(int fd, int flag)
305 int flags;
307 flags = fcntl(fd, F_GETFL);
308 if (flags == -1)
309 return -errno;
311 if (fcntl(fd, F_SETFL, flags | flag) == -1)
312 return -errno;
314 return 0;
316 #endif
318 static int64_t suffix_mul(char suffix, int64_t unit)
320 switch (qemu_toupper(suffix)) {
321 case STRTOSZ_DEFSUFFIX_B:
322 return 1;
323 case STRTOSZ_DEFSUFFIX_KB:
324 return unit;
325 case STRTOSZ_DEFSUFFIX_MB:
326 return unit * unit;
327 case STRTOSZ_DEFSUFFIX_GB:
328 return unit * unit * unit;
329 case STRTOSZ_DEFSUFFIX_TB:
330 return unit * unit * unit * unit;
332 return -1;
336 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
337 * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
338 * in *end, if not NULL. Return -1 on error.
340 int64_t strtosz_suffix_unit(const char *nptr, char **end,
341 const char default_suffix, int64_t unit)
343 int64_t retval = -1;
344 char *endptr;
345 unsigned char c;
346 int mul_required = 0;
347 double val, mul, integral, fraction;
349 errno = 0;
350 val = strtod(nptr, &endptr);
351 if (isnan(val) || endptr == nptr || errno != 0) {
352 goto fail;
354 fraction = modf(val, &integral);
355 if (fraction != 0) {
356 mul_required = 1;
358 c = *endptr;
359 mul = suffix_mul(c, unit);
360 if (mul >= 0) {
361 endptr++;
362 } else {
363 mul = suffix_mul(default_suffix, unit);
364 assert(mul >= 0);
366 if (mul == 1 && mul_required) {
367 goto fail;
369 if ((val * mul >= INT64_MAX) || val < 0) {
370 goto fail;
372 retval = val * mul;
374 fail:
375 if (end) {
376 *end = endptr;
379 return retval;
382 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
384 return strtosz_suffix_unit(nptr, end, default_suffix, 1024);
387 int64_t strtosz(const char *nptr, char **end)
389 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
392 int qemu_parse_fd(const char *param)
394 int fd;
395 char *endptr = NULL;
397 fd = strtol(param, &endptr, 10);
398 if (*endptr || (fd == 0 && param == endptr)) {
399 return -1;
401 return fd;