]>
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 | 27 | |
8c5135f9 | 28 | #include "qemu_socket.h" |
3d9b4925 | 29 | #include "iov.h" |
8c5135f9 | 30 | |
18607dcb FB |
31 | void pstrcpy(char *buf, int buf_size, const char *str) |
32 | { | |
33 | int c; | |
34 | char *q = buf; | |
35 | ||
36 | if (buf_size <= 0) | |
37 | return; | |
38 | ||
39 | for(;;) { | |
40 | c = *str++; | |
41 | if (c == 0 || q >= buf + buf_size - 1) | |
42 | break; | |
43 | *q++ = c; | |
44 | } | |
45 | *q = '\0'; | |
46 | } | |
47 | ||
48 | /* strcat and truncate. */ | |
49 | char *pstrcat(char *buf, int buf_size, const char *s) | |
50 | { | |
51 | int len; | |
52 | len = strlen(buf); | |
5fafdf24 | 53 | if (len < buf_size) |
18607dcb FB |
54 | pstrcpy(buf + len, buf_size - len, s); |
55 | return buf; | |
56 | } | |
57 | ||
58 | int strstart(const char *str, const char *val, const char **ptr) | |
59 | { | |
60 | const char *p, *q; | |
61 | p = str; | |
62 | q = val; | |
63 | while (*q != '\0') { | |
64 | if (*p != *q) | |
65 | return 0; | |
66 | p++; | |
67 | q++; | |
68 | } | |
69 | if (ptr) | |
70 | *ptr = p; | |
71 | return 1; | |
72 | } | |
73 | ||
74 | int stristart(const char *str, const char *val, const char **ptr) | |
75 | { | |
76 | const char *p, *q; | |
77 | p = str; | |
78 | q = val; | |
79 | while (*q != '\0') { | |
cd390083 | 80 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
18607dcb FB |
81 | return 0; |
82 | p++; | |
83 | q++; | |
84 | } | |
85 | if (ptr) | |
86 | *ptr = p; | |
87 | return 1; | |
88 | } | |
3c6b2088 | 89 | |
d43277c5 BS |
90 | /* XXX: use host strnlen if available ? */ |
91 | int qemu_strnlen(const char *s, int max_len) | |
92 | { | |
93 | int i; | |
94 | ||
95 | for(i = 0; i < max_len; i++) { | |
96 | if (s[i] == '\0') { | |
97 | break; | |
98 | } | |
99 | } | |
100 | return i; | |
101 | } | |
102 | ||
3c6b2088 FB |
103 | time_t mktimegm(struct tm *tm) |
104 | { | |
105 | time_t t; | |
106 | int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; | |
107 | if (m < 3) { | |
108 | m += 12; | |
109 | y--; | |
110 | } | |
111 | t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + | |
112 | y / 400 - 719469); | |
113 | t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; | |
114 | return t; | |
115 | } | |
b39ade83 | 116 | |
ad46db9a | 117 | int qemu_fls(int i) |
b39ade83 | 118 | { |
8d371d4b | 119 | return 32 - clz32(i); |
b39ade83 | 120 | } |
44e3ee8a | 121 | |
6f1953c4 CH |
122 | /* |
123 | * Make sure data goes on disk, but if possible do not bother to | |
124 | * write out the inode just for timestamp updates. | |
125 | * | |
126 | * Unfortunately even in 2009 many operating systems do not support | |
127 | * fdatasync and have to fall back to fsync. | |
128 | */ | |
129 | int qemu_fdatasync(int fd) | |
130 | { | |
5f6b9e8f | 131 | #ifdef CONFIG_FDATASYNC |
6f1953c4 CH |
132 | return fdatasync(fd); |
133 | #else | |
134 | return fsync(fd); | |
135 | #endif | |
136 | } | |
137 | ||
44e3ee8a AL |
138 | /* io vectors */ |
139 | ||
140 | void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint) | |
141 | { | |
7267c094 | 142 | qiov->iov = g_malloc(alloc_hint * sizeof(struct iovec)); |
44e3ee8a AL |
143 | qiov->niov = 0; |
144 | qiov->nalloc = alloc_hint; | |
249aa745 | 145 | qiov->size = 0; |
44e3ee8a AL |
146 | } |
147 | ||
522584a5 AL |
148 | void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov) |
149 | { | |
150 | int i; | |
151 | ||
152 | qiov->iov = iov; | |
153 | qiov->niov = niov; | |
154 | qiov->nalloc = -1; | |
155 | qiov->size = 0; | |
156 | for (i = 0; i < niov; i++) | |
157 | qiov->size += iov[i].iov_len; | |
158 | } | |
159 | ||
44e3ee8a AL |
160 | void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len) |
161 | { | |
522584a5 AL |
162 | assert(qiov->nalloc != -1); |
163 | ||
44e3ee8a AL |
164 | if (qiov->niov == qiov->nalloc) { |
165 | qiov->nalloc = 2 * qiov->nalloc + 1; | |
7267c094 | 166 | qiov->iov = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec)); |
44e3ee8a AL |
167 | } |
168 | qiov->iov[qiov->niov].iov_base = base; | |
169 | qiov->iov[qiov->niov].iov_len = len; | |
249aa745 | 170 | qiov->size += len; |
44e3ee8a AL |
171 | ++qiov->niov; |
172 | } | |
173 | ||
40b4f539 | 174 | /* |
b8a83a4f KW |
175 | * Copies iovecs from src to the end of dst. It starts copying after skipping |
176 | * the given number of bytes in src and copies until src is completely copied | |
177 | * or the total size of the copied iovec reaches size.The size of the last | |
178 | * copied iovec is changed in order to fit the specified total size if it isn't | |
179 | * a perfect fit already. | |
40b4f539 | 180 | */ |
b8a83a4f KW |
181 | void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip, |
182 | size_t size) | |
40b4f539 KW |
183 | { |
184 | int i; | |
185 | size_t done; | |
b8a83a4f KW |
186 | void *iov_base; |
187 | uint64_t iov_len; | |
40b4f539 KW |
188 | |
189 | assert(dst->nalloc != -1); | |
190 | ||
191 | done = 0; | |
192 | for (i = 0; (i < src->niov) && (done != size); i++) { | |
b8a83a4f KW |
193 | if (skip >= src->iov[i].iov_len) { |
194 | /* Skip the whole iov */ | |
195 | skip -= src->iov[i].iov_len; | |
196 | continue; | |
197 | } else { | |
198 | /* Skip only part (or nothing) of the iov */ | |
199 | iov_base = (uint8_t*) src->iov[i].iov_base + skip; | |
200 | iov_len = src->iov[i].iov_len - skip; | |
201 | skip = 0; | |
202 | } | |
203 | ||
204 | if (done + iov_len > size) { | |
205 | qemu_iovec_add(dst, iov_base, size - done); | |
40b4f539 KW |
206 | break; |
207 | } else { | |
b8a83a4f | 208 | qemu_iovec_add(dst, iov_base, iov_len); |
40b4f539 | 209 | } |
b8a83a4f | 210 | done += iov_len; |
40b4f539 KW |
211 | } |
212 | } | |
213 | ||
b8a83a4f KW |
214 | void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size) |
215 | { | |
216 | qemu_iovec_copy(dst, src, 0, size); | |
217 | } | |
218 | ||
44e3ee8a AL |
219 | void qemu_iovec_destroy(QEMUIOVector *qiov) |
220 | { | |
522584a5 AL |
221 | assert(qiov->nalloc != -1); |
222 | ||
bd83b362 | 223 | qemu_iovec_reset(qiov); |
7267c094 | 224 | g_free(qiov->iov); |
bd83b362 PB |
225 | qiov->nalloc = 0; |
226 | qiov->iov = NULL; | |
44e3ee8a AL |
227 | } |
228 | ||
be959463 AL |
229 | void qemu_iovec_reset(QEMUIOVector *qiov) |
230 | { | |
522584a5 AL |
231 | assert(qiov->nalloc != -1); |
232 | ||
be959463 AL |
233 | qiov->niov = 0; |
234 | qiov->size = 0; | |
235 | } | |
236 | ||
44e3ee8a AL |
237 | void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf) |
238 | { | |
239 | uint8_t *p = (uint8_t *)buf; | |
240 | int i; | |
241 | ||
242 | for (i = 0; i < qiov->niov; ++i) { | |
243 | memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len); | |
244 | p += qiov->iov[i].iov_len; | |
245 | } | |
246 | } | |
247 | ||
03396148 MT |
248 | size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset, |
249 | const void *buf, size_t bytes) | |
44e3ee8a | 250 | { |
03396148 | 251 | return iov_from_buf(qiov->iov, qiov->niov, offset, buf, bytes); |
44e3ee8a | 252 | } |
db1a4972 | 253 | |
3d9b4925 MT |
254 | size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset, |
255 | int fillc, size_t bytes) | |
b8a83a4f | 256 | { |
3d9b4925 | 257 | return iov_memset(qiov->iov, qiov->niov, offset, fillc, bytes); |
e0d9c6f9 CT |
258 | } |
259 | ||
1a6d39fd SH |
260 | /* |
261 | * Checks if a buffer is all zeroes | |
262 | * | |
263 | * Attention! The len must be a multiple of 4 * sizeof(long) due to | |
264 | * restriction of optimizations in this function. | |
265 | */ | |
266 | bool buffer_is_zero(const void *buf, size_t len) | |
267 | { | |
268 | /* | |
269 | * Use long as the biggest available internal data type that fits into the | |
270 | * CPU register and unroll the loop to smooth out the effect of memory | |
271 | * latency. | |
272 | */ | |
273 | ||
274 | size_t i; | |
275 | long d0, d1, d2, d3; | |
276 | const long * const data = buf; | |
277 | ||
278 | assert(len % (4 * sizeof(long)) == 0); | |
279 | len /= sizeof(long); | |
280 | ||
281 | for (i = 0; i < len; i += 4) { | |
282 | d0 = data[i + 0]; | |
283 | d1 = data[i + 1]; | |
284 | d2 = data[i + 2]; | |
285 | d3 = data[i + 3]; | |
286 | ||
287 | if (d0 || d1 || d2 || d3) { | |
288 | return false; | |
289 | } | |
290 | } | |
291 | ||
292 | return true; | |
293 | } | |
294 | ||
db1a4972 PB |
295 | #ifndef _WIN32 |
296 | /* Sets a specific flag */ | |
297 | int fcntl_setfl(int fd, int flag) | |
298 | { | |
299 | int flags; | |
300 | ||
301 | flags = fcntl(fd, F_GETFL); | |
302 | if (flags == -1) | |
303 | return -errno; | |
304 | ||
305 | if (fcntl(fd, F_SETFL, flags | flag) == -1) | |
306 | return -errno; | |
307 | ||
308 | return 0; | |
309 | } | |
310 | #endif | |
311 | ||
eba90e4e MA |
312 | static int64_t suffix_mul(char suffix, int64_t unit) |
313 | { | |
314 | switch (qemu_toupper(suffix)) { | |
315 | case STRTOSZ_DEFSUFFIX_B: | |
316 | return 1; | |
317 | case STRTOSZ_DEFSUFFIX_KB: | |
318 | return unit; | |
319 | case STRTOSZ_DEFSUFFIX_MB: | |
320 | return unit * unit; | |
321 | case STRTOSZ_DEFSUFFIX_GB: | |
322 | return unit * unit * unit; | |
323 | case STRTOSZ_DEFSUFFIX_TB: | |
324 | return unit * unit * unit * unit; | |
325 | } | |
326 | return -1; | |
327 | } | |
328 | ||
9f9b17a4 JS |
329 | /* |
330 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, | |
8dddfb55 | 331 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
eba90e4e | 332 | * in *end, if not NULL. Return -1 on error. |
9f9b17a4 | 333 | */ |
a732e1ba JR |
334 | int64_t strtosz_suffix_unit(const char *nptr, char **end, |
335 | const char default_suffix, int64_t unit) | |
9f9b17a4 | 336 | { |
70b4f4bb | 337 | int64_t retval = -1; |
f3bd362a | 338 | char *endptr; |
eba90e4e | 339 | unsigned char c; |
9f9b17a4 JS |
340 | int mul_required = 0; |
341 | double val, mul, integral, fraction; | |
342 | ||
343 | errno = 0; | |
344 | val = strtod(nptr, &endptr); | |
345 | if (isnan(val) || endptr == nptr || errno != 0) { | |
346 | goto fail; | |
347 | } | |
7eb05349 JS |
348 | fraction = modf(val, &integral); |
349 | if (fraction != 0) { | |
9f9b17a4 JS |
350 | mul_required = 1; |
351 | } | |
9f9b17a4 | 352 | c = *endptr; |
eba90e4e MA |
353 | mul = suffix_mul(c, unit); |
354 | if (mul >= 0) { | |
355 | endptr++; | |
356 | } else { | |
357 | mul = suffix_mul(default_suffix, unit); | |
358 | assert(mul >= 0); | |
9f9b17a4 | 359 | } |
eba90e4e | 360 | if (mul == 1 && mul_required) { |
9f9b17a4 JS |
361 | goto fail; |
362 | } | |
70b4f4bb | 363 | if ((val * mul >= INT64_MAX) || val < 0) { |
9f9b17a4 JS |
364 | goto fail; |
365 | } | |
366 | retval = val * mul; | |
367 | ||
368 | fail: | |
369 | if (end) { | |
370 | *end = endptr; | |
371 | } | |
372 | ||
373 | return retval; | |
374 | } | |
d8427002 | 375 | |
a732e1ba JR |
376 | int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) |
377 | { | |
fdc9c41a | 378 | return strtosz_suffix_unit(nptr, end, default_suffix, 1024); |
a732e1ba JR |
379 | } |
380 | ||
70b4f4bb | 381 | int64_t strtosz(const char *nptr, char **end) |
d8427002 JS |
382 | { |
383 | return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); | |
384 | } | |
443916d1 SB |
385 | |
386 | int qemu_parse_fd(const char *param) | |
387 | { | |
388 | int fd; | |
389 | char *endptr = NULL; | |
390 | ||
391 | fd = strtol(param, &endptr, 10); | |
392 | if (*endptr || (fd == 0 && param == endptr)) { | |
393 | return -1; | |
394 | } | |
395 | return fd; | |
396 | } | |
8c5135f9 PB |
397 | |
398 | /* | |
399 | * Send/recv data with iovec buffers | |
400 | * | |
401 | * This function send/recv data from/to the iovec buffer directly. | |
402 | * The first `offset' bytes in the iovec buffer are skipped and next | |
403 | * `len' bytes are used. | |
404 | * | |
405 | * For example, | |
406 | * | |
407 | * do_sendv_recvv(sockfd, iov, len, offset, 1); | |
408 | * | |
409 | * is equal to | |
410 | * | |
411 | * char *buf = malloc(size); | |
412 | * iov_to_buf(iov, iovcnt, buf, offset, size); | |
413 | * send(sockfd, buf, size, 0); | |
414 | * free(buf); | |
415 | */ | |
416 | static int do_sendv_recvv(int sockfd, struct iovec *iov, int len, int offset, | |
417 | int do_sendv) | |
418 | { | |
419 | int ret, diff, iovlen; | |
420 | struct iovec *last_iov; | |
421 | ||
422 | /* last_iov is inclusive, so count from one. */ | |
423 | iovlen = 1; | |
424 | last_iov = iov; | |
425 | len += offset; | |
426 | ||
427 | while (last_iov->iov_len < len) { | |
428 | len -= last_iov->iov_len; | |
429 | ||
430 | last_iov++; | |
431 | iovlen++; | |
432 | } | |
433 | ||
434 | diff = last_iov->iov_len - len; | |
435 | last_iov->iov_len -= diff; | |
436 | ||
437 | while (iov->iov_len <= offset) { | |
438 | offset -= iov->iov_len; | |
439 | ||
440 | iov++; | |
441 | iovlen--; | |
442 | } | |
443 | ||
444 | iov->iov_base = (char *) iov->iov_base + offset; | |
445 | iov->iov_len -= offset; | |
446 | ||
447 | { | |
448 | #if defined CONFIG_IOVEC && defined CONFIG_POSIX | |
449 | struct msghdr msg; | |
450 | memset(&msg, 0, sizeof(msg)); | |
451 | msg.msg_iov = iov; | |
452 | msg.msg_iovlen = iovlen; | |
453 | ||
454 | do { | |
455 | if (do_sendv) { | |
456 | ret = sendmsg(sockfd, &msg, 0); | |
457 | } else { | |
458 | ret = recvmsg(sockfd, &msg, 0); | |
459 | } | |
460 | } while (ret == -1 && errno == EINTR); | |
461 | #else | |
462 | struct iovec *p = iov; | |
463 | ret = 0; | |
464 | while (iovlen > 0) { | |
465 | int rc; | |
466 | if (do_sendv) { | |
467 | rc = send(sockfd, p->iov_base, p->iov_len, 0); | |
468 | } else { | |
469 | rc = qemu_recv(sockfd, p->iov_base, p->iov_len, 0); | |
470 | } | |
471 | if (rc == -1) { | |
472 | if (errno == EINTR) { | |
473 | continue; | |
474 | } | |
475 | if (ret == 0) { | |
476 | ret = -1; | |
477 | } | |
478 | break; | |
479 | } | |
480 | if (rc == 0) { | |
481 | break; | |
482 | } | |
483 | ret += rc; | |
484 | iovlen--, p++; | |
485 | } | |
486 | #endif | |
487 | } | |
488 | ||
489 | /* Undo the changes above */ | |
490 | iov->iov_base = (char *) iov->iov_base - offset; | |
491 | iov->iov_len += offset; | |
492 | last_iov->iov_len += diff; | |
493 | return ret; | |
494 | } | |
495 | ||
496 | int qemu_recvv(int sockfd, struct iovec *iov, int len, int iov_offset) | |
497 | { | |
498 | return do_sendv_recvv(sockfd, iov, len, iov_offset, 0); | |
499 | } | |
500 | ||
501 | int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset) | |
502 | { | |
503 | return do_sendv_recvv(sockfd, iov, len, iov_offset, 1); | |
504 | } | |
505 |