void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
{
- qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
+ qiov->iov = g_malloc(alloc_hint * sizeof(struct iovec));
qiov->niov = 0;
qiov->nalloc = alloc_hint;
qiov->size = 0;
if (qiov->niov == qiov->nalloc) {
qiov->nalloc = 2 * qiov->nalloc + 1;
- qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
+ qiov->iov = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
}
qiov->iov[qiov->niov].iov_base = base;
qiov->iov[qiov->niov].iov_len = len;
{
assert(qiov->nalloc != -1);
- qemu_free(qiov->iov);
+ g_free(qiov->iov);
}
void qemu_iovec_reset(QEMUIOVector *qiov)
}
#endif
+static int64_t suffix_mul(char suffix, int64_t unit)
+{
+ switch (qemu_toupper(suffix)) {
+ case STRTOSZ_DEFSUFFIX_B:
+ return 1;
+ case STRTOSZ_DEFSUFFIX_KB:
+ return unit;
+ case STRTOSZ_DEFSUFFIX_MB:
+ return unit * unit;
+ case STRTOSZ_DEFSUFFIX_GB:
+ return unit * unit * unit;
+ case STRTOSZ_DEFSUFFIX_TB:
+ return unit * unit * unit * unit;
+ }
+ return -1;
+}
+
/*
* Convert string to bytes, allowing either B/b for bytes, K/k for KB,
- * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
- * is MB. End pointer will be returned in *end, if not NULL. A valid
- * value must be terminated by whitespace, ',' or '\0'. Return -1 on
- * error.
+ * M/m for MB, G/g for GB or T/t for TB. End pointer will be returned
+ * in *end, if not NULL. Return -1 on error.
*/
-int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
+int64_t strtosz_suffix_unit(const char *nptr, char **end,
+ const char default_suffix, int64_t unit)
{
int64_t retval = -1;
char *endptr;
- unsigned char c, d;
+ unsigned char c;
int mul_required = 0;
double val, mul, integral, fraction;
if (fraction != 0) {
mul_required = 1;
}
- /*
- * Any whitespace character is fine for terminating the number,
- * in addition we accept ',' to handle strings where the size is
- * part of a multi token argument.
- */
c = *endptr;
- d = c;
- if (qemu_isspace(c) || c == '\0' || c == ',') {
- c = 0;
- if (default_suffix) {
- d = default_suffix;
- } else {
- d = c;
- }
+ mul = suffix_mul(c, unit);
+ if (mul >= 0) {
+ endptr++;
+ } else {
+ mul = suffix_mul(default_suffix, unit);
+ assert(mul >= 0);
}
- switch (qemu_toupper(d)) {
- case STRTOSZ_DEFSUFFIX_B:
- mul = 1;
- if (mul_required) {
- goto fail;
- }
- break;
- case STRTOSZ_DEFSUFFIX_KB:
- mul = 1 << 10;
- break;
- case 0:
- if (mul_required) {
- goto fail;
- }
- case STRTOSZ_DEFSUFFIX_MB:
- mul = 1ULL << 20;
- break;
- case STRTOSZ_DEFSUFFIX_GB:
- mul = 1ULL << 30;
- break;
- case STRTOSZ_DEFSUFFIX_TB:
- mul = 1ULL << 40;
- break;
- default:
+ if (mul == 1 && mul_required) {
goto fail;
}
- /*
- * If not terminated by whitespace, ',', or \0, increment endptr
- * to point to next character, then check that we are terminated
- * by an appropriate separating character, ie. whitespace, ',', or
- * \0. If not, we are seeing trailing garbage, thus fail.
- */
- if (c != 0) {
- endptr++;
- if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) {
- goto fail;
- }
- }
if ((val * mul >= INT64_MAX) || val < 0) {
goto fail;
}
return retval;
}
+int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
+{
+ return strtosz_suffix_unit(nptr, end, default_suffix, 1024);
+}
+
int64_t strtosz(const char *nptr, char **end)
{
return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
}
+
+int qemu_parse_fd(const char *param)
+{
+ int fd;
+ char *endptr = NULL;
+
+ fd = strtol(param, &endptr, 10);
+ if (*endptr || (fd == 0 && param == endptr)) {
+ return -1;
+ }
+ return fd;
+}