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 110baacf047SPaolo Bonzini time_t mktimegm(struct tm *tm) 111baacf047SPaolo Bonzini { 112baacf047SPaolo Bonzini time_t t; 113baacf047SPaolo Bonzini int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 114baacf047SPaolo Bonzini if (m < 3) { 115baacf047SPaolo Bonzini m += 12; 116baacf047SPaolo Bonzini y--; 117baacf047SPaolo Bonzini } 118baacf047SPaolo Bonzini t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 119baacf047SPaolo Bonzini y / 400 - 719469); 120baacf047SPaolo Bonzini t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 121baacf047SPaolo Bonzini return t; 122baacf047SPaolo Bonzini } 123baacf047SPaolo Bonzini 124baacf047SPaolo Bonzini int qemu_fls(int i) 125baacf047SPaolo Bonzini { 126baacf047SPaolo Bonzini return 32 - clz32(i); 127baacf047SPaolo Bonzini } 128baacf047SPaolo Bonzini 129baacf047SPaolo Bonzini /* 130baacf047SPaolo Bonzini * Make sure data goes on disk, but if possible do not bother to 131baacf047SPaolo Bonzini * write out the inode just for timestamp updates. 132baacf047SPaolo Bonzini * 133baacf047SPaolo Bonzini * Unfortunately even in 2009 many operating systems do not support 134baacf047SPaolo Bonzini * fdatasync and have to fall back to fsync. 135baacf047SPaolo Bonzini */ 136baacf047SPaolo Bonzini int qemu_fdatasync(int fd) 137baacf047SPaolo Bonzini { 138baacf047SPaolo Bonzini #ifdef CONFIG_FDATASYNC 139baacf047SPaolo Bonzini return fdatasync(fd); 140baacf047SPaolo Bonzini #else 141baacf047SPaolo Bonzini return fsync(fd); 142baacf047SPaolo Bonzini #endif 143baacf047SPaolo Bonzini } 144baacf047SPaolo Bonzini 145baacf047SPaolo Bonzini /* 14641a259bdSPeter Lieven * Searches for an area with non-zero content in a buffer 14741a259bdSPeter Lieven * 14841a259bdSPeter Lieven * Attention! The len must be a multiple of 14941a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE) 15041a259bdSPeter Lieven * and addr must be a multiple of sizeof(VECTYPE) due to 15141a259bdSPeter Lieven * restriction of optimizations in this function. 15241a259bdSPeter Lieven * 15341a259bdSPeter Lieven * can_use_buffer_find_nonzero_offset() can be used to check 15441a259bdSPeter Lieven * these requirements. 15541a259bdSPeter Lieven * 15641a259bdSPeter Lieven * The return value is the offset of the non-zero area rounded 15741a259bdSPeter Lieven * down to a multiple of sizeof(VECTYPE) for the first 15841a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR chunks and down to 15941a259bdSPeter Lieven * BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE) 16041a259bdSPeter Lieven * afterwards. 16141a259bdSPeter Lieven * 16241a259bdSPeter Lieven * If the buffer is all zero the return value is equal to len. 16341a259bdSPeter Lieven */ 16441a259bdSPeter Lieven 16541a259bdSPeter Lieven size_t buffer_find_nonzero_offset(const void *buf, size_t len) 16641a259bdSPeter Lieven { 16741a259bdSPeter Lieven const VECTYPE *p = buf; 16841a259bdSPeter Lieven const VECTYPE zero = (VECTYPE){0}; 16941a259bdSPeter Lieven size_t i; 17041a259bdSPeter Lieven 17141a259bdSPeter Lieven assert(can_use_buffer_find_nonzero_offset(buf, len)); 17241a259bdSPeter Lieven 17341a259bdSPeter Lieven if (!len) { 17441a259bdSPeter Lieven return 0; 17541a259bdSPeter Lieven } 17641a259bdSPeter Lieven 17741a259bdSPeter Lieven for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) { 17841a259bdSPeter Lieven if (!ALL_EQ(p[i], zero)) { 17941a259bdSPeter Lieven return i * sizeof(VECTYPE); 18041a259bdSPeter Lieven } 18141a259bdSPeter Lieven } 18241a259bdSPeter Lieven 18341a259bdSPeter Lieven for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; 18441a259bdSPeter Lieven i < len / sizeof(VECTYPE); 18541a259bdSPeter Lieven i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) { 18641a259bdSPeter Lieven VECTYPE tmp0 = p[i + 0] | p[i + 1]; 18741a259bdSPeter Lieven VECTYPE tmp1 = p[i + 2] | p[i + 3]; 18841a259bdSPeter Lieven VECTYPE tmp2 = p[i + 4] | p[i + 5]; 18941a259bdSPeter Lieven VECTYPE tmp3 = p[i + 6] | p[i + 7]; 19041a259bdSPeter Lieven VECTYPE tmp01 = tmp0 | tmp1; 19141a259bdSPeter Lieven VECTYPE tmp23 = tmp2 | tmp3; 19241a259bdSPeter Lieven if (!ALL_EQ(tmp01 | tmp23, zero)) { 19341a259bdSPeter Lieven break; 19441a259bdSPeter Lieven } 19541a259bdSPeter Lieven } 19641a259bdSPeter Lieven 19741a259bdSPeter Lieven return i * sizeof(VECTYPE); 19841a259bdSPeter Lieven } 19941a259bdSPeter Lieven 20041a259bdSPeter Lieven /* 201baacf047SPaolo Bonzini * Checks if a buffer is all zeroes 202baacf047SPaolo Bonzini * 203baacf047SPaolo Bonzini * Attention! The len must be a multiple of 4 * sizeof(long) due to 204baacf047SPaolo Bonzini * restriction of optimizations in this function. 205baacf047SPaolo Bonzini */ 206baacf047SPaolo Bonzini bool buffer_is_zero(const void *buf, size_t len) 207baacf047SPaolo Bonzini { 208baacf047SPaolo Bonzini /* 209baacf047SPaolo Bonzini * Use long as the biggest available internal data type that fits into the 210baacf047SPaolo Bonzini * CPU register and unroll the loop to smooth out the effect of memory 211baacf047SPaolo Bonzini * latency. 212baacf047SPaolo Bonzini */ 213baacf047SPaolo Bonzini 214baacf047SPaolo Bonzini size_t i; 215baacf047SPaolo Bonzini long d0, d1, d2, d3; 216baacf047SPaolo Bonzini const long * const data = buf; 217baacf047SPaolo Bonzini 218*56ded708SPeter Lieven /* use vector optimized zero check if possible */ 219*56ded708SPeter Lieven if (can_use_buffer_find_nonzero_offset(buf, len)) { 220*56ded708SPeter Lieven return buffer_find_nonzero_offset(buf, len) == len; 221*56ded708SPeter Lieven } 222*56ded708SPeter Lieven 223baacf047SPaolo Bonzini assert(len % (4 * sizeof(long)) == 0); 224baacf047SPaolo Bonzini len /= sizeof(long); 225baacf047SPaolo Bonzini 226baacf047SPaolo Bonzini for (i = 0; i < len; i += 4) { 227baacf047SPaolo Bonzini d0 = data[i + 0]; 228baacf047SPaolo Bonzini d1 = data[i + 1]; 229baacf047SPaolo Bonzini d2 = data[i + 2]; 230baacf047SPaolo Bonzini d3 = data[i + 3]; 231baacf047SPaolo Bonzini 232baacf047SPaolo Bonzini if (d0 || d1 || d2 || d3) { 233baacf047SPaolo Bonzini return false; 234baacf047SPaolo Bonzini } 235baacf047SPaolo Bonzini } 236baacf047SPaolo Bonzini 237baacf047SPaolo Bonzini return true; 238baacf047SPaolo Bonzini } 239baacf047SPaolo Bonzini 240baacf047SPaolo Bonzini #ifndef _WIN32 241baacf047SPaolo Bonzini /* Sets a specific flag */ 242baacf047SPaolo Bonzini int fcntl_setfl(int fd, int flag) 243baacf047SPaolo Bonzini { 244baacf047SPaolo Bonzini int flags; 245baacf047SPaolo Bonzini 246baacf047SPaolo Bonzini flags = fcntl(fd, F_GETFL); 247baacf047SPaolo Bonzini if (flags == -1) 248baacf047SPaolo Bonzini return -errno; 249baacf047SPaolo Bonzini 250baacf047SPaolo Bonzini if (fcntl(fd, F_SETFL, flags | flag) == -1) 251baacf047SPaolo Bonzini return -errno; 252baacf047SPaolo Bonzini 253baacf047SPaolo Bonzini return 0; 254baacf047SPaolo Bonzini } 255baacf047SPaolo Bonzini #endif 256baacf047SPaolo Bonzini 257baacf047SPaolo Bonzini static int64_t suffix_mul(char suffix, int64_t unit) 258baacf047SPaolo Bonzini { 259baacf047SPaolo Bonzini switch (qemu_toupper(suffix)) { 260baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_B: 261baacf047SPaolo Bonzini return 1; 262baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_KB: 263baacf047SPaolo Bonzini return unit; 264baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_MB: 265baacf047SPaolo Bonzini return unit * unit; 266baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_GB: 267baacf047SPaolo Bonzini return unit * unit * unit; 268baacf047SPaolo Bonzini case STRTOSZ_DEFSUFFIX_TB: 269baacf047SPaolo Bonzini return unit * unit * unit * unit; 270baacf047SPaolo Bonzini } 271baacf047SPaolo Bonzini return -1; 272baacf047SPaolo Bonzini } 273baacf047SPaolo Bonzini 274baacf047SPaolo Bonzini /* 275baacf047SPaolo Bonzini * Convert string to bytes, allowing either B/b for bytes, K/k for KB, 276baacf047SPaolo Bonzini * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned 277baacf047SPaolo Bonzini * in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on 278baacf047SPaolo Bonzini * other error. 279baacf047SPaolo Bonzini */ 280baacf047SPaolo Bonzini int64_t strtosz_suffix_unit(const char *nptr, char **end, 281baacf047SPaolo Bonzini const char default_suffix, int64_t unit) 282baacf047SPaolo Bonzini { 283baacf047SPaolo Bonzini int64_t retval = -EINVAL; 284baacf047SPaolo Bonzini char *endptr; 285baacf047SPaolo Bonzini unsigned char c; 286baacf047SPaolo Bonzini int mul_required = 0; 287baacf047SPaolo Bonzini double val, mul, integral, fraction; 288baacf047SPaolo Bonzini 289baacf047SPaolo Bonzini errno = 0; 290baacf047SPaolo Bonzini val = strtod(nptr, &endptr); 291baacf047SPaolo Bonzini if (isnan(val) || endptr == nptr || errno != 0) { 292baacf047SPaolo Bonzini goto fail; 293baacf047SPaolo Bonzini } 294baacf047SPaolo Bonzini fraction = modf(val, &integral); 295baacf047SPaolo Bonzini if (fraction != 0) { 296baacf047SPaolo Bonzini mul_required = 1; 297baacf047SPaolo Bonzini } 298baacf047SPaolo Bonzini c = *endptr; 299baacf047SPaolo Bonzini mul = suffix_mul(c, unit); 300baacf047SPaolo Bonzini if (mul >= 0) { 301baacf047SPaolo Bonzini endptr++; 302baacf047SPaolo Bonzini } else { 303baacf047SPaolo Bonzini mul = suffix_mul(default_suffix, unit); 304baacf047SPaolo Bonzini assert(mul >= 0); 305baacf047SPaolo Bonzini } 306baacf047SPaolo Bonzini if (mul == 1 && mul_required) { 307baacf047SPaolo Bonzini goto fail; 308baacf047SPaolo Bonzini } 309baacf047SPaolo Bonzini if ((val * mul >= INT64_MAX) || val < 0) { 310baacf047SPaolo Bonzini retval = -ERANGE; 311baacf047SPaolo Bonzini goto fail; 312baacf047SPaolo Bonzini } 313baacf047SPaolo Bonzini retval = val * mul; 314baacf047SPaolo Bonzini 315baacf047SPaolo Bonzini fail: 316baacf047SPaolo Bonzini if (end) { 317baacf047SPaolo Bonzini *end = endptr; 318baacf047SPaolo Bonzini } 319baacf047SPaolo Bonzini 320baacf047SPaolo Bonzini return retval; 321baacf047SPaolo Bonzini } 322baacf047SPaolo Bonzini 323baacf047SPaolo Bonzini int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) 324baacf047SPaolo Bonzini { 325baacf047SPaolo Bonzini return strtosz_suffix_unit(nptr, end, default_suffix, 1024); 326baacf047SPaolo Bonzini } 327baacf047SPaolo Bonzini 328baacf047SPaolo Bonzini int64_t strtosz(const char *nptr, char **end) 329baacf047SPaolo Bonzini { 330baacf047SPaolo Bonzini return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); 331baacf047SPaolo Bonzini } 332baacf047SPaolo Bonzini 333e3f9fe2dSEduardo Habkost /** 334e3f9fe2dSEduardo Habkost * parse_uint: 335e3f9fe2dSEduardo Habkost * 336e3f9fe2dSEduardo Habkost * @s: String to parse 337e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 338e3f9fe2dSEduardo Habkost * @endptr: Destination for pointer to first character not consumed 339e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 340e3f9fe2dSEduardo Habkost * 341e3f9fe2dSEduardo Habkost * Parse unsigned integer 342e3f9fe2dSEduardo Habkost * 343e3f9fe2dSEduardo Habkost * Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional 344e3f9fe2dSEduardo Habkost * '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits. 345e3f9fe2dSEduardo Habkost * 346e3f9fe2dSEduardo Habkost * If @s is null, or @base is invalid, or @s doesn't start with an 347e3f9fe2dSEduardo Habkost * integer in the syntax above, set *@value to 0, *@endptr to @s, and 348e3f9fe2dSEduardo Habkost * return -EINVAL. 349e3f9fe2dSEduardo Habkost * 350e3f9fe2dSEduardo Habkost * Set *@endptr to point right beyond the parsed integer (even if the integer 351e3f9fe2dSEduardo Habkost * overflows or is negative, all digits will be parsed and *@endptr will 352e3f9fe2dSEduardo Habkost * point right beyond them). 353e3f9fe2dSEduardo Habkost * 354e3f9fe2dSEduardo Habkost * If the integer is negative, set *@value to 0, and return -ERANGE. 355e3f9fe2dSEduardo Habkost * 356e3f9fe2dSEduardo Habkost * If the integer overflows unsigned long long, set *@value to 357e3f9fe2dSEduardo Habkost * ULLONG_MAX, and return -ERANGE. 358e3f9fe2dSEduardo Habkost * 359e3f9fe2dSEduardo Habkost * Else, set *@value to the parsed integer, and return 0. 360e3f9fe2dSEduardo Habkost */ 361e3f9fe2dSEduardo Habkost int parse_uint(const char *s, unsigned long long *value, char **endptr, 362e3f9fe2dSEduardo Habkost int base) 363e3f9fe2dSEduardo Habkost { 364e3f9fe2dSEduardo Habkost int r = 0; 365e3f9fe2dSEduardo Habkost char *endp = (char *)s; 366e3f9fe2dSEduardo Habkost unsigned long long val = 0; 367e3f9fe2dSEduardo Habkost 368e3f9fe2dSEduardo Habkost if (!s) { 369e3f9fe2dSEduardo Habkost r = -EINVAL; 370e3f9fe2dSEduardo Habkost goto out; 371e3f9fe2dSEduardo Habkost } 372e3f9fe2dSEduardo Habkost 373e3f9fe2dSEduardo Habkost errno = 0; 374e3f9fe2dSEduardo Habkost val = strtoull(s, &endp, base); 375e3f9fe2dSEduardo Habkost if (errno) { 376e3f9fe2dSEduardo Habkost r = -errno; 377e3f9fe2dSEduardo Habkost goto out; 378e3f9fe2dSEduardo Habkost } 379e3f9fe2dSEduardo Habkost 380e3f9fe2dSEduardo Habkost if (endp == s) { 381e3f9fe2dSEduardo Habkost r = -EINVAL; 382e3f9fe2dSEduardo Habkost goto out; 383e3f9fe2dSEduardo Habkost } 384e3f9fe2dSEduardo Habkost 385e3f9fe2dSEduardo Habkost /* make sure we reject negative numbers: */ 386e3f9fe2dSEduardo Habkost while (isspace((unsigned char)*s)) { 387e3f9fe2dSEduardo Habkost s++; 388e3f9fe2dSEduardo Habkost } 389e3f9fe2dSEduardo Habkost if (*s == '-') { 390e3f9fe2dSEduardo Habkost val = 0; 391e3f9fe2dSEduardo Habkost r = -ERANGE; 392e3f9fe2dSEduardo Habkost goto out; 393e3f9fe2dSEduardo Habkost } 394e3f9fe2dSEduardo Habkost 395e3f9fe2dSEduardo Habkost out: 396e3f9fe2dSEduardo Habkost *value = val; 397e3f9fe2dSEduardo Habkost *endptr = endp; 398e3f9fe2dSEduardo Habkost return r; 399e3f9fe2dSEduardo Habkost } 400e3f9fe2dSEduardo Habkost 401e3f9fe2dSEduardo Habkost /** 402e3f9fe2dSEduardo Habkost * parse_uint_full: 403e3f9fe2dSEduardo Habkost * 404e3f9fe2dSEduardo Habkost * @s: String to parse 405e3f9fe2dSEduardo Habkost * @value: Destination for parsed integer value 406e3f9fe2dSEduardo Habkost * @base: integer base, between 2 and 36 inclusive, or 0 407e3f9fe2dSEduardo Habkost * 408e3f9fe2dSEduardo Habkost * Parse unsigned integer from entire string 409e3f9fe2dSEduardo Habkost * 410e3f9fe2dSEduardo Habkost * Have the same behavior of parse_uint(), but with an additional check 411e3f9fe2dSEduardo Habkost * for additional data after the parsed number. If extra characters are present 412e3f9fe2dSEduardo Habkost * after the parsed number, the function will return -EINVAL, and *@v will 413e3f9fe2dSEduardo Habkost * be set to 0. 414e3f9fe2dSEduardo Habkost */ 415e3f9fe2dSEduardo Habkost int parse_uint_full(const char *s, unsigned long long *value, int base) 416e3f9fe2dSEduardo Habkost { 417e3f9fe2dSEduardo Habkost char *endp; 418e3f9fe2dSEduardo Habkost int r; 419e3f9fe2dSEduardo Habkost 420e3f9fe2dSEduardo Habkost r = parse_uint(s, value, &endp, base); 421e3f9fe2dSEduardo Habkost if (r < 0) { 422e3f9fe2dSEduardo Habkost return r; 423e3f9fe2dSEduardo Habkost } 424e3f9fe2dSEduardo Habkost if (*endp) { 425e3f9fe2dSEduardo Habkost *value = 0; 426e3f9fe2dSEduardo Habkost return -EINVAL; 427e3f9fe2dSEduardo Habkost } 428e3f9fe2dSEduardo Habkost 429e3f9fe2dSEduardo Habkost return 0; 430e3f9fe2dSEduardo Habkost } 431e3f9fe2dSEduardo Habkost 432baacf047SPaolo Bonzini int qemu_parse_fd(const char *param) 433baacf047SPaolo Bonzini { 434baacf047SPaolo Bonzini int fd; 435baacf047SPaolo Bonzini char *endptr = NULL; 436baacf047SPaolo Bonzini 437baacf047SPaolo Bonzini fd = strtol(param, &endptr, 10); 438baacf047SPaolo Bonzini if (*endptr || (fd == 0 && param == endptr)) { 439baacf047SPaolo Bonzini return -1; 440baacf047SPaolo Bonzini } 441baacf047SPaolo Bonzini return fd; 442baacf047SPaolo Bonzini } 443baacf047SPaolo Bonzini 444baacf047SPaolo Bonzini /* round down to the nearest power of 2*/ 445baacf047SPaolo Bonzini int64_t pow2floor(int64_t value) 446baacf047SPaolo Bonzini { 447baacf047SPaolo Bonzini if (!is_power_of_2(value)) { 448baacf047SPaolo Bonzini value = 0x8000000000000000ULL >> clz64(value); 449baacf047SPaolo Bonzini } 450baacf047SPaolo Bonzini return value; 451baacf047SPaolo Bonzini } 452baacf047SPaolo Bonzini 453baacf047SPaolo Bonzini /* 454baacf047SPaolo Bonzini * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 455baacf047SPaolo Bonzini * Input is limited to 14-bit numbers 456baacf047SPaolo Bonzini */ 457baacf047SPaolo Bonzini int uleb128_encode_small(uint8_t *out, uint32_t n) 458baacf047SPaolo Bonzini { 459baacf047SPaolo Bonzini g_assert(n <= 0x3fff); 460baacf047SPaolo Bonzini if (n < 0x80) { 461baacf047SPaolo Bonzini *out++ = n; 462baacf047SPaolo Bonzini return 1; 463baacf047SPaolo Bonzini } else { 464baacf047SPaolo Bonzini *out++ = (n & 0x7f) | 0x80; 465baacf047SPaolo Bonzini *out++ = n >> 7; 466baacf047SPaolo Bonzini return 2; 467baacf047SPaolo Bonzini } 468baacf047SPaolo Bonzini } 469baacf047SPaolo Bonzini 470baacf047SPaolo Bonzini int uleb128_decode_small(const uint8_t *in, uint32_t *n) 471baacf047SPaolo Bonzini { 472baacf047SPaolo Bonzini if (!(*in & 0x80)) { 473baacf047SPaolo Bonzini *n = *in++; 474baacf047SPaolo Bonzini return 1; 475baacf047SPaolo Bonzini } else { 476baacf047SPaolo Bonzini *n = *in++ & 0x7f; 477baacf047SPaolo Bonzini /* we exceed 14 bit number */ 478baacf047SPaolo Bonzini if (*in & 0x80) { 479baacf047SPaolo Bonzini return -1; 480baacf047SPaolo Bonzini } 481baacf047SPaolo Bonzini *n |= *in++ << 7; 482baacf047SPaolo Bonzini return 2; 483baacf047SPaolo Bonzini } 484baacf047SPaolo Bonzini } 485