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.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:49:55 +01:00
|
|
|
#include "qemu/osdep.h"
|
2009-05-18 16:42:09 +02:00
|
|
|
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
2018-02-01 12:18:35 +01:00
|
|
|
#include "qapi/qmp/qbool.h"
|
|
|
|
#include "qapi/qmp/qdict.h"
|
2018-02-01 12:18:36 +01:00
|
|
|
#include "qapi/qmp/qnum.h"
|
2018-02-01 12:18:35 +01:00
|
|
|
#include "qapi/qmp/qstring.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/option_int.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
|
|
|
#include "qemu/id.h"
|
|
|
|
#include "qemu/help_option.h"
|
2009-05-18 16:42:09 +02:00
|
|
|
|
|
|
|
/*
|
2020-11-08 16:21:21 +01:00
|
|
|
* Extracts the name of an option from the parameter string (@p points at the
|
2009-05-18 16:42:09 +02:00
|
|
|
* first byte of the option name)
|
|
|
|
*
|
2020-11-08 16:21:21 +01:00
|
|
|
* The option name is @len characters long and is copied into @option. The
|
|
|
|
* caller is responsible for free'ing @option when no longer required.
|
2009-05-18 16:42:09 +02:00
|
|
|
*
|
|
|
|
* The return value is the position of the delimiter/zero byte after the option
|
2020-11-08 16:21:21 +01:00
|
|
|
* name in @p.
|
2009-05-18 16:42:09 +02:00
|
|
|
*/
|
2020-11-08 16:21:21 +01:00
|
|
|
static const char *get_opt_name(const char *p, char **option, size_t len)
|
2009-05-18 16:42:09 +02:00
|
|
|
{
|
2020-11-08 16:21:21 +01:00
|
|
|
*option = g_strndup(p, len);
|
|
|
|
return p + len;
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-04-16 13:17:43 +02:00
|
|
|
const char *get_opt_value(const char *p, char **value)
|
2009-05-18 16:42:09 +02:00
|
|
|
{
|
2018-04-16 13:17:43 +02:00
|
|
|
size_t capacity = 0, length;
|
|
|
|
const char *offset;
|
2009-05-18 16:42:09 +02:00
|
|
|
|
2018-05-14 19:19:13 +02:00
|
|
|
*value = NULL;
|
2018-04-16 13:17:43 +02:00
|
|
|
while (1) {
|
2018-06-29 12:32:10 +02:00
|
|
|
offset = qemu_strchrnul(p, ',');
|
2018-04-16 13:17:43 +02:00
|
|
|
length = offset - p;
|
|
|
|
if (*offset != '\0' && *(offset + 1) == ',') {
|
|
|
|
length++;
|
|
|
|
}
|
2018-05-14 19:19:13 +02:00
|
|
|
*value = g_renew(char, *value, capacity + length + 1);
|
|
|
|
strncpy(*value + capacity, p, length);
|
|
|
|
(*value)[capacity + length] = '\0';
|
2018-04-16 13:17:43 +02:00
|
|
|
capacity += length;
|
|
|
|
if (*offset == '\0' ||
|
|
|
|
*(offset + 1) != ',') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
p += (offset - p) + 2;
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
|
2018-04-16 13:17:43 +02:00
|
|
|
return offset;
|
2009-05-18 16:42:09 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
static bool parse_option_number(const char *name, const char *value,
|
2012-03-21 18:37:44 +01:00
|
|
|
uint64_t *ret, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
uint64_t number;
|
2017-02-21 21:13:53 +01:00
|
|
|
int err;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2017-02-21 21:13:53 +01:00
|
|
|
err = qemu_strtou64(value, NULL, 0, &number);
|
|
|
|
if (err == -ERANGE) {
|
|
|
|
error_setg(errp, "Value '%s' is too large for parameter '%s'",
|
|
|
|
value, name);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2017-02-21 21:13:53 +01:00
|
|
|
}
|
|
|
|
if (err) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2017-02-21 21:13:46 +01:00
|
|
|
*ret = number;
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
2014-06-05 11:20:40 +02:00
|
|
|
static const QemuOptDesc *find_desc_by_name(const QemuOptDesc *desc,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; desc[i].name != NULL; i++) {
|
|
|
|
if (strcmp(desc[i].name, name) == 0) {
|
|
|
|
return &desc[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:37 +02:00
|
|
|
static const char *find_default_by_name(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name);
|
|
|
|
|
|
|
|
return desc ? desc->def_value_str : NULL;
|
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
bool parse_option_size(const char *name, const char *value,
|
2013-07-29 16:47:56 +02:00
|
|
|
uint64_t *ret, Error **errp)
|
2009-07-22 16:43:02 +02:00
|
|
|
{
|
2017-02-21 21:14:08 +01:00
|
|
|
uint64_t size;
|
|
|
|
int err;
|
2009-07-22 16:43:02 +02:00
|
|
|
|
2017-02-21 21:14:08 +01:00
|
|
|
err = qemu_strtosz(value, NULL, &size);
|
|
|
|
if (err == -ERANGE) {
|
2017-02-27 13:55:43 +01:00
|
|
|
error_setg(errp, "Value '%s' is out of range for parameter '%s'",
|
2017-02-21 21:14:08 +01:00
|
|
|
value, name);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2017-02-21 21:13:46 +01:00
|
|
|
}
|
2017-02-21 21:14:08 +01:00
|
|
|
if (err) {
|
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
|
|
|
|
"a non-negative number below 2^64");
|
|
|
|
error_append_hint(errp, "Optional suffix k, M, G, T, P or E means"
|
|
|
|
" kilo-, mega-, giga-, tera-, peta-\n"
|
|
|
|
"and exabytes, respectively.\n");
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2009-07-22 16:43:02 +02:00
|
|
|
}
|
2017-02-21 21:14:08 +01:00
|
|
|
*ret = size;
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2009-07-22 16:43:02 +02:00
|
|
|
}
|
|
|
|
|
2018-08-14 17:08:04 +02:00
|
|
|
static const char *opt_type_to_string(enum QemuOptType type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case QEMU_OPT_STRING:
|
|
|
|
return "str";
|
|
|
|
case QEMU_OPT_BOOL:
|
|
|
|
return "bool (on/off)";
|
|
|
|
case QEMU_OPT_NUMBER:
|
|
|
|
return "num";
|
|
|
|
case QEMU_OPT_SIZE:
|
|
|
|
return "size";
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2018-10-19 18:49:25 +02:00
|
|
|
/**
|
|
|
|
* Print the list of options available in the given list. If
|
|
|
|
* @print_caption is true, a caption (including the list name, if it
|
|
|
|
* exists) is printed. The options itself will be indented, so
|
|
|
|
* @print_caption should only be set to false if the caller prints its
|
|
|
|
* own custom caption (so that the indentation makes sense).
|
|
|
|
*/
|
|
|
|
void qemu_opts_print_help(QemuOptsList *list, bool print_caption)
|
2014-06-05 11:20:47 +02:00
|
|
|
{
|
|
|
|
QemuOptDesc *desc;
|
2018-08-14 17:08:04 +02:00
|
|
|
int i;
|
|
|
|
GPtrArray *array = g_ptr_array_new();
|
2014-06-05 11:20:47 +02:00
|
|
|
|
|
|
|
assert(list);
|
|
|
|
desc = list->desc;
|
|
|
|
while (desc && desc->name) {
|
2018-08-14 17:08:04 +02:00
|
|
|
GString *str = g_string_new(NULL);
|
2018-10-19 18:49:25 +02:00
|
|
|
g_string_append_printf(str, " %s=<%s>", desc->name,
|
2018-08-14 17:08:04 +02:00
|
|
|
opt_type_to_string(desc->type));
|
|
|
|
if (desc->help) {
|
2018-10-19 18:49:25 +02:00
|
|
|
if (str->len < 24) {
|
|
|
|
g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
|
|
|
|
}
|
2018-08-14 17:08:04 +02:00
|
|
|
g_string_append_printf(str, " - %s", desc->help);
|
|
|
|
}
|
|
|
|
g_ptr_array_add(array, g_string_free(str, false));
|
2014-06-05 11:20:47 +02:00
|
|
|
desc++;
|
|
|
|
}
|
2018-08-14 17:08:04 +02:00
|
|
|
|
|
|
|
g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
|
2018-10-19 18:49:25 +02:00
|
|
|
if (print_caption && array->len > 0) {
|
|
|
|
if (list->name) {
|
|
|
|
printf("%s options:\n", list->name);
|
|
|
|
} else {
|
|
|
|
printf("Options:\n");
|
|
|
|
}
|
|
|
|
} else if (array->len == 0) {
|
|
|
|
if (list->name) {
|
|
|
|
printf("There are no options for %s.\n", list->name);
|
|
|
|
} else {
|
|
|
|
printf("No options available.\n");
|
|
|
|
}
|
|
|
|
}
|
2018-08-14 17:08:04 +02:00
|
|
|
for (i = 0; i < array->len; i++) {
|
|
|
|
printf("%s\n", (char *)array->pdata[i]);
|
|
|
|
}
|
|
|
|
g_ptr_array_set_free_func(array, g_free);
|
|
|
|
g_ptr_array_free(array, true);
|
|
|
|
|
2014-06-05 11:20:47 +02:00
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
|
2014-06-05 11:20:58 +02:00
|
|
|
QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
2018-12-06 13:10:34 +01:00
|
|
|
QTAILQ_FOREACH_REVERSE(opt, &opts->head, next) {
|
2009-07-22 16:43:03 +02:00
|
|
|
if (strcmp(opt->name, name) != 0)
|
|
|
|
continue;
|
|
|
|
return opt;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-05 11:20:45 +02:00
|
|
|
static void qemu_opt_del(QemuOpt *opt)
|
|
|
|
{
|
|
|
|
QTAILQ_REMOVE(&opt->opts->head, opt, next);
|
|
|
|
g_free(opt->name);
|
|
|
|
g_free(opt->str);
|
|
|
|
g_free(opt);
|
|
|
|
}
|
|
|
|
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
/* qemu_opt_set allows many settings for the same option.
|
|
|
|
* This function deletes all settings for an option.
|
|
|
|
*/
|
|
|
|
static void qemu_opt_del_all(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt, *next_opt;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH_SAFE(opt, &opts->head, next, next_opt) {
|
|
|
|
if (!strcmp(opt->name, name)) {
|
|
|
|
qemu_opt_del(opt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
const char *qemu_opt_get(QemuOpts *opts, const char *name)
|
|
|
|
{
|
2014-06-18 04:47:26 +02:00
|
|
|
QemuOpt *opt;
|
|
|
|
|
|
|
|
if (opts == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-06-05 11:20:42 +02:00
|
|
|
|
2014-06-18 04:47:26 +02:00
|
|
|
opt = qemu_opt_find(opts, name);
|
2014-06-05 11:20:42 +02:00
|
|
|
if (!opt) {
|
2020-07-07 18:05:38 +02:00
|
|
|
return find_default_by_name(opts, name);
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
2020-07-07 18:05:38 +02:00
|
|
|
|
|
|
|
return opt->str;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
2017-02-03 13:06:48 +01:00
|
|
|
void qemu_opt_iter_init(QemuOptsIter *iter, QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
iter->opts = opts;
|
|
|
|
iter->opt = QTAILQ_FIRST(&opts->head);
|
|
|
|
iter->name = name;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *qemu_opt_iter_next(QemuOptsIter *iter)
|
|
|
|
{
|
|
|
|
QemuOpt *ret = iter->opt;
|
|
|
|
if (iter->name) {
|
|
|
|
while (ret && !g_str_equal(iter->name, ret->name)) {
|
|
|
|
ret = QTAILQ_NEXT(ret, next);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
iter->opt = ret ? QTAILQ_NEXT(ret, next) : NULL;
|
|
|
|
return ret ? ret->str : NULL;
|
|
|
|
}
|
|
|
|
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
/* Get a known option (or its default) and remove it from the list
|
|
|
|
* all in one action. Return a malloced string of the option value.
|
|
|
|
* Result must be freed by caller with g_free().
|
|
|
|
*/
|
|
|
|
char *qemu_opt_get_del(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:38 +02:00
|
|
|
char *str;
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
|
|
|
|
if (opts == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
opt = qemu_opt_find(opts, name);
|
|
|
|
if (!opt) {
|
2020-07-07 18:05:38 +02:00
|
|
|
return g_strdup(find_default_by_name(opts, name));
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
}
|
|
|
|
str = opt->str;
|
|
|
|
opt->str = NULL;
|
|
|
|
qemu_opt_del_all(opts, name);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2012-08-02 14:45:54 +02:00
|
|
|
bool qemu_opt_has_help_opt(QemuOpts *opts)
|
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
2018-12-06 13:10:34 +01:00
|
|
|
QTAILQ_FOREACH_REVERSE(opt, &opts->head, next) {
|
2012-08-02 14:45:54 +02:00
|
|
|
if (is_help_option(opt->name)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
static bool qemu_opt_get_bool_helper(QemuOpts *opts, const char *name,
|
|
|
|
bool defval, bool del)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2014-06-18 04:47:26 +02:00
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:37 +02:00
|
|
|
const char *def_val;
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
bool ret = defval;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2014-06-18 04:47:26 +02:00
|
|
|
if (opts == NULL) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
opt = qemu_opt_find(opts, name);
|
2014-06-05 11:20:42 +02:00
|
|
|
if (opt == NULL) {
|
2020-07-07 18:05:37 +02:00
|
|
|
def_val = find_default_by_name(opts, name);
|
|
|
|
if (def_val) {
|
2020-11-03 17:13:39 +01:00
|
|
|
qapi_bool_parse(name, def_val, &ret, &error_abort);
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
return ret;
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL);
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
ret = opt->value.boolean;
|
|
|
|
if (del) {
|
|
|
|
qemu_opt_del_all(opts, name);
|
|
|
|
}
|
|
|
|
return ret;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_bool_helper(opts, name, defval, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool qemu_opt_get_bool_del(QemuOpts *opts, const char *name, bool defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_bool_helper(opts, name, defval, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t qemu_opt_get_number_helper(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval, bool del)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2014-06-18 04:47:26 +02:00
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:37 +02:00
|
|
|
const char *def_val;
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
uint64_t ret = defval;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2014-06-18 04:47:26 +02:00
|
|
|
if (opts == NULL) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
opt = qemu_opt_find(opts, name);
|
2014-06-05 11:20:42 +02:00
|
|
|
if (opt == NULL) {
|
2020-07-07 18:05:37 +02:00
|
|
|
def_val = find_default_by_name(opts, name);
|
|
|
|
if (def_val) {
|
|
|
|
parse_option_number(name, def_val, &ret, &error_abort);
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
return ret;
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER);
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
ret = opt->value.uint;
|
|
|
|
if (del) {
|
|
|
|
qemu_opt_del_all(opts, name);
|
|
|
|
}
|
|
|
|
return ret;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_number_helper(opts, name, defval, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_opt_get_number_del(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_number_helper(opts, name, defval, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t qemu_opt_get_size_helper(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval, bool del)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2014-06-18 04:47:26 +02:00
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:37 +02:00
|
|
|
const char *def_val;
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
uint64_t ret = defval;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2014-06-18 04:47:26 +02:00
|
|
|
if (opts == NULL) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
opt = qemu_opt_find(opts, name);
|
2014-06-05 11:20:42 +02:00
|
|
|
if (opt == NULL) {
|
2020-07-07 18:05:37 +02:00
|
|
|
def_val = find_default_by_name(opts, name);
|
|
|
|
if (def_val) {
|
|
|
|
parse_option_size(name, def_val, &ret, &error_abort);
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
return ret;
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE);
|
QemuOpts: add qemu_opt_get_*_del functions for replace work
Add qemu_opt_get_del, qemu_opt_get_bool_del, qemu_opt_get_number_del and
qemu_opt_get_size_del to replace the same handling of QEMUOptionParameter
(get and delete).
Several drivers are coded to parse a known subset of options, then
remove them from the list before handing all remaining options to a
second driver for further option processing. get_*_del makes it easier
to retrieve a known option (or its default) and remove it from the list
all in one action.
Share common helper function:
For qemu_opt_get_bool/size/number, they and their get_*_del counterpart
could share most of the code except whether or not deleting the opt from
option list, so generate common helper functions.
For qemu_opt_get and qemu_opt_get_del, keep code duplication, since
1. qemu_opt_get_del returns malloc'd memory while qemu_opt_get returns
in-place memory
2. qemu_opt_get_del returns (char *), qemu_opt_get returns (const char *),
and could not change to (char *), since in one case, it will return
desc->def_value_str, which is (const char *).
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: Chunyan Liu <cyliu@suse.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-05 11:20:46 +02:00
|
|
|
ret = opt->value.uint;
|
|
|
|
if (del) {
|
|
|
|
qemu_opt_del_all(opts, name);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_size_helper(opts, name, defval, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_opt_get_size_del(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval)
|
|
|
|
{
|
|
|
|
return qemu_opt_get_size_helper(opts, name, defval, true);
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
static bool qemu_opt_parse(QemuOpt *opt, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
if (opt->desc == NULL)
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
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 */
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_BOOL:
|
2020-11-03 17:13:39 +01:00
|
|
|
return qapi_bool_parse(opt->name, opt->str, &opt->value.boolean, errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_NUMBER:
|
2020-07-07 18:05:41 +02:00
|
|
|
return parse_option_number(opt->name, opt->str, &opt->value.uint,
|
|
|
|
errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
case QEMU_OPT_SIZE:
|
2020-07-07 18:05:41 +02:00
|
|
|
return parse_option_size(opt->name, opt->str, &opt->value.uint,
|
|
|
|
errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
static bool opts_accepts_any(const QemuOptsList *list)
|
2012-12-06 07:47:18 +01:00
|
|
|
{
|
2020-11-09 09:50:46 +01:00
|
|
|
return list->desc[0].name == NULL;
|
2012-12-06 07:47:18 +01:00
|
|
|
}
|
|
|
|
|
2013-07-17 14:40:37 +02:00
|
|
|
int qemu_opt_unset(QemuOpts *opts, const char *name)
|
|
|
|
{
|
|
|
|
QemuOpt *opt = qemu_opt_find(opts, name);
|
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
assert(opts_accepts_any(opts->list));
|
2013-07-17 14:40:37 +02:00
|
|
|
|
|
|
|
if (opt == NULL) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
qemu_opt_del(opt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-11 15:03:37 +01:00
|
|
|
static QemuOpt *opt_create(QemuOpts *opts, const char *name, char *value)
|
2020-07-07 18:05:39 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt = g_malloc0(sizeof(*opt));
|
|
|
|
|
|
|
|
opt->name = g_strdup(name);
|
|
|
|
opt->str = value;
|
|
|
|
opt->opts = opts;
|
2020-11-11 15:03:37 +01:00
|
|
|
QTAILQ_INSERT_TAIL(&opts->head, opt, next);
|
2020-07-07 18:05:39 +02:00
|
|
|
|
|
|
|
return opt;
|
|
|
|
}
|
|
|
|
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
static bool opt_validate(QemuOpt *opt, Error **errp)
|
2012-12-06 07:47:18 +01:00
|
|
|
{
|
|
|
|
const QemuOptDesc *desc;
|
2020-11-09 09:50:46 +01:00
|
|
|
const QemuOptsList *list = opt->opts->list;
|
2012-12-06 07:47:18 +01:00
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
desc = find_desc_by_name(list->desc, opt->name);
|
|
|
|
if (!desc && !opts_accepts_any(list)) {
|
2020-07-07 18:05:40 +02:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, opt->name);
|
|
|
|
return false;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2009-10-06 13:17:04 +02:00
|
|
|
|
2012-12-06 07:47:18 +01:00
|
|
|
opt->desc = desc;
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
if (!qemu_opt_parse(opt, errp)) {
|
2020-07-07 18:05:40 +02:00
|
|
|
return false;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2020-07-07 18:05:40 +02:00
|
|
|
|
|
|
|
return true;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opt_set(QemuOpts *opts, const char *name, const char *value,
|
2015-02-12 17:52:20 +01:00
|
|
|
Error **errp)
|
2012-03-21 20:17:21 +01:00
|
|
|
{
|
2020-11-11 15:03:37 +01:00
|
|
|
QemuOpt *opt = opt_create(opts, name, g_strdup(value));
|
2020-07-07 18:05:40 +02:00
|
|
|
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
if (!opt_validate(opt, errp)) {
|
2020-07-07 18:05:40 +02:00
|
|
|
qemu_opt_del(opt);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2020-07-07 18:05:40 +02:00
|
|
|
}
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2012-03-21 20:17:21 +01:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val,
|
2015-02-12 16:37:44 +01:00
|
|
|
Error **errp)
|
2011-10-25 08:40:39 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:36 +02:00
|
|
|
const QemuOptDesc *desc;
|
2020-11-09 09:50:46 +01:00
|
|
|
const QemuOptsList *list = opts->list;
|
2011-10-25 08:40:39 +02:00
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
desc = find_desc_by_name(list->desc, name);
|
|
|
|
if (!desc && !opts_accepts_any(list)) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, name);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2011-10-25 08:40:39 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:36 +02:00
|
|
|
opt = g_malloc0(sizeof(*opt));
|
2011-10-25 08:40:39 +02:00
|
|
|
opt->name = g_strdup(name);
|
|
|
|
opt->opts = opts;
|
2020-07-07 18:05:36 +02:00
|
|
|
opt->desc = desc;
|
2011-10-25 08:40:39 +02:00
|
|
|
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);
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2011-10-25 08:40:39 +02:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val,
|
2015-02-12 16:46:36 +01:00
|
|
|
Error **errp)
|
2012-12-06 07:47:23 +01:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2020-07-07 18:05:36 +02:00
|
|
|
const QemuOptDesc *desc;
|
2020-11-09 09:50:46 +01:00
|
|
|
const QemuOptsList *list = opts->list;
|
2012-12-06 07:47:23 +01:00
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
desc = find_desc_by_name(list->desc, name);
|
|
|
|
if (!desc && !opts_accepts_any(list)) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, name);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2012-12-06 07:47:23 +01:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:36 +02:00
|
|
|
opt = g_malloc0(sizeof(*opt));
|
2012-12-06 07:47:23 +01:00
|
|
|
opt->name = g_strdup(name);
|
|
|
|
opt->opts = opts;
|
2020-07-07 18:05:36 +02:00
|
|
|
opt->desc = desc;
|
2012-12-06 07:47:23 +01:00
|
|
|
opt->value.uint = val;
|
|
|
|
opt->str = g_strdup_printf("%" PRId64, val);
|
|
|
|
QTAILQ_INSERT_TAIL(&opts->head, opt, next);
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2012-12-06 07:47:23 +01:00
|
|
|
}
|
|
|
|
|
2015-03-12 07:45:10 +01:00
|
|
|
/**
|
2015-03-12 08:40:25 +01:00
|
|
|
* For each member of @opts, call @func(@opaque, name, value, @errp).
|
|
|
|
* @func() may store an Error through @errp, but must return non-zero then.
|
2015-03-12 07:45:10 +01:00
|
|
|
* When @func() returns non-zero, break the loop and return that value.
|
|
|
|
* Return zero when the loop completes.
|
|
|
|
*/
|
2015-03-12 08:40:25 +01:00
|
|
|
int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
|
|
|
|
Error **errp)
|
2009-07-31 12:25:32 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2015-03-12 07:45:10 +01:00
|
|
|
int rc;
|
2009-07-31 12:25:32 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
2015-03-12 08:40:25 +01:00
|
|
|
rc = func(opaque, opt->name, opt->str, errp);
|
2015-03-12 07:45:10 +01:00
|
|
|
if (rc) {
|
|
|
|
return rc;
|
|
|
|
}
|
2015-03-12 08:40:25 +01:00
|
|
|
assert(!errp || !*errp);
|
2009-07-31 12:25:32 +02:00
|
|
|
}
|
2015-03-12 07:45:10 +01:00
|
|
|
return 0;
|
2009-07-31 12:25:32 +02:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
qemu-option: clean up id vs. list->merge_lists
Looking at all merge-lists QemuOptsList, here is how they access their
QemuOpts:
reopen_opts in qemu-io-cmds.c ("qemu-img reopen -o")
qemu_opts_find(&reopen_opts, NULL)
empty_opts in qemu-io.c ("qemu-io open -o")
qemu_opts_find(&empty_opts, NULL)
qemu_rtc_opts ("-rtc")
qemu_find_opts_singleton("rtc")
qemu_machine_opts ("-M")
qemu_find_opts_singleton("machine")
qemu_action_opts ("-name")
qemu_opts_foreach->process_runstate_actions
qemu_boot_opts ("-boot")
in hw/nvram/fw_cfg.c and hw/s390x/ipl.c:
QTAILQ_FIRST(&qemu_find_opts("bootopts")->head)
in softmmu/vl.c:
qemu_opts_find(qemu_find_opts("boot-opts"), NULL)
qemu_name_opts ("-name")
qemu_opts_foreach->parse_name
parse_name does not use id
qemu_mem_opts ("-m")
qemu_find_opts_singleton("memory")
qemu_icount_opts ("-icount")
qemu_opts_foreach->do_configure_icount
do_configure_icount->icount_configure
icount_configure does not use id
qemu_smp_opts ("-smp")
qemu_opts_find(qemu_find_opts("smp-opts"), NULL)
qemu_spice_opts ("-spice")
QTAILQ_FIRST(&qemu_spice_opts.head)
i.e. they don't need an id. Sometimes its presence is ignored
(e.g. when using qemu_opts_foreach), sometimes all the options
with the id are skipped, sometimes only the first option on the
command line is considered. -boot does two different things
depending on who's looking at the options.
With this patch we just forbid id on merge-lists QemuOptsLists; if the
command line still works, it has the same semantics as before.
qemu_opts_create's fail_if_exists parameter is now unnecessary:
- it is unused if id is NULL
- opts_parse only passes false if reached from qemu_opts_set_defaults,
in which case this patch enforces that id must be NULL
- other callers that can pass a non-NULL id always set it to true
Assert that it is true in the only case where "fail_if_exists" matters,
i.e. "id && !lists->merge_lists". This means that if an id is present,
duplicates are always forbidden, which was already the status quo.
Discounting the case that aborts as it's not user-controlled (it's
"just" a matter of inspecting qemu_opts_create callers), the paths
through qemu_opts_create can be summarized as:
- merge_lists = true: singleton opts with NULL id; non-NULL id fails
- merge_lists = false: always return new opts; non-NULL id fails if dup
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-09 10:58:24 +01:00
|
|
|
if (list->merge_lists) {
|
|
|
|
if (id) {
|
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "id");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
opts = qemu_opts_find(list, NULL);
|
|
|
|
if (opts) {
|
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
} else if (id) {
|
|
|
|
assert(fail_if_exists);
|
2014-09-30 13:59:30 +02:00
|
|
|
if (!id_wellformed(id)) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id",
|
|
|
|
"an identifier");
|
hmp: Allow for error message hints on HMP
Commits 7216ae3d and d2828429 disabled some error message hints,
all because a change to use modern error reporting meant that the
hint would be output prior to the actual error. Fix this by making
hints a first-class member of Error.
For example, we are now back to the pleasant:
$ qemu-system-x86_64 --nodefaults -S --vnc :0 --chardev null,id=,
qemu-system-x86_64: --chardev null,id=,: Parameter 'id' expects an identifier
Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <1441901956-21991-1-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-09-10 18:19:16 +02:00
|
|
|
error_append_hint(errp, "Identifiers consist of letters, digits, "
|
2015-12-17 17:35:14 +01:00
|
|
|
"'-', '.', '_', starting with a letter.\n");
|
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) {
|
qemu-option: clean up id vs. list->merge_lists
Looking at all merge-lists QemuOptsList, here is how they access their
QemuOpts:
reopen_opts in qemu-io-cmds.c ("qemu-img reopen -o")
qemu_opts_find(&reopen_opts, NULL)
empty_opts in qemu-io.c ("qemu-io open -o")
qemu_opts_find(&empty_opts, NULL)
qemu_rtc_opts ("-rtc")
qemu_find_opts_singleton("rtc")
qemu_machine_opts ("-M")
qemu_find_opts_singleton("machine")
qemu_action_opts ("-name")
qemu_opts_foreach->process_runstate_actions
qemu_boot_opts ("-boot")
in hw/nvram/fw_cfg.c and hw/s390x/ipl.c:
QTAILQ_FIRST(&qemu_find_opts("bootopts")->head)
in softmmu/vl.c:
qemu_opts_find(qemu_find_opts("boot-opts"), NULL)
qemu_name_opts ("-name")
qemu_opts_foreach->parse_name
parse_name does not use id
qemu_mem_opts ("-m")
qemu_find_opts_singleton("memory")
qemu_icount_opts ("-icount")
qemu_opts_foreach->do_configure_icount
do_configure_icount->icount_configure
icount_configure does not use id
qemu_smp_opts ("-smp")
qemu_opts_find(qemu_find_opts("smp-opts"), NULL)
qemu_spice_opts ("-spice")
QTAILQ_FIRST(&qemu_spice_opts.head)
i.e. they don't need an id. Sometimes its presence is ignored
(e.g. when using qemu_opts_foreach), sometimes all the options
with the id are skipped, sometimes only the first option on the
command line is considered. -boot does two different things
depending on who's looking at the options.
With this patch we just forbid id on merge-lists QemuOptsLists; if the
command line still works, it has the same semantics as before.
qemu_opts_create's fail_if_exists parameter is now unnecessary:
- it is unused if id is NULL
- opts_parse only passes false if reached from qemu_opts_set_defaults,
in which case this patch enforces that id must be NULL
- other callers that can pass a non-NULL id always set it to true
Assert that it is true in the only case where "fail_if_exists" matters,
i.e. "id && !lists->merge_lists". This means that if an id is present,
duplicates are always forbidden, which was already the status quo.
Discounting the case that aborts as it's not user-controlled (it's
"just" a matter of inspecting qemu_opts_create callers), the paths
through qemu_opts_create can be summarized as:
- merge_lists = true: singleton opts with NULL id; non-NULL id fails
- merge_lists = false: always return new opts; non-NULL id fails if dup
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-09 10:58:24 +01:00
|
|
|
error_setg(errp, "Duplicate ID '%s' for %s", id, list->name);
|
|
|
|
return NULL;
|
2012-02-08 06:41:37 +01:00
|
|
|
}
|
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-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;
|
|
|
|
|
2014-06-05 11:20:50 +02:00
|
|
|
if (opts == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-07-07 16:42:10 +02:00
|
|
|
/* print value, escaping any commas in value */
|
|
|
|
static void escaped_print(const char *value)
|
|
|
|
{
|
|
|
|
const char *ptr;
|
|
|
|
|
|
|
|
for (ptr = value; *ptr; ++ptr) {
|
|
|
|
if (*ptr == ',') {
|
|
|
|
putchar(',');
|
|
|
|
}
|
|
|
|
putchar(*ptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_opts_print(QemuOpts *opts, const char *separator)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
2014-06-05 11:20:42 +02:00
|
|
|
QemuOptDesc *desc = opts->list->desc;
|
2015-07-07 16:42:10 +02:00
|
|
|
const char *sep = "";
|
|
|
|
|
|
|
|
if (opts->id) {
|
|
|
|
printf("id=%s", opts->id); /* passed id_wellformed -> no commas */
|
|
|
|
sep = separator;
|
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2014-06-05 11:20:42 +02:00
|
|
|
if (desc[0].name == NULL) {
|
|
|
|
QTAILQ_FOREACH(opt, &opts->head, next) {
|
2015-07-07 16:42:10 +02:00
|
|
|
printf("%s%s=", sep, opt->name);
|
|
|
|
escaped_print(opt->str);
|
|
|
|
sep = separator;
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (; desc && desc->name; desc++) {
|
|
|
|
const char *value;
|
2017-10-05 21:07:25 +02:00
|
|
|
opt = qemu_opt_find(opts, desc->name);
|
2014-06-05 11:20:42 +02:00
|
|
|
|
|
|
|
value = opt ? opt->str : desc->def_value_str;
|
|
|
|
if (!value) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (desc->type == QEMU_OPT_STRING) {
|
2015-07-07 16:42:10 +02:00
|
|
|
printf("%s%s=", sep, desc->name);
|
|
|
|
escaped_print(value);
|
2014-06-05 11:20:42 +02:00
|
|
|
} else if ((desc->type == QEMU_OPT_SIZE ||
|
|
|
|
desc->type == QEMU_OPT_NUMBER) && opt) {
|
2014-12-09 08:38:04 +01:00
|
|
|
printf("%s%s=%" PRId64, sep, desc->name, opt->value.uint);
|
2014-06-05 11:20:42 +02:00
|
|
|
} else {
|
2014-12-09 08:38:04 +01:00
|
|
|
printf("%s%s=%s", sep, desc->name, value);
|
2014-06-05 11:20:42 +02:00
|
|
|
}
|
2015-07-07 16:42:10 +02:00
|
|
|
sep = separator;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-15 09:49:20 +02:00
|
|
|
static const char *get_opt_name_value(const char *params,
|
|
|
|
const char *firstname,
|
2020-11-09 10:13:39 +01:00
|
|
|
bool warn_on_flag,
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
bool *help_wanted,
|
2020-04-15 09:49:20 +02:00
|
|
|
char **name, char **value)
|
|
|
|
{
|
2020-11-08 16:21:21 +01:00
|
|
|
const char *p;
|
2020-11-09 10:13:39 +01:00
|
|
|
const char *prefix = "";
|
2020-11-08 16:21:21 +01:00
|
|
|
size_t len;
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
bool is_help = false;
|
2020-04-15 09:49:20 +02:00
|
|
|
|
2020-11-08 16:21:21 +01:00
|
|
|
len = strcspn(params, "=,");
|
|
|
|
if (params[len] != '=') {
|
2020-04-15 09:49:20 +02:00
|
|
|
/* found "foo,more" */
|
|
|
|
if (firstname) {
|
|
|
|
/* implicitly named first option */
|
|
|
|
*name = g_strdup(firstname);
|
|
|
|
p = get_opt_value(params, value);
|
|
|
|
} else {
|
|
|
|
/* option without value, must be a flag */
|
2020-11-08 16:21:21 +01:00
|
|
|
p = get_opt_name(params, name, len);
|
2020-04-15 09:49:20 +02:00
|
|
|
if (strncmp(*name, "no", 2) == 0) {
|
|
|
|
memmove(*name, *name + 2, strlen(*name + 2) + 1);
|
|
|
|
*value = g_strdup("off");
|
2020-11-09 10:13:39 +01:00
|
|
|
prefix = "no";
|
2020-04-15 09:49:20 +02:00
|
|
|
} else {
|
|
|
|
*value = g_strdup("on");
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
is_help = is_help_option(*name);
|
2020-04-15 09:49:20 +02:00
|
|
|
}
|
2020-11-09 10:13:39 +01:00
|
|
|
if (!is_help && warn_on_flag) {
|
|
|
|
warn_report("short-form boolean option '%s%s' deprecated", prefix, *name);
|
2021-02-25 11:51:30 +01:00
|
|
|
if (g_str_equal(*name, "delay")) {
|
|
|
|
error_printf("Please use nodelay=%s instead\n", prefix[0] ? "on" : "off");
|
|
|
|
} else {
|
|
|
|
error_printf("Please use %s=%s instead\n", *name, *value);
|
|
|
|
}
|
2020-11-09 10:13:39 +01:00
|
|
|
}
|
2020-04-15 09:49:20 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* found "foo=bar,more" */
|
2020-11-08 16:21:21 +01:00
|
|
|
p = get_opt_name(params, name, len);
|
2020-04-15 09:49:20 +02:00
|
|
|
assert(*p == '=');
|
|
|
|
p++;
|
|
|
|
p = get_opt_value(p, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!*p || *p == ',');
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
if (help_wanted && is_help) {
|
|
|
|
*help_wanted = true;
|
|
|
|
}
|
2020-04-15 09:49:20 +02:00
|
|
|
if (*p == ',') {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
static bool opts_do_parse(QemuOpts *opts, const char *params,
|
2020-11-11 15:03:37 +01:00
|
|
|
const char *firstname,
|
2020-11-09 10:13:39 +01:00
|
|
|
bool warn_on_flag, bool *help_wanted, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2020-04-15 09:49:20 +02:00
|
|
|
char *option, *value;
|
|
|
|
const char *p;
|
2020-07-07 18:05:40 +02:00
|
|
|
QemuOpt *opt;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2020-04-15 09:49:20 +02:00
|
|
|
for (p = params; *p;) {
|
2020-11-09 10:13:39 +01:00
|
|
|
p = get_opt_name_value(p, firstname, warn_on_flag, help_wanted, &option, &value);
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
if (help_wanted && *help_wanted) {
|
|
|
|
g_free(option);
|
|
|
|
g_free(value);
|
|
|
|
return false;
|
|
|
|
}
|
2020-04-15 09:49:20 +02:00
|
|
|
firstname = NULL;
|
|
|
|
|
|
|
|
if (!strcmp(option, "id")) {
|
|
|
|
g_free(option);
|
|
|
|
g_free(value);
|
|
|
|
continue;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2020-04-15 09:49:20 +02:00
|
|
|
|
2020-11-11 15:03:37 +01:00
|
|
|
opt = opt_create(opts, option, value);
|
opts: don't silently truncate long parameter keys
The existing QemuOpts parsing code uses a fixed size 128 byte buffer
for storing the parameter keys. If a key exceeded this size it was
silently truncate and no error reported to the user. This behaviour was
reasonable & harmless because traditionally the key names are all
statically declared, and it was known that no code was declaring a key
longer than 127 bytes. This assumption, however, ceased to be valid once
the block layer added support for dot-separate compound keys. This
syntax allows for keys that can be arbitrarily long, limited only by the
number of block drivers you can stack up. With this usage, silently
truncating the key name can never lead to correct behaviour.
Hopefully such truncation would turn into an error, when the block code
then tried to extract options later, but there's no guarantee that will
happen. It is conceivable that an option specified by the user may be
truncated and then ignored. This could have serious consequences,
possibly even leading to security problems if the ignored option set a
security relevant parameter.
If the operating system didn't limit the user's argv when spawning QEMU,
the code should honour whatever length arguments were given without
imposing its own length restrictions. This patch thus changes the code
to use a heap allocated buffer for storing the keys during parsing,
lifting the arbitrary length restriction.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20180416111743.8473-3-berrange@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-04-16 13:17:42 +02:00
|
|
|
g_free(option);
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
if (!opt_validate(opt, errp)) {
|
2020-07-07 18:05:40 +02:00
|
|
|
qemu_opt_del(opt);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2020-04-15 09:49:20 +02:00
|
|
|
}
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2020-07-07 18:05:41 +02:00
|
|
|
|
|
|
|
return true;
|
2009-09-10 10:58:33 +02:00
|
|
|
}
|
|
|
|
|
2020-04-15 09:49:21 +02:00
|
|
|
static char *opts_parse_id(const char *params)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
char *name, *value;
|
|
|
|
|
|
|
|
for (p = params; *p;) {
|
2020-11-09 10:13:39 +01:00
|
|
|
p = get_opt_name_value(p, NULL, false, NULL, &name, &value);
|
2020-04-15 09:49:21 +02:00
|
|
|
if (!strcmp(name, "id")) {
|
|
|
|
g_free(name);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
g_free(name);
|
|
|
|
g_free(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-04-15 09:49:22 +02:00
|
|
|
bool has_help_option(const char *params)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
char *name, *value;
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
bool ret = false;
|
2020-04-15 09:49:22 +02:00
|
|
|
|
|
|
|
for (p = params; *p;) {
|
2020-11-09 10:13:39 +01:00
|
|
|
p = get_opt_name_value(p, NULL, false, &ret, &name, &value);
|
2020-04-15 09:49:22 +02:00
|
|
|
g_free(name);
|
|
|
|
g_free(value);
|
|
|
|
if (ret) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-02-12 18:37:11 +01:00
|
|
|
/**
|
|
|
|
* Store options parsed from @params into @opts.
|
|
|
|
* If @firstname is non-null, the first key=value in @params may omit
|
|
|
|
* key=, and is treated as if key was @firstname.
|
|
|
|
* On error, store an error object through @errp if non-null.
|
|
|
|
*/
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opts_do_parse(QemuOpts *opts, const char *params,
|
2015-02-12 18:37:11 +01:00
|
|
|
const char *firstname, Error **errp)
|
2012-01-27 19:54:54 +01:00
|
|
|
{
|
2020-11-11 15:03:37 +01:00
|
|
|
return opts_do_parse(opts, params, firstname, false, NULL, errp);
|
2012-01-27 19:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
|
2020-11-11 15:03:37 +01:00
|
|
|
bool permit_abbrev,
|
2020-11-09 10:13:39 +01:00
|
|
|
bool warn_on_flag, bool *help_wanted, Error **errp)
|
2009-09-10 10:58:33 +02:00
|
|
|
{
|
2010-02-10 19:52:18 +01:00
|
|
|
const char *firstname;
|
2020-04-15 09:49:21 +02:00
|
|
|
char *id = opts_parse_id(params);
|
2009-09-10 10:58:33 +02:00
|
|
|
QemuOpts *opts;
|
|
|
|
|
2010-02-10 19:52:18 +01:00
|
|
|
assert(!permit_abbrev || list->implied_opt_name);
|
|
|
|
firstname = permit_abbrev ? list->implied_opt_name : NULL;
|
|
|
|
|
qemu-option: clean up id vs. list->merge_lists
Looking at all merge-lists QemuOptsList, here is how they access their
QemuOpts:
reopen_opts in qemu-io-cmds.c ("qemu-img reopen -o")
qemu_opts_find(&reopen_opts, NULL)
empty_opts in qemu-io.c ("qemu-io open -o")
qemu_opts_find(&empty_opts, NULL)
qemu_rtc_opts ("-rtc")
qemu_find_opts_singleton("rtc")
qemu_machine_opts ("-M")
qemu_find_opts_singleton("machine")
qemu_action_opts ("-name")
qemu_opts_foreach->process_runstate_actions
qemu_boot_opts ("-boot")
in hw/nvram/fw_cfg.c and hw/s390x/ipl.c:
QTAILQ_FIRST(&qemu_find_opts("bootopts")->head)
in softmmu/vl.c:
qemu_opts_find(qemu_find_opts("boot-opts"), NULL)
qemu_name_opts ("-name")
qemu_opts_foreach->parse_name
parse_name does not use id
qemu_mem_opts ("-m")
qemu_find_opts_singleton("memory")
qemu_icount_opts ("-icount")
qemu_opts_foreach->do_configure_icount
do_configure_icount->icount_configure
icount_configure does not use id
qemu_smp_opts ("-smp")
qemu_opts_find(qemu_find_opts("smp-opts"), NULL)
qemu_spice_opts ("-spice")
QTAILQ_FIRST(&qemu_spice_opts.head)
i.e. they don't need an id. Sometimes its presence is ignored
(e.g. when using qemu_opts_foreach), sometimes all the options
with the id are skipped, sometimes only the first option on the
command line is considered. -boot does two different things
depending on who's looking at the options.
With this patch we just forbid id on merge-lists QemuOptsLists; if the
command line still works, it has the same semantics as before.
qemu_opts_create's fail_if_exists parameter is now unnecessary:
- it is unused if id is NULL
- opts_parse only passes false if reached from qemu_opts_set_defaults,
in which case this patch enforces that id must be NULL
- other callers that can pass a non-NULL id always set it to true
Assert that it is true in the only case where "fail_if_exists" matters,
i.e. "id && !lists->merge_lists". This means that if an id is present,
duplicates are always forbidden, which was already the status quo.
Discounting the case that aborts as it's not user-controlled (it's
"just" a matter of inspecting qemu_opts_create callers), the paths
through qemu_opts_create can be summarized as:
- merge_lists = true: singleton opts with NULL id; non-NULL id fails
- merge_lists = false: always return new opts; non-NULL id fails if dup
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-09 10:58:24 +01:00
|
|
|
opts = qemu_opts_create(list, id, !list->merge_lists, errp);
|
2018-04-16 13:17:43 +02:00
|
|
|
g_free(id);
|
2012-03-20 19:51:57 +01:00
|
|
|
if (opts == NULL) {
|
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
|
|
|
|
2020-11-11 15:03:37 +01:00
|
|
|
if (!opts_do_parse(opts, params, firstname,
|
2020-11-09 10:13:39 +01:00
|
|
|
warn_on_flag, help_wanted, errp)) {
|
2009-09-10 10:58:33 +02:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
return opts;
|
|
|
|
}
|
|
|
|
|
2015-02-12 18:24:10 +01:00
|
|
|
/**
|
|
|
|
* Create a QemuOpts in @list and with options parsed from @params.
|
|
|
|
* If @permit_abbrev, the first key=value in @params may omit key=,
|
|
|
|
* and is treated as if key was @list->implied_opt_name.
|
QemuOpts: Wean off qerror_report_err()
qerror_report_err() is a transitional interface to help with
converting existing monitor commands to QMP. It should not be used
elsewhere.
The only remaining user in qemu-option.c is qemu_opts_parse(). Is it
used in QMP context? If not, we can simply replace
qerror_report_err() by error_report_err().
The uses in qemu-img.c, qemu-io.c, qemu-nbd.c and under tests/ are
clearly not in QMP context.
The uses in vl.c aren't either, because the only QMP command handlers
there are qmp_query_status() and qmp_query_machines(), and they don't
call it.
Remaining uses:
* drive_def(): Command line -drive and such, HMP drive_add and pci_add
* hmp_chardev_add(): HMP chardev-add
* monitor_parse_command(): HMP core
* tmp_config_parse(): Command line -tpmdev
* net_host_device_add(): HMP host_net_add
* net_client_parse(): Command line -net and -netdev
* qemu_global_option(): Command line -global
* vnc_parse_func(): Command line -display, -vnc, default display, HMP
change, QMP change. Bummer.
* qemu_pci_hot_add_nic(): HMP pci_add
* usb_net_init(): Command line -usbdevice, HMP usb_add
Propagate errors through qemu_opts_parse(). Create a convenience
function qemu_opts_parse_noisily() that passes errors to
error_report_err(). Switch all non-QMP users outside tests to it.
That leaves vnc_parse_func(). Propagate errors through it. Since I'm
touching it anyway, rename it to vnc_parse().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-13 12:50:26 +01:00
|
|
|
* On error, store an error object through @errp if non-null.
|
2015-02-12 18:24:10 +01:00
|
|
|
* Return the new QemuOpts on success, null pointer on error.
|
|
|
|
*/
|
2012-01-27 19:54:54 +01:00
|
|
|
QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
|
QemuOpts: Wean off qerror_report_err()
qerror_report_err() is a transitional interface to help with
converting existing monitor commands to QMP. It should not be used
elsewhere.
The only remaining user in qemu-option.c is qemu_opts_parse(). Is it
used in QMP context? If not, we can simply replace
qerror_report_err() by error_report_err().
The uses in qemu-img.c, qemu-io.c, qemu-nbd.c and under tests/ are
clearly not in QMP context.
The uses in vl.c aren't either, because the only QMP command handlers
there are qmp_query_status() and qmp_query_machines(), and they don't
call it.
Remaining uses:
* drive_def(): Command line -drive and such, HMP drive_add and pci_add
* hmp_chardev_add(): HMP chardev-add
* monitor_parse_command(): HMP core
* tmp_config_parse(): Command line -tpmdev
* net_host_device_add(): HMP host_net_add
* net_client_parse(): Command line -net and -netdev
* qemu_global_option(): Command line -global
* vnc_parse_func(): Command line -display, -vnc, default display, HMP
change, QMP change. Bummer.
* qemu_pci_hot_add_nic(): HMP pci_add
* usb_net_init(): Command line -usbdevice, HMP usb_add
Propagate errors through qemu_opts_parse(). Create a convenience
function qemu_opts_parse_noisily() that passes errors to
error_report_err(). Switch all non-QMP users outside tests to it.
That leaves vnc_parse_func(). Propagate errors through it. Since I'm
touching it anyway, rename it to vnc_parse().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-13 12:50:26 +01:00
|
|
|
bool permit_abbrev, Error **errp)
|
|
|
|
{
|
2020-11-11 15:03:37 +01:00
|
|
|
return opts_parse(list, params, permit_abbrev, false, NULL, errp);
|
QemuOpts: Wean off qerror_report_err()
qerror_report_err() is a transitional interface to help with
converting existing monitor commands to QMP. It should not be used
elsewhere.
The only remaining user in qemu-option.c is qemu_opts_parse(). Is it
used in QMP context? If not, we can simply replace
qerror_report_err() by error_report_err().
The uses in qemu-img.c, qemu-io.c, qemu-nbd.c and under tests/ are
clearly not in QMP context.
The uses in vl.c aren't either, because the only QMP command handlers
there are qmp_query_status() and qmp_query_machines(), and they don't
call it.
Remaining uses:
* drive_def(): Command line -drive and such, HMP drive_add and pci_add
* hmp_chardev_add(): HMP chardev-add
* monitor_parse_command(): HMP core
* tmp_config_parse(): Command line -tpmdev
* net_host_device_add(): HMP host_net_add
* net_client_parse(): Command line -net and -netdev
* qemu_global_option(): Command line -global
* vnc_parse_func(): Command line -display, -vnc, default display, HMP
change, QMP change. Bummer.
* qemu_pci_hot_add_nic(): HMP pci_add
* usb_net_init(): Command line -usbdevice, HMP usb_add
Propagate errors through qemu_opts_parse(). Create a convenience
function qemu_opts_parse_noisily() that passes errors to
error_report_err(). Switch all non-QMP users outside tests to it.
That leaves vnc_parse_func(). Propagate errors through it. Since I'm
touching it anyway, rename it to vnc_parse().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-13 12:50:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a QemuOpts in @list and with options parsed from @params.
|
|
|
|
* If @permit_abbrev, the first key=value in @params may omit key=,
|
|
|
|
* and is treated as if key was @list->implied_opt_name.
|
|
|
|
* Report errors with error_report_err(). This is inappropriate in
|
|
|
|
* QMP context. Do not use this function there!
|
|
|
|
* Return the new QemuOpts on success, null pointer on error.
|
|
|
|
*/
|
|
|
|
QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params,
|
|
|
|
bool permit_abbrev)
|
2012-01-27 19:54:54 +01:00
|
|
|
{
|
2015-02-12 18:24:10 +01:00
|
|
|
Error *err = NULL;
|
|
|
|
QemuOpts *opts;
|
2020-04-15 09:49:24 +02:00
|
|
|
bool help_wanted = false;
|
2015-02-12 18:24:10 +01:00
|
|
|
|
2020-11-11 15:03:37 +01:00
|
|
|
opts = opts_parse(list, params, permit_abbrev, true,
|
qemu-option: move help handling to get_opt_name_value
Right now, help options are parsed normally and then checked
specially in opt_validate, but only if coming from
qemu_opts_parse_noisily. has_help_option does the check on its own.
opt_validate() has two callers: qemu_opt_set(), which passes null and is
therefore unaffected, and opts_do_parse(), which is affected.
opts_do_parse() is called by qemu_opts_do_parse(), which passes null and
is therefore unaffected, and opts_parse().
opts_parse() is called by qemu_opts_parse() and qemu_opts_set_defaults(),
which pass null and are therefore unaffected, and
qemu_opts_parse_noisily().
Move the check from opt_validate to the parsing workhorse of QemuOpts,
get_opt_name_value. This will come in handy in the next patch, which
will raise a warning for "-object memory-backend-ram,share" ("flag" option
with no =on/=off part) but not for "-object memory-backend-ram,help".
As a result:
- opts_parse and opts_do_parse do not return an error anymore
when help is requested; qemu_opts_parse_noisily does not have
to work around that anymore.
- various crazy ways to request help are not recognized anymore:
- "help=..."
- "nohelp" (sugar for "help=off")
- "?=..."
- "no?" (sugar for "?=off")
- "help" would be recognized as help request even if there is a (foolishly
named) parameter "help". No such parameters exist, though.
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-03 14:48:11 +01:00
|
|
|
opts_accepts_any(list) ? NULL : &help_wanted,
|
|
|
|
&err);
|
|
|
|
if (!opts) {
|
|
|
|
assert(!!err + !!help_wanted == 1);
|
2020-04-15 09:49:24 +02:00
|
|
|
if (help_wanted) {
|
2018-10-19 18:49:25 +02:00
|
|
|
qemu_opts_print_help(list, true);
|
2018-08-15 21:50:50 +02:00
|
|
|
} else {
|
|
|
|
error_report_err(err);
|
|
|
|
}
|
2015-02-12 18:24:10 +01:00
|
|
|
}
|
|
|
|
return opts;
|
2012-01-27 19:54:54 +01:00
|
|
|
}
|
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
static bool qemu_opts_from_qdict_entry(QemuOpts *opts,
|
2020-04-15 10:30:48 +02:00
|
|
|
const QDictEntry *entry,
|
|
|
|
Error **errp)
|
2010-02-10 20:15:29 +01:00
|
|
|
{
|
2020-04-15 10:30:48 +02:00
|
|
|
const char *key = qdict_entry_key(entry);
|
|
|
|
QObject *obj = qdict_entry_value(entry);
|
2020-07-07 18:05:41 +02:00
|
|
|
char buf[32];
|
|
|
|
g_autofree char *tmp = NULL;
|
2010-02-10 20:15:29 +01:00
|
|
|
const char *value;
|
|
|
|
|
2020-04-15 10:30:48 +02:00
|
|
|
if (!strcmp(key, "id")) {
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (qobject_type(obj)) {
|
|
|
|
case QTYPE_QSTRING:
|
2018-02-24 16:40:29 +01:00
|
|
|
value = qstring_get_str(qobject_to(QString, obj));
|
2010-02-10 20:15:29 +01:00
|
|
|
break;
|
2017-06-07 18:35:58 +02:00
|
|
|
case QTYPE_QNUM:
|
2018-02-24 16:40:29 +01:00
|
|
|
tmp = qnum_to_string(qobject_to(QNum, obj));
|
2017-06-07 18:35:58 +02:00
|
|
|
value = tmp;
|
2010-02-10 20:15:29 +01:00
|
|
|
break;
|
|
|
|
case QTYPE_QBOOL:
|
2010-03-18 21:48:19 +01:00
|
|
|
pstrcpy(buf, sizeof(buf),
|
2018-02-24 16:40:29 +01:00
|
|
|
qbool_get_bool(qobject_to(QBool, obj)) ? "on" : "off");
|
2010-02-10 20:15:29 +01:00
|
|
|
value = buf;
|
|
|
|
break;
|
|
|
|
default:
|
2020-07-07 18:05:41 +02:00
|
|
|
return true;
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
2012-04-18 22:24:01 +02:00
|
|
|
|
2020-07-07 18:05:41 +02:00
|
|
|
return qemu_opt_set(opts, key, value, errp);
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create QemuOpts from a QDict.
|
2017-06-07 18:35:58 +02:00
|
|
|
* Use value of key "id" as ID if it exists and is a QString. Only
|
|
|
|
* QStrings, QNums and QBools are copied. Entries with other types
|
|
|
|
* are silently ignored.
|
2010-02-10 20:15:29 +01:00
|
|
|
*/
|
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
|
|
|
QemuOpts *opts;
|
2020-04-15 10:30:47 +02:00
|
|
|
const QDictEntry *entry;
|
2010-02-10 20:15:29 +01:00
|
|
|
|
2020-07-07 18:05:35 +02:00
|
|
|
opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1, errp);
|
|
|
|
if (!opts) {
|
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
|
|
|
|
2020-04-15 10:30:47 +02:00
|
|
|
for (entry = qdict_first(qdict);
|
|
|
|
entry;
|
|
|
|
entry = qdict_next(qdict, entry)) {
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
if (!qemu_opts_from_qdict_entry(opts, entry, errp)) {
|
2020-04-15 10:30:48 +02:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-04-18 22:24:01 +02:00
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
|
2013-03-15 10:35:05 +01:00
|
|
|
{
|
|
|
|
const QDictEntry *entry, *next;
|
|
|
|
|
|
|
|
entry = qdict_first(qdict);
|
|
|
|
|
|
|
|
while (entry != NULL) {
|
|
|
|
next = qdict_next(qdict, entry);
|
|
|
|
|
2020-11-11 14:42:27 +01:00
|
|
|
if (opts_accepts_any(opts->list) ||
|
|
|
|
find_desc_by_name(opts->list->desc, entry->key)) {
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
if (!qemu_opts_from_qdict_entry(opts, entry, errp)) {
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2013-03-15 10:35:05 +01:00
|
|
|
}
|
2020-04-15 10:30:48 +02:00
|
|
|
qdict_del(qdict, entry->key);
|
2013-03-15 10:35:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
entry = next;
|
|
|
|
}
|
2020-07-07 18:05:41 +02:00
|
|
|
|
|
|
|
return true;
|
2013-03-15 10:35:05 +01:00
|
|
|
}
|
|
|
|
|
2010-02-10 20:15:29 +01:00
|
|
|
/*
|
2018-01-11 17:37:23 +01:00
|
|
|
* Convert from QemuOpts to QDict. The QDict values are of type QString.
|
|
|
|
*
|
|
|
|
* If @list is given, only add those options to the QDict that are contained in
|
|
|
|
* the list. If @del is true, any options added to the QDict are removed from
|
|
|
|
* the QemuOpts, otherwise they remain there.
|
|
|
|
*
|
|
|
|
* If two options in @opts have the same name, they are processed in order
|
|
|
|
* so that the last one wins (consistent with the reverse iteration in
|
|
|
|
* qemu_opt_find()), but all of them are deleted if @del is true.
|
|
|
|
*
|
2010-02-10 20:15:29 +01:00
|
|
|
* TODO We'll want to use types appropriate for opt->desc->type, but
|
|
|
|
* this is enough for now.
|
|
|
|
*/
|
2018-01-11 17:37:23 +01:00
|
|
|
QDict *qemu_opts_to_qdict_filtered(QemuOpts *opts, QDict *qdict,
|
|
|
|
QemuOptsList *list, bool del)
|
2010-02-10 20:15:29 +01:00
|
|
|
{
|
2018-01-11 17:37:23 +01:00
|
|
|
QemuOpt *opt, *next;
|
2010-02-10 20:15:29 +01:00
|
|
|
|
|
|
|
if (!qdict) {
|
|
|
|
qdict = qdict_new();
|
|
|
|
}
|
|
|
|
if (opts->id) {
|
2017-04-27 23:58:17 +02:00
|
|
|
qdict_put_str(qdict, "id", opts->id);
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
2018-01-11 17:37:23 +01:00
|
|
|
QTAILQ_FOREACH_SAFE(opt, &opts->head, next, next) {
|
|
|
|
if (list) {
|
|
|
|
QemuOptDesc *desc;
|
|
|
|
bool found = false;
|
|
|
|
for (desc = list->desc; desc->name; desc++) {
|
|
|
|
if (!strcmp(desc->name, opt->name)) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2017-04-27 23:58:19 +02:00
|
|
|
qdict_put_str(qdict, opt->name, opt->str);
|
2018-01-11 17:37:23 +01:00
|
|
|
if (del) {
|
|
|
|
qemu_opt_del(opt);
|
|
|
|
}
|
2010-02-10 20:15:29 +01:00
|
|
|
}
|
|
|
|
return qdict;
|
|
|
|
}
|
|
|
|
|
2018-01-11 17:37:23 +01:00
|
|
|
/* Copy all options in a QemuOpts to the given QDict. See
|
|
|
|
* qemu_opts_to_qdict_filtered() for details. */
|
|
|
|
QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
|
|
|
|
{
|
|
|
|
return qemu_opts_to_qdict_filtered(opts, qdict, NULL, false);
|
|
|
|
}
|
|
|
|
|
2009-10-06 13:17:03 +02:00
|
|
|
/* Validate parsed opts against descriptions where no
|
|
|
|
* descriptions were provided in the QemuOptsList.
|
|
|
|
*/
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp)
|
2009-10-06 13:17:03 +02:00
|
|
|
{
|
|
|
|
QemuOpt *opt;
|
|
|
|
|
2020-11-09 09:50:46 +01:00
|
|
|
assert(opts_accepts_any(opts->list));
|
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) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, opt->name);
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2009-10-06 13:17:03 +02:00
|
|
|
}
|
|
|
|
|
error: Eliminate error_propagate() with Coccinelle, part 1
When all we do with an Error we receive into a local variable is
propagating to somewhere else, we can just as well receive it there
right away. Convert
if (!foo(..., &err)) {
...
error_propagate(errp, err);
...
return ...
}
to
if (!foo(..., errp)) {
...
...
return ...
}
where nothing else needs @err. Coccinelle script:
@rule1 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
binary operator op;
constant c1, c2;
symbol false;
@@
if (
(
- fun(args, &err, args2)
+ fun(args, errp, args2)
|
- !fun(args, &err, args2)
+ !fun(args, errp, args2)
|
- fun(args, &err, args2) op c1
+ fun(args, errp, args2) op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
)
}
@rule2 forall@
identifier fun, err, errp, lbl;
expression list args, args2;
expression var;
binary operator op;
constant c1, c2;
symbol false;
@@
- var = fun(args, &err, args2);
+ var = fun(args, errp, args2);
... when != err
if (
(
var
|
!var
|
var op c1
)
)
{
... when != err
when != lbl:
when strict
- error_propagate(errp, err);
... when != err
(
return;
|
return c2;
|
return false;
|
return var;
)
}
@depends on rule1 || rule2@
identifier err;
@@
- Error *err = NULL;
... when != err
Not exactly elegant, I'm afraid.
The "when != lbl:" is necessary to avoid transforming
if (fun(args, &err)) {
goto out
}
...
out:
error_propagate(errp, err);
even though other paths to label out still need the error_propagate().
For an actual example, see sclp_realize().
Without the "when strict", Coccinelle transforms vfio_msix_setup(),
incorrectly. I don't know what exactly "when strict" does, only that
it helps here.
The match of return is narrower than what I want, but I can't figure
out how to express "return where the operand doesn't use @err". For
an example where it's too narrow, see vfio_intx_enable().
Silently fails to convert hw/arm/armsse.c, because Coccinelle gets
confused by ARMSSE being used both as typedef and function-like macro
there. Converted manually.
Line breaks tidied up manually. One nested declaration of @local_err
deleted manually. Preexisting unwanted blank line dropped in
hw/riscv/sifive_e.c.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200707160613.848843-35-armbru@redhat.com>
2020-07-07 18:06:02 +02:00
|
|
|
if (!qemu_opt_parse(opt, errp)) {
|
2020-07-07 18:05:41 +02:00
|
|
|
return false;
|
2009-10-06 13:17:03 +02:00
|
|
|
}
|
|
|
|
}
|
2020-07-07 18:05:41 +02:00
|
|
|
|
|
|
|
return true;
|
2009-10-06 13:17:03 +02:00
|
|
|
}
|
|
|
|
|
2015-03-13 11:07:24 +01:00
|
|
|
/**
|
2015-03-13 13:35:14 +01:00
|
|
|
* For each member of @list, call @func(@opaque, member, @errp).
|
2015-03-13 11:07:24 +01:00
|
|
|
* Call it with the current location temporarily set to the member's.
|
2015-03-13 13:35:14 +01:00
|
|
|
* @func() may store an Error through @errp, but must return non-zero then.
|
2015-03-13 11:07:24 +01:00
|
|
|
* When @func() returns non-zero, break the loop and return that value.
|
|
|
|
* Return zero when the loop completes.
|
|
|
|
*/
|
|
|
|
int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func,
|
2015-03-13 13:35:14 +01:00
|
|
|
void *opaque, Error **errp)
|
2009-07-22 16:43:03 +02:00
|
|
|
{
|
2010-02-18 19:46:49 +01:00
|
|
|
Location loc;
|
2009-07-22 16:43:03 +02:00
|
|
|
QemuOpts *opts;
|
QemuOpts: Fix qemu_opts_foreach() dangling location regression
qemu_opts_foreach() pushes and pops a Location with automatic storage
duration. Except it fails to pop when @func() returns non-zero.
cur_loc then points to unused stack space, and will most likely get
clobbered in short order.
Clobbered cur_loc can make loc_pop() and error_print_loc() crash or
report bogus locations.
Affects several qemu command line options as well as qemu-img,
qemu-io, qemu-nbd -object, and blkdebug's configuration file.
Broken in commit a4c7367, v2.4.0.
Reproducer:
$ qemu-system-x86_64 -nodefaults -display none -object secret,id=foo,foo=bar
main() reports "Property '.foo' not found" like this:
if (qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach,
object_create_delayed, &err)) {
error_report_err(err);
exit(1);
}
cur_loc then points to where qemu_opts_foreach()'s Location used to
be, i.e. unused stack space. With optimization, this Location doesn't
get clobbered for me, and also happens to be the correct location.
Without optimization, it does get clobbered in a way that makes
error_report_err() report no location.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1461767349-15329-2-git-send-email-armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2016-04-27 16:29:07 +02:00
|
|
|
int rc = 0;
|
2009-07-22 16:43:03 +02:00
|
|
|
|
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);
|
2015-03-13 13:35:14 +01:00
|
|
|
rc = func(opaque, opts, errp);
|
2015-03-13 11:07:24 +01:00
|
|
|
if (rc) {
|
QemuOpts: Fix qemu_opts_foreach() dangling location regression
qemu_opts_foreach() pushes and pops a Location with automatic storage
duration. Except it fails to pop when @func() returns non-zero.
cur_loc then points to unused stack space, and will most likely get
clobbered in short order.
Clobbered cur_loc can make loc_pop() and error_print_loc() crash or
report bogus locations.
Affects several qemu command line options as well as qemu-img,
qemu-io, qemu-nbd -object, and blkdebug's configuration file.
Broken in commit a4c7367, v2.4.0.
Reproducer:
$ qemu-system-x86_64 -nodefaults -display none -object secret,id=foo,foo=bar
main() reports "Property '.foo' not found" like this:
if (qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach,
object_create_delayed, &err)) {
error_report_err(err);
exit(1);
}
cur_loc then points to where qemu_opts_foreach()'s Location used to
be, i.e. unused stack space. With optimization, this Location doesn't
get clobbered for me, and also happens to be the correct location.
Without optimization, it does get clobbered in a way that makes
error_report_err() report no location.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1461767349-15329-2-git-send-email-armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2016-04-27 16:29:07 +02:00
|
|
|
break;
|
2015-03-13 11:07:24 +01:00
|
|
|
}
|
2015-03-13 13:35:14 +01:00
|
|
|
assert(!errp || !*errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2010-02-18 19:46:49 +01:00
|
|
|
loc_pop(&loc);
|
QemuOpts: Fix qemu_opts_foreach() dangling location regression
qemu_opts_foreach() pushes and pops a Location with automatic storage
duration. Except it fails to pop when @func() returns non-zero.
cur_loc then points to unused stack space, and will most likely get
clobbered in short order.
Clobbered cur_loc can make loc_pop() and error_print_loc() crash or
report bogus locations.
Affects several qemu command line options as well as qemu-img,
qemu-io, qemu-nbd -object, and blkdebug's configuration file.
Broken in commit a4c7367, v2.4.0.
Reproducer:
$ qemu-system-x86_64 -nodefaults -display none -object secret,id=foo,foo=bar
main() reports "Property '.foo' not found" like this:
if (qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach,
object_create_delayed, &err)) {
error_report_err(err);
exit(1);
}
cur_loc then points to where qemu_opts_foreach()'s Location used to
be, i.e. unused stack space. With optimization, this Location doesn't
get clobbered for me, and also happens to be the correct location.
Without optimization, it does get clobbered in a way that makes
error_report_err() report no location.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1461767349-15329-2-git-send-email-armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2016-04-27 16:29:07 +02:00
|
|
|
return rc;
|
2009-07-22 16:43:03 +02:00
|
|
|
}
|
2014-06-05 11:20:48 +02:00
|
|
|
|
|
|
|
static size_t count_opts_list(QemuOptsList *list)
|
|
|
|
{
|
|
|
|
QemuOptDesc *desc = NULL;
|
|
|
|
size_t num_opts = 0;
|
|
|
|
|
|
|
|
if (!list) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = list->desc;
|
|
|
|
while (desc && desc->name) {
|
|
|
|
num_opts++;
|
|
|
|
desc++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return num_opts;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_opts_free(QemuOptsList *list)
|
|
|
|
{
|
|
|
|
g_free(list);
|
|
|
|
}
|
2014-06-05 11:20:49 +02:00
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
/* Realloc dst option list and append options from an option list (list)
|
|
|
|
* to it. dst could be NULL or a malloced list.
|
2014-06-05 11:21:12 +02:00
|
|
|
* The lifetime of dst must be shorter than the input list because the
|
|
|
|
* QemuOptDesc->name, ->help, and ->def_value_str strings are shared.
|
2014-06-05 11:20:49 +02:00
|
|
|
*/
|
|
|
|
QemuOptsList *qemu_opts_append(QemuOptsList *dst,
|
2014-06-05 11:21:11 +02:00
|
|
|
QemuOptsList *list)
|
2014-06-05 11:20:49 +02:00
|
|
|
{
|
|
|
|
size_t num_opts, num_dst_opts;
|
|
|
|
QemuOptDesc *desc;
|
|
|
|
bool need_init = false;
|
2014-06-25 10:38:41 +02:00
|
|
|
bool need_head_update;
|
2014-06-05 11:20:49 +02:00
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
if (!list) {
|
2014-06-05 11:20:49 +02:00
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If dst is NULL, after realloc, some area of dst should be initialized
|
|
|
|
* before adding options to it.
|
|
|
|
*/
|
|
|
|
if (!dst) {
|
|
|
|
need_init = true;
|
2014-06-25 10:38:41 +02:00
|
|
|
need_head_update = true;
|
|
|
|
} else {
|
|
|
|
/* Moreover, even if dst is not NULL, the realloc may move it to a
|
|
|
|
* different address in which case we may get a stale tail pointer
|
|
|
|
* in dst->head. */
|
|
|
|
need_head_update = QTAILQ_EMPTY(&dst->head);
|
2014-06-05 11:20:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
num_opts = count_opts_list(dst);
|
|
|
|
num_dst_opts = num_opts;
|
|
|
|
num_opts += count_opts_list(list);
|
|
|
|
dst = g_realloc(dst, sizeof(QemuOptsList) +
|
|
|
|
(num_opts + 1) * sizeof(QemuOptDesc));
|
|
|
|
if (need_init) {
|
|
|
|
dst->name = NULL;
|
|
|
|
dst->implied_opt_name = NULL;
|
|
|
|
dst->merge_lists = false;
|
|
|
|
}
|
2014-06-25 10:38:41 +02:00
|
|
|
if (need_head_update) {
|
|
|
|
QTAILQ_INIT(&dst->head);
|
|
|
|
}
|
2014-06-05 11:20:49 +02:00
|
|
|
dst->desc[num_dst_opts].name = NULL;
|
|
|
|
|
|
|
|
/* append list->desc to dst->desc */
|
|
|
|
if (list) {
|
|
|
|
desc = list->desc;
|
|
|
|
while (desc && desc->name) {
|
|
|
|
if (find_desc_by_name(dst->desc, desc->name) == NULL) {
|
2014-06-05 11:21:12 +02:00
|
|
|
dst->desc[num_dst_opts++] = *desc;
|
2014-06-05 11:20:49 +02:00
|
|
|
dst->desc[num_dst_opts].name = NULL;
|
|
|
|
}
|
|
|
|
desc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dst;
|
|
|
|
}
|