]>
Commit | Line | Data |
---|---|---|
18607dcb FB |
1 | /* |
2 | * Simple C functions to supplement the C library | |
5fafdf24 | 3 | * |
18607dcb FB |
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 | */ | |
faf07963 | 24 | #include "qemu-common.h" |
8d371d4b | 25 | #include "host-utils.h" |
9f9b17a4 | 26 | #include <math.h> |
18607dcb FB |
27 | |
28 | void 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. */ | |
46 | char *pstrcat(char *buf, int buf_size, const char *s) | |
47 | { | |
48 | int len; | |
49 | len = strlen(buf); | |
5fafdf24 | 50 | if (len < buf_size) |
18607dcb FB |
51 | pstrcpy(buf + len, buf_size - len, s); |
52 | return buf; | |
53 | } | |
54 | ||
55 | int 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 | ||
71 | int 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') { | |
cd390083 | 77 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
18607dcb FB |
78 | return 0; |
79 | p++; | |
80 | q++; | |
81 | } | |
82 | if (ptr) | |
83 | *ptr = p; | |
84 | return 1; | |
85 | } | |
3c6b2088 | 86 | |
d43277c5 BS |
87 | /* XXX: use host strnlen if available ? */ |
88 | int 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 | ||
3c6b2088 FB |
100 | time_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 | } | |
b39ade83 | 113 | |
ad46db9a | 114 | int qemu_fls(int i) |
b39ade83 | 115 | { |
8d371d4b | 116 | return 32 - clz32(i); |
b39ade83 | 117 | } |
44e3ee8a | 118 | |
6f1953c4 CH |
119 | /* |
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 | */ | |
126 | int qemu_fdatasync(int fd) | |
127 | { | |
5f6b9e8f | 128 | #ifdef CONFIG_FDATASYNC |
6f1953c4 CH |
129 | return fdatasync(fd); |
130 | #else | |
131 | return fsync(fd); | |
132 | #endif | |
133 | } | |
134 | ||
44e3ee8a AL |
135 | /* io vectors */ |
136 | ||
137 | void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint) | |
138 | { | |
7267c094 | 139 | qiov->iov = g_malloc(alloc_hint * sizeof(struct iovec)); |
44e3ee8a AL |
140 | qiov->niov = 0; |
141 | qiov->nalloc = alloc_hint; | |
249aa745 | 142 | qiov->size = 0; |
44e3ee8a AL |
143 | } |
144 | ||
522584a5 AL |
145 | void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov) |
146 | { | |
147 | 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; | |
155 | } | |
156 | ||
44e3ee8a AL |
157 | void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len) |
158 | { | |
522584a5 AL |
159 | assert(qiov->nalloc != -1); |
160 | ||
44e3ee8a AL |
161 | if (qiov->niov == qiov->nalloc) { |
162 | qiov->nalloc = 2 * qiov->nalloc + 1; | |
7267c094 | 163 | qiov->iov = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec)); |
44e3ee8a AL |
164 | } |
165 | qiov->iov[qiov->niov].iov_base = base; | |
166 | qiov->iov[qiov->niov].iov_len = len; | |
249aa745 | 167 | qiov->size += len; |
44e3ee8a AL |
168 | ++qiov->niov; |
169 | } | |
170 | ||
40b4f539 | 171 | /* |
b8a83a4f KW |
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. | |
40b4f539 | 177 | */ |
b8a83a4f KW |
178 | void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip, |
179 | size_t size) | |
40b4f539 KW |
180 | { |
181 | int i; | |
182 | size_t done; | |
b8a83a4f KW |
183 | void *iov_base; |
184 | uint64_t iov_len; | |
40b4f539 KW |
185 | |
186 | assert(dst->nalloc != -1); | |
187 | ||
188 | done = 0; | |
189 | for (i = 0; (i < src->niov) && (done != size); i++) { | |
b8a83a4f KW |
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; | |
199 | } | |
200 | ||
201 | if (done + iov_len > size) { | |
202 | qemu_iovec_add(dst, iov_base, size - done); | |
40b4f539 KW |
203 | break; |
204 | } else { | |
b8a83a4f | 205 | qemu_iovec_add(dst, iov_base, iov_len); |
40b4f539 | 206 | } |
b8a83a4f | 207 | done += iov_len; |
40b4f539 KW |
208 | } |
209 | } | |
210 | ||
b8a83a4f KW |
211 | void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size) |
212 | { | |
213 | qemu_iovec_copy(dst, src, 0, size); | |
214 | } | |
215 | ||
44e3ee8a AL |
216 | void qemu_iovec_destroy(QEMUIOVector *qiov) |
217 | { | |
522584a5 AL |
218 | assert(qiov->nalloc != -1); |
219 | ||
bd83b362 | 220 | qemu_iovec_reset(qiov); |
7267c094 | 221 | g_free(qiov->iov); |
bd83b362 PB |
222 | qiov->nalloc = 0; |
223 | qiov->iov = NULL; | |
44e3ee8a AL |
224 | } |
225 | ||
be959463 AL |
226 | void qemu_iovec_reset(QEMUIOVector *qiov) |
227 | { | |
522584a5 AL |
228 | assert(qiov->nalloc != -1); |
229 | ||
be959463 AL |
230 | qiov->niov = 0; |
231 | qiov->size = 0; | |
232 | } | |
233 | ||
44e3ee8a AL |
234 | void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf) |
235 | { | |
236 | uint8_t *p = (uint8_t *)buf; | |
237 | int i; | |
238 | ||
239 | for (i = 0; i < qiov->niov; ++i) { | |
240 | memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len); | |
241 | p += qiov->iov[i].iov_len; | |
242 | } | |
243 | } | |
244 | ||
249aa745 | 245 | void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count) |
44e3ee8a AL |
246 | { |
247 | const uint8_t *p = (const uint8_t *)buf; | |
249aa745 | 248 | size_t copy; |
44e3ee8a AL |
249 | int i; |
250 | ||
249aa745 AL |
251 | for (i = 0; i < qiov->niov && count; ++i) { |
252 | copy = count; | |
253 | if (copy > qiov->iov[i].iov_len) | |
254 | copy = qiov->iov[i].iov_len; | |
255 | memcpy(qiov->iov[i].iov_base, p, copy); | |
256 | p += copy; | |
257 | count -= copy; | |
44e3ee8a AL |
258 | } |
259 | } | |
db1a4972 | 260 | |
b8a83a4f KW |
261 | void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count) |
262 | { | |
263 | size_t n; | |
264 | int i; | |
265 | ||
266 | for (i = 0; i < qiov->niov && count; ++i) { | |
267 | n = MIN(count, qiov->iov[i].iov_len); | |
268 | memset(qiov->iov[i].iov_base, c, n); | |
269 | count -= n; | |
270 | } | |
271 | } | |
272 | ||
e0d9c6f9 CT |
273 | void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count, |
274 | size_t skip) | |
275 | { | |
276 | int i; | |
277 | size_t done; | |
278 | void *iov_base; | |
279 | uint64_t iov_len; | |
280 | ||
281 | done = 0; | |
282 | for (i = 0; (i < qiov->niov) && (done != count); i++) { | |
283 | if (skip >= qiov->iov[i].iov_len) { | |
284 | /* Skip the whole iov */ | |
285 | skip -= qiov->iov[i].iov_len; | |
286 | continue; | |
287 | } else { | |
288 | /* Skip only part (or nothing) of the iov */ | |
289 | iov_base = (uint8_t*) qiov->iov[i].iov_base + skip; | |
290 | iov_len = qiov->iov[i].iov_len - skip; | |
291 | skip = 0; | |
292 | } | |
293 | ||
294 | if (done + iov_len > count) { | |
295 | memset(iov_base, c, count - done); | |
296 | break; | |
297 | } else { | |
298 | memset(iov_base, c, iov_len); | |
299 | } | |
300 | done += iov_len; | |
301 | } | |
302 | } | |
303 | ||
db1a4972 PB |
304 | #ifndef _WIN32 |
305 | /* Sets a specific flag */ | |
306 | int fcntl_setfl(int fd, int flag) | |
307 | { | |
308 | int flags; | |
309 | ||
310 | flags = fcntl(fd, F_GETFL); | |
311 | if (flags == -1) | |
312 | return -errno; | |
313 | ||
314 | if (fcntl(fd, F_SETFL, flags | flag) == -1) | |
315 | return -errno; | |
316 | ||
317 | return 0; | |
318 | } | |
319 | #endif | |
320 | ||
eba90e4e MA |
321 | static int64_t suffix_mul(char suffix, int64_t unit) |
322 | { | |
323 | switch (qemu_toupper(suffix)) { | |
324 | case STRTOSZ_DEFSUFFIX_B: | |
325 | return 1; | |
326 | case STRTOSZ_DEFSUFFIX_KB: | |
327 | return unit; | |
328 | case STRTOSZ_DEFSUFFIX_MB: | |
329 | return unit * unit; | |
330 | case STRTOSZ_DEFSUFFIX_GB: | |
331 | return unit * unit * unit; | |
332 | case STRTOSZ_DEFSUFFIX_TB: | |
333 | return unit * unit * unit * unit; | |
334 | } | |
335 | return -1; | |
336 | } | |
337 | ||
9f9b17a4 JS |
338 | /* |
339 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, | |
8dddfb55 | 340 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
eba90e4e | 341 | * in *end, if not NULL. Return -1 on error. |
9f9b17a4 | 342 | */ |
a732e1ba JR |
343 | int64_t strtosz_suffix_unit(const char *nptr, char **end, |
344 | const char default_suffix, int64_t unit) | |
9f9b17a4 | 345 | { |
70b4f4bb | 346 | int64_t retval = -1; |
f3bd362a | 347 | char *endptr; |
eba90e4e | 348 | unsigned char c; |
9f9b17a4 JS |
349 | int mul_required = 0; |
350 | double val, mul, integral, fraction; | |
351 | ||
352 | errno = 0; | |
353 | val = strtod(nptr, &endptr); | |
354 | if (isnan(val) || endptr == nptr || errno != 0) { | |
355 | goto fail; | |
356 | } | |
7eb05349 JS |
357 | fraction = modf(val, &integral); |
358 | if (fraction != 0) { | |
9f9b17a4 JS |
359 | mul_required = 1; |
360 | } | |
9f9b17a4 | 361 | c = *endptr; |
eba90e4e MA |
362 | mul = suffix_mul(c, unit); |
363 | if (mul >= 0) { | |
364 | endptr++; | |
365 | } else { | |
366 | mul = suffix_mul(default_suffix, unit); | |
367 | assert(mul >= 0); | |
9f9b17a4 | 368 | } |
eba90e4e | 369 | if (mul == 1 && mul_required) { |
9f9b17a4 JS |
370 | goto fail; |
371 | } | |
70b4f4bb | 372 | if ((val * mul >= INT64_MAX) || val < 0) { |
9f9b17a4 JS |
373 | goto fail; |
374 | } | |
375 | retval = val * mul; | |
376 | ||
377 | fail: | |
378 | if (end) { | |
379 | *end = endptr; | |
380 | } | |
381 | ||
382 | return retval; | |
383 | } | |
d8427002 | 384 | |
a732e1ba JR |
385 | int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) |
386 | { | |
fdc9c41a | 387 | return strtosz_suffix_unit(nptr, end, default_suffix, 1024); |
a732e1ba JR |
388 | } |
389 | ||
70b4f4bb | 390 | int64_t strtosz(const char *nptr, char **end) |
d8427002 JS |
391 | { |
392 | return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); | |
393 | } | |
443916d1 SB |
394 | |
395 | int qemu_parse_fd(const char *param) | |
396 | { | |
397 | int fd; | |
398 | char *endptr = NULL; | |
399 | ||
400 | fd = strtol(param, &endptr, 10); | |
401 | if (*endptr || (fd == 0 && param == endptr)) { | |
402 | return -1; | |
403 | } | |
404 | return fd; | |
405 | } |