1baacf047SPaolo Bonzini /* 2baacf047SPaolo Bonzini * Simple C functions to supplement the C library 3baacf047SPaolo Bonzini * 4baacf047SPaolo Bonzini * Copyright (c) 2006 Fabrice Bellard 5baacf047SPaolo Bonzini * 6baacf047SPaolo Bonzini * Permission is hereby granted, free of charge, to any person obtaining a copy 7baacf047SPaolo Bonzini * of this software and associated documentation files (the "Software"), to deal 8baacf047SPaolo Bonzini * in the Software without restriction, including without limitation the rights 9baacf047SPaolo Bonzini * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10baacf047SPaolo Bonzini * copies of the Software, and to permit persons to whom the Software is 11baacf047SPaolo Bonzini * furnished to do so, subject to the following conditions: 12baacf047SPaolo Bonzini * 13baacf047SPaolo Bonzini * The above copyright notice and this permission notice shall be included in 14baacf047SPaolo Bonzini * all copies or substantial portions of the Software. 15baacf047SPaolo Bonzini * 16baacf047SPaolo Bonzini * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17baacf047SPaolo Bonzini * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18baacf047SPaolo Bonzini * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19baacf047SPaolo Bonzini * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20baacf047SPaolo Bonzini * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21baacf047SPaolo Bonzini * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22baacf047SPaolo Bonzini * THE SOFTWARE. 23baacf047SPaolo Bonzini */ 24baacf047SPaolo Bonzini #include "qemu-common.h" 25baacf047SPaolo Bonzini #include "qemu/host-utils.h" 26baacf047SPaolo Bonzini #include <math.h> 27baacf047SPaolo Bonzini 28baacf047SPaolo Bonzini #include "qemu/sockets.h" 29baacf047SPaolo Bonzini #include "qemu/iov.h" 30baacf047SPaolo Bonzini 31baacf047SPaolo Bonzini void strpadcpy(char *buf, int buf_size, const char *str, char pad) 32baacf047SPaolo Bonzini { 33baacf047SPaolo Bonzini int len = qemu_strnlen(str, buf_size); 34baacf047SPaolo Bonzini memcpy(buf, str, len); 35baacf047SPaolo Bonzini memset(buf + len, pad, buf_size - len); 36baacf047SPaolo Bonzini } 37baacf047SPaolo Bonzini 38baacf047SPaolo Bonzini void pstrcpy(char *buf, int buf_size, const char *str) 39baacf047SPaolo Bonzini { 40baacf047SPaolo Bonzini int c; 41baacf047SPaolo Bonzini char *q = buf; 42baacf047SPaolo Bonzini 43baacf047SPaolo Bonzini if (buf_size <= 0) 44baacf047SPaolo Bonzini return; 45baacf047SPaolo Bonzini 46baacf047SPaolo Bonzini for(;;) { 47baacf047SPaolo Bonzini c = *str++; 48baacf047SPaolo Bonzini if (c == 0 || q >= buf + buf_size - 1) 49baacf047SPaolo Bonzini break; 50baacf047SPaolo Bonzini *q++ = c; 51baacf047SPaolo Bonzini } 52baacf047SPaolo Bonzini *q = '\0'; 53baacf047SPaolo Bonzini } 54baacf047SPaolo Bonzini 55baacf047SPaolo Bonzini /* strcat and truncate. */ 56baacf047SPaolo Bonzini char *pstrcat(char *buf, int buf_size, const char *s) 57baacf047SPaolo Bonzini { 58baacf047SPaolo Bonzini int len; 59baacf047SPaolo Bonzini len = strlen(buf); 60baacf047SPaolo Bonzini if (len < buf_size) 61baacf047SPaolo Bonzini pstrcpy(buf + len, buf_size - len, s); 62baacf047SPaolo Bonzini return buf; 63baacf047SPaolo Bonzini } 64baacf047SPaolo Bonzini 65baacf047SPaolo Bonzini int strstart(const char *str, const char *val, const char **ptr) 66baacf047SPaolo Bonzini { 67baacf047SPaolo Bonzini const char *p, *q; 68baacf047SPaolo Bonzini p = str; 69baacf047SPaolo Bonzini q = val; 70baacf047SPaolo Bonzini while (*q != '\0') { 71baacf047SPaolo Bonzini if (*p != *q) 72baacf047SPaolo Bonzini return 0; 73baacf047SPaolo Bonzini p++; 74baacf047SPaolo Bonzini q++; 75baacf047SPaolo Bonzini } 76baacf047SPaolo Bonzini if (ptr) 77baacf047SPaolo Bonzini *ptr = p; 78baacf047SPaolo Bonzini return 1; 79baacf047SPaolo Bonzini } 80baacf047SPaolo Bonzini 81baacf047SPaolo Bonzini int stristart(const char *str, const char *val, const char **ptr) 82baacf047SPaolo Bonzini { 83baacf047SPaolo Bonzini const char *p, *q; 84baacf047SPaolo Bonzini p = str; 85baacf047SPaolo Bonzini q = val; 86baacf047SPaolo Bonzini while (*q != '\0') { 87baacf047SPaolo Bonzini if (qemu_toupper(*p) != qemu_toupper(*q)) 88baacf047SPaolo Bonzini return 0; 89baacf047SPaolo Bonzini p++; 90baacf047SPaolo Bonzini q++; 91baacf047SPaolo Bonzini } 92baacf047SPaolo Bonzini if (ptr) 93baacf047SPaolo Bonzini *ptr = p; 94baacf047SPaolo Bonzini return 1; 95baacf047SPaolo Bonzini } 96baacf047SPaolo Bonzini 97baacf047SPaolo Bonzini /* XXX: use host strnlen if available ? */ 98baacf047SPaolo Bonzini int qemu_strnlen(const char *s, int max_len) 99baacf047SPaolo Bonzini { 100baacf047SPaolo Bonzini int i; 101baacf047SPaolo Bonzini 102baacf047SPaolo Bonzini for(i = 0; i < max_len; i++) { 103baacf047SPaolo Bonzini if (s[i] == '\0') { 104baacf047SPaolo Bonzini break; 105baacf047SPaolo Bonzini } 106baacf047SPaolo Bonzini } 107baacf047SPaolo Bonzini return i; 108baacf047SPaolo Bonzini } 109baacf047SPaolo Bonzini 110*a38ed811SKevin Wolf char *qemu_strsep(char **input, const char *delim) 111*a38ed811SKevin Wolf { 112*a38ed811SKevin Wolf char *result = *input; 113*a38ed811SKevin Wolf if (result != NULL) { 114*a38ed811SKevin Wolf char *p; 115*a38ed811SKevin Wolf 116*a38ed811SKevin Wolf for (p = result; *p != '\0'; p++) { 117*a38ed811SKevin Wolf if (strchr(delim, *p)) { 118*a38ed811SKevin Wolf break; 119*a38ed811SKevin Wolf } 120*a38ed811SKevin Wolf } 121*a38ed811SKevin Wolf if (*p == '\0') { 122*a38ed811SKevin Wolf *input = NULL; 123*a38ed811SKevin Wolf } else { 124*a38ed811SKevin Wolf *p = '\0'; 125*a38ed811SKevin Wolf *input = p + 1; 126*a38ed811SKevin Wolf } 127*a38ed811SKevin Wolf } 128*a38ed811SKevin Wolf return result; 129*a38ed811SKevin Wolf } 130*a38ed811SKevin Wolf 131baacf047SPaolo Bonzini time_t mktimegm(struct tm *tm) 132baacf047SPaolo Bonzini { 133baacf047SPaolo Bonzini time_t t; 134baacf047SPaolo Bonzini int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 135baacf047SPaolo Bonzini if (m < 3) { 136baacf047SPaolo Bonzini m += 12; 137baacf047SPaolo Bonzini y--; 138baacf047SPaolo Bonzini } 139baacf047SPaolo Bonzini t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 140baacf047SPaolo Bonzini y / 400 - 719469); 141baacf047SPaolo Bonzini t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 142baacf047SPaolo Bonzini return t; 143baacf047SPaolo Bonzini } 144baacf047SPaolo Bonzini 145baacf047SPaolo Bonzini int qemu_fls(int i) 146baacf047SPaolo Bonzini { 147baacf047SPaolo Bonzini return 32 - clz32(i); 148baacf047SPaolo Bonzini } 149baacf047SPaolo Bonzini 150baacf047SPaolo Bonzini /* 151baacf047SPaolo Bonzini * Make sure data goes on disk, but if possible do not bother to 152baacf047SPaolo Bonzini * write out the inode just for timestamp updates. 153baacf047SPaolo Bonzini * 154baacf047SPaolo Bonzini * Unfortunately even in 2009 many operating systems do not support 155baacf047SPaolo Bonzini * fdatasync and have to fall back to fsync. 156baacf047SPaolo Bonzini */ 157baacf047SPaolo Bonzini int qemu_fdatasync(int fd) 158baacf047SPaolo Bonzini { 159baacf047SPaolo Bonzini #ifdef CONFIG_FDATASYNC 160baacf047SPaolo Bonzini return fdatasync(fd); 161baacf047SPaolo Bonzini #else 162baacf047SPaolo Bonzini return fsync(fd); 163baacf047SPaolo Bonzini #endif 164baacf047SPaolo Bonzini } 165baacf047SPaolo Bonzini 166baacf047SPaolo Bonzini /* 16741a259bdSPeter Lieven * Searches for an area with non-zero content in a buffer 16841a259bdSPeter Lieven * 16941a259bdSPeter Lieven * Attention! The len must be a multiple of 17041a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE) 17141a259bdSPeter Lieven * and addr must be a multiple of sizeof(VECTYPE) due to 17241a259bdSPeter Lieven * restriction of optimizations in this function. 17341a259bdSPeter Lieven * 17441a259bdSPeter Lieven * can_use_buffer_find_nonzero_offset() can be used to check 17541a259bdSPeter Lieven * these requirements. 17641a259bdSPeter Lieven * 17741a259bdSPeter Lieven * The return value is the offset of the non-zero area rounded 17841a259bdSPeter Lieven * down to a multiple of sizeof(VECTYPE) for the first 17941a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR chunks and down to 18041a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE) 18141a259bdSPeter Lieven * afterwards. 18241a259bdSPeter Lieven * 18341a259bdSPeter Lieven * If the buffer is all zero the return value is equal to len. 18441a259bdSPeter Lieven */ 18541a259bdSPeter Lieven 18641a259bdSPeter Lieven size_t buffer_find_nonzero_offset(const void *buf, size_t len) 18741a259bdSPeter Lieven { 18841a259bdSPeter Lieven const VECTYPE *p = buf; 18941a259bdSPeter Lieven const VECTYPE zero = (VECTYPE){0}; 19041a259bdSPeter Lieven size_t i; 19141a259bdSPeter Lieven 19241a259bdSPeter Lieven assert(can_use_buffer_find_nonzero_offset(buf, len)); 19341a259bdSPeter Lieven 19441a259bdSPeter Lieven if (!len) { 19541a259bdSPeter Lieven return 0; 19641a259bdSPeter Lieven } 19741a259bdSPeter Lieven 19841a259bdSPeter Lieven for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) { 19941a259bdSPeter Lieven if (!ALL_EQ(p[i], zero)) { 20041a259bdSPeter Lieven return i * sizeof(VECTYPE); 20141a259bdSPeter Lieven } 20241a259bdSPeter Lieven } 20341a259bdSPeter Lieven 20441a259bdSPeter Lieven for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; 20541a259bdSPeter Lieven i < len / sizeof(VECTYPE); 20641a259bdSPeter Lieven i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) { 20741a259bdSPeter Lieven VECTYPE tmp0 = p[i + 0] | p[i + 1]; 20841a259bdSPeter Lieven VECTYPE tmp1 = p[i + 2] | p[i + 3]; 20941a259bdSPeter Lieven VECTYPE tmp2 = p[i + 4] | p[i + 5]; 21041a259bdSPeter Lieven VECTYPE tmp3 = p[i + 6] | p[i + 7]; 21141a259bdSPeter Lieven VECTYPE tmp01 = tmp0 | tmp1; 21241a259bdSPeter Lieven VECTYPE tmp23 = tmp2 | tmp3; 21341a259bdSPeter Lieven if (!ALL_EQ(tmp01 | tmp23, zero)) { 21441a259bdSPeter Lieven break; 21541a259bdSPeter Lieven } 21641a259bdSPeter Lieven } 21741a259bdSPeter Lieven 21841a259bdSPeter Lieven return i * sizeof(VECTYPE); 21941a259bdSPeter Lieven } 22041a259bdSPeter Lieven 22141a259bdSPeter Lieven /* 222baacf047SPaolo Bonzini * Checks if a buffer is all zeroes 223baacf047SPaolo Bonzini * 224baacf047SPaolo Bonzini * Attention! The len must be a multiple of 4 * sizeof(long) due to 225baacf047SPaolo Bonzini * restriction of optimizations in this function. 226baacf047SPaolo Bonzini */ 227baacf047SPaolo Bonzini bool buffer_is_zero(const void *buf, size_t len) 228baacf047SPaolo Bonzini { 229baacf047SPaolo Bonzini /* 230baacf047SPaolo Bonzini * Use long as the biggest available internal data type that fits into the 231baacf047SPaolo Bonzini * CPU register and unroll the loop to smooth out the effect of memory 232baacf047SPaolo Bonzini * latency. 233baacf047SPaolo Bonzini */ 234baacf047SPaolo Bonzini 235baacf047SPaolo Bonzini size_t i; 236baacf047SPaolo Bonzini long d0, d1, d2, d3; 237baacf047SPaolo Bonzini const long * const data = buf; 238baacf047SPaolo Bonzini 23956ded708SPeter Lieven /* use vector optimized zero check if possible */ 24056ded708SPeter Lieven if (can_use_buffer_find_nonzero_offset(buf, len)) { 24156ded708SPeter Lieven return buffer_find_nonzero_offset(buf, len) == len; 24256ded708SPeter Lieven } 24356ded708SPeter Lieven 244baacf047SPaolo Bonzini assert(len % (4 * sizeof(long)) == 0); 245baacf047SPaolo Bonzini len /= sizeof(long); 246baacf047SPaolo Bonzini 247baacf047SPaolo Bonzini for (i = 0; i < len; i += 4) { 248baacf047SPaolo Bonzini d0 = data[i + 0]; 249baacf047SPaolo Bonzini d1 = data[i + 1]; 250baacf047SPaolo Bonzini d2 = data[i + 2]; 251baacf047SPaolo Bonzini d3 = data[i + 3]; 252baacf047SPaolo Bonzini 253baacf047SPaolo Bonzini if (d0 || d1 || d2 || d3) { 254baacf047SPaolo Bonzini return false; 255baacf047SPaolo Bonzini } 256baacf047SPaolo Bonzini } 257baacf047SPaolo Bonzini 258baacf047SPaolo Bonzini return true; 259baacf047SPaolo Bonzini } 260baacf047SPaolo Bonzini 261baacf047SPaolo Bonzini #ifndef _WIN32 262baacf047SPaolo Bonzini /* Sets a specific flag */ 263baacf047SPaolo Bonzini int fcntl_setfl(int fd, int flag) 264baacf047SPaolo Bonzini { 265baacf047SPaolo Bonzini int flags; 266baacf047SPaolo Bonzini 267baacf047SPaolo Bonzini flags = fcntl(fd, F_GETFL); 268baacf047SPaolo Bonzini if (flags == -1) 269baacf047SPaolo Bonzini return -errno; 270baacf047SPaolo Bonzini 271baacf047SPaolo Bonzini if (fcntl(fd, F_SETFL, flags | flag) == -1) 272baacf047SPaolo Bonzini return -errno; 273baacf047SPaolo Bonzini 274baacf047SPaolo Bonzini return 0; 275baacf047SPaolo Bonzini } 276baacf047SPaolo Bonzini #endif 277baacf047SPaolo Bonzini 278baacf047SPaolo Bonzini static int64_t suffix_mul(char suffix, int64_t unit) 279baacf047SPaolo Bonzini { 280baacf047SPaolo Bonzini switch (qemu_toupper(suffix)) { 281baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_B: 282baacf047SPaolo Bonzini return 1; 283baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_KB: 284baacf047SPaolo Bonzini return unit; 285baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_MB: 286baacf047SPaolo Bonzini return unit * unit; 287baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_GB: 288baacf047SPaolo Bonzini return unit * unit * unit; 289baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_TB: 290baacf047SPaolo Bonzini return unit * unit * unit * unit; 2915e00984aSKevin Wolf case STRTOSZ_DEFSUFFIX_PB: 2925e00984aSKevin Wolf return unit * unit * unit * unit * unit; 2935e00984aSKevin Wolf case STRTOSZ_DEFSUFFIX_EB: 2945e00984aSKevin Wolf return unit * unit * unit * unit * unit * unit; 295baacf047SPaolo Bonzini } 296baacf047SPaolo Bonzini return -1; 297baacf047SPaolo Bonzini } 298baacf047SPaolo Bonzini 299baacf047SPaolo Bonzini /* 300baacf047SPaolo Bonzini * Convert string to bytes, allowing either B/b for bytes, K/k for KB, 301baacf047SPaolo Bonzini * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned 302baacf047SPaolo Bonzini * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on 303baacf047SPaolo Bonzini * other error. 304baacf047SPaolo Bonzini */ 305baacf047SPaolo Bonzini int64_t strtosz_suffix_unit(const char *nptr, char **end, 306baacf047SPaolo Bonzini const char default_suffix, int64_t unit) 307baacf047SPaolo Bonzini { 308baacf047SPaolo Bonzini int64_t retval = -EINVAL; 309baacf047SPaolo Bonzini char *endptr; 310baacf047SPaolo Bonzini unsigned char c; 311baacf047SPaolo Bonzini int mul_required = 0; 312baacf047SPaolo Bonzini double val, mul, integral, fraction; 313baacf047SPaolo Bonzini 314baacf047SPaolo Bonzini errno = 0; 315baacf047SPaolo Bonzini val = strtod(nptr, &endptr); 316baacf047SPaolo Bonzini if (isnan(val) || endptr == nptr || errno != 0) { 317baacf047SPaolo Bonzini goto fail; 318baacf047SPaolo Bonzini } 319baacf047SPaolo Bonzini fraction = modf(val, &integral); 320baacf047SPaolo Bonzini if (fraction != 0) { 321baacf047SPaolo Bonzini mul_required = 1; 322baacf047SPaolo Bonzini } 323baacf047SPaolo Bonzini c = *endptr; 324baacf047SPaolo Bonzini mul = suffix_mul(c, unit); 325baacf047SPaolo Bonzini if (mul >= 0) { 326baacf047SPaolo Bonzini endptr++; 327baacf047SPaolo Bonzini } else { 328baacf047SPaolo Bonzini mul = suffix_mul(default_suffix, unit); 329baacf047SPaolo Bonzini assert(mul >= 0); 330baacf047SPaolo Bonzini } 331baacf047SPaolo Bonzini if (mul == 1 && mul_required) { 332baacf047SPaolo Bonzini goto fail; 333baacf047SPaolo Bonzini } 334baacf047SPaolo Bonzini if ((val * mul >= INT64_MAX) || val < 0) { 335baacf047SPaolo Bonzini retval = -ERANGE; 336baacf047SPaolo Bonzini goto fail; 337baacf047SPaolo Bonzini } 338baacf047SPaolo Bonzini retval = val * mul; 339baacf047SPaolo Bonzini 340baacf047SPaolo Bonzini fail: 341baacf047SPaolo Bonzini if (end) { 342baacf047SPaolo Bonzini *end = endptr; 343baacf047SPaolo Bonzini } 344baacf047SPaolo Bonzini 345baacf047SPaolo Bonzini return retval; 346baacf047SPaolo Bonzini } 347baacf047SPaolo Bonzini 348baacf047SPaolo Bonzini int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) 349baacf047SPaolo Bonzini { 350baacf047SPaolo Bonzini return strtosz_suffix_unit(nptr, end, default_suffix, 1024); 351baacf047SPaolo Bonzini } 352baacf047SPaolo Bonzini 353baacf047SPaolo Bonzini int64_t strtosz(const char *nptr, char **end) 354baacf047SPaolo Bonzini { 355baacf047SPaolo Bonzini return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); 356baacf047SPaolo Bonzini } 357baacf047SPaolo Bonzini 358e3f9fe2dSEduardo Habkost /** 359e3f9fe2dSEduardo Habkost * parse_uint: 360e3f9fe2dSEduardo Habkost * 361e3f9fe2dSEduardo Habkost * @s: String to parse 362e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 363e3f9fe2dSEduardo Habkost * @endptr: Destination for pointer to first character not consumed 364e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 365e3f9fe2dSEduardo Habkost * 366e3f9fe2dSEduardo Habkost * Parse unsigned integer 367e3f9fe2dSEduardo Habkost * 368e3f9fe2dSEduardo Habkost * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional 369e3f9fe2dSEduardo Habkost * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. 370e3f9fe2dSEduardo Habkost * 371e3f9fe2dSEduardo Habkost * If @s is null, or @base is invalid, or @s doesn't start with an 372e3f9fe2dSEduardo Habkost * integer in the syntax above, set *@value to 0, *@endptr to @s, and 373e3f9fe2dSEduardo Habkost * return -EINVAL. 374e3f9fe2dSEduardo Habkost * 375e3f9fe2dSEduardo Habkost * Set *@endptr to point right beyond the parsed integer (even if the integer 376e3f9fe2dSEduardo Habkost * overflows or is negative, all digits will be parsed and *@endptr will 377e3f9fe2dSEduardo Habkost * point right beyond them). 378e3f9fe2dSEduardo Habkost * 379e3f9fe2dSEduardo Habkost * If the integer is negative, set *@value to 0, and return -ERANGE. 380e3f9fe2dSEduardo Habkost * 381e3f9fe2dSEduardo Habkost * If the integer overflows unsigned long long, set *@value to 382e3f9fe2dSEduardo Habkost * ULLONG_MAX, and return -ERANGE. 383e3f9fe2dSEduardo Habkost * 384e3f9fe2dSEduardo Habkost * Else, set *@value to the parsed integer, and return 0. 385e3f9fe2dSEduardo Habkost */ 386e3f9fe2dSEduardo Habkost int parse_uint(const char *s, unsigned long long *value, char **endptr, 387e3f9fe2dSEduardo Habkost int base) 388e3f9fe2dSEduardo Habkost { 389e3f9fe2dSEduardo Habkost int r = 0; 390e3f9fe2dSEduardo Habkost char *endp = (char *)s; 391e3f9fe2dSEduardo Habkost unsigned long long val = 0; 392e3f9fe2dSEduardo Habkost 393e3f9fe2dSEduardo Habkost if (!s) { 394e3f9fe2dSEduardo Habkost r = -EINVAL; 395e3f9fe2dSEduardo Habkost goto out; 396e3f9fe2dSEduardo Habkost } 397e3f9fe2dSEduardo Habkost 398e3f9fe2dSEduardo Habkost errno = 0; 399e3f9fe2dSEduardo Habkost val = strtoull(s, &endp, base); 400e3f9fe2dSEduardo Habkost if (errno) { 401e3f9fe2dSEduardo Habkost r = -errno; 402e3f9fe2dSEduardo Habkost goto out; 403e3f9fe2dSEduardo Habkost } 404e3f9fe2dSEduardo Habkost 405e3f9fe2dSEduardo Habkost if (endp == s) { 406e3f9fe2dSEduardo Habkost r = -EINVAL; 407e3f9fe2dSEduardo Habkost goto out; 408e3f9fe2dSEduardo Habkost } 409e3f9fe2dSEduardo Habkost 410e3f9fe2dSEduardo Habkost /* make sure we reject negative numbers: */ 411e3f9fe2dSEduardo Habkost while (isspace((unsigned char)*s)) { 412e3f9fe2dSEduardo Habkost s++; 413e3f9fe2dSEduardo Habkost } 414e3f9fe2dSEduardo Habkost if (*s == '-') { 415e3f9fe2dSEduardo Habkost val = 0; 416e3f9fe2dSEduardo Habkost r = -ERANGE; 417e3f9fe2dSEduardo Habkost goto out; 418e3f9fe2dSEduardo Habkost } 419e3f9fe2dSEduardo Habkost 420e3f9fe2dSEduardo Habkost out: 421e3f9fe2dSEduardo Habkost *value = val; 422e3f9fe2dSEduardo Habkost *endptr = endp; 423e3f9fe2dSEduardo Habkost return r; 424e3f9fe2dSEduardo Habkost } 425e3f9fe2dSEduardo Habkost 426e3f9fe2dSEduardo Habkost /** 427e3f9fe2dSEduardo Habkost * parse_uint_full: 428e3f9fe2dSEduardo Habkost * 429e3f9fe2dSEduardo Habkost * @s: String to parse 430e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 431e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 432e3f9fe2dSEduardo Habkost * 433e3f9fe2dSEduardo Habkost * Parse unsigned integer from entire string 434e3f9fe2dSEduardo Habkost * 435e3f9fe2dSEduardo Habkost * Have the same behavior of parse_uint(), but with an additional check 436e3f9fe2dSEduardo Habkost * for additional data after the parsed number. If extra characters are present 437e3f9fe2dSEduardo Habkost * after the parsed number, the function will return -EINVAL, and *@v will 438e3f9fe2dSEduardo Habkost * be set to 0. 439e3f9fe2dSEduardo Habkost */ 440e3f9fe2dSEduardo Habkost int parse_uint_full(const char *s, unsigned long long *value, int base) 441e3f9fe2dSEduardo Habkost { 442e3f9fe2dSEduardo Habkost char *endp; 443e3f9fe2dSEduardo Habkost int r; 444e3f9fe2dSEduardo Habkost 445e3f9fe2dSEduardo Habkost r = parse_uint(s, value, &endp, base); 446e3f9fe2dSEduardo Habkost if (r < 0) { 447e3f9fe2dSEduardo Habkost return r; 448e3f9fe2dSEduardo Habkost } 449e3f9fe2dSEduardo Habkost if (*endp) { 450e3f9fe2dSEduardo Habkost *value = 0; 451e3f9fe2dSEduardo Habkost return -EINVAL; 452e3f9fe2dSEduardo Habkost } 453e3f9fe2dSEduardo Habkost 454e3f9fe2dSEduardo Habkost return 0; 455e3f9fe2dSEduardo Habkost } 456e3f9fe2dSEduardo Habkost 457baacf047SPaolo Bonzini int qemu_parse_fd(const char *param) 458baacf047SPaolo Bonzini { 459baacf047SPaolo Bonzini int fd; 460baacf047SPaolo Bonzini char *endptr = NULL; 461baacf047SPaolo Bonzini 462baacf047SPaolo Bonzini fd = strtol(param, &endptr, 10); 463baacf047SPaolo Bonzini if (*endptr || (fd == 0 && param == endptr)) { 464baacf047SPaolo Bonzini return -1; 465baacf047SPaolo Bonzini } 466baacf047SPaolo Bonzini return fd; 467baacf047SPaolo Bonzini } 468baacf047SPaolo Bonzini 469baacf047SPaolo Bonzini /* round down to the nearest power of 2*/ 470baacf047SPaolo Bonzini int64_t pow2floor(int64_t value) 471baacf047SPaolo Bonzini { 472baacf047SPaolo Bonzini if (!is_power_of_2(value)) { 473baacf047SPaolo Bonzini value = 0x8000000000000000ULL >> clz64(value); 474baacf047SPaolo Bonzini } 475baacf047SPaolo Bonzini return value; 476baacf047SPaolo Bonzini } 477baacf047SPaolo Bonzini 478baacf047SPaolo Bonzini /* 479baacf047SPaolo Bonzini * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 480baacf047SPaolo Bonzini * Input is limited to 14-bit numbers 481baacf047SPaolo Bonzini */ 482baacf047SPaolo Bonzini int uleb128_encode_small(uint8_t *out, uint32_t n) 483baacf047SPaolo Bonzini { 484baacf047SPaolo Bonzini g_assert(n <= 0x3fff); 485baacf047SPaolo Bonzini if (n < 0x80) { 486baacf047SPaolo Bonzini *out++ = n; 487baacf047SPaolo Bonzini return 1; 488baacf047SPaolo Bonzini } else { 489baacf047SPaolo Bonzini *out++ = (n & 0x7f) | 0x80; 490baacf047SPaolo Bonzini *out++ = n >> 7; 491baacf047SPaolo Bonzini return 2; 492baacf047SPaolo Bonzini } 493baacf047SPaolo Bonzini } 494baacf047SPaolo Bonzini 495baacf047SPaolo Bonzini int uleb128_decode_small(const uint8_t *in, uint32_t *n) 496baacf047SPaolo Bonzini { 497baacf047SPaolo Bonzini if (!(*in & 0x80)) { 498baacf047SPaolo Bonzini *n = *in++; 499baacf047SPaolo Bonzini return 1; 500baacf047SPaolo Bonzini } else { 501baacf047SPaolo Bonzini *n = *in++ & 0x7f; 502baacf047SPaolo Bonzini /* we exceed 14 bit number */ 503baacf047SPaolo Bonzini if (*in & 0x80) { 504baacf047SPaolo Bonzini return -1; 505baacf047SPaolo Bonzini } 506baacf047SPaolo Bonzini *n |= *in++ << 7; 507baacf047SPaolo Bonzini return 2; 508baacf047SPaolo Bonzini } 509baacf047SPaolo Bonzini } 510b16352acSAlon Levy 511b16352acSAlon Levy /* 512b16352acSAlon Levy * helper to parse debug environment variables 513b16352acSAlon Levy */ 514b16352acSAlon Levy int parse_debug_env(const char *name, int max, int initial) 515b16352acSAlon Levy { 516b16352acSAlon Levy char *debug_env = getenv(name); 517b16352acSAlon Levy char *inv = NULL; 518b16352acSAlon Levy int debug; 519b16352acSAlon Levy 520b16352acSAlon Levy if (!debug_env) { 521b16352acSAlon Levy return initial; 522b16352acSAlon Levy } 523b16352acSAlon Levy debug = strtol(debug_env, &inv, 10); 524b16352acSAlon Levy if (inv == debug_env) { 525b16352acSAlon Levy return initial; 526b16352acSAlon Levy } 527b16352acSAlon Levy if (debug < 0 || debug > max) { 528b16352acSAlon Levy fprintf(stderr, "warning: %s not in [0, %d]", name, max); 529b16352acSAlon Levy return initial; 530b16352acSAlon Levy } 531b16352acSAlon Levy return debug; 532b16352acSAlon Levy } 533