xref: /openbmc/qemu/util/cutils.c (revision 500eb6db)
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/sockets.h"
31 #include "qemu/iov.h"
32 #include "net/net.h"
33 #include "qemu/ctype.h"
34 #include "qemu/cutils.h"
35 #include "qemu/error-report.h"
36 
37 void strpadcpy(char *buf, int buf_size, const char *str, char pad)
38 {
39     int len = qemu_strnlen(str, buf_size);
40     memcpy(buf, str, len);
41     memset(buf + len, pad, buf_size - len);
42 }
43 
44 void pstrcpy(char *buf, int buf_size, const char *str)
45 {
46     int c;
47     char *q = buf;
48 
49     if (buf_size <= 0)
50         return;
51 
52     for(;;) {
53         c = *str++;
54         if (c == 0 || q >= buf + buf_size - 1)
55             break;
56         *q++ = c;
57     }
58     *q = '\0';
59 }
60 
61 /* strcat and truncate. */
62 char *pstrcat(char *buf, int buf_size, const char *s)
63 {
64     int len;
65     len = strlen(buf);
66     if (len < buf_size)
67         pstrcpy(buf + len, buf_size - len, s);
68     return buf;
69 }
70 
71 int strstart(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') {
77         if (*p != *q)
78             return 0;
79         p++;
80         q++;
81     }
82     if (ptr)
83         *ptr = p;
84     return 1;
85 }
86 
87 int stristart(const char *str, const char *val, const char **ptr)
88 {
89     const char *p, *q;
90     p = str;
91     q = val;
92     while (*q != '\0') {
93         if (qemu_toupper(*p) != qemu_toupper(*q))
94             return 0;
95         p++;
96         q++;
97     }
98     if (ptr)
99         *ptr = p;
100     return 1;
101 }
102 
103 /* XXX: use host strnlen if available ? */
104 int qemu_strnlen(const char *s, int max_len)
105 {
106     int i;
107 
108     for(i = 0; i < max_len; i++) {
109         if (s[i] == '\0') {
110             break;
111         }
112     }
113     return i;
114 }
115 
116 char *qemu_strsep(char **input, const char *delim)
117 {
118     char *result = *input;
119     if (result != NULL) {
120         char *p;
121 
122         for (p = result; *p != '\0'; p++) {
123             if (strchr(delim, *p)) {
124                 break;
125             }
126         }
127         if (*p == '\0') {
128             *input = NULL;
129         } else {
130             *p = '\0';
131             *input = p + 1;
132         }
133     }
134     return result;
135 }
136 
137 time_t mktimegm(struct tm *tm)
138 {
139     time_t t;
140     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
141     if (m < 3) {
142         m += 12;
143         y--;
144     }
145     t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
146                  y / 400 - 719469);
147     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
148     return t;
149 }
150 
151 /*
152  * Make sure data goes on disk, but if possible do not bother to
153  * write out the inode just for timestamp updates.
154  *
155  * Unfortunately even in 2009 many operating systems do not support
156  * fdatasync and have to fall back to fsync.
157  */
158 int qemu_fdatasync(int fd)
159 {
160 #ifdef CONFIG_FDATASYNC
161     return fdatasync(fd);
162 #else
163     return fsync(fd);
164 #endif
165 }
166 
167 #ifndef _WIN32
168 /* Sets a specific flag */
169 int fcntl_setfl(int fd, int flag)
170 {
171     int flags;
172 
173     flags = fcntl(fd, F_GETFL);
174     if (flags == -1)
175         return -errno;
176 
177     if (fcntl(fd, F_SETFL, flags | flag) == -1)
178         return -errno;
179 
180     return 0;
181 }
182 #endif
183 
184 static int64_t suffix_mul(char suffix, int64_t unit)
185 {
186     switch (qemu_toupper(suffix)) {
187     case 'B':
188         return 1;
189     case 'K':
190         return unit;
191     case 'M':
192         return unit * unit;
193     case 'G':
194         return unit * unit * unit;
195     case 'T':
196         return unit * unit * unit * unit;
197     case 'P':
198         return unit * unit * unit * unit * unit;
199     case 'E':
200         return unit * unit * unit * unit * unit * unit;
201     }
202     return -1;
203 }
204 
205 /*
206  * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
207  * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
208  * in *end, if not NULL. Return -ERANGE on overflow, and -EINVAL on
209  * other error.
210  */
211 static int do_strtosz(const char *nptr, const char **end,
212                       const char default_suffix, int64_t unit,
213                       uint64_t *result)
214 {
215     int retval;
216     const char *endptr;
217     unsigned char c;
218     int mul_required = 0;
219     double val, mul, integral, fraction;
220 
221     retval = qemu_strtod_finite(nptr, &endptr, &val);
222     if (retval) {
223         goto out;
224     }
225     fraction = modf(val, &integral);
226     if (fraction != 0) {
227         mul_required = 1;
228     }
229     c = *endptr;
230     mul = suffix_mul(c, unit);
231     if (mul >= 0) {
232         endptr++;
233     } else {
234         mul = suffix_mul(default_suffix, unit);
235         assert(mul >= 0);
236     }
237     if (mul == 1 && mul_required) {
238         retval = -EINVAL;
239         goto out;
240     }
241     /*
242      * Values >= 0xfffffffffffffc00 overflow uint64_t after their trip
243      * through double (53 bits of precision).
244      */
245     if ((val * mul >= 0xfffffffffffffc00) || val < 0) {
246         retval = -ERANGE;
247         goto out;
248     }
249     *result = val * mul;
250     retval = 0;
251 
252 out:
253     if (end) {
254         *end = endptr;
255     } else if (*endptr) {
256         retval = -EINVAL;
257     }
258 
259     return retval;
260 }
261 
262 int qemu_strtosz(const char *nptr, const char **end, uint64_t *result)
263 {
264     return do_strtosz(nptr, end, 'B', 1024, result);
265 }
266 
267 int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result)
268 {
269     return do_strtosz(nptr, end, 'M', 1024, result);
270 }
271 
272 int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result)
273 {
274     return do_strtosz(nptr, end, 'B', 1000, result);
275 }
276 
277 /**
278  * Helper function for error checking after strtol() and the like
279  */
280 static int check_strtox_error(const char *nptr, char *ep,
281                               const char **endptr, int libc_errno)
282 {
283     assert(ep >= nptr);
284     if (endptr) {
285         *endptr = ep;
286     }
287 
288     /* Turn "no conversion" into an error */
289     if (libc_errno == 0 && ep == nptr) {
290         return -EINVAL;
291     }
292 
293     /* Fail when we're expected to consume the string, but didn't */
294     if (!endptr && *ep) {
295         return -EINVAL;
296     }
297 
298     return -libc_errno;
299 }
300 
301 /**
302  * Convert string @nptr to an integer, and store it in @result.
303  *
304  * This is a wrapper around strtol() that is harder to misuse.
305  * Semantics of @nptr, @endptr, @base match strtol() with differences
306  * noted below.
307  *
308  * @nptr may be null, and no conversion is performed then.
309  *
310  * If no conversion is performed, store @nptr in *@endptr and return
311  * -EINVAL.
312  *
313  * If @endptr is null, and the string isn't fully converted, return
314  * -EINVAL.  This is the case when the pointer that would be stored in
315  * a non-null @endptr points to a character other than '\0'.
316  *
317  * If the conversion overflows @result, store INT_MAX in @result,
318  * and return -ERANGE.
319  *
320  * If the conversion underflows @result, store INT_MIN in @result,
321  * and return -ERANGE.
322  *
323  * Else store the converted value in @result, and return zero.
324  */
325 int qemu_strtoi(const char *nptr, const char **endptr, int base,
326                 int *result)
327 {
328     char *ep;
329     long long lresult;
330 
331     assert((unsigned) base <= 36 && base != 1);
332     if (!nptr) {
333         if (endptr) {
334             *endptr = nptr;
335         }
336         return -EINVAL;
337     }
338 
339     errno = 0;
340     lresult = strtoll(nptr, &ep, base);
341     if (lresult < INT_MIN) {
342         *result = INT_MIN;
343         errno = ERANGE;
344     } else if (lresult > INT_MAX) {
345         *result = INT_MAX;
346         errno = ERANGE;
347     } else {
348         *result = lresult;
349     }
350     return check_strtox_error(nptr, ep, endptr, errno);
351 }
352 
353 /**
354  * Convert string @nptr to an unsigned integer, and store it in @result.
355  *
356  * This is a wrapper around strtoul() that is harder to misuse.
357  * Semantics of @nptr, @endptr, @base match strtoul() with differences
358  * noted below.
359  *
360  * @nptr may be null, and no conversion is performed then.
361  *
362  * If no conversion is performed, store @nptr in *@endptr and return
363  * -EINVAL.
364  *
365  * If @endptr is null, and the string isn't fully converted, return
366  * -EINVAL.  This is the case when the pointer that would be stored in
367  * a non-null @endptr points to a character other than '\0'.
368  *
369  * If the conversion overflows @result, store UINT_MAX in @result,
370  * and return -ERANGE.
371  *
372  * Else store the converted value in @result, and return zero.
373  *
374  * Note that a number with a leading minus sign gets converted without
375  * the minus sign, checked for overflow (see above), then negated (in
376  * @result's type).  This is exactly how strtoul() works.
377  */
378 int qemu_strtoui(const char *nptr, const char **endptr, int base,
379                  unsigned int *result)
380 {
381     char *ep;
382     long long lresult;
383 
384     assert((unsigned) base <= 36 && base != 1);
385     if (!nptr) {
386         if (endptr) {
387             *endptr = nptr;
388         }
389         return -EINVAL;
390     }
391 
392     errno = 0;
393     lresult = strtoull(nptr, &ep, base);
394 
395     /* Windows returns 1 for negative out-of-range values.  */
396     if (errno == ERANGE) {
397         *result = -1;
398     } else {
399         if (lresult > UINT_MAX) {
400             *result = UINT_MAX;
401             errno = ERANGE;
402         } else if (lresult < INT_MIN) {
403             *result = UINT_MAX;
404             errno = ERANGE;
405         } else {
406             *result = lresult;
407         }
408     }
409     return check_strtox_error(nptr, ep, endptr, errno);
410 }
411 
412 /**
413  * Convert string @nptr to a long integer, and store it in @result.
414  *
415  * This is a wrapper around strtol() that is harder to misuse.
416  * Semantics of @nptr, @endptr, @base match strtol() with differences
417  * noted below.
418  *
419  * @nptr may be null, and no conversion is performed then.
420  *
421  * If no conversion is performed, store @nptr in *@endptr and return
422  * -EINVAL.
423  *
424  * If @endptr is null, and the string isn't fully converted, return
425  * -EINVAL.  This is the case when the pointer that would be stored in
426  * a non-null @endptr points to a character other than '\0'.
427  *
428  * If the conversion overflows @result, store LONG_MAX in @result,
429  * and return -ERANGE.
430  *
431  * If the conversion underflows @result, store LONG_MIN in @result,
432  * and return -ERANGE.
433  *
434  * Else store the converted value in @result, and return zero.
435  */
436 int qemu_strtol(const char *nptr, const char **endptr, int base,
437                 long *result)
438 {
439     char *ep;
440 
441     assert((unsigned) base <= 36 && base != 1);
442     if (!nptr) {
443         if (endptr) {
444             *endptr = nptr;
445         }
446         return -EINVAL;
447     }
448 
449     errno = 0;
450     *result = strtol(nptr, &ep, base);
451     return check_strtox_error(nptr, ep, endptr, errno);
452 }
453 
454 /**
455  * Convert string @nptr to an unsigned long, and store it in @result.
456  *
457  * This is a wrapper around strtoul() that is harder to misuse.
458  * Semantics of @nptr, @endptr, @base match strtoul() with differences
459  * noted below.
460  *
461  * @nptr may be null, and no conversion is performed then.
462  *
463  * If no conversion is performed, store @nptr in *@endptr and return
464  * -EINVAL.
465  *
466  * If @endptr is null, and the string isn't fully converted, return
467  * -EINVAL.  This is the case when the pointer that would be stored in
468  * a non-null @endptr points to a character other than '\0'.
469  *
470  * If the conversion overflows @result, store ULONG_MAX in @result,
471  * and return -ERANGE.
472  *
473  * Else store the converted value in @result, and return zero.
474  *
475  * Note that a number with a leading minus sign gets converted without
476  * the minus sign, checked for overflow (see above), then negated (in
477  * @result's type).  This is exactly how strtoul() works.
478  */
479 int qemu_strtoul(const char *nptr, const char **endptr, int base,
480                  unsigned long *result)
481 {
482     char *ep;
483 
484     assert((unsigned) base <= 36 && base != 1);
485     if (!nptr) {
486         if (endptr) {
487             *endptr = nptr;
488         }
489         return -EINVAL;
490     }
491 
492     errno = 0;
493     *result = strtoul(nptr, &ep, base);
494     /* Windows returns 1 for negative out-of-range values.  */
495     if (errno == ERANGE) {
496         *result = -1;
497     }
498     return check_strtox_error(nptr, ep, endptr, errno);
499 }
500 
501 /**
502  * Convert string @nptr to an int64_t.
503  *
504  * Works like qemu_strtol(), except it stores INT64_MAX on overflow,
505  * and INT_MIN on underflow.
506  */
507 int qemu_strtoi64(const char *nptr, const char **endptr, int base,
508                  int64_t *result)
509 {
510     char *ep;
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     /* FIXME This assumes int64_t is long long */
522     *result = strtoll(nptr, &ep, base);
523     return check_strtox_error(nptr, ep, endptr, errno);
524 }
525 
526 /**
527  * Convert string @nptr to an uint64_t.
528  *
529  * Works like qemu_strtoul(), except it stores UINT64_MAX on overflow.
530  */
531 int qemu_strtou64(const char *nptr, const char **endptr, int base,
532                   uint64_t *result)
533 {
534     char *ep;
535 
536     assert((unsigned) base <= 36 && base != 1);
537     if (!nptr) {
538         if (endptr) {
539             *endptr = nptr;
540         }
541         return -EINVAL;
542     }
543 
544     errno = 0;
545     /* FIXME This assumes uint64_t is unsigned long long */
546     *result = strtoull(nptr, &ep, base);
547     /* Windows returns 1 for negative out-of-range values.  */
548     if (errno == ERANGE) {
549         *result = -1;
550     }
551     return check_strtox_error(nptr, ep, endptr, errno);
552 }
553 
554 /**
555  * Convert string @nptr to a double.
556   *
557  * This is a wrapper around strtod() that is harder to misuse.
558  * Semantics of @nptr and @endptr match strtod() with differences
559  * noted below.
560  *
561  * @nptr may be null, and no conversion is performed then.
562  *
563  * If no conversion is performed, store @nptr in *@endptr and return
564  * -EINVAL.
565  *
566  * If @endptr is null, and the string isn't fully converted, return
567  * -EINVAL. This is the case when the pointer that would be stored in
568  * a non-null @endptr points to a character other than '\0'.
569  *
570  * If the conversion overflows, store +/-HUGE_VAL in @result, depending
571  * on the sign, and return -ERANGE.
572  *
573  * If the conversion underflows, store +/-0.0 in @result, depending on the
574  * sign, and return -ERANGE.
575  *
576  * Else store the converted value in @result, and return zero.
577  */
578 int qemu_strtod(const char *nptr, const char **endptr, double *result)
579 {
580     char *ep;
581 
582     if (!nptr) {
583         if (endptr) {
584             *endptr = nptr;
585         }
586         return -EINVAL;
587     }
588 
589     errno = 0;
590     *result = strtod(nptr, &ep);
591     return check_strtox_error(nptr, ep, endptr, errno);
592 }
593 
594 /**
595  * Convert string @nptr to a finite double.
596  *
597  * Works like qemu_strtod(), except that "NaN" and "inf" are rejected
598  * with -EINVAL and no conversion is performed.
599  */
600 int qemu_strtod_finite(const char *nptr, const char **endptr, double *result)
601 {
602     double tmp;
603     int ret;
604 
605     ret = qemu_strtod(nptr, endptr, &tmp);
606     if (!ret && !isfinite(tmp)) {
607         if (endptr) {
608             *endptr = nptr;
609         }
610         ret = -EINVAL;
611     }
612 
613     if (ret != -EINVAL) {
614         *result = tmp;
615     }
616     return ret;
617 }
618 
619 /**
620  * Searches for the first occurrence of 'c' in 's', and returns a pointer
621  * to the trailing null byte if none was found.
622  */
623 #ifndef HAVE_STRCHRNUL
624 const char *qemu_strchrnul(const char *s, int c)
625 {
626     const char *e = strchr(s, c);
627     if (!e) {
628         e = s + strlen(s);
629     }
630     return e;
631 }
632 #endif
633 
634 /**
635  * parse_uint:
636  *
637  * @s: String to parse
638  * @value: Destination for parsed integer value
639  * @endptr: Destination for pointer to first character not consumed
640  * @base: integer base, between 2 and 36 inclusive, or 0
641  *
642  * Parse unsigned integer
643  *
644  * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
645  * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
646  *
647  * If @s is null, or @base is invalid, or @s doesn't start with an
648  * integer in the syntax above, set *@value to 0, *@endptr to @s, and
649  * return -EINVAL.
650  *
651  * Set *@endptr to point right beyond the parsed integer (even if the integer
652  * overflows or is negative, all digits will be parsed and *@endptr will
653  * point right beyond them).
654  *
655  * If the integer is negative, set *@value to 0, and return -ERANGE.
656  *
657  * If the integer overflows unsigned long long, set *@value to
658  * ULLONG_MAX, and return -ERANGE.
659  *
660  * Else, set *@value to the parsed integer, and return 0.
661  */
662 int parse_uint(const char *s, unsigned long long *value, char **endptr,
663                int base)
664 {
665     int r = 0;
666     char *endp = (char *)s;
667     unsigned long long val = 0;
668 
669     assert((unsigned) base <= 36 && base != 1);
670     if (!s) {
671         r = -EINVAL;
672         goto out;
673     }
674 
675     errno = 0;
676     val = strtoull(s, &endp, base);
677     if (errno) {
678         r = -errno;
679         goto out;
680     }
681 
682     if (endp == s) {
683         r = -EINVAL;
684         goto out;
685     }
686 
687     /* make sure we reject negative numbers: */
688     while (qemu_isspace(*s)) {
689         s++;
690     }
691     if (*s == '-') {
692         val = 0;
693         r = -ERANGE;
694         goto out;
695     }
696 
697 out:
698     *value = val;
699     *endptr = endp;
700     return r;
701 }
702 
703 /**
704  * parse_uint_full:
705  *
706  * @s: String to parse
707  * @value: Destination for parsed integer value
708  * @base: integer base, between 2 and 36 inclusive, or 0
709  *
710  * Parse unsigned integer from entire string
711  *
712  * Have the same behavior of parse_uint(), but with an additional check
713  * for additional data after the parsed number. If extra characters are present
714  * after the parsed number, the function will return -EINVAL, and *@v will
715  * be set to 0.
716  */
717 int parse_uint_full(const char *s, unsigned long long *value, int base)
718 {
719     char *endp;
720     int r;
721 
722     r = parse_uint(s, value, &endp, base);
723     if (r < 0) {
724         return r;
725     }
726     if (*endp) {
727         *value = 0;
728         return -EINVAL;
729     }
730 
731     return 0;
732 }
733 
734 int qemu_parse_fd(const char *param)
735 {
736     long fd;
737     char *endptr;
738 
739     errno = 0;
740     fd = strtol(param, &endptr, 10);
741     if (param == endptr /* no conversion performed */                    ||
742         errno != 0      /* not representable as long; possibly others */ ||
743         *endptr != '\0' /* final string not empty */                     ||
744         fd < 0          /* invalid as file descriptor */                 ||
745         fd > INT_MAX    /* not representable as int */) {
746         return -1;
747     }
748     return fd;
749 }
750 
751 /*
752  * Implementation of  ULEB128 (http://en.wikipedia.org/wiki/LEB128)
753  * Input is limited to 14-bit numbers
754  */
755 int uleb128_encode_small(uint8_t *out, uint32_t n)
756 {
757     g_assert(n <= 0x3fff);
758     if (n < 0x80) {
759         *out++ = n;
760         return 1;
761     } else {
762         *out++ = (n & 0x7f) | 0x80;
763         *out++ = n >> 7;
764         return 2;
765     }
766 }
767 
768 int uleb128_decode_small(const uint8_t *in, uint32_t *n)
769 {
770     if (!(*in & 0x80)) {
771         *n = *in++;
772         return 1;
773     } else {
774         *n = *in++ & 0x7f;
775         /* we exceed 14 bit number */
776         if (*in & 0x80) {
777             return -1;
778         }
779         *n |= *in++ << 7;
780         return 2;
781     }
782 }
783 
784 /*
785  * helper to parse debug environment variables
786  */
787 int parse_debug_env(const char *name, int max, int initial)
788 {
789     char *debug_env = getenv(name);
790     char *inv = NULL;
791     long debug;
792 
793     if (!debug_env) {
794         return initial;
795     }
796     errno = 0;
797     debug = strtol(debug_env, &inv, 10);
798     if (inv == debug_env) {
799         return initial;
800     }
801     if (debug < 0 || debug > max || errno != 0) {
802         warn_report("%s not in [0, %d]", name, max);
803         return initial;
804     }
805     return debug;
806 }
807 
808 /*
809  * Helper to print ethernet mac address
810  */
811 const char *qemu_ether_ntoa(const MACAddr *mac)
812 {
813     static char ret[18];
814 
815     snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
816              mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
817 
818     return ret;
819 }
820 
821 /*
822  * Return human readable string for size @val.
823  * @val can be anything that uint64_t allows (no more than "16 EiB").
824  * Use IEC binary units like KiB, MiB, and so forth.
825  * Caller is responsible for passing it to g_free().
826  */
827 char *size_to_str(uint64_t val)
828 {
829     static const char *suffixes[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei" };
830     uint64_t div;
831     int i;
832 
833     /*
834      * The exponent (returned in i) minus one gives us
835      * floor(log2(val * 1024 / 1000).  The correction makes us
836      * switch to the higher power when the integer part is >= 1000.
837      * (see e41b509d68afb1f for more info)
838      */
839     frexp(val / (1000.0 / 1024.0), &i);
840     i = (i - 1) / 10;
841     div = 1ULL << (i * 10);
842 
843     return g_strdup_printf("%0.3g %sB", (double)val / div, suffixes[i]);
844 }
845 
846 int qemu_pstrcmp0(const char **str1, const char **str2)
847 {
848     return g_strcmp0(*str1, *str2);
849 }
850