2009-05-18 16:42:09 +02:00
|
|
|
/*
|
|
|
|
* Commandline option parsing functions
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
|
|
|
* Copyright (c) 2009 Kevin Wolf <kwolf@redhat.com>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "qemu-common.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/types.h"
|
|
|
|
#include "qapi/error.h"
|
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/option_int.h"
|
2009-05-18 16:42:09 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Extracts the name of an option from the parameter string (p points at the
|
|
|
|
* first byte of the option name)
|
|
|
|
*
|
|
|
|
* The option name is delimited by delim (usually , or =) or the string end
|
|
|
|
* and is copied into buf. If the option name is longer than buf_size, it is
|
|
|
|
* truncated. buf is always zero terminated.
|
|
|
|
*
|
|
|
|
* The return value is the position of the delimiter/zero byte after the option
|
|
|
|
* name in p.
|
|
|
|
*/
|
|
|
|
const char *get_opt_name(char *buf, int buf_size, const char *p, char delim)
|
|
|
|
{
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
q = buf;
|
|
|
|
while (*p != '\0' && *p != delim) {
|
|
|
|
if (q && (q - buf) < buf_size - 1)
|
|
|
|
*q++ = *p;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if (q)
|
|
|
|
*q = '\0';
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extracts the value of an option from the parameter string p (p points at the
|
|
|
|
* first byte of the option value)
|
|
|
|
*
|
|
|
|
* This function is comparable to get_opt_name with the difference that the
|
|
|
|
* delimiter is fixed to be comma which starts a new option. To specify an
|
|
|
|
* option value that contains commas, double each comma.
|
|
|
|
*/
|
|
|
|
const char *get_opt_value(char *buf, int buf_size, const char *p)
|
|
|
|
{
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
q = buf;
|
|
|
|
while (*p != '\0') {
|
|
|
|
if (*p == ',') {
|
|
|
|
if (*(p + 1) != ',')
|
|
|
|
break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if (q && (q - buf) < buf_size - 1)
|
|
|
|
*q++ = *p;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if (q)
|
|
|
|
*q = '\0';
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:00 +02:00
|
|
|
int get_next_param_value(char *buf, int buf_size,
|
|
|
|
const char *tag, const char **pstr)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
char option[128];
|
|
|
|
|
|
|
|
p = *pstr;
|
|
|
|
for(;;) {
|
|
|
|
p = get_opt_name(option, sizeof(option), p, '=');
|
|
|
|
if (*p != '=')
|
|
|
|
break;
|
|
|
|
p++;
|
|
|
|
if (!strcmp(tag, option)) {
|
|
|
|
*pstr = get_opt_value(buf, buf_size, p);
|
|
|
|
if (**pstr == ',') {
|
|
|
|
(*pstr)++;
|
|
|
|
}
|
|
|
|
return strlen(buf);
|
|
|
|
} else {
|
|
|
|
p = get_opt_value(NULL, 0, p);
|
|
|
|
}
|
|
|
|
if (*p != ',')
|
|
|
|
break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_param_value(char *buf, int buf_size,
|
|
|
|
const char *tag, const char *str)
|
|
|
|
{
|
|
|
|
return get_next_param_value(buf, buf_size, tag, &str);
|
|
|
|
}
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
/*
|
|
|
|
* Searches an option list for an option with the given name
|
|
|
|
*/
|
|
|
|
QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
while (list && list->name) {
|
|
|
|
if (!strcmp(list->name, name)) {
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-21 18:54:42 +01:00
|
|
|
static void parse_option_bool(const char *name, const char *value, bool *ret,
|
|
|
|
Error **errp)
|
2009-07-22 16:43:01 +02:00
|
|
|
{
|
|
|
|
if (value != NULL) {
|
|
|
|
if (!strcmp(value, "on")) {
|
|
|
|
*ret = 1;
|
|
|
|
} else if (!strcmp(value, "off")) {
|
|
|
|
*ret = 0;
|
|
|
|
} else {
|
2012-03-21 18:54:42 +01:00
|
|
|
error_set(errp,QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'");
|
2009-07-22 16:43:01 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-21 18:37:44 +01:00
|
|
|
static void parse_option_number(const char *name, const char *value,
|
|
|
|
uint64_t *ret, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
char *postfix;
|
|
|
|
uint64_t number;
|
|
|
|
|
|
|
|
if (value != NULL) {
|
|
|
|
number = strtoull(value, &postfix, 0);
|
|
|
|
if (*postfix != '\0') {
|
2012-03-21 18:37:44 +01:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
|
|
|
|
return;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2009-07-29 10:39:59 +02:00
|
|
|
*ret = number;
|
2009-07-22 16:43:03 +02:00
|
|
|
} else {
|
2012-03-21 18:37:44 +01:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-29 16:47:56 +02:00
|
|
|
void parse_option_size(const char *name, const char *value,
|
|
|
|
uint64_t *ret, Error **errp)
|
2009-07-22 16:43:02 +02:00
|
|
|
{
|
|
|
|
char *postfix;
|
|
|
|
double sizef;
|
|
|
|
|
|
|
|
if (value != NULL) {
|
|
|
|
sizef = strtod(value, &postfix);
|
|
|
|
switch (*postfix) {
|
|
|
|
case 'T':
|
|
|
|
sizef *= 1024;
|
2012-01-09 18:29:51 +01:00
|
|
|
/* fall through */
|
2009-07-22 16:43:02 +02:00
|
|
|
case 'G':
|
|
|
|
sizef *= 1024;
|
2012-01-09 18:29:51 +01:00
|
|
|
/* fall through */
|
2009-07-22 16:43:02 +02:00
|
|
|
case 'M':
|
|
|
|
sizef *= 1024;
|
2012-01-09 18:29:51 +01:00
|
|
|
/* fall through */
|
2009-07-22 16:43:02 +02:00
|
|
|
case 'K':
|
|
|
|
case 'k':
|
|
|
|
sizef *= 1024;
|
2012-01-09 18:29:51 +01:00
|
|
|
/* fall through */
|
2009-07-22 16:43:02 +02:00
|
|
|
case 'b':
|
|
|
|
case '\0':
|
|
|
|
*ret = (uint64_t) sizef;
|
|
|
|
break;
|
|
|
|
default:
|
2012-03-21 19:03:45 +01:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size");
|
qemu-option: Disable two helpful messages that got broken recently
commit 8be7e7e4 and commit ec7b2ccb messed up the ordering of error
message and the helpful explanation that should follow it, like this:
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --chardev null,id=,
Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.
qemu-system-x86_64: -chardev null,id=,: Parameter 'id' expects an identifier
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --machine kvm_shadow_mem=dunno
You may use k, M, G or T suffixes for kilobytes, megabytes, gigabytes and terabytes.
qemu-system-x86_64: -machine kvm_shadow_mem=dunno: Parameter 'kvm_shadow_mem' expects a size
Pity. Disable them for now.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-5-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:17 +01:00
|
|
|
#if 0 /* conversion from qerror_report() to error_set() broke this: */
|
2010-03-25 17:22:34 +01:00
|
|
|
error_printf_unless_qmp("You may use k, M, G or T suffixes for "
|
2009-07-22 16:43:02 +02:00
|
|
|
"kilobytes, megabytes, gigabytes and terabytes.\n");
|
qemu-option: Disable two helpful messages that got broken recently
commit 8be7e7e4 and commit ec7b2ccb messed up the ordering of error
message and the helpful explanation that should follow it, like this:
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --chardev null,id=,
Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.
qemu-system-x86_64: -chardev null,id=,: Parameter 'id' expects an identifier
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --machine kvm_shadow_mem=dunno
You may use k, M, G or T suffixes for kilobytes, megabytes, gigabytes and terabytes.
qemu-system-x86_64: -machine kvm_shadow_mem=dunno: Parameter 'kvm_shadow_mem' expects a size
Pity. Disable them for now.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-5-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:17 +01:00
|
|
|
#endif
|
2012-03-21 19:03:45 +01:00
|
|
|
return;
|
2009-07-22 16:43:02 +02:00
|
|
|
}
|
|
|
|
} else {
|
2012-03-21 19:03:45 +01:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size");
|
2009-07-22 16:43:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
/*
|
|
|
|
* Sets the value of a parameter in a given option list. The parsing of the
|
|
|
|
* value depends on the type of option:
|
|
|
|
*
|
|
|
|
* OPT_FLAG (uses value.n):
|
|
|
|
* If no value is given, the flag is set to 1.
|
|
|
|
* Otherwise the value must be "on" (set to 1) or "off" (set to 0)
|
|
|
|
*
|
|
|
|
* OPT_STRING (uses value.s):
|
|
|
|
* value is strdup()ed and assigned as option value
|
|
|
|
*
|
|
|
|
* OPT_SIZE (uses value.n):
|
|
|
|
* The value is converted to an integer. Suffixes for kilobytes etc. are
|
|
|
|
* allowed (powers of 1024).
|
|
|
|
*
|
|
|
|
* Returns 0 on succes, -1 in error cases
|
|
|
|
*/
|
|
|
|
int set_option_parameter(QEMUOptionParameter *list, const char *name,
|
|
|
|
const char *value)
|
|
|
|
{
|
2011-10-25 08:40:39 +02:00
|
|
|
bool flag;
|
2012-03-21 18:54:42 +01:00
|
|
|
Error *local_err = NULL;
|
2009-07-22 16:43:01 +02:00
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
// Find a matching parameter
|
|
|
|
list = get_option_parameter(list, name);
|
|
|
|
if (list == NULL) {
|
|
|
|
fprintf(stderr, "Unknown option '%s'\n", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Process parameter
|
|
|
|
switch (list->type) {
|
|
|
|
case OPT_FLAG:
|
2012-03-21 18:54:42 +01:00
|
|
|
parse_option_bool(name, value, &flag, &local_err);
|
|
|
|
if (!error_is_set(&local_err)) {
|
|
|
|
list->value.n = flag;
|
|
|
|
}
|
2009-05-18 16:42:09 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case OPT_STRING:
|
|
|
|
if (value != NULL) {
|
2011-08-21 05:09:37 +02:00
|
|
|
list->value.s = g_strdup(value);
|
2009-05-18 16:42:09 +02:00
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Option '%s' needs a parameter\n", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OPT_SIZE:
|
2012-03-21 19:03:45 +01:00
|
|
|
parse_option_size(name, value, &list->value.n, &local_err);
|
2009-05-18 16:42:09 +02:00
|
|
|
break;
|
2009-07-22 16:43:02 +02:00
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
default:
|
|
|
|
fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-03-21 18:54:42 +01:00
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:15:44 +02:00
|
|
|
list->assigned = true;
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sets the given parameter to an integer instead of a string.
|
|
|
|
* This function cannot be used to set string options.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, -1 in error cases
|
|
|
|
*/
|
|
|
|
int set_option_parameter_int(QEMUOptionParameter *list, const char *name,
|
|
|
|
uint64_t value)
|
|
|
|
{
|
|
|
|
// Find a matching parameter
|
|
|
|
list = get_option_parameter(list, name);
|
|
|
|
if (list == NULL) {
|
|
|
|
fprintf(stderr, "Unknown option '%s'\n", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Process parameter
|
|
|
|
switch (list->type) {
|
|
|
|
case OPT_FLAG:
|
|
|
|
case OPT_NUMBER:
|
|
|
|
case OPT_SIZE:
|
|
|
|
list->value.n = value;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-08-29 11:15:44 +02:00
|
|
|
list->assigned = true;
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frees a option list. If it contains strings, the strings are freed as well.
|
|
|
|
*/
|
|
|
|
void free_option_parameters(QEMUOptionParameter *list)
|
|
|
|
{
|
|
|
|
QEMUOptionParameter *cur = list;
|
|
|
|
|
|
|
|
while (cur && cur->name) {
|
|
|
|
if (cur->type == OPT_STRING) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(cur->value.s);
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(list);
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
|
2010-05-26 04:35:36 +02:00
|
|
|
/*
|
|
|
|
* Count valid options in list
|
|
|
|
*/
|
|
|
|
static size_t count_option_parameters(QEMUOptionParameter *list)
|
|
|
|
{
|
|
|
|
size_t num_options = 0;
|
|
|
|
|
|
|
|
while (list && list->name) {
|
|
|
|
num_options++;
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return num_options;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Append an option list (list) to an option list (dest).
|
|
|
|
*
|
|
|
|
* If dest is NULL, a new copy of list is created.
|
|
|
|
*
|
|
|
|
* Returns a pointer to the first element of dest (or the newly allocated copy)
|
|
|
|
*/
|
|
|
|
QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest,
|
|
|
|
QEMUOptionParameter *list)
|
|
|
|
{
|
|
|
|
size_t num_options, num_dest_options;
|
|
|
|
|
|
|
|
num_options = count_option_parameters(dest);
|
|
|
|
num_dest_options = num_options;
|
|
|
|
|
|
|
|
num_options += count_option_parameters(list);
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
dest = g_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter));
|
2010-06-11 10:19:41 +02:00
|
|
|
dest[num_dest_options].name = NULL;
|
2010-05-26 04:35:36 +02:00
|
|
|
|
|
|
|
while (list && list->name) {
|
|
|
|
if (get_option_parameter(dest, list->name) == NULL) {
|
|
|
|
dest[num_dest_options++] = *list;
|
|
|
|
dest[num_dest_options].name = NULL;
|
|
|
|
}
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
/*
|
|
|
|
* Parses a parameter string (param) into an option list (dest).
|
|
|
|
*
|
2010-12-07 10:35:54 +01:00
|
|
|
* list is the template option list. If dest is NULL, a new copy of list is
|
|
|
|
* created. If list is NULL, this function fails.
|
2009-05-18 16:42:09 +02:00
|
|
|
*
|
|
|
|
* A parameter string consists of one or more parameters, separated by commas.
|
|
|
|
* Each parameter consists of its name and possibly of a value. In the latter
|
|
|
|
* case, the value is delimited by an = character. To specify a value which
|
|
|
|
* contains commas, double each comma so it won't be recognized as the end of
|
|
|
|
* the parameter.
|
|
|
|
*
|
|
|
|
* For more details of the parsing see above.
|
|
|
|
*
|
|
|
|
* Returns a pointer to the first element of dest (or the newly allocated copy)
|
|
|
|
* or NULL in error cases
|
|
|
|
*/
|
|
|
|
QEMUOptionParameter *parse_option_parameters(const char *param,
|
|
|
|
QEMUOptionParameter *list, QEMUOptionParameter *dest)
|
|
|
|
{
|
|
|
|
QEMUOptionParameter *allocated = NULL;
|
|
|
|
char name[256];
|
|
|
|
char value[256];
|
|
|
|
char *param_delim, *value_delim;
|
|
|
|
char next_delim;
|
2013-08-29 11:15:44 +02:00
|
|
|
int i;
|
2009-05-18 16:42:09 +02:00
|
|
|
|
|
|
|
if (list == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dest == NULL) {
|
2010-12-07 10:35:53 +01:00
|
|
|
dest = allocated = append_option_parameters(NULL, list);
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
|
2013-08-29 11:15:44 +02:00
|
|
|
for (i = 0; dest[i].name; i++) {
|
|
|
|
dest[i].assigned = false;
|
|
|
|
}
|
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
while (*param) {
|
|
|
|
|
|
|
|
// Find parameter name and value in the string
|
|
|
|
param_delim = strchr(param, ',');
|
|
|
|
value_delim = strchr(param, '=');
|
|
|
|
|
|
|
|
if (value_delim && (value_delim < param_delim || !param_delim)) {
|
|
|
|
next_delim = '=';
|
|
|
|
} else {
|
|
|
|
next_delim = ',';
|
|
|
|
value_delim = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
param = get_opt_name(name, sizeof(name), param, next_delim);
|
|
|
|
if (value_delim) {
|
|
|
|
param = get_opt_value(value, sizeof(value), param + 1);
|
|
|
|
}
|
|
|
|
if (*param != '\0') {
|
|
|
|
param++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the parameter
|
|
|
|
if (set_option_parameter(dest, name, value_delim ? value : NULL)) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dest;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
// Only free the list if it was newly allocated
|
|
|
|
free_option_parameters(allocated);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prints all options of a list that have a value to stdout
|
|
|
|
*/
|
|
|
|
void print_option_parameters(QEMUOptionParameter *list)
|
|
|
|
{
|
|
|
|
while (list && list->name) {
|
|
|
|
switch (list->type) {
|
|
|
|
case OPT_STRING:
|
|
|
|
if (list->value.s != NULL) {
|
|
|
|
printf("%s='%s' ", list->name, list->value.s);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case OPT_FLAG:
|
|
|
|
printf("%s=%s ", list->name, list->value.n ? "on" : "off");
|
|
|
|
break;
|
|
|
|
case OPT_SIZE:
|
|
|
|
case OPT_NUMBER:
|
|
|
|
printf("%s=%" PRId64 " ", list->name, list->value.n);
|
|
|
|
break;
|
|
|
|
default:
|
2011-11-22 11:06:26 +01:00
|
|
|
printf("%s=(unknown type) ", list->name);
|
2009-05-18 16:42:09 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
}
|
2009-06-04 15:39:38 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prints an overview of all available options
|
|
|
|
*/
|
|
|
|
void print_option_help(QEMUOptionParameter *list)
|
|
|
|
{
|
|
|
|
printf("Supported options:\n");
|
|
|
|
while (list && list->name) {
|
|
|
|
printf("%-16s %s\n", list->name,
|
|
|
|
list->help ? list->help : "No description available");
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
|
|
|
|
static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
2009-10-06 13:17:04 +02:00
|
|
|
QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
|
2009-07-22 16:43:03 +02:00
|
|
|
if (strcmp(opt->name, name) != 0)
|
|
|
|
continue;
|
|
|
|
return opt;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *qemu_opt_get(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
return opt ? opt->str : NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-02 14:45:54 +02:00
|
|
|
bool qemu_opt_has_help_opt(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
|
|
|
|
if (is_help_option(opt->name)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:39 +02:00
|
|
|
bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
|
|
|
|
if (opt == NULL)
|
|
|
|
return defval;
|
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL);
|
2009-09-21 13:08:34 +02:00
|
|
|
return opt->value.boolean;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval)
|
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
|
|
|
|
if (opt == NULL)
|
|
|
|
return defval;
|
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER);
|
|
|
|
return opt->value.uint;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval)
|
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
|
|
|
|
if (opt == NULL)
|
|
|
|
return defval;
|
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE);
|
|
|
|
return opt->value.uint;
|
|
|
|
}
|
|
|
|
|
2012-03-21 19:21:26 +01:00
|
|
|
static void qemu_opt_parse(QemuOpt *opt, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
if (opt->desc == NULL)
|
2012-03-21 19:21:26 +01:00
|
|
|
return;
|
2012-03-21 18:37:44 +01:00
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
switch (opt->desc->type) {
|
|
|
|
case QEMU_OPT_STRING:
|
|
|
|
/* nothing */
|
2012-03-21 19:21:26 +01:00
|
|
|
return;
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_BOOL:
|
2012-03-21 19:21:26 +01:00
|
|
|
parse_option_bool(opt->name, opt->str, &opt->value.boolean, errp);
|
2012-03-21 18:54:42 +01:00
|
|
|
break;
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_NUMBER:
|
2012-03-21 19:21:26 +01:00
|
|
|
parse_option_number(opt->name, opt->str, &opt->value.uint, errp);
|
2012-03-21 18:37:44 +01:00
|
|
|
break;
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_SIZE:
|
2012-03-21 19:21:26 +01:00
|
|
|
parse_option_size(opt->name, opt->str, &opt->value.uint, errp);
|
2012-03-21 19:03:45 +01:00
|
|
|
break;
|
2009-07-22 16:43:03 +02:00
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemu_opt_del(QemuOpt *opt)
|
|
|
|
{
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&opt->opts->head, opt, next);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free((/* !const */ char*)opt->name);
|
|
|
|
g_free((/* !const */ char*)opt->str);
|
|
|
|
g_free(opt);
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
2012-12-06 07:47:18 +01:00
|
|
|
static bool opts_accepts_any(const QemuOpts *opts)
|
|
|
|
{
|
|
|
|
return opts->list->desc[0].name == NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const QemuOptDesc *find_desc_by_name(const QemuOptDesc *desc,
|
|
|
|
const char *name)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2009-10-06 13:17:04 +02:00
|
|
|
int i;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2009-10-06 13:17:04 +02:00
|
|
|
for (i = 0; desc[i].name != NULL; i++) {
|
|
|
|
if (strcmp(desc[i].name, name) == 0) {
|
2012-12-06 07:47:18 +01:00
|
|
|
return &desc[i];
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2009-10-06 13:17:04 +02:00
|
|
|
}
|
2012-12-06 07:47:18 +01:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-17 14:40:37 +02:00
|
|
|
int qemu_opt_unset(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
|
|
|
|
assert(opts_accepts_any(opts));
|
|
|
|
|
|
|
|
if (opt == NULL) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
qemu_opt_del(opt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-06 07:47:18 +01:00
|
|
|
static void opt_set(QemuOpts *opts, const char *name, const char *value,
|
|
|
|
bool prepend, Error **errp)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
const QemuOptDesc *desc;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
desc = find_desc_by_name(opts->list->desc, name);
|
|
|
|
if (!desc && !opts_accepts_any(opts)) {
|
|
|
|
error_set(errp, QERR_INVALID_PARAMETER, name);
|
|
|
|
return;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2009-10-06 13:17:04 +02:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
opt = g_malloc0(sizeof(*opt));
|
|
|
|
opt->name = g_strdup(name);
|
2009-10-06 13:17:04 +02:00
|
|
|
opt->opts = opts;
|
2012-01-27 19:54:54 +01:00
|
|
|
if (prepend) {
|
|
|
|
QTAILQ_INSERT_HEAD(&opts->head, opt, next);
|
|
|
|
} else {
|
|
|
|
QTAILQ_INSERT_TAIL(&opts->head, opt, next);
|
|
|
|
}
|
2012-12-06 07:47:18 +01:00
|
|
|
opt->desc = desc;
|
2013-01-22 11:07:57 +01:00
|
|
|
opt->str = g_strdup(value);
|
2012-03-21 19:21:26 +01:00
|
|
|
qemu_opt_parse(opt, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
2012-03-21 20:13:24 +01:00
|
|
|
error_propagate(errp, local_err);
|
2009-07-22 16:43:03 +02:00
|
|
|
qemu_opt_del(opt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-27 19:54:54 +01:00
|
|
|
int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
|
|
|
|
{
|
2012-03-21 20:13:24 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
opt_set(opts, name, value, false, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2012-01-27 19:54:54 +01:00
|
|
|
}
|
|
|
|
|
2012-03-21 20:17:21 +01:00
|
|
|
void qemu_opt_set_err(QemuOpts *opts, const char *name, const char *value,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
opt_set(opts, name, value, false, errp);
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:40:39 +02:00
|
|
|
int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
const QemuOptDesc *desc = opts->list->desc;
|
|
|
|
|
2012-12-06 07:47:20 +01:00
|
|
|
opt = g_malloc0(sizeof(*opt));
|
|
|
|
opt->desc = find_desc_by_name(desc, name);
|
|
|
|
if (!opt->desc && !opts_accepts_any(opts)) {
|
|
|
|
qerror_report(QERR_INVALID_PARAMETER, name);
|
|
|
|
g_free(opt);
|
|
|
|
return -1;
|
2011-10-25 08:40:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
opt->name = g_strdup(name);
|
|
|
|
opt->opts = opts;
|
|
|
|
opt->value.boolean = !!val;
|
2012-12-06 07:47:20 +01:00
|
|
|
opt->str = g_strdup(val ? "on" : "off");
|
|
|
|
QTAILQ_INSERT_TAIL(&opts->head, opt, next);
|
|
|
|
|
2011-10-25 08:40:39 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-06 07:47:23 +01:00
|
|
|
int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
const QemuOptDesc *desc = opts->list->desc;
|
|
|
|
|
|
|
|
opt = g_malloc0(sizeof(*opt));
|
|
|
|
opt->desc = find_desc_by_name(desc, name);
|
|
|
|
if (!opt->desc && !opts_accepts_any(opts)) {
|
|
|
|
qerror_report(QERR_INVALID_PARAMETER, name);
|
|
|
|
g_free(opt);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
opt->name = g_strdup(name);
|
|
|
|
opt->opts = opts;
|
|
|
|
opt->value.uint = val;
|
|
|
|
opt->str = g_strdup_printf("%" PRId64, val);
|
|
|
|
QTAILQ_INSERT_TAIL(&opts->head, opt, next);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-31 12:25:32 +02:00
|
|
|
int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
|
|
|
|
int abort_on_failure)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
int rc = 0;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
2009-07-31 12:25:32 +02:00
|
|
|
rc = func(opt->name, opt->str, opaque);
|
|
|
|
if (abort_on_failure && rc != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(opts, &list->head, next) {
|
2013-07-04 15:09:17 +02:00
|
|
|
if (!opts->id && !id) {
|
|
|
|
return opts;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2013-07-04 15:09:17 +02:00
|
|
|
if (opts->id && id && !strcmp(opts->id, id)) {
|
|
|
|
return opts;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-08 13:54:26 +02:00
|
|
|
static int id_wellformed(const char *id)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!qemu_isalpha(id[0])) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
for (i = 1; id[i]; i++) {
|
|
|
|
if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-03-20 19:51:57 +01:00
|
|
|
QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id,
|
|
|
|
int fail_if_exists, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
QemuOpts *opts = NULL;
|
|
|
|
|
|
|
|
if (id) {
|
2010-06-08 13:54:26 +02:00
|
|
|
if (!id_wellformed(id)) {
|
2012-03-20 19:51:57 +01:00
|
|
|
error_set(errp,QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
|
qemu-option: Disable two helpful messages that got broken recently
commit 8be7e7e4 and commit ec7b2ccb messed up the ordering of error
message and the helpful explanation that should follow it, like this:
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --chardev null,id=,
Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.
qemu-system-x86_64: -chardev null,id=,: Parameter 'id' expects an identifier
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --machine kvm_shadow_mem=dunno
You may use k, M, G or T suffixes for kilobytes, megabytes, gigabytes and terabytes.
qemu-system-x86_64: -machine kvm_shadow_mem=dunno: Parameter 'kvm_shadow_mem' expects a size
Pity. Disable them for now.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-5-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:17 +01:00
|
|
|
#if 0 /* conversion from qerror_report() to error_set() broke this: */
|
2010-06-08 13:54:26 +02:00
|
|
|
error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n");
|
qemu-option: Disable two helpful messages that got broken recently
commit 8be7e7e4 and commit ec7b2ccb messed up the ordering of error
message and the helpful explanation that should follow it, like this:
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --chardev null,id=,
Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.
qemu-system-x86_64: -chardev null,id=,: Parameter 'id' expects an identifier
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --machine kvm_shadow_mem=dunno
You may use k, M, G or T suffixes for kilobytes, megabytes, gigabytes and terabytes.
qemu-system-x86_64: -machine kvm_shadow_mem=dunno: Parameter 'kvm_shadow_mem' expects a size
Pity. Disable them for now.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-5-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:17 +01:00
|
|
|
#endif
|
2010-06-08 13:54:26 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
opts = qemu_opts_find(list, id);
|
|
|
|
if (opts != NULL) {
|
2012-02-08 06:41:37 +01:00
|
|
|
if (fail_if_exists && !list->merge_lists) {
|
2012-03-20 19:51:57 +01:00
|
|
|
error_set(errp, QERR_DUPLICATE_ID, id, list->name);
|
2009-07-22 16:43:03 +02:00
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
}
|
2012-02-08 06:41:37 +01:00
|
|
|
} else if (list->merge_lists) {
|
|
|
|
opts = qemu_opts_find(list, NULL);
|
|
|
|
if (opts) {
|
|
|
|
return opts;
|
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
opts = g_malloc0(sizeof(*opts));
|
2013-01-22 11:07:57 +01:00
|
|
|
opts->id = g_strdup(id);
|
2009-07-22 16:43:03 +02:00
|
|
|
opts->list = list;
|
2010-02-18 19:46:49 +01:00
|
|
|
loc_save(&opts->loc);
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INIT(&opts->head);
|
|
|
|
QTAILQ_INSERT_TAIL(&list->head, opts, next);
|
2009-07-22 16:43:03 +02:00
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2010-06-01 10:47:34 +02:00
|
|
|
void qemu_opts_reset(QemuOptsList *list)
|
|
|
|
{
|
|
|
|
QemuOpts *opts, *next_opts;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) {
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-27 21:06:04 +02:00
|
|
|
void qemu_opts_loc_restore(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
loc_restore(&opts->loc);
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
int qemu_opts_set(QemuOptsList *list, const char *id,
|
|
|
|
const char *name, const char *value)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
2012-03-20 19:51:57 +01:00
|
|
|
Error *local_err = NULL;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2012-03-20 19:51:57 +01:00
|
|
|
opts = qemu_opts_create(list, id, 1, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
2009-07-22 16:43:03 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return qemu_opt_set(opts, name, value);
|
|
|
|
}
|
|
|
|
|
2009-07-31 12:25:32 +02:00
|
|
|
const char *qemu_opts_id(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
return opts->id;
|
|
|
|
}
|
|
|
|
|
2013-07-11 12:52:34 +02:00
|
|
|
/* The id string will be g_free()d by qemu_opts_del */
|
|
|
|
void qemu_opts_set_id(QemuOpts *opts, char *id)
|
|
|
|
{
|
|
|
|
opts->id = id;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
void qemu_opts_del(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
|
|
|
for (;;) {
|
2009-09-12 09:36:22 +02:00
|
|
|
opt = QTAILQ_FIRST(&opts->head);
|
2009-07-22 16:43:03 +02:00
|
|
|
if (opt == NULL)
|
|
|
|
break;
|
|
|
|
qemu_opt_del(opt);
|
|
|
|
}
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&opts->list->head, opts, next);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(opts->id);
|
|
|
|
g_free(opts);
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_opts_print(QemuOpts *opts, void *dummy)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
|
|
|
fprintf(stderr, "%s: %s:", opts->list->name,
|
|
|
|
opts->id ? opts->id : "<noid>");
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
2009-07-22 16:43:03 +02:00
|
|
|
fprintf(stderr, " %s=\"%s\"", opt->name, opt->str);
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-27 19:54:54 +01:00
|
|
|
static int opts_do_parse(QemuOpts *opts, const char *params,
|
|
|
|
const char *firstname, bool prepend)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2009-12-10 11:11:08 +01:00
|
|
|
char option[128], value[1024];
|
2009-07-22 16:43:03 +02:00
|
|
|
const char *p,*pe,*pc;
|
2012-03-21 20:13:24 +01:00
|
|
|
Error *local_err = NULL;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2009-10-06 13:17:02 +02:00
|
|
|
for (p = params; *p != '\0'; p++) {
|
2009-07-22 16:43:03 +02:00
|
|
|
pe = strchr(p, '=');
|
|
|
|
pc = strchr(p, ',');
|
|
|
|
if (!pe || (pc && pc < pe)) {
|
|
|
|
/* found "foo,more" */
|
|
|
|
if (p == params && firstname) {
|
|
|
|
/* implicitly named first option */
|
|
|
|
pstrcpy(option, sizeof(option), firstname);
|
|
|
|
p = get_opt_value(value, sizeof(value), p);
|
|
|
|
} else {
|
|
|
|
/* option without value, probably a flag */
|
|
|
|
p = get_opt_name(option, sizeof(option), p, ',');
|
2009-09-10 10:58:33 +02:00
|
|
|
if (strncmp(option, "no", 2) == 0) {
|
2009-07-22 16:43:03 +02:00
|
|
|
memmove(option, option+2, strlen(option+2)+1);
|
|
|
|
pstrcpy(value, sizeof(value), "off");
|
|
|
|
} else {
|
|
|
|
pstrcpy(value, sizeof(value), "on");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* found "foo=bar,more" */
|
|
|
|
p = get_opt_name(option, sizeof(option), p, '=');
|
|
|
|
if (*p != '=') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
p = get_opt_value(value, sizeof(value), p);
|
|
|
|
}
|
|
|
|
if (strcmp(option, "id") != 0) {
|
|
|
|
/* store and parse */
|
2012-03-21 20:13:24 +01:00
|
|
|
opt_set(opts, option, value, prepend, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
2009-09-10 10:58:33 +02:00
|
|
|
return -1;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*p != ',') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-09-10 10:58:33 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-27 19:54:54 +01:00
|
|
|
int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname)
|
|
|
|
{
|
|
|
|
return opts_do_parse(opts, params, firstname, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
|
|
|
|
int permit_abbrev, bool defaults)
|
2009-09-10 10:58:33 +02:00
|
|
|
{
|
2010-02-10 19:52:18 +01:00
|
|
|
const char *firstname;
|
2009-12-10 11:11:08 +01:00
|
|
|
char value[1024], *id = NULL;
|
2009-09-10 10:58:33 +02:00
|
|
|
const char *p;
|
|
|
|
QemuOpts *opts;
|
2012-03-20 19:51:57 +01:00
|
|
|
Error *local_err = NULL;
|
2009-09-10 10:58:33 +02:00
|
|
|
|
2010-02-10 19:52:18 +01:00
|
|
|
assert(!permit_abbrev || list->implied_opt_name);
|
|
|
|
firstname = permit_abbrev ? list->implied_opt_name : NULL;
|
|
|
|
|
2009-09-10 10:58:33 +02:00
|
|
|
if (strncmp(params, "id=", 3) == 0) {
|
|
|
|
get_opt_value(value, sizeof(value), params+3);
|
2010-04-29 18:24:43 +02:00
|
|
|
id = value;
|
2009-09-10 10:58:33 +02:00
|
|
|
} else if ((p = strstr(params, ",id=")) != NULL) {
|
|
|
|
get_opt_value(value, sizeof(value), p+4);
|
2010-04-29 18:24:43 +02:00
|
|
|
id = value;
|
2009-09-10 10:58:33 +02:00
|
|
|
}
|
qemu-option: Guard against qemu_opts_set_defaults() misuse
Commit 6d4cd40 fixed qemu_opts_set_defaults() for an existing corner
case, but broke it for another one that can't be reached in current
code.
Quote from its commit message:
I believe [opts_parse()] attempts to do the following:
If options don't yet exist, create new options
Else, if defaults, modify the existing options
Else, if list->merge_lists, modify the existing options
Else, fail
The only caller that passes true for defaults is
qemu_opts_set_defaults().
The commit message then claims:
A straightforward call of qemu_opts_create() does exactly that.
Wrong. When !list->merge_lists, and the option string doesn't contain
id=, and options without ID exist, then we don't actually modify the
existing options, we create new ones.
Not reachable, because we never pass lists with !list->merge_lists to
qemu_opts_set_defaults().
Guard against possible (if unlikely) future misuse with assert().
Reported-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 1375428840-5275-1-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-08-02 09:34:00 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This code doesn't work for defaults && !list->merge_lists: when
|
|
|
|
* params has no id=, and list has an element with !opts->id, it
|
|
|
|
* appends a new element instead of returning the existing opts.
|
|
|
|
* However, we got no use for this case. Guard against possible
|
|
|
|
* (if unlikely) future misuse:
|
|
|
|
*/
|
|
|
|
assert(!defaults || list->merge_lists);
|
qemu-option: Fix qemu_opts_set_defaults() for corner cases
Commit 4f6dd9a changed the initialization of opts in opts_parse() to
this:
if (defaults) {
if (!id && !QTAILQ_EMPTY(&list->head)) {
opts = qemu_opts_find(list, NULL);
} else {
opts = qemu_opts_create(list, id, 0);
}
} else {
opts = qemu_opts_create(list, id, 1);
}
Same as before for !defaults.
If defaults is true, and params has no ID, and options exist, we use
the first assignment. It sets opts to null if all options have an ID.
opts_parse() then returns null. qemu_opts_set_defaults() asserts the
value is non-null. It's the only caller that passes true for
defaults.
To reproduce, try "-M xenpv -machine id=foo" (yes, "id=foo" is silly,
but it shouldn't crash).
I believe the function attempts to do the following:
If options don't yet exist, create new options
Else, if defaults, modify the existing options
Else, if list->merge_lists, modify the existing options
Else, fail
A straightforward call of qemu_opts_create() does exactly that.
Cc: Jan Kiszka <jan.kiszka@siemens.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1372943363-24081-3-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-07-04 15:09:18 +02:00
|
|
|
opts = qemu_opts_create(list, id, !defaults, &local_err);
|
2012-03-20 19:51:57 +01:00
|
|
|
if (opts == NULL) {
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
qerror_report_err(local_err);
|
|
|
|
error_free(local_err);
|
|
|
|
}
|
2009-09-10 10:58:33 +02:00
|
|
|
return NULL;
|
2012-03-20 19:51:57 +01:00
|
|
|
}
|
2009-09-10 10:58:33 +02:00
|
|
|
|
2012-01-27 19:54:54 +01:00
|
|
|
if (opts_do_parse(opts, params, firstname, defaults) != 0) {
|
2009-09-10 10:58:33 +02:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2012-01-27 19:54:54 +01:00
|
|
|
QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
|
|
|
|
int permit_abbrev)
|
|
|
|
{
|
|
|
|
return opts_parse(list, params, permit_abbrev, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
|
|
|
|
int permit_abbrev)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
|
|
|
|
opts = opts_parse(list, params, permit_abbrev, true);
|
|
|
|
assert(opts);
|
|
|
|
}
|
|
|
|
|
2012-04-18 22:24:01 +02:00
|
|
|
typedef struct OptsFromQDictState {
|
|
|
|
QemuOpts *opts;
|
|
|
|
Error **errp;
|
|
|
|
} OptsFromQDictState;
|
|
|
|
|
2010-02-10 20:15:29 +01:00
|
|
|
static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
|
|
|
|
{
|
2012-04-18 22:24:01 +02:00
|
|
|
OptsFromQDictState *state = opaque;
|
2010-02-10 20:15:29 +01:00
|
|
|
char buf[32];
|
|
|
|
const char *value;
|
|
|
|
int n;
|
|
|
|
|
2012-04-18 22:24:01 +02:00
|
|
|
if (!strcmp(key, "id") || error_is_set(state->errp)) {
|
2010-02-10 20:15:29 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (qobject_type(obj)) {
|
|
|
|
case QTYPE_QSTRING:
|
|
|
|
value = qstring_get_str(qobject_to_qstring(obj));
|
|
|
|
break;
|
|
|
|
case QTYPE_QINT:
|
|
|
|
n = snprintf(buf, sizeof(buf), "%" PRId64,
|
|
|
|
qint_get_int(qobject_to_qint(obj)));
|
|
|
|
assert(n < sizeof(buf));
|
|
|
|
value = buf;
|
|
|
|
break;
|
|
|
|
case QTYPE_QFLOAT:
|
|
|
|
n = snprintf(buf, sizeof(buf), "%.17g",
|
|
|
|
qfloat_get_double(qobject_to_qfloat(obj)));
|
|
|
|
assert(n < sizeof(buf));
|
|
|
|
value = buf;
|
|
|
|
break;
|
|
|
|
case QTYPE_QBOOL:
|
2010-03-18 21:48:19 +01:00
|
|
|
pstrcpy(buf, sizeof(buf),
|
|
|
|
qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off");
|
2010-02-10 20:15:29 +01:00
|
|
|
value = buf;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
2012-04-18 22:24:01 +02:00
|
|
|
|
|
|
|
qemu_opt_set_err(state->opts, key, value, state->errp);
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create QemuOpts from a QDict.
|
|
|
|
* Use value of key "id" as ID if it exists and is a QString.
|
|
|
|
* Only QStrings, QInts, QFloats and QBools are copied. Entries with
|
|
|
|
* other types are silently ignored.
|
|
|
|
*/
|
2012-04-18 22:24:01 +02:00
|
|
|
QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
|
|
|
|
Error **errp)
|
2010-02-10 20:15:29 +01:00
|
|
|
{
|
2012-04-18 22:24:01 +02:00
|
|
|
OptsFromQDictState state;
|
2012-03-20 19:51:57 +01:00
|
|
|
Error *local_err = NULL;
|
2012-04-18 22:24:01 +02:00
|
|
|
QemuOpts *opts;
|
2010-02-10 20:15:29 +01:00
|
|
|
|
2012-03-20 19:51:57 +01:00
|
|
|
opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1,
|
|
|
|
&local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
2012-04-18 22:24:01 +02:00
|
|
|
error_propagate(errp, local_err);
|
2010-02-10 20:15:29 +01:00
|
|
|
return NULL;
|
2012-03-20 19:51:57 +01:00
|
|
|
}
|
2010-02-10 20:15:29 +01:00
|
|
|
|
2012-03-20 19:51:57 +01:00
|
|
|
assert(opts != NULL);
|
2012-04-18 22:24:01 +02:00
|
|
|
|
|
|
|
state.errp = &local_err;
|
|
|
|
state.opts = opts;
|
|
|
|
qdict_iter(qdict, qemu_opts_from_qdict_1, &state);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-02-10 20:15:29 +01:00
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2013-03-15 10:35:05 +01:00
|
|
|
/*
|
|
|
|
* Adds all QDict entries to the QemuOpts that can be added and removes them
|
|
|
|
* from the QDict. When this function returns, the QDict contains only those
|
|
|
|
* entries that couldn't be added to the QemuOpts.
|
|
|
|
*/
|
|
|
|
void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
|
|
|
|
{
|
|
|
|
const QDictEntry *entry, *next;
|
|
|
|
|
|
|
|
entry = qdict_first(qdict);
|
|
|
|
|
|
|
|
while (entry != NULL) {
|
|
|
|
Error *local_err = NULL;
|
|
|
|
OptsFromQDictState state = {
|
|
|
|
.errp = &local_err,
|
|
|
|
.opts = opts,
|
|
|
|
};
|
|
|
|
|
|
|
|
next = qdict_next(qdict, entry);
|
|
|
|
|
|
|
|
if (find_desc_by_name(opts->list->desc, entry->key)) {
|
|
|
|
qemu_opts_from_qdict_1(entry->key, entry->value, &state);
|
|
|
|
if (error_is_set(&local_err)) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
qdict_del(qdict, entry->key);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-10 20:15:29 +01:00
|
|
|
/*
|
|
|
|
* Convert from QemuOpts to QDict.
|
|
|
|
* The QDict values are of type QString.
|
|
|
|
* TODO We'll want to use types appropriate for opt->desc->type, but
|
|
|
|
* this is enough for now.
|
|
|
|
*/
|
|
|
|
QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
QObject *val;
|
|
|
|
|
|
|
|
if (!qdict) {
|
|
|
|
qdict = qdict_new();
|
|
|
|
}
|
|
|
|
if (opts->id) {
|
|
|
|
qdict_put(qdict, "id", qstring_from_str(opts->id));
|
|
|
|
}
|
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
|
|
|
val = QOBJECT(qstring_from_str(opt->str));
|
|
|
|
qdict_put_obj(qdict, opt->name, val);
|
|
|
|
}
|
|
|
|
return qdict;
|
|
|
|
}
|
|
|
|
|
2009-10-06 13:17:03 +02:00
|
|
|
/* Validate parsed opts against descriptions where no
|
|
|
|
* descriptions were provided in the QemuOptsList.
|
|
|
|
*/
|
2012-04-12 16:58:57 +02:00
|
|
|
void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp)
|
2009-10-06 13:17:03 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2012-03-21 19:21:26 +01:00
|
|
|
Error *local_err = NULL;
|
2009-10-06 13:17:03 +02:00
|
|
|
|
2012-12-06 07:47:19 +01:00
|
|
|
assert(opts_accepts_any(opts));
|
2009-10-06 13:17:03 +02:00
|
|
|
|
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
2012-12-06 07:47:19 +01:00
|
|
|
opt->desc = find_desc_by_name(desc, opt->name);
|
|
|
|
if (!opt->desc) {
|
2012-04-12 16:58:57 +02:00
|
|
|
error_set(errp, QERR_INVALID_PARAMETER, opt->name);
|
|
|
|
return;
|
2009-10-06 13:17:03 +02:00
|
|
|
}
|
|
|
|
|
2012-03-21 19:21:26 +01:00
|
|
|
qemu_opt_parse(opt, &local_err);
|
|
|
|
if (error_is_set(&local_err)) {
|
2012-04-12 16:58:57 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
2009-10-06 13:17:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
|
|
|
|
int abort_on_failure)
|
|
|
|
{
|
2010-02-18 19:46:49 +01:00
|
|
|
Location loc;
|
2009-07-22 16:43:03 +02:00
|
|
|
QemuOpts *opts;
|
|
|
|
int rc = 0;
|
|
|
|
|
2010-02-18 19:46:49 +01:00
|
|
|
loc_push_none(&loc);
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(opts, &list->head, next) {
|
2010-02-18 19:46:49 +01:00
|
|
|
loc_restore(&opts->loc);
|
2010-01-29 19:48:56 +01:00
|
|
|
rc |= func(opts, opaque);
|
2009-07-22 16:43:03 +02:00
|
|
|
if (abort_on_failure && rc != 0)
|
|
|
|
break;
|
|
|
|
}
|
2010-02-18 19:46:49 +01:00
|
|
|
loc_pop(&loc);
|
2009-07-22 16:43:03 +02:00
|
|
|
return rc;
|
|
|
|
}
|