]>
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 | /* |
1b093c48 MT |
175 | * Concatenates (partial) iovecs from src to the end of dst. |
176 | * It starts copying after skipping `soffset' bytes at the | |
177 | * beginning of src and adds individual vectors from src to | |
178 | * dst copies up to `sbytes' bytes total, or up to the end | |
179 | * of src if it comes first. This way, it is okay to specify | |
180 | * very large value for `sbytes' to indicate "up to the end | |
181 | * of src". | |
182 | * Only vector pointers are processed, not the actual data buffers. | |
40b4f539 | 183 | */ |
1b093c48 MT |
184 | void qemu_iovec_concat(QEMUIOVector *dst, |
185 | QEMUIOVector *src, size_t soffset, size_t sbytes) | |
40b4f539 KW |
186 | { |
187 | int i; | |
188 | size_t done; | |
1b093c48 | 189 | struct iovec *siov = src->iov; |
40b4f539 | 190 | assert(dst->nalloc != -1); |
1b093c48 MT |
191 | assert(src->size >= soffset); |
192 | for (i = 0, done = 0; done < sbytes && i < src->niov; i++) { | |
193 | if (soffset < siov[i].iov_len) { | |
194 | size_t len = MIN(siov[i].iov_len - soffset, sbytes - done); | |
195 | qemu_iovec_add(dst, siov[i].iov_base + soffset, len); | |
196 | done += len; | |
197 | soffset = 0; | |
b8a83a4f | 198 | } else { |
1b093c48 | 199 | soffset -= siov[i].iov_len; |
b8a83a4f | 200 | } |
40b4f539 | 201 | } |
1b093c48 | 202 | /* return done; */ |
b8a83a4f KW |
203 | } |
204 | ||
44e3ee8a AL |
205 | void qemu_iovec_destroy(QEMUIOVector *qiov) |
206 | { | |
522584a5 AL |
207 | assert(qiov->nalloc != -1); |
208 | ||
bd83b362 | 209 | qemu_iovec_reset(qiov); |
7267c094 | 210 | g_free(qiov->iov); |
bd83b362 PB |
211 | qiov->nalloc = 0; |
212 | qiov->iov = NULL; | |
44e3ee8a AL |
213 | } |
214 | ||
be959463 AL |
215 | void qemu_iovec_reset(QEMUIOVector *qiov) |
216 | { | |
522584a5 AL |
217 | assert(qiov->nalloc != -1); |
218 | ||
be959463 AL |
219 | qiov->niov = 0; |
220 | qiov->size = 0; | |
221 | } | |
222 | ||
44e3ee8a AL |
223 | void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf) |
224 | { | |
225 | uint8_t *p = (uint8_t *)buf; | |
226 | int i; | |
227 | ||
228 | for (i = 0; i < qiov->niov; ++i) { | |
229 | memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len); | |
230 | p += qiov->iov[i].iov_len; | |
231 | } | |
232 | } | |
233 | ||
03396148 MT |
234 | size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset, |
235 | const void *buf, size_t bytes) | |
44e3ee8a | 236 | { |
03396148 | 237 | return iov_from_buf(qiov->iov, qiov->niov, offset, buf, bytes); |
44e3ee8a | 238 | } |
db1a4972 | 239 | |
3d9b4925 MT |
240 | size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset, |
241 | int fillc, size_t bytes) | |
b8a83a4f | 242 | { |
3d9b4925 | 243 | return iov_memset(qiov->iov, qiov->niov, offset, fillc, bytes); |
e0d9c6f9 CT |
244 | } |
245 | ||
1a6d39fd SH |
246 | /* |
247 | * Checks if a buffer is all zeroes | |
248 | * | |
249 | * Attention! The len must be a multiple of 4 * sizeof(long) due to | |
250 | * restriction of optimizations in this function. | |
251 | */ | |
252 | bool buffer_is_zero(const void *buf, size_t len) | |
253 | { | |
254 | /* | |
255 | * Use long as the biggest available internal data type that fits into the | |
256 | * CPU register and unroll the loop to smooth out the effect of memory | |
257 | * latency. | |
258 | */ | |
259 | ||
260 | size_t i; | |
261 | long d0, d1, d2, d3; | |
262 | const long * const data = buf; | |
263 | ||
264 | assert(len % (4 * sizeof(long)) == 0); | |
265 | len /= sizeof(long); | |
266 | ||
267 | for (i = 0; i < len; i += 4) { | |
268 | d0 = data[i + 0]; | |
269 | d1 = data[i + 1]; | |
270 | d2 = data[i + 2]; | |
271 | d3 = data[i + 3]; | |
272 | ||
273 | if (d0 || d1 || d2 || d3) { | |
274 | return false; | |
275 | } | |
276 | } | |
277 | ||
278 | return true; | |
279 | } | |
280 | ||
db1a4972 PB |
281 | #ifndef _WIN32 |
282 | /* Sets a specific flag */ | |
283 | int fcntl_setfl(int fd, int flag) | |
284 | { | |
285 | int flags; | |
286 | ||
287 | flags = fcntl(fd, F_GETFL); | |
288 | if (flags == -1) | |
289 | return -errno; | |
290 | ||
291 | if (fcntl(fd, F_SETFL, flags | flag) == -1) | |
292 | return -errno; | |
293 | ||
294 | return 0; | |
295 | } | |
296 | #endif | |
297 | ||
eba90e4e MA |
298 | static int64_t suffix_mul(char suffix, int64_t unit) |
299 | { | |
300 | switch (qemu_toupper(suffix)) { | |
301 | case STRTOSZ_DEFSUFFIX_B: | |
302 | return 1; | |
303 | case STRTOSZ_DEFSUFFIX_KB: | |
304 | return unit; | |
305 | case STRTOSZ_DEFSUFFIX_MB: | |
306 | return unit * unit; | |
307 | case STRTOSZ_DEFSUFFIX_GB: | |
308 | return unit * unit * unit; | |
309 | case STRTOSZ_DEFSUFFIX_TB: | |
310 | return unit * unit * unit * unit; | |
311 | } | |
312 | return -1; | |
313 | } | |
314 | ||
9f9b17a4 JS |
315 | /* |
316 | * Convert string to bytes, allowing either B/b for bytes, K/k for KB, | |
8dddfb55 | 317 | * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned |
eba90e4e | 318 | * in *end, if not NULL. Return -1 on error. |
9f9b17a4 | 319 | */ |
a732e1ba JR |
320 | int64_t strtosz_suffix_unit(const char *nptr, char **end, |
321 | const char default_suffix, int64_t unit) | |
9f9b17a4 | 322 | { |
70b4f4bb | 323 | int64_t retval = -1; |
f3bd362a | 324 | char *endptr; |
eba90e4e | 325 | unsigned char c; |
9f9b17a4 JS |
326 | int mul_required = 0; |
327 | double val, mul, integral, fraction; | |
328 | ||
329 | errno = 0; | |
330 | val = strtod(nptr, &endptr); | |
331 | if (isnan(val) || endptr == nptr || errno != 0) { | |
332 | goto fail; | |
333 | } | |
7eb05349 JS |
334 | fraction = modf(val, &integral); |
335 | if (fraction != 0) { | |
9f9b17a4 JS |
336 | mul_required = 1; |
337 | } | |
9f9b17a4 | 338 | c = *endptr; |
eba90e4e MA |
339 | mul = suffix_mul(c, unit); |
340 | if (mul >= 0) { | |
341 | endptr++; | |
342 | } else { | |
343 | mul = suffix_mul(default_suffix, unit); | |
344 | assert(mul >= 0); | |
9f9b17a4 | 345 | } |
eba90e4e | 346 | if (mul == 1 && mul_required) { |
9f9b17a4 JS |
347 | goto fail; |
348 | } | |
70b4f4bb | 349 | if ((val * mul >= INT64_MAX) || val < 0) { |
9f9b17a4 JS |
350 | goto fail; |
351 | } | |
352 | retval = val * mul; | |
353 | ||
354 | fail: | |
355 | if (end) { | |
356 | *end = endptr; | |
357 | } | |
358 | ||
359 | return retval; | |
360 | } | |
d8427002 | 361 | |
a732e1ba JR |
362 | int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) |
363 | { | |
fdc9c41a | 364 | return strtosz_suffix_unit(nptr, end, default_suffix, 1024); |
a732e1ba JR |
365 | } |
366 | ||
70b4f4bb | 367 | int64_t strtosz(const char *nptr, char **end) |
d8427002 JS |
368 | { |
369 | return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); | |
370 | } | |
443916d1 SB |
371 | |
372 | int qemu_parse_fd(const char *param) | |
373 | { | |
374 | int fd; | |
375 | char *endptr = NULL; | |
376 | ||
377 | fd = strtol(param, &endptr, 10); | |
378 | if (*endptr || (fd == 0 && param == endptr)) { | |
379 | return -1; | |
380 | } | |
381 | return fd; | |
382 | } | |
8c5135f9 PB |
383 | |
384 | /* | |
385 | * Send/recv data with iovec buffers | |
386 | * | |
387 | * This function send/recv data from/to the iovec buffer directly. | |
388 | * The first `offset' bytes in the iovec buffer are skipped and next | |
389 | * `len' bytes are used. | |
390 | * | |
391 | * For example, | |
392 | * | |
393 | * do_sendv_recvv(sockfd, iov, len, offset, 1); | |
394 | * | |
395 | * is equal to | |
396 | * | |
397 | * char *buf = malloc(size); | |
398 | * iov_to_buf(iov, iovcnt, buf, offset, size); | |
399 | * send(sockfd, buf, size, 0); | |
400 | * free(buf); | |
401 | */ | |
402 | static int do_sendv_recvv(int sockfd, struct iovec *iov, int len, int offset, | |
403 | int do_sendv) | |
404 | { | |
405 | int ret, diff, iovlen; | |
406 | struct iovec *last_iov; | |
407 | ||
408 | /* last_iov is inclusive, so count from one. */ | |
409 | iovlen = 1; | |
410 | last_iov = iov; | |
411 | len += offset; | |
412 | ||
413 | while (last_iov->iov_len < len) { | |
414 | len -= last_iov->iov_len; | |
415 | ||
416 | last_iov++; | |
417 | iovlen++; | |
418 | } | |
419 | ||
420 | diff = last_iov->iov_len - len; | |
421 | last_iov->iov_len -= diff; | |
422 | ||
423 | while (iov->iov_len <= offset) { | |
424 | offset -= iov->iov_len; | |
425 | ||
426 | iov++; | |
427 | iovlen--; | |
428 | } | |
429 | ||
430 | iov->iov_base = (char *) iov->iov_base + offset; | |
431 | iov->iov_len -= offset; | |
432 | ||
433 | { | |
434 | #if defined CONFIG_IOVEC && defined CONFIG_POSIX | |
435 | struct msghdr msg; | |
436 | memset(&msg, 0, sizeof(msg)); | |
437 | msg.msg_iov = iov; | |
438 | msg.msg_iovlen = iovlen; | |
439 | ||
440 | do { | |
441 | if (do_sendv) { | |
442 | ret = sendmsg(sockfd, &msg, 0); | |
443 | } else { | |
444 | ret = recvmsg(sockfd, &msg, 0); | |
445 | } | |
446 | } while (ret == -1 && errno == EINTR); | |
447 | #else | |
448 | struct iovec *p = iov; | |
449 | ret = 0; | |
450 | while (iovlen > 0) { | |
451 | int rc; | |
452 | if (do_sendv) { | |
453 | rc = send(sockfd, p->iov_base, p->iov_len, 0); | |
454 | } else { | |
455 | rc = qemu_recv(sockfd, p->iov_base, p->iov_len, 0); | |
456 | } | |
457 | if (rc == -1) { | |
458 | if (errno == EINTR) { | |
459 | continue; | |
460 | } | |
461 | if (ret == 0) { | |
462 | ret = -1; | |
463 | } | |
464 | break; | |
465 | } | |
466 | if (rc == 0) { | |
467 | break; | |
468 | } | |
469 | ret += rc; | |
470 | iovlen--, p++; | |
471 | } | |
472 | #endif | |
473 | } | |
474 | ||
475 | /* Undo the changes above */ | |
476 | iov->iov_base = (char *) iov->iov_base - offset; | |
477 | iov->iov_len += offset; | |
478 | last_iov->iov_len += diff; | |
479 | return ret; | |
480 | } | |
481 | ||
482 | int qemu_recvv(int sockfd, struct iovec *iov, int len, int iov_offset) | |
483 | { | |
484 | return do_sendv_recvv(sockfd, iov, len, iov_offset, 0); | |
485 | } | |
486 | ||
487 | int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset) | |
488 | { | |
489 | return do_sendv_recvv(sockfd, iov, len, iov_offset, 1); | |
490 | } | |
491 |