]> git.proxmox.com Git - mirror_qemu.git/blob - util/cutils.c
Merge tag 'linux-user-for-7.0-pull-request' of https://gitlab.com/laurent_vivier...
[mirror_qemu.git] / util / cutils.c
1 /*
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
25 #include "qemu/osdep.h"
26 #include "qemu/host-utils.h"
27 #include <math.h>
28
29 #include "qemu-common.h"
30 #include "qemu/ctype.h"
31 #include "qemu/cutils.h"
32 #include "qemu/error-report.h"
33
34 void strpadcpy(char *buf, int buf_size, const char *str, char pad)
35 {
36 int len = qemu_strnlen(str, buf_size);
37 memcpy(buf, str, len);
38 memset(buf + len, pad, buf_size - len);
39 }
40
41 void pstrcpy(char *buf, int buf_size, const char *str)
42 {
43 int c;
44 char *q = buf;
45
46 if (buf_size <= 0)
47 return;
48
49 for(;;) {
50 c = *str++;
51 if (c == 0 || q >= buf + buf_size - 1)
52 break;
53 *q++ = c;
54 }
55 *q = '\0';
56 }
57
58 /* strcat and truncate. */
59 char *pstrcat(char *buf, int buf_size, const char *s)
60 {
61 int len;
62 len = strlen(buf);
63 if (len < buf_size)
64 pstrcpy(buf + len, buf_size - len, s);
65 return buf;
66 }
67
68 int strstart(const char *str, const char *val, const char **ptr)
69 {
70 const char *p, *q;
71 p = str;
72 q = val;
73 while (*q != '\0') {
74 if (*p != *q)
75 return 0;
76 p++;
77 q++;
78 }
79 if (ptr)
80 *ptr = p;
81 return 1;
82 }
83
84 int stristart(const char *str, const char *val, const char **ptr)
85 {
86 const char *p, *q;
87 p = str;
88 q = val;
89 while (*q != '\0') {
90 if (qemu_toupper(*p) != qemu_toupper(*q))
91 return 0;
92 p++;
93 q++;
94 }
95 if (ptr)
96 *ptr = p;
97 return 1;
98 }
99
100 /* XXX: use host strnlen if available ? */
101 int qemu_strnlen(const char *s, int max_len)
102 {
103 int i;
104
105 for(i = 0; i < max_len; i++) {
106 if (s[i] == '\0') {
107 break;
108 }
109 }
110 return i;
111 }
112
113 char *qemu_strsep(char **input, const char *delim)
114 {
115 char *result = *input;
116 if (result != NULL) {
117 char *p;
118
119 for (p = result; *p != '\0'; p++) {
120 if (strchr(delim, *p)) {
121 break;
122 }
123 }
124 if (*p == '\0') {
125 *input = NULL;
126 } else {
127 *p = '\0';
128 *input = p + 1;
129 }
130 }
131 return result;
132 }
133
134 time_t mktimegm(struct tm *tm)
135 {
136 time_t t;
137 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
138 if (m < 3) {
139 m += 12;
140 y--;
141 }
142 t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
143 y / 400 - 719469);
144 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
145 return t;
146 }
147
148 /*
149 * Make sure data goes on disk, but if possible do not bother to
150 * write out the inode just for timestamp updates.
151 *
152 * Unfortunately even in 2009 many operating systems do not support
153 * fdatasync and have to fall back to fsync.
154 */
155 int qemu_fdatasync(int fd)
156 {
157 #ifdef CONFIG_FDATASYNC
158 return fdatasync(fd);
159 #else
160 return fsync(fd);
161 #endif
162 }
163
164 /**
165 * Sync changes made to the memory mapped file back to the backing
166 * storage. For POSIX compliant systems this will fallback
167 * to regular msync call. Otherwise it will trigger whole file sync
168 * (including the metadata case there is no support to skip that otherwise)
169 *
170 * @addr - start of the memory area to be synced
171 * @length - length of the are to be synced
172 * @fd - file descriptor for the file to be synced
173 * (mandatory only for POSIX non-compliant systems)
174 */
175 int qemu_msync(void *addr, size_t length, int fd)
176 {
177 #ifdef CONFIG_POSIX
178 size_t align_mask = ~(qemu_real_host_page_size - 1);
179
180 /**
181 * There are no strict reqs as per the length of mapping
182 * to be synced. Still the length needs to follow the address
183 * alignment changes. Additionally - round the size to the multiple
184 * of PAGE_SIZE
185 */
186 length += ((uintptr_t)addr & (qemu_real_host_page_size - 1));
187 length = (length + ~align_mask) & align_mask;
188
189 addr = (void *)((uintptr_t)addr & align_mask);
190
191 return msync(addr, length, MS_SYNC);
192 #else /* CONFIG_POSIX */
193 /**
194 * Perform the sync based on the file descriptor
195 * The sync range will most probably be wider than the one
196 * requested - but it will still get the job done
197 */
198 return qemu_fdatasync(fd);
199 #endif /* CONFIG_POSIX */
200 }
201
202 #ifndef _WIN32
203 /* Sets a specific flag */
204 int fcntl_setfl(int fd, int flag)
205 {
206 int flags;
207
208 flags = fcntl(fd, F_GETFL);
209 if (flags == -1)
210 return -errno;
211
212 if (fcntl(fd, F_SETFL, flags | flag) == -1)
213 return -errno;
214
215 return 0;
216 }
217 #endif
218
219 static int64_t suffix_mul(char suffix, int64_t unit)
220 {
221 switch (qemu_toupper(suffix)) {
222 case 'B':
223 return 1;
224 case 'K':
225 return unit;
226 case 'M':
227 return unit * unit;
228 case 'G':
229 return unit * unit * unit;
230 case 'T':
231 return unit * unit * unit * unit;
232 case 'P':
233 return unit * unit * unit * unit * unit;
234 case 'E':
235 return unit * unit * unit * unit * unit * unit;
236 }
237 return -1;
238 }
239
240 /*
241 * Convert size string to bytes.
242 *
243 * The size parsing supports the following syntaxes
244 * - 12345 - decimal, scale determined by @default_suffix and @unit
245 * - 12345{bBkKmMgGtTpPeE} - decimal, scale determined by suffix and @unit
246 * - 12345.678{kKmMgGtTpPeE} - decimal, scale determined by suffix, and
247 * fractional portion is truncated to byte
248 * - 0x7fEE - hexadecimal, unit determined by @default_suffix
249 *
250 * The following cause a deprecation warning, and may be removed in the future
251 * - 0xabc{kKmMgGtTpP} - hex with scaling suffix
252 *
253 * The following are intentionally not supported
254 * - octal, such as 08
255 * - fractional hex, such as 0x1.8
256 * - floating point exponents, such as 1e3
257 *
258 * The end pointer will be returned in *end, if not NULL. If there is
259 * no fraction, the input can be decimal or hexadecimal; if there is a
260 * fraction, then the input must be decimal and there must be a suffix
261 * (possibly by @default_suffix) larger than Byte, and the fractional
262 * portion may suffer from precision loss or rounding. The input must
263 * be positive.
264 *
265 * Return -ERANGE on overflow (with *@end advanced), and -EINVAL on
266 * other error (with *@end left unchanged).
267 */
268 static int do_strtosz(const char *nptr, const char **end,
269 const char default_suffix, int64_t unit,
270 uint64_t *result)
271 {
272 int retval;
273 const char *endptr, *f;
274 unsigned char c;
275 bool hex = false;
276 uint64_t val, valf = 0;
277 int64_t mul;
278
279 /* Parse integral portion as decimal. */
280 retval = qemu_strtou64(nptr, &endptr, 10, &val);
281 if (retval) {
282 goto out;
283 }
284 if (memchr(nptr, '-', endptr - nptr) != NULL) {
285 endptr = nptr;
286 retval = -EINVAL;
287 goto out;
288 }
289 if (val == 0 && (*endptr == 'x' || *endptr == 'X')) {
290 /* Input looks like hex, reparse, and insist on no fraction. */
291 retval = qemu_strtou64(nptr, &endptr, 16, &val);
292 if (retval) {
293 goto out;
294 }
295 if (*endptr == '.') {
296 endptr = nptr;
297 retval = -EINVAL;
298 goto out;
299 }
300 hex = true;
301 } else if (*endptr == '.') {
302 /*
303 * Input looks like a fraction. Make sure even 1.k works
304 * without fractional digits. If we see an exponent, treat
305 * the entire input as invalid instead.
306 */
307 double fraction;
308
309 f = endptr;
310 retval = qemu_strtod_finite(f, &endptr, &fraction);
311 if (retval) {
312 endptr++;
313 } else if (memchr(f, 'e', endptr - f) || memchr(f, 'E', endptr - f)) {
314 endptr = nptr;
315 retval = -EINVAL;
316 goto out;
317 } else {
318 /* Extract into a 64-bit fixed-point fraction. */
319 valf = (uint64_t)(fraction * 0x1p64);
320 }
321 }
322 c = *endptr;
323 mul = suffix_mul(c, unit);
324 if (mul > 0) {
325 if (hex) {
326 warn_report("Using a multiplier suffix on hex numbers "
327 "is deprecated: %s", nptr);
328 }
329 endptr++;
330 } else {
331 mul = suffix_mul(default_suffix, unit);
332 assert(mul > 0);
333 }
334 if (mul == 1) {
335 /* When a fraction is present, a scale is required. */
336 if (valf != 0) {
337 endptr = nptr;
338 retval = -EINVAL;
339 goto out;
340 }
341 } else {
342 uint64_t valh, tmp;
343
344 /* Compute exact result: 64.64 x 64.0 -> 128.64 fixed point */
345 mulu64(&val, &valh, val, mul);
346 mulu64(&valf, &tmp, valf, mul);
347 val += tmp;
348 valh += val < tmp;
349
350 /* Round 0.5 upward. */
351 tmp = valf >> 63;
352 val += tmp;
353 valh += val < tmp;
354
355 /* Report overflow. */
356 if (valh != 0) {
357 retval = -ERANGE;
358 goto out;
359 }
360 }
361
362 retval = 0;
363
364 out:
365 if (end) {
366 *end = endptr;
367 } else if (*endptr) {
368 retval = -EINVAL;
369 }
370 if (retval == 0) {
371 *result = val;
372 }
373
374 return retval;
375 }
376
377 int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
378 {
379 return do_strtosz(nptr, end, 'B', 1024, result);
380 }
381
382 int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
383 {
384 return do_strtosz(nptr, end, 'M', 1024, result);
385 }
386
387 int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
388 {
389 return do_strtosz(nptr, end, 'B', 1000, result);
390 }
391
392 /**
393 * Helper function for error checking after strtol() and the like
394 */
395 static int check_strtox_error(const char *nptr, char *ep,
396 const char **endptr, bool check_zero,
397 int libc_errno)
398 {
399 assert(ep >= nptr);
400
401 /* Windows has a bug in that it fails to parse 0 from "0x" in base 16 */
402 if (check_zero && ep == nptr && libc_errno == 0) {
403 char *tmp;
404
405 errno = 0;
406 if (strtol(nptr, &tmp, 10) == 0 && errno == 0 &&
407 (*tmp == 'x' || *tmp == 'X')) {
408 ep = tmp;
409 }
410 }
411
412 if (endptr) {
413 *endptr = ep;
414 }
415
416 /* Turn "no conversion" into an error */
417 if (libc_errno == 0 && ep == nptr) {
418 return -EINVAL;
419 }
420
421 /* Fail when we're expected to consume the string, but didn't */
422 if (!endptr && *ep) {
423 return -EINVAL;
424 }
425
426 return -libc_errno;
427 }
428
429 /**
430 * Convert string @nptr to an integer, and store it in @result.
431 *
432 * This is a wrapper around strtol() that is harder to misuse.
433 * Semantics of @nptr, @endptr, @base match strtol() with differences
434 * noted below.
435 *
436 * @nptr may be null, and no conversion is performed then.
437 *
438 * If no conversion is performed, store @nptr in *@endptr and return
439 * -EINVAL.
440 *
441 * If @endptr is null, and the string isn't fully converted, return
442 * -EINVAL. This is the case when the pointer that would be stored in
443 * a non-null @endptr points to a character other than '\0'.
444 *
445 * If the conversion overflows @result, store INT_MAX in @result,
446 * and return -ERANGE.
447 *
448 * If the conversion underflows @result, store INT_MIN in @result,
449 * and return -ERANGE.
450 *
451 * Else store the converted value in @result, and return zero.
452 */
453 int qemu_strtoi(const char *nptr, const char **endptr, int base,
454 int *result)
455 {
456 char *ep;
457 long long lresult;
458
459 assert((unsigned) base <= 36 && base != 1);
460 if (!nptr) {
461 if (endptr) {
462 *endptr = nptr;
463 }
464 return -EINVAL;
465 }
466
467 errno = 0;
468 lresult = strtoll(nptr, &ep, base);
469 if (lresult < INT_MIN) {
470 *result = INT_MIN;
471 errno = ERANGE;
472 } else if (lresult > INT_MAX) {
473 *result = INT_MAX;
474 errno = ERANGE;
475 } else {
476 *result = lresult;
477 }
478 return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
479 }
480
481 /**
482 * Convert string @nptr to an unsigned integer, and store it in @result.
483 *
484 * This is a wrapper around strtoul() that is harder to misuse.
485 * Semantics of @nptr, @endptr, @base match strtoul() with differences
486 * noted below.
487 *
488 * @nptr may be null, and no conversion is performed then.
489 *
490 * If no conversion is performed, store @nptr in *@endptr and return
491 * -EINVAL.
492 *
493 * If @endptr is null, and the string isn't fully converted, return
494 * -EINVAL. This is the case when the pointer that would be stored in
495 * a non-null @endptr points to a character other than '\0'.
496 *
497 * If the conversion overflows @result, store UINT_MAX in @result,
498 * and return -ERANGE.
499 *
500 * Else store the converted value in @result, and return zero.
501 *
502 * Note that a number with a leading minus sign gets converted without
503 * the minus sign, checked for overflow (see above), then negated (in
504 * @result's type). This is exactly how strtoul() works.
505 */
506 int qemu_strtoui(const char *nptr, const char **endptr, int base,
507 unsigned int *result)
508 {
509 char *ep;
510 long long lresult;
511
512 assert((unsigned) base <= 36 && base != 1);
513 if (!nptr) {
514 if (endptr) {
515 *endptr = nptr;
516 }
517 return -EINVAL;
518 }
519
520 errno = 0;
521 lresult = strtoull(nptr, &ep, base);
522
523 /* Windows returns 1 for negative out-of-range values. */
524 if (errno == ERANGE) {
525 *result = -1;
526 } else {
527 if (lresult > UINT_MAX) {
528 *result = UINT_MAX;
529 errno = ERANGE;
530 } else if (lresult < INT_MIN) {
531 *result = UINT_MAX;
532 errno = ERANGE;
533 } else {
534 *result = lresult;
535 }
536 }
537 return check_strtox_error(nptr, ep, endptr, lresult == 0, errno);
538 }
539
540 /**
541 * Convert string @nptr to a long integer, and store it in @result.
542 *
543 * This is a wrapper around strtol() that is harder to misuse.
544 * Semantics of @nptr, @endptr, @base match strtol() with differences
545 * noted below.
546 *
547 * @nptr may be null, and no conversion is performed then.
548 *
549 * If no conversion is performed, store @nptr in *@endptr and return
550 * -EINVAL.
551 *
552 * If @endptr is null, and the string isn't fully converted, return
553 * -EINVAL. This is the case when the pointer that would be stored in
554 * a non-null @endptr points to a character other than '\0'.
555 *
556 * If the conversion overflows @result, store LONG_MAX in @result,
557 * and return -ERANGE.
558 *
559 * If the conversion underflows @result, store LONG_MIN in @result,
560 * and return -ERANGE.
561 *
562 * Else store the converted value in @result, and return zero.
563 */
564 int qemu_strtol(const char *nptr, const char **endptr, int base,
565 long *result)
566 {
567 char *ep;
568
569 assert((unsigned) base <= 36 && base != 1);
570 if (!nptr) {
571 if (endptr) {
572 *endptr = nptr;
573 }
574 return -EINVAL;
575 }
576
577 errno = 0;
578 *result = strtol(nptr, &ep, base);
579 return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
580 }
581
582 /**
583 * Convert string @nptr to an unsigned long, and store it in @result.
584 *
585 * This is a wrapper around strtoul() that is harder to misuse.
586 * Semantics of @nptr, @endptr, @base match strtoul() with differences
587 * noted below.
588 *
589 * @nptr may be null, and no conversion is performed then.
590 *
591 * If no conversion is performed, store @nptr in *@endptr and return
592 * -EINVAL.
593 *
594 * If @endptr is null, and the string isn't fully converted, return
595 * -EINVAL. This is the case when the pointer that would be stored in
596 * a non-null @endptr points to a character other than '\0'.
597 *
598 * If the conversion overflows @result, store ULONG_MAX in @result,
599 * and return -ERANGE.
600 *
601 * Else store the converted value in @result, and return zero.
602 *
603 * Note that a number with a leading minus sign gets converted without
604 * the minus sign, checked for overflow (see above), then negated (in
605 * @result's type). This is exactly how strtoul() works.
606 */
607 int qemu_strtoul(const char *nptr, const char **endptr, int base,
608 unsigned long *result)
609 {
610 char *ep;
611
612 assert((unsigned) base <= 36 && base != 1);
613 if (!nptr) {
614 if (endptr) {
615 *endptr = nptr;
616 }
617 return -EINVAL;
618 }
619
620 errno = 0;
621 *result = strtoul(nptr, &ep, base);
622 /* Windows returns 1 for negative out-of-range values. */
623 if (errno == ERANGE) {
624 *result = -1;
625 }
626 return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
627 }
628
629 /**
630 * Convert string @nptr to an int64_t.
631 *
632 * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
633 * and INT64_MIN on underflow.
634 */
635 int qemu_strtoi64(const char *nptr, const char **endptr, int base,
636 int64_t *result)
637 {
638 char *ep;
639
640 assert((unsigned) base <= 36 && base != 1);
641 if (!nptr) {
642 if (endptr) {
643 *endptr = nptr;
644 }
645 return -EINVAL;
646 }
647
648 /* This assumes int64_t is long long TODO relax */
649 QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long));
650 errno = 0;
651 *result = strtoll(nptr, &ep, base);
652 return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
653 }
654
655 /**
656 * Convert string @nptr to an uint64_t.
657 *
658 * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
659 */
660 int qemu_strtou64(const char *nptr, const char **endptr, int base,
661 uint64_t *result)
662 {
663 char *ep;
664
665 assert((unsigned) base <= 36 && base != 1);
666 if (!nptr) {
667 if (endptr) {
668 *endptr = nptr;
669 }
670 return -EINVAL;
671 }
672
673 /* This assumes uint64_t is unsigned long long TODO relax */
674 QEMU_BUILD_BUG_ON(sizeof(uint64_t) != sizeof(unsigned long long));
675 errno = 0;
676 *result = strtoull(nptr, &ep, base);
677 /* Windows returns 1 for negative out-of-range values. */
678 if (errno == ERANGE) {
679 *result = -1;
680 }
681 return check_strtox_error(nptr, ep, endptr, *result == 0, errno);
682 }
683
684 /**
685 * Convert string @nptr to a double.
686 *
687 * This is a wrapper around strtod() that is harder to misuse.
688 * Semantics of @nptr and @endptr match strtod() with differences
689 * noted below.
690 *
691 * @nptr may be null, and no conversion is performed then.
692 *
693 * If no conversion is performed, store @nptr in *@endptr and return
694 * -EINVAL.
695 *
696 * If @endptr is null, and the string isn't fully converted, return
697 * -EINVAL. This is the case when the pointer that would be stored in
698 * a non-null @endptr points to a character other than '\0'.
699 *
700 * If the conversion overflows, store +/-HUGE_VAL in @result, depending
701 * on the sign, and return -ERANGE.
702 *
703 * If the conversion underflows, store +/-0.0 in @result, depending on the
704 * sign, and return -ERANGE.
705 *
706 * Else store the converted value in @result, and return zero.
707 */
708 int qemu_strtod(const char *nptr, const char **endptr, double *result)
709 {
710 char *ep;
711
712 if (!nptr) {
713 if (endptr) {
714 *endptr = nptr;
715 }
716 return -EINVAL;
717 }
718
719 errno = 0;
720 *result = strtod(nptr, &ep);
721 return check_strtox_error(nptr, ep, endptr, false, errno);
722 }
723
724 /**
725 * Convert string @nptr to a finite double.
726 *
727 * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
728 * with -EINVAL and no conversion is performed.
729 */
730 int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
731 {
732 double tmp;
733 int ret;
734
735 ret = qemu_strtod(nptr, endptr, &tmp);
736 if (!ret && !isfinite(tmp)) {
737 if (endptr) {
738 *endptr = nptr;
739 }
740 ret = -EINVAL;
741 }
742
743 if (ret != -EINVAL) {
744 *result = tmp;
745 }
746 return ret;
747 }
748
749 /**
750 * Searches for the first occurrence of 'c' in 's', and returns a pointer
751 * to the trailing null byte if none was found.
752 */
753 #ifndef HAVE_STRCHRNUL
754 const char *qemu_strchrnul(const char *s, int c)
755 {
756 const char *e = strchr(s, c);
757 if (!e) {
758 e = s + strlen(s);
759 }
760 return e;
761 }
762 #endif
763
764 /**
765 * parse_uint:
766 *
767 * @s: String to parse
768 * @value: Destination for parsed integer value
769 * @endptr: Destination for pointer to first character not consumed
770 * @base: integer base, between 2 and 36 inclusive, or 0
771 *
772 * Parse unsigned integer
773 *
774 * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
775 * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
776 *
777 * If @s is null, or @base is invalid, or @s doesn't start with an
778 * integer in the syntax above, set *@value to 0, *@endptr to @s, and
779 * return -EINVAL.
780 *
781 * Set *@endptr to point right beyond the parsed integer (even if the integer
782 * overflows or is negative, all digits will be parsed and *@endptr will
783 * point right beyond them).
784 *
785 * If the integer is negative, set *@value to 0, and return -ERANGE.
786 *
787 * If the integer overflows unsigned long long, set *@value to
788 * ULLONG_MAX, and return -ERANGE.
789 *
790 * Else, set *@value to the parsed integer, and return 0.
791 */
792 int parse_uint(const char *s, unsigned long long *value, char **endptr,
793 int base)
794 {
795 int r = 0;
796 char *endp = (char *)s;
797 unsigned long long val = 0;
798
799 assert((unsigned) base <= 36 && base != 1);
800 if (!s) {
801 r = -EINVAL;
802 goto out;
803 }
804
805 errno = 0;
806 val = strtoull(s, &endp, base);
807 if (errno) {
808 r = -errno;
809 goto out;
810 }
811
812 if (endp == s) {
813 r = -EINVAL;
814 goto out;
815 }
816
817 /* make sure we reject negative numbers: */
818 while (qemu_isspace(*s)) {
819 s++;
820 }
821 if (*s == '-') {
822 val = 0;
823 r = -ERANGE;
824 goto out;
825 }
826
827 out:
828 *value = val;
829 *endptr = endp;
830 return r;
831 }
832
833 /**
834 * parse_uint_full:
835 *
836 * @s: String to parse
837 * @value: Destination for parsed integer value
838 * @base: integer base, between 2 and 36 inclusive, or 0
839 *
840 * Parse unsigned integer from entire string
841 *
842 * Have the same behavior of parse_uint(), but with an additional check
843 * for additional data after the parsed number. If extra characters are present
844 * after the parsed number, the function will return -EINVAL, and *@v will
845 * be set to 0.
846 */
847 int parse_uint_full(const char *s, unsigned long long *value, int base)
848 {
849 char *endp;
850 int r;
851
852 r = parse_uint(s, value, &endp, base);
853 if (r < 0) {
854 return r;
855 }
856 if (*endp) {
857 *value = 0;
858 return -EINVAL;
859 }
860
861 return 0;
862 }
863
864 int qemu_parse_fd(const char *param)
865 {
866 long fd;
867 char *endptr;
868
869 errno = 0;
870 fd = strtol(param, &endptr, 10);
871 if (param == endptr /* no conversion performed */ ||
872 errno != 0 /* not representable as long; possibly others */ ||
873 *endptr != '\0' /* final string not empty */ ||
874 fd < 0 /* invalid as file descriptor */ ||
875 fd > INT_MAX /* not representable as int */) {
876 return -1;
877 }
878 return fd;
879 }
880
881 /*
882 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128)
883 * Input is limited to 14-bit numbers
884 */
885 int uleb128_encode_small(uint8_t *out, uint32_t n)
886 {
887 g_assert(n <= 0x3fff);
888 if (n < 0x80) {
889 *out = n;
890 return 1;
891 } else {
892 *out++ = (n & 0x7f) | 0x80;
893 *out = n >> 7;
894 return 2;
895 }
896 }
897
898 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
899 {
900 if (!(*in & 0x80)) {
901 *n = *in;
902 return 1;
903 } else {
904 *n = *in++ & 0x7f;
905 /* we exceed 14 bit number */
906 if (*in & 0x80) {
907 return -1;
908 }
909 *n |= *in << 7;
910 return 2;
911 }
912 }
913
914 /*
915 * helper to parse debug environment variables
916 */
917 int parse_debug_env(const char *name, int max, int initial)
918 {
919 char *debug_env = getenv(name);
920 char *inv = NULL;
921 long debug;
922
923 if (!debug_env) {
924 return initial;
925 }
926 errno = 0;
927 debug = strtol(debug_env, &inv, 10);
928 if (inv == debug_env) {
929 return initial;
930 }
931 if (debug < 0 || debug > max || errno != 0) {
932 warn_report("%s not in [0, %d]", name, max);
933 return initial;
934 }
935 return debug;
936 }
937
938 /*
939 * Return human readable string for size @val.
940 * @val can be anything that uint64_t allows (no more than "16 EiB").
941 * Use IEC binary units like KiB, MiB, and so forth.
942 * Caller is responsible for passing it to g_free().
943 */
944 char *size_to_str(uint64_t val)
945 {
946 static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
947 uint64_t div;
948 int i;
949
950 /*
951 * The exponent (returned in i) minus one gives us
952 * floor(log2(val * 1024 / 1000). The correction makes us
953 * switch to the higher power when the integer part is >= 1000.
954 * (see e41b509d68afb1f for more info)
955 */
956 frexp(val / (1000.0 / 1024.0), &i);
957 i = (i - 1) / 10;
958 div = 1ULL << (i * 10);
959
960 return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
961 }
962
963 char *freq_to_str(uint64_t freq_hz)
964 {
965 static const char *const suffixes[] = { "", "K", "M", "G", "T", "P", "E" };
966 double freq = freq_hz;
967 size_t idx = 0;
968
969 while (freq >= 1000.0) {
970 freq /= 1000.0;
971 idx++;
972 }
973 assert(idx < ARRAY_SIZE(suffixes));
974
975 return g_strdup_printf("%0.3g %sHz", freq, suffixes[idx]);
976 }
977
978 int qemu_pstrcmp0(const char **str1, const char **str2)
979 {
980 return g_strcmp0(*str1, *str2);
981 }
982
983 static inline bool starts_with_prefix(const char *dir)
984 {
985 size_t prefix_len = strlen(CONFIG_PREFIX);
986 return !memcmp(dir, CONFIG_PREFIX, prefix_len) &&
987 (!dir[prefix_len] || G_IS_DIR_SEPARATOR(dir[prefix_len]));
988 }
989
990 /* Return the next path component in dir, and store its length in *p_len. */
991 static inline const char *next_component(const char *dir, int *p_len)
992 {
993 int len;
994 while ((*dir && G_IS_DIR_SEPARATOR(*dir)) ||
995 (*dir == '.' && (G_IS_DIR_SEPARATOR(dir[1]) || dir[1] == '\0'))) {
996 dir++;
997 }
998 len = 0;
999 while (dir[len] && !G_IS_DIR_SEPARATOR(dir[len])) {
1000 len++;
1001 }
1002 *p_len = len;
1003 return dir;
1004 }
1005
1006 char *get_relocated_path(const char *dir)
1007 {
1008 size_t prefix_len = strlen(CONFIG_PREFIX);
1009 const char *bindir = CONFIG_BINDIR;
1010 const char *exec_dir = qemu_get_exec_dir();
1011 GString *result;
1012 int len_dir, len_bindir;
1013
1014 /* Fail if qemu_init_exec_dir was not called. */
1015 assert(exec_dir[0]);
1016 if (!starts_with_prefix(dir) || !starts_with_prefix(bindir)) {
1017 return g_strdup(dir);
1018 }
1019
1020 result = g_string_new(exec_dir);
1021
1022 /* Advance over common components. */
1023 len_dir = len_bindir = prefix_len;
1024 do {
1025 dir += len_dir;
1026 bindir += len_bindir;
1027 dir = next_component(dir, &len_dir);
1028 bindir = next_component(bindir, &len_bindir);
1029 } while (len_dir && len_dir == len_bindir && !memcmp(dir, bindir, len_dir));
1030
1031 /* Ascend from bindir to the common prefix with dir. */
1032 while (len_bindir) {
1033 bindir += len_bindir;
1034 g_string_append(result, "/..");
1035 bindir = next_component(bindir, &len_bindir);
1036 }
1037
1038 if (*dir) {
1039 assert(G_IS_DIR_SEPARATOR(dir[-1]));
1040 g_string_append(result, dir - 1);
1041 }
1042 return g_string_free(result, false);
1043 }