2007-01-07 23:04:40 +01:00
|
|
|
/*
|
|
|
|
* Simple C functions to supplement the C library
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2007-01-07 23:04:40 +01:00
|
|
|
* Copyright (c) 2006 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2016-01-29 18:49:55 +01:00
|
|
|
#include "qemu/osdep.h"
|
2007-11-11 03:51:17 +01:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/host-utils.h"
|
2010-10-21 17:15:46 +02:00
|
|
|
#include <math.h>
|
2007-01-07 23:04:40 +01:00
|
|
|
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/sockets.h"
|
|
|
|
#include "qemu/iov.h"
|
2014-03-11 00:42:26 +01:00
|
|
|
#include "net/net.h"
|
2011-09-08 13:46:25 +02:00
|
|
|
|
2012-07-09 08:50:43 +02:00
|
|
|
void strpadcpy(char *buf, int buf_size, const char *str, char pad)
|
|
|
|
{
|
|
|
|
int len = qemu_strnlen(str, buf_size);
|
|
|
|
memcpy(buf, str, len);
|
|
|
|
memset(buf + len, pad, buf_size - len);
|
|
|
|
}
|
|
|
|
|
2007-01-07 23:04:40 +01:00
|
|
|
void pstrcpy(char *buf, int buf_size, const char *str)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
char *q = buf;
|
|
|
|
|
|
|
|
if (buf_size <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
c = *str++;
|
|
|
|
if (c == 0 || q >= buf + buf_size - 1)
|
|
|
|
break;
|
|
|
|
*q++ = c;
|
|
|
|
}
|
|
|
|
*q = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* strcat and truncate. */
|
|
|
|
char *pstrcat(char *buf, int buf_size, const char *s)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
len = strlen(buf);
|
2007-09-16 23:08:06 +02:00
|
|
|
if (len < buf_size)
|
2007-01-07 23:04:40 +01:00
|
|
|
pstrcpy(buf + len, buf_size - len, s);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
int strstart(const char *str, const char *val, const char **ptr)
|
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
p = str;
|
|
|
|
q = val;
|
|
|
|
while (*q != '\0') {
|
|
|
|
if (*p != *q)
|
|
|
|
return 0;
|
|
|
|
p++;
|
|
|
|
q++;
|
|
|
|
}
|
|
|
|
if (ptr)
|
|
|
|
*ptr = p;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int stristart(const char *str, const char *val, const char **ptr)
|
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
p = str;
|
|
|
|
q = val;
|
|
|
|
while (*q != '\0') {
|
2008-11-16 14:53:32 +01:00
|
|
|
if (qemu_toupper(*p) != qemu_toupper(*q))
|
2007-01-07 23:04:40 +01:00
|
|
|
return 0;
|
|
|
|
p++;
|
|
|
|
q++;
|
|
|
|
}
|
|
|
|
if (ptr)
|
|
|
|
*ptr = p;
|
|
|
|
return 1;
|
|
|
|
}
|
2007-11-10 20:36:39 +01:00
|
|
|
|
2009-07-01 20:24:44 +02:00
|
|
|
/* XXX: use host strnlen if available ? */
|
|
|
|
int qemu_strnlen(const char *s, int max_len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < max_len; i++) {
|
|
|
|
if (s[i] == '\0') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2013-06-05 14:19:35 +02:00
|
|
|
char *qemu_strsep(char **input, const char *delim)
|
|
|
|
{
|
|
|
|
char *result = *input;
|
|
|
|
if (result != NULL) {
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
for (p = result; *p != '\0'; p++) {
|
|
|
|
if (strchr(delim, *p)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*p == '\0') {
|
|
|
|
*input = NULL;
|
|
|
|
} else {
|
|
|
|
*p = '\0';
|
|
|
|
*input = p + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-11-10 20:36:39 +01:00
|
|
|
time_t mktimegm(struct tm *tm)
|
|
|
|
{
|
|
|
|
time_t t;
|
|
|
|
int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
|
|
|
|
if (m < 3) {
|
|
|
|
m += 12;
|
|
|
|
y--;
|
|
|
|
}
|
2012-10-01 14:22:06 +02:00
|
|
|
t = 86400ULL * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
|
2007-11-10 20:36:39 +01:00
|
|
|
y / 400 - 719469);
|
|
|
|
t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
|
|
|
|
return t;
|
|
|
|
}
|
2008-12-04 20:19:45 +01:00
|
|
|
|
2009-09-04 19:01:32 +02:00
|
|
|
/*
|
|
|
|
* Make sure data goes on disk, but if possible do not bother to
|
|
|
|
* write out the inode just for timestamp updates.
|
|
|
|
*
|
|
|
|
* Unfortunately even in 2009 many operating systems do not support
|
|
|
|
* fdatasync and have to fall back to fsync.
|
|
|
|
*/
|
|
|
|
int qemu_fdatasync(int fd)
|
|
|
|
{
|
2009-09-20 08:56:26 +02:00
|
|
|
#ifdef CONFIG_FDATASYNC
|
2009-09-04 19:01:32 +02:00
|
|
|
return fdatasync(fd);
|
|
|
|
#else
|
|
|
|
return fsync(fd);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-03-08 06:53:17 +01:00
|
|
|
static bool
|
|
|
|
can_use_buffer_find_nonzero_offset_inner(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
|
|
|
|
* sizeof(VECTYPE)) == 0
|
|
|
|
&& ((uintptr_t) buf) % sizeof(VECTYPE) == 0);
|
|
|
|
}
|
|
|
|
|
2013-03-26 10:58:32 +01:00
|
|
|
/*
|
|
|
|
* Searches for an area with non-zero content in a buffer
|
|
|
|
*
|
|
|
|
* Attention! The len must be a multiple of
|
|
|
|
* BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
|
|
|
|
* and addr must be a multiple of sizeof(VECTYPE) due to
|
|
|
|
* restriction of optimizations in this function.
|
|
|
|
*
|
2016-03-08 06:53:17 +01:00
|
|
|
* can_use_buffer_find_nonzero_offset_inner() can be used to
|
|
|
|
* check these requirements.
|
2013-03-26 10:58:32 +01:00
|
|
|
*
|
|
|
|
* The return value is the offset of the non-zero area rounded
|
|
|
|
* down to a multiple of sizeof(VECTYPE) for the first
|
|
|
|
* BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR chunks and down to
|
|
|
|
* BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR * sizeof(VECTYPE)
|
|
|
|
* afterwards.
|
|
|
|
*
|
|
|
|
* If the buffer is all zero the return value is equal to len.
|
|
|
|
*/
|
|
|
|
|
2016-03-08 06:53:17 +01:00
|
|
|
static size_t buffer_find_nonzero_offset_inner(const void *buf, size_t len)
|
2013-03-26 10:58:32 +01:00
|
|
|
{
|
|
|
|
const VECTYPE *p = buf;
|
|
|
|
const VECTYPE zero = (VECTYPE){0};
|
|
|
|
size_t i;
|
|
|
|
|
2016-03-08 06:53:17 +01:00
|
|
|
assert(can_use_buffer_find_nonzero_offset_inner(buf, len));
|
2013-03-26 10:58:32 +01:00
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
|
|
|
|
if (!ALL_EQ(p[i], zero)) {
|
|
|
|
return i * sizeof(VECTYPE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
|
|
|
|
i < len / sizeof(VECTYPE);
|
|
|
|
i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
|
2015-06-23 14:30:18 +02:00
|
|
|
VECTYPE tmp0 = VEC_OR(p[i + 0], p[i + 1]);
|
|
|
|
VECTYPE tmp1 = VEC_OR(p[i + 2], p[i + 3]);
|
|
|
|
VECTYPE tmp2 = VEC_OR(p[i + 4], p[i + 5]);
|
|
|
|
VECTYPE tmp3 = VEC_OR(p[i + 6], p[i + 7]);
|
|
|
|
VECTYPE tmp01 = VEC_OR(tmp0, tmp1);
|
|
|
|
VECTYPE tmp23 = VEC_OR(tmp2, tmp3);
|
|
|
|
if (!ALL_EQ(VEC_OR(tmp01, tmp23), zero)) {
|
2013-03-26 10:58:32 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return i * sizeof(VECTYPE);
|
|
|
|
}
|
|
|
|
|
2016-03-08 06:53:17 +01:00
|
|
|
/*
|
|
|
|
* GCC before version 4.9 has a bug which will cause the target
|
|
|
|
* attribute work incorrectly and failed to compile in some case,
|
|
|
|
* restrict the gcc version to 4.9+ to prevent the failure.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if defined CONFIG_AVX2_OPT && QEMU_GNUC_PREREQ(4, 9)
|
|
|
|
#pragma GCC push_options
|
|
|
|
#pragma GCC target("avx2")
|
|
|
|
#include <cpuid.h>
|
|
|
|
#include <immintrin.h>
|
|
|
|
|
|
|
|
#define AVX2_VECTYPE __m256i
|
|
|
|
#define AVX2_SPLAT(p) _mm256_set1_epi8(*(p))
|
|
|
|
#define AVX2_ALL_EQ(v1, v2) \
|
|
|
|
(_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, v2)) == 0xFFFFFFFF)
|
|
|
|
#define AVX2_VEC_OR(v1, v2) (_mm256_or_si256(v1, v2))
|
|
|
|
|
|
|
|
static bool
|
|
|
|
can_use_buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
return (len % (BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR
|
|
|
|
* sizeof(AVX2_VECTYPE)) == 0
|
|
|
|
&& ((uintptr_t) buf) % sizeof(AVX2_VECTYPE) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t buffer_find_nonzero_offset_avx2(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
const AVX2_VECTYPE *p = buf;
|
|
|
|
const AVX2_VECTYPE zero = (AVX2_VECTYPE){0};
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
assert(can_use_buffer_find_nonzero_offset_avx2(buf, len));
|
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR; i++) {
|
|
|
|
if (!AVX2_ALL_EQ(p[i], zero)) {
|
|
|
|
return i * sizeof(AVX2_VECTYPE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR;
|
|
|
|
i < len / sizeof(AVX2_VECTYPE);
|
|
|
|
i += BUFFER_FIND_NONZERO_OFFSET_UNROLL_FACTOR) {
|
|
|
|
AVX2_VECTYPE tmp0 = AVX2_VEC_OR(p[i + 0], p[i + 1]);
|
|
|
|
AVX2_VECTYPE tmp1 = AVX2_VEC_OR(p[i + 2], p[i + 3]);
|
|
|
|
AVX2_VECTYPE tmp2 = AVX2_VEC_OR(p[i + 4], p[i + 5]);
|
|
|
|
AVX2_VECTYPE tmp3 = AVX2_VEC_OR(p[i + 6], p[i + 7]);
|
|
|
|
AVX2_VECTYPE tmp01 = AVX2_VEC_OR(tmp0, tmp1);
|
|
|
|
AVX2_VECTYPE tmp23 = AVX2_VEC_OR(tmp2, tmp3);
|
|
|
|
if (!AVX2_ALL_EQ(AVX2_VEC_OR(tmp01, tmp23), zero)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return i * sizeof(AVX2_VECTYPE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool avx2_support(void)
|
|
|
|
{
|
|
|
|
int a, b, c, d;
|
|
|
|
|
|
|
|
if (__get_cpuid_max(0, NULL) < 7) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
__cpuid_count(7, 0, a, b, c, d);
|
|
|
|
|
|
|
|
return b & bit_AVX2;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len) \
|
|
|
|
__attribute__ ((ifunc("can_use_buffer_find_nonzero_offset_ifunc")));
|
|
|
|
size_t buffer_find_nonzero_offset(const void *buf, size_t len) \
|
|
|
|
__attribute__ ((ifunc("buffer_find_nonzero_offset_ifunc")));
|
|
|
|
|
|
|
|
static void *buffer_find_nonzero_offset_ifunc(void)
|
|
|
|
{
|
|
|
|
typeof(buffer_find_nonzero_offset) *func = (avx2_support()) ?
|
|
|
|
buffer_find_nonzero_offset_avx2 : buffer_find_nonzero_offset_inner;
|
|
|
|
|
|
|
|
return func;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *can_use_buffer_find_nonzero_offset_ifunc(void)
|
|
|
|
{
|
|
|
|
typeof(can_use_buffer_find_nonzero_offset) *func = (avx2_support()) ?
|
|
|
|
can_use_buffer_find_nonzero_offset_avx2 :
|
|
|
|
can_use_buffer_find_nonzero_offset_inner;
|
|
|
|
|
|
|
|
return func;
|
|
|
|
}
|
|
|
|
#pragma GCC pop_options
|
|
|
|
#else
|
|
|
|
bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
return can_use_buffer_find_nonzero_offset_inner(buf, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t buffer_find_nonzero_offset(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
return buffer_find_nonzero_offset_inner(buf, len);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-02-07 14:27:24 +01:00
|
|
|
/*
|
|
|
|
* Checks if a buffer is all zeroes
|
|
|
|
*
|
|
|
|
* Attention! The len must be a multiple of 4 * sizeof(long) due to
|
|
|
|
* restriction of optimizations in this function.
|
|
|
|
*/
|
|
|
|
bool buffer_is_zero(const void *buf, size_t len)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Use long as the biggest available internal data type that fits into the
|
|
|
|
* CPU register and unroll the loop to smooth out the effect of memory
|
|
|
|
* latency.
|
|
|
|
*/
|
|
|
|
|
|
|
|
size_t i;
|
|
|
|
long d0, d1, d2, d3;
|
|
|
|
const long * const data = buf;
|
|
|
|
|
2013-03-26 10:58:33 +01:00
|
|
|
/* use vector optimized zero check if possible */
|
|
|
|
if (can_use_buffer_find_nonzero_offset(buf, len)) {
|
|
|
|
return buffer_find_nonzero_offset(buf, len) == len;
|
|
|
|
}
|
|
|
|
|
2012-02-07 14:27:24 +01:00
|
|
|
assert(len % (4 * sizeof(long)) == 0);
|
|
|
|
len /= sizeof(long);
|
|
|
|
|
|
|
|
for (i = 0; i < len; i += 4) {
|
|
|
|
d0 = data[i + 0];
|
|
|
|
d1 = data[i + 1];
|
|
|
|
d2 = data[i + 2];
|
|
|
|
d3 = data[i + 3];
|
|
|
|
|
|
|
|
if (d0 || d1 || d2 || d3) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-03-10 11:38:55 +01:00
|
|
|
#ifndef _WIN32
|
|
|
|
/* Sets a specific flag */
|
|
|
|
int fcntl_setfl(int fd, int flag)
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
|
|
if (flags == -1)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
if (fcntl(fd, F_SETFL, flags | flag) == -1)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
static int64_t suffix_mul(char suffix, int64_t unit)
|
|
|
|
{
|
|
|
|
switch (qemu_toupper(suffix)) {
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_B:
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
return 1;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_KB:
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
return unit;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_MB:
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
return unit * unit;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_GB:
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
return unit * unit * unit;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_TB:
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
return unit * unit * unit * unit;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_PB:
|
2013-06-05 14:19:27 +02:00
|
|
|
return unit * unit * unit * unit * unit;
|
2015-09-16 18:02:56 +02:00
|
|
|
case QEMU_STRTOSZ_DEFSUFFIX_EB:
|
2013-06-05 14:19:27 +02:00
|
|
|
return unit * unit * unit * unit * unit * unit;
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-10-21 17:15:46 +02:00
|
|
|
/*
|
|
|
|
* Convert string to bytes, allowing either B/b for bytes, K/k for KB,
|
2011-11-22 09:46:01 +01:00
|
|
|
* M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
|
2012-12-17 02:49:22 +01:00
|
|
|
* in *end, if not NULL. Return -ERANGE on overflow, Return -EINVAL on
|
|
|
|
* other error.
|
2010-10-21 17:15:46 +02:00
|
|
|
*/
|
2015-09-16 18:02:56 +02:00
|
|
|
int64_t qemu_strtosz_suffix_unit(const char *nptr, char **end,
|
2011-07-07 16:13:11 +02:00
|
|
|
const char default_suffix, int64_t unit)
|
2010-10-21 17:15:46 +02:00
|
|
|
{
|
2012-12-17 02:49:22 +01:00
|
|
|
int64_t retval = -EINVAL;
|
2011-01-24 16:33:28 +01:00
|
|
|
char *endptr;
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
unsigned char c;
|
2010-10-21 17:15:46 +02:00
|
|
|
int mul_required = 0;
|
|
|
|
double val, mul, integral, fraction;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
val = strtod(nptr, &endptr);
|
|
|
|
if (isnan(val) || endptr == nptr || errno != 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-01-24 16:33:30 +01:00
|
|
|
fraction = modf(val, &integral);
|
|
|
|
if (fraction != 0) {
|
2010-10-21 17:15:46 +02:00
|
|
|
mul_required = 1;
|
|
|
|
}
|
|
|
|
c = *endptr;
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
mul = suffix_mul(c, unit);
|
|
|
|
if (mul >= 0) {
|
|
|
|
endptr++;
|
|
|
|
} else {
|
|
|
|
mul = suffix_mul(default_suffix, unit);
|
|
|
|
assert(mul >= 0);
|
2010-10-21 17:15:46 +02:00
|
|
|
}
|
cutils: Make strtosz & friends leave follow set to callers
strtosz() & friends require the size to be at the end of the string,
or be followed by whitespace or ','. I find this surprising, because
the name suggests it works like strtol().
The check simplifies callers that accept exactly that follow set
slightly. No such callers exist.
The check is redundant for callers that accept a smaller follow set,
and thus need to check themselves anyway. Right now, this is the case
for all but one caller. All of them neglected to check, or checked
incorrectly, but the previous few commits fixed them up.
Finally, the check is problematic for callers that accept a larger
follow set. This is the case in monitor_parse_command().
Fortunately, the problems there are relatively harmless.
monitor_parse_command() uses strtosz() for argument type 'o'. When
the last argument is of type 'o', a trailing ',' is diagnosed
differently than other trailing junk:
(qemu) migrate_set_speed 1x
invalid size
(qemu) migrate_set_speed 1,
migrate_set_speed: extraneous characters at the end of line
A related inconsistency exists with non-last arguments. No such
command exists, but let's use memsave to explore the inconsistency.
The monitor permits, but does not require whitespace between
arguments. For instance, "memsave (1-1)1024foo" is parsed as command
memsave with three arguments 0, 1024 and "foo". Yes, this is daft,
but at least it's consistently daft.
If I change memsave's second argument from 'i' to 'o', then "memsave
(1-1)1foo" is rejected, because the size is followed by an 'f'. But
"memsave (1-1)1," is still accepted, and duly saves to file ",".
We don't have any users of strtosz that profit from the check. In the
users we have, it appears to encourage sloppy error checking, or gets
in the way. Drop the bothersome check.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2011-11-22 09:46:06 +01:00
|
|
|
if (mul == 1 && mul_required) {
|
2010-10-21 17:15:46 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
2011-01-05 11:41:02 +01:00
|
|
|
if ((val * mul >= INT64_MAX) || val < 0) {
|
2012-12-17 02:49:22 +01:00
|
|
|
retval = -ERANGE;
|
2010-10-21 17:15:46 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
retval = val * mul;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (end) {
|
|
|
|
*end = endptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2010-12-09 14:17:24 +01:00
|
|
|
|
2015-09-16 18:02:56 +02:00
|
|
|
int64_t qemu_strtosz_suffix(const char *nptr, char **end,
|
|
|
|
const char default_suffix)
|
2011-07-07 16:13:11 +02:00
|
|
|
{
|
2015-09-16 18:02:56 +02:00
|
|
|
return qemu_strtosz_suffix_unit(nptr, end, default_suffix, 1024);
|
2011-07-07 16:13:11 +02:00
|
|
|
}
|
|
|
|
|
2015-09-16 18:02:56 +02:00
|
|
|
int64_t qemu_strtosz(const char *nptr, char **end)
|
2010-12-09 14:17:24 +01:00
|
|
|
{
|
2015-09-16 18:02:56 +02:00
|
|
|
return qemu_strtosz_suffix(nptr, end, QEMU_STRTOSZ_DEFSUFFIX_MB);
|
2010-12-09 14:17:24 +01:00
|
|
|
}
|
2011-09-28 12:41:32 +02:00
|
|
|
|
2015-07-20 01:02:17 +02:00
|
|
|
/**
|
|
|
|
* Helper function for qemu_strto*l() functions.
|
|
|
|
*/
|
2015-09-10 10:02:00 +02:00
|
|
|
static int check_strtox_error(const char *p, char *endptr, const char **next,
|
2015-07-20 01:02:17 +02:00
|
|
|
int err)
|
|
|
|
{
|
2015-09-10 10:02:00 +02:00
|
|
|
/* If no conversion was performed, prefer BSD behavior over glibc
|
|
|
|
* behavior.
|
|
|
|
*/
|
|
|
|
if (err == 0 && endptr == p) {
|
|
|
|
err = EINVAL;
|
|
|
|
}
|
2015-07-20 01:02:17 +02:00
|
|
|
if (!next && *endptr) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (next) {
|
|
|
|
*next = endptr;
|
|
|
|
}
|
|
|
|
return -err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* QEMU wrappers for strtol(), strtoll(), strtoul(), strotull() C functions.
|
|
|
|
*
|
|
|
|
* Convert ASCII string @nptr to a long integer value
|
|
|
|
* from the given @base. Parameters @nptr, @endptr, @base
|
|
|
|
* follows same semantics as strtol() C function.
|
|
|
|
*
|
|
|
|
* Unlike from strtol() function, if @endptr is not NULL, this
|
|
|
|
* function will return -EINVAL whenever it cannot fully convert
|
|
|
|
* the string in @nptr with given @base to a long. This function returns
|
|
|
|
* the result of the conversion only through the @result parameter.
|
|
|
|
*
|
|
|
|
* If NULL is passed in @endptr, then the whole string in @ntpr
|
|
|
|
* is a number otherwise it returns -EINVAL.
|
|
|
|
*
|
|
|
|
* RETURN VALUE
|
|
|
|
* Unlike from strtol() function, this wrapper returns either
|
|
|
|
* -EINVAL or the errno set by strtol() function (e.g -ERANGE).
|
|
|
|
* If the conversion overflows, -ERANGE is returned, and @result
|
|
|
|
* is set to the max value of the desired type
|
|
|
|
* (e.g. LONG_MAX, LLONG_MAX, ULONG_MAX, ULLONG_MAX). If the case
|
|
|
|
* of underflow, -ERANGE is returned, and @result is set to the min
|
|
|
|
* value of the desired type. For strtol(), strtoll(), @result is set to
|
|
|
|
* LONG_MIN, LLONG_MIN, respectively, and for strtoul(), strtoull() it
|
|
|
|
* is set to 0.
|
|
|
|
*/
|
|
|
|
int qemu_strtol(const char *nptr, const char **endptr, int base,
|
|
|
|
long *result)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int err = 0;
|
|
|
|
if (!nptr) {
|
|
|
|
if (endptr) {
|
|
|
|
*endptr = nptr;
|
|
|
|
}
|
|
|
|
err = -EINVAL;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
*result = strtol(nptr, &p, base);
|
2015-09-10 10:02:00 +02:00
|
|
|
err = check_strtox_error(nptr, p, endptr, errno);
|
2015-07-20 01:02:17 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
2015-07-20 01:02:18 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts ASCII string to an unsigned long integer.
|
|
|
|
*
|
|
|
|
* If string contains a negative number, value will be converted to
|
|
|
|
* the unsigned representation of the signed value, unless the original
|
|
|
|
* (nonnegated) value would overflow, in this case, it will set @result
|
|
|
|
* to ULONG_MAX, and return ERANGE.
|
|
|
|
*
|
|
|
|
* The same behavior holds, for qemu_strtoull() but sets @result to
|
|
|
|
* ULLONG_MAX instead of ULONG_MAX.
|
|
|
|
*
|
|
|
|
* See qemu_strtol() documentation for more info.
|
|
|
|
*/
|
|
|
|
int qemu_strtoul(const char *nptr, const char **endptr, int base,
|
|
|
|
unsigned long *result)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int err = 0;
|
|
|
|
if (!nptr) {
|
|
|
|
if (endptr) {
|
|
|
|
*endptr = nptr;
|
|
|
|
}
|
|
|
|
err = -EINVAL;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
*result = strtoul(nptr, &p, base);
|
2015-09-10 10:02:00 +02:00
|
|
|
/* Windows returns 1 for negative out-of-range values. */
|
|
|
|
if (errno == ERANGE) {
|
|
|
|
*result = -1;
|
|
|
|
}
|
|
|
|
err = check_strtox_error(nptr, p, endptr, errno);
|
2015-07-20 01:02:18 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-07-20 01:02:19 +02:00
|
|
|
/**
|
|
|
|
* Converts ASCII string to a long long integer.
|
|
|
|
*
|
|
|
|
* See qemu_strtol() documentation for more info.
|
|
|
|
*/
|
|
|
|
int qemu_strtoll(const char *nptr, const char **endptr, int base,
|
|
|
|
int64_t *result)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int err = 0;
|
|
|
|
if (!nptr) {
|
|
|
|
if (endptr) {
|
|
|
|
*endptr = nptr;
|
|
|
|
}
|
|
|
|
err = -EINVAL;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
*result = strtoll(nptr, &p, base);
|
2015-09-10 10:02:00 +02:00
|
|
|
err = check_strtox_error(nptr, p, endptr, errno);
|
2015-07-20 01:02:19 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-07-20 01:02:20 +02:00
|
|
|
/**
|
|
|
|
* Converts ASCII string to an unsigned long long integer.
|
|
|
|
*
|
|
|
|
* See qemu_strtol() documentation for more info.
|
|
|
|
*/
|
|
|
|
int qemu_strtoull(const char *nptr, const char **endptr, int base,
|
|
|
|
uint64_t *result)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int err = 0;
|
|
|
|
if (!nptr) {
|
|
|
|
if (endptr) {
|
|
|
|
*endptr = nptr;
|
|
|
|
}
|
|
|
|
err = -EINVAL;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
*result = strtoull(nptr, &p, base);
|
2015-09-10 10:02:00 +02:00
|
|
|
/* Windows returns 1 for negative out-of-range values. */
|
|
|
|
if (errno == ERANGE) {
|
|
|
|
*result = -1;
|
|
|
|
}
|
|
|
|
err = check_strtox_error(nptr, p, endptr, errno);
|
2015-07-20 01:02:20 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-02-04 19:27:45 +01:00
|
|
|
/**
|
|
|
|
* parse_uint:
|
|
|
|
*
|
|
|
|
* @s: String to parse
|
|
|
|
* @value: Destination for parsed integer value
|
|
|
|
* @endptr: Destination for pointer to first character not consumed
|
|
|
|
* @base: integer base, between 2 and 36 inclusive, or 0
|
|
|
|
*
|
|
|
|
* Parse unsigned integer
|
|
|
|
*
|
|
|
|
* Parsed syntax is like strtoull()'s: arbitrary whitespace, a single optional
|
|
|
|
* '+' or '-', an optional "0x" if @base is 0 or 16, one or more digits.
|
|
|
|
*
|
|
|
|
* If @s is null, or @base is invalid, or @s doesn't start with an
|
|
|
|
* integer in the syntax above, set *@value to 0, *@endptr to @s, and
|
|
|
|
* return -EINVAL.
|
|
|
|
*
|
|
|
|
* Set *@endptr to point right beyond the parsed integer (even if the integer
|
|
|
|
* overflows or is negative, all digits will be parsed and *@endptr will
|
|
|
|
* point right beyond them).
|
|
|
|
*
|
|
|
|
* If the integer is negative, set *@value to 0, and return -ERANGE.
|
|
|
|
*
|
|
|
|
* If the integer overflows unsigned long long, set *@value to
|
|
|
|
* ULLONG_MAX, and return -ERANGE.
|
|
|
|
*
|
|
|
|
* Else, set *@value to the parsed integer, and return 0.
|
|
|
|
*/
|
|
|
|
int parse_uint(const char *s, unsigned long long *value, char **endptr,
|
|
|
|
int base)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
char *endp = (char *)s;
|
|
|
|
unsigned long long val = 0;
|
|
|
|
|
|
|
|
if (!s) {
|
|
|
|
r = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
val = strtoull(s, &endp, base);
|
|
|
|
if (errno) {
|
|
|
|
r = -errno;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (endp == s) {
|
|
|
|
r = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure we reject negative numbers: */
|
|
|
|
while (isspace((unsigned char)*s)) {
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
if (*s == '-') {
|
|
|
|
val = 0;
|
|
|
|
r = -ERANGE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
*value = val;
|
|
|
|
*endptr = endp;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* parse_uint_full:
|
|
|
|
*
|
|
|
|
* @s: String to parse
|
|
|
|
* @value: Destination for parsed integer value
|
|
|
|
* @base: integer base, between 2 and 36 inclusive, or 0
|
|
|
|
*
|
|
|
|
* Parse unsigned integer from entire string
|
|
|
|
*
|
|
|
|
* Have the same behavior of parse_uint(), but with an additional check
|
|
|
|
* for additional data after the parsed number. If extra characters are present
|
|
|
|
* after the parsed number, the function will return -EINVAL, and *@v will
|
|
|
|
* be set to 0.
|
|
|
|
*/
|
|
|
|
int parse_uint_full(const char *s, unsigned long long *value, int base)
|
|
|
|
{
|
|
|
|
char *endp;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = parse_uint(s, value, &endp, base);
|
|
|
|
if (r < 0) {
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
if (*endp) {
|
|
|
|
*value = 0;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-28 12:41:32 +02:00
|
|
|
int qemu_parse_fd(const char *param)
|
|
|
|
{
|
2014-04-10 10:24:30 +02:00
|
|
|
long fd;
|
|
|
|
char *endptr;
|
2011-09-28 12:41:32 +02:00
|
|
|
|
2014-04-10 10:24:30 +02:00
|
|
|
errno = 0;
|
2011-09-28 12:41:32 +02:00
|
|
|
fd = strtol(param, &endptr, 10);
|
2014-04-10 10:24:30 +02:00
|
|
|
if (param == endptr /* no conversion performed */ ||
|
|
|
|
errno != 0 /* not representable as long; possibly others */ ||
|
|
|
|
*endptr != '\0' /* final string not empty */ ||
|
|
|
|
fd < 0 /* invalid as file descriptor */ ||
|
|
|
|
fd > INT_MAX /* not representable as int */) {
|
2011-09-28 12:41:32 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
2012-08-06 20:42:50 +02:00
|
|
|
|
2012-08-06 20:42:51 +02:00
|
|
|
/*
|
|
|
|
* Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128)
|
|
|
|
* Input is limited to 14-bit numbers
|
|
|
|
*/
|
|
|
|
int uleb128_encode_small(uint8_t *out, uint32_t n)
|
|
|
|
{
|
|
|
|
g_assert(n <= 0x3fff);
|
|
|
|
if (n < 0x80) {
|
|
|
|
*out++ = n;
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
*out++ = (n & 0x7f) | 0x80;
|
|
|
|
*out++ = n >> 7;
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int uleb128_decode_small(const uint8_t *in, uint32_t *n)
|
|
|
|
{
|
|
|
|
if (!(*in & 0x80)) {
|
|
|
|
*n = *in++;
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
*n = *in++ & 0x7f;
|
|
|
|
/* we exceed 14 bit number */
|
|
|
|
if (*in & 0x80) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*n |= *in++ << 7;
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
}
|
2013-03-04 17:41:28 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* helper to parse debug environment variables
|
|
|
|
*/
|
|
|
|
int parse_debug_env(const char *name, int max, int initial)
|
|
|
|
{
|
|
|
|
char *debug_env = getenv(name);
|
|
|
|
char *inv = NULL;
|
2015-02-11 12:30:43 +01:00
|
|
|
long debug;
|
2013-03-04 17:41:28 +01:00
|
|
|
|
|
|
|
if (!debug_env) {
|
|
|
|
return initial;
|
|
|
|
}
|
2015-02-11 12:30:43 +01:00
|
|
|
errno = 0;
|
2013-03-04 17:41:28 +01:00
|
|
|
debug = strtol(debug_env, &inv, 10);
|
|
|
|
if (inv == debug_env) {
|
|
|
|
return initial;
|
|
|
|
}
|
2015-02-11 12:30:43 +01:00
|
|
|
if (debug < 0 || debug > max || errno != 0) {
|
2013-03-04 17:41:28 +01:00
|
|
|
fprintf(stderr, "warning: %s not in [0, %d]", name, max);
|
|
|
|
return initial;
|
|
|
|
}
|
|
|
|
return debug;
|
|
|
|
}
|
2014-03-11 00:42:26 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper to print ethernet mac address
|
|
|
|
*/
|
|
|
|
const char *qemu_ether_ntoa(const MACAddr *mac)
|
|
|
|
{
|
|
|
|
static char ret[18];
|
|
|
|
|
|
|
|
snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
|
|
|
|
mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|