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-06-29 10:12:57 +02:00
|
|
|
#ifndef QEMU_OPTION_H
|
|
|
|
#define QEMU_OPTION_H
|
2009-05-18 16:42:09 +02:00
|
|
|
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/queue.h"
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2020-06-29 09:08:58 +02:00
|
|
|
/**
|
|
|
|
* get_opt_value
|
|
|
|
* @p: a pointer to the option name, delimited by commas
|
|
|
|
* @value: a non-NULL pointer that will received the delimited options
|
|
|
|
*
|
|
|
|
* The @value char pointer will be allocated and filled with
|
|
|
|
* the delimited options.
|
|
|
|
*
|
|
|
|
* Returns the position of the comma delimiter/zero byte after the
|
|
|
|
* option name in @p.
|
|
|
|
* The memory pointer in @value must be released with a call to g_free()
|
|
|
|
* when no longer required.
|
|
|
|
*/
|
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
|
|
|
|
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);
|
2014-02-21 16:24:03 +01:00
|
|
|
bool has_help_option(const char *param);
|
2009-05-18 16:42:09 +02:00
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
enum QemuOptType {
|
|
|
|
QEMU_OPT_STRING = 0, /* no parsing (use string as-is) */
|
|
|
|
QEMU_OPT_BOOL, /* on/off */
|
|
|
|
QEMU_OPT_NUMBER, /* simple number */
|
|
|
|
QEMU_OPT_SIZE, /* size, accepts (K)ilo, (M)ega, (G)iga, (T)era postfix */
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct QemuOptDesc {
|
|
|
|
const char *name;
|
|
|
|
enum QemuOptType type;
|
|
|
|
const char *help;
|
2014-06-05 11:20:42 +02:00
|
|
|
const char *def_value_str;
|
2009-07-22 16:43:03 +02:00
|
|
|
} QemuOptDesc;
|
|
|
|
|
|
|
|
struct QemuOptsList {
|
|
|
|
const char *name;
|
2010-02-10 19:52:18 +01:00
|
|
|
const char *implied_opt_name;
|
2012-02-08 06:41:37 +01:00
|
|
|
bool merge_lists; /* Merge multiple uses of option into a single list? */
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_HEAD(, QemuOpts) head;
|
2009-07-22 16:43:03 +02:00
|
|
|
QemuOptDesc desc[];
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *qemu_opt_get(QemuOpts *opts, const char *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
|
|
|
char *qemu_opt_get_del(QemuOpts *opts, const char *name);
|
2012-08-02 14:45:54 +02:00
|
|
|
/**
|
|
|
|
* qemu_opt_has_help_opt:
|
|
|
|
* @opts: options to search for a help request
|
|
|
|
*
|
|
|
|
* Check whether the options specified by @opts include one of the
|
|
|
|
* standard strings which indicate that the user is asking for a
|
|
|
|
* list of the valid values for a command line option (as defined
|
|
|
|
* by is_help_option()).
|
|
|
|
*
|
|
|
|
* Returns: true if @opts includes 'help' or equivalent.
|
|
|
|
*/
|
|
|
|
bool qemu_opt_has_help_opt(QemuOpts *opts);
|
2014-06-05 11:20:58 +02:00
|
|
|
QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name);
|
2011-10-25 08:40:39 +02:00
|
|
|
bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval);
|
2009-07-22 16:43:03 +02:00
|
|
|
uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval);
|
|
|
|
uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval);
|
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_del(QemuOpts *opts, const char *name, bool defval);
|
|
|
|
uint64_t qemu_opt_get_number_del(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval);
|
|
|
|
uint64_t qemu_opt_get_size_del(QemuOpts *opts, const char *name,
|
|
|
|
uint64_t defval);
|
2013-07-17 14:40:37 +02:00
|
|
|
int qemu_opt_unset(QemuOpts *opts, const char *name);
|
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);
|
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);
|
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);
|
2015-03-12 08:40:25 +01:00
|
|
|
typedef int (*qemu_opt_loopfunc)(void *opaque,
|
|
|
|
const char *name, const char *value,
|
|
|
|
Error **errp);
|
|
|
|
int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
|
|
|
|
Error **errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2017-02-03 13:06:48 +01:00
|
|
|
typedef struct {
|
|
|
|
QemuOpts *opts;
|
|
|
|
QemuOpt *opt;
|
|
|
|
const char *name;
|
|
|
|
} QemuOptsIter;
|
|
|
|
|
|
|
|
void qemu_opt_iter_init(QemuOptsIter *iter, QemuOpts *opts, const char *name);
|
|
|
|
const char *qemu_opt_iter_next(QemuOptsIter *iter);
|
|
|
|
|
2009-07-22 16:43:03 +02:00
|
|
|
QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id);
|
2012-03-20 19:51:57 +01:00
|
|
|
QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id,
|
|
|
|
int fail_if_exists, Error **errp);
|
2010-06-01 10:47:34 +02:00
|
|
|
void qemu_opts_reset(QemuOptsList *list);
|
2010-05-27 21:06:04 +02:00
|
|
|
void qemu_opts_loc_restore(QemuOpts *opts);
|
qemu-option: restrict qemu_opts_set to merge-lists QemuOpts
qemu_opts_set is used to create default network backends and to
parse sugar options -kernel, -initrd, -append, -bios and -dtb.
These are very different uses:
I would *expect* a function named qemu_opts_set to set an option in a
merge-lists QemuOptsList, such as -kernel, and possibly to set an option
in a non-merge-lists QemuOptsList with non-NULL id, similar to -set.
However, it wouldn't *work* to use qemu_opts_set for the latter
because qemu_opts_set uses fail_if_exists==1. So, for non-merge-lists
QemuOptsList and non-NULL id, the semantics of qemu_opts_set (fail if the
(QemuOptsList, id) pair already exists) are debatable.
On the other hand, I would not expect qemu_opts_set to create a
non-merge-lists QemuOpts with a single option; which it does, though.
For this case of non-merge-lists QemuOptsList and NULL id, qemu_opts_set
hardly adds value over qemu_opts_parse. It does skip some parsing and
unescaping, but that's not needed when creating default network
backends.
So qemu_opts_set has warty behavior for non-merge-lists QemuOptsList
if id is non-NULL, and it's mostly pointless if id is NULL. My
solution to keeping the API as simple as possible is to limit
qemu_opts_set to merge-lists QemuOptsList. For them, it's useful (we
don't want comma-unescaping for -kernel) *and* has sane semantics.
Network backend creation is switched to qemu_opts_parse.
qemu_opts_set is now only used on merge-lists QemuOptsList... except
in the testcase, which is changed to use a merge-list QemuOptsList.
With this change we can also remove the id parameter. With the
parameter always NULL, we know that qemu_opts_create cannot fail
and can pass &error_abort to it.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-11-09 10:46:30 +01:00
|
|
|
bool qemu_opts_set(QemuOptsList *list, const char *name, const char *value, Error **errp);
|
2009-07-31 12:25:32 +02:00
|
|
|
const char *qemu_opts_id(QemuOpts *opts);
|
2013-07-11 12:52:34 +02:00
|
|
|
void qemu_opts_set_id(QemuOpts *opts, char *id);
|
2009-07-22 16:43:03 +02:00
|
|
|
void qemu_opts_del(QemuOpts *opts);
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp);
|
|
|
|
bool qemu_opts_do_parse(QemuOpts *opts, const char *params,
|
2015-02-12 18:37:11 +01:00
|
|
|
const char *firstname, Error **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
|
|
|
QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params,
|
|
|
|
bool permit_abbrev);
|
|
|
|
QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
|
|
|
|
bool permit_abbrev, Error **errp);
|
2012-01-27 19:54:54 +01:00
|
|
|
void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
|
|
|
|
int permit_abbrev);
|
2012-04-18 22:24:01 +02:00
|
|
|
QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
|
|
|
|
Error **errp);
|
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
|
|
|
QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict);
|
2020-07-07 18:05:41 +02:00
|
|
|
bool qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp);
|
2009-07-22 16:43:03 +02:00
|
|
|
|
2015-03-13 13:35:14 +01:00
|
|
|
typedef int (*qemu_opts_loopfunc)(void *opaque, QemuOpts *opts, Error **errp);
|
2015-03-13 11:07:24 +01:00
|
|
|
int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func,
|
2015-03-13 13:35:14 +01:00
|
|
|
void *opaque, Error **errp);
|
2014-12-09 08:38:04 +01:00
|
|
|
void qemu_opts_print(QemuOpts *opts, const char *sep);
|
2018-10-19 18:49:25 +02:00
|
|
|
void qemu_opts_print_help(QemuOptsList *list, bool print_caption);
|
2014-06-05 11:20:48 +02:00
|
|
|
void qemu_opts_free(QemuOptsList *list);
|
2014-06-05 11:21:11 +02:00
|
|
|
QemuOptsList *qemu_opts_append(QemuOptsList *dst, QemuOptsList *list);
|
2009-07-22 16:43:03 +02:00
|
|
|
|
keyval: New keyval_parse()
keyval_parse() parses KEY=VALUE,... into a QDict. Works like
qemu_opts_parse(), except:
* Returns a QDict instead of a QemuOpts (d'oh).
* Supports nesting, unlike QemuOpts: a KEY is split into key
fragments at '.' (dotted key convention; the block layer does
something similar on top of QemuOpts). The key fragments are QDict
keys, and the last one's value is updated to VALUE.
* Each key fragment may be up to 127 bytes long. qemu_opts_parse()
limits the entire key to 127 bytes.
* Overlong key fragments are rejected. qemu_opts_parse() silently
truncates them.
* Empty key fragments are rejected. qemu_opts_parse() happily
accepts empty keys.
* It does not store the returned value. qemu_opts_parse() stores it
in the QemuOptsList.
* It does not treat parameter "id" specially. qemu_opts_parse()
ignores all but the first "id", and fails when its value isn't
id_wellformed(), or duplicate (a QemuOpts with the same ID is
already stored). It also screws up when a value contains ",id=".
* Implied value is not supported. qemu_opts_parse() desugars "foo" to
"foo=on", and "nofoo" to "foo=off".
* An implied key's value can't be empty, and can't contain ','.
I intend to grow this into a saner replacement for QemuOpts. It'll
take time, though.
Note: keyval_parse() provides no way to do lists, and its key syntax
is incompatible with the __RFQDN_ prefix convention for downstream
extensions, because it blindly splits at '.', even in __RFQDN_. Both
issues will be addressed later in the series.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1488317230-26248-4-git-send-email-armbru@redhat.com>
2017-02-28 22:26:49 +01:00
|
|
|
QDict *keyval_parse(const char *params, const char *implied_key,
|
keyval: Parse help options
This adds a special meaning for 'help' and '?' as options to the keyval
parser. Instead of being an error (because of a missing value) or a
value for an implied key, they now request help, which is a new boolean
output of the parser in addition to the QDict.
A new parameter 'p_help' is added to keyval_parse() that contains on
return whether help was requested. If NULL is passed, requesting help
results in an error and all other cases work like before.
Turning previous error cases into help is a compatible extension. The
behaviour potentially changes for implied keys: They could previously
get 'help' as their value, which is now interpreted as requesting help.
This is not a problem in practice because 'help' and '?' are not a valid
values for the implied key of any option parsed with keyval_parse():
* audiodev: union Audiodev, implied key "driver" is enum AudiodevDriver,
"help" and "?" are not among its values
* display: union DisplayOptions, implied key "type" is enum
DisplayType, "help" and "?" are not among its values
* blockdev: union BlockdevOptions, implied key "driver is enum
BlockdevDriver, "help" and "?" are not among its values
* export: union BlockExport, implied key "type" is enum BlockExportType,
"help" and "?" are not among its values
* monitor: struct MonitorOptions, implied key "mode" is enum MonitorMode,
"help" and "?" are not among its values
* nbd-server: struct NbdServerOptions, no implied key.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20201011073505.1185335-5-armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-10-11 09:35:02 +02:00
|
|
|
bool *help, Error **errp);
|
2020-11-12 14:40:11 +01:00
|
|
|
void keyval_merge(QDict *old, const QDict *new, Error **errp);
|
keyval: New keyval_parse()
keyval_parse() parses KEY=VALUE,... into a QDict. Works like
qemu_opts_parse(), except:
* Returns a QDict instead of a QemuOpts (d'oh).
* Supports nesting, unlike QemuOpts: a KEY is split into key
fragments at '.' (dotted key convention; the block layer does
something similar on top of QemuOpts). The key fragments are QDict
keys, and the last one's value is updated to VALUE.
* Each key fragment may be up to 127 bytes long. qemu_opts_parse()
limits the entire key to 127 bytes.
* Overlong key fragments are rejected. qemu_opts_parse() silently
truncates them.
* Empty key fragments are rejected. qemu_opts_parse() happily
accepts empty keys.
* It does not store the returned value. qemu_opts_parse() stores it
in the QemuOptsList.
* It does not treat parameter "id" specially. qemu_opts_parse()
ignores all but the first "id", and fails when its value isn't
id_wellformed(), or duplicate (a QemuOpts with the same ID is
already stored). It also screws up when a value contains ",id=".
* Implied value is not supported. qemu_opts_parse() desugars "foo" to
"foo=on", and "nofoo" to "foo=off".
* An implied key's value can't be empty, and can't contain ','.
I intend to grow this into a saner replacement for QemuOpts. It'll
take time, though.
Note: keyval_parse() provides no way to do lists, and its key syntax
is incompatible with the __RFQDN_ prefix convention for downstream
extensions, because it blindly splits at '.', even in __RFQDN_. Both
issues will be addressed later in the series.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <1488317230-26248-4-git-send-email-armbru@redhat.com>
2017-02-28 22:26:49 +01:00
|
|
|
|
2009-05-18 16:42:09 +02:00
|
|
|
#endif
|