2 * Commandline option parsing functions
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2009 Kevin Wolf <kwolf@redhat.com>
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "qemu/osdep.h"
28 #include "qapi/error.h"
29 #include "qemu/error-report.h"
30 #include "qapi/qmp/qbool.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qapi/qmp/qnum.h"
33 #include "qapi/qmp/qstring.h"
34 #include "qapi/qmp/qerror.h"
35 #include "qemu/option_int.h"
36 #include "qemu/cutils.h"
38 #include "qemu/help_option.h"
41 * Extracts the name of an option from the parameter string (p points at the
42 * first byte of the option name)
44 * The option name is delimited by delim (usually , or =) or the string end
45 * and is copied into option. The caller is responsible for free'ing option
46 * when no longer required.
48 * The return value is the position of the delimiter/zero byte after the option
51 static const char *get_opt_name(const char *p
, char **option
, char delim
)
53 char *offset
= strchr(p
, delim
);
56 *option
= g_strndup(p
, offset
- p
);
59 *option
= g_strdup(p
);
65 * Extracts the value of an option from the parameter string p (p points at the
66 * first byte of the option value)
68 * This function is comparable to get_opt_name with the difference that the
69 * delimiter is fixed to be comma which starts a new option. To specify an
70 * option value that contains commas, double each comma.
72 const char *get_opt_value(const char *p
, char **value
)
74 size_t capacity
= 0, length
;
79 offset
= qemu_strchrnul(p
, ',');
81 if (*offset
!= '\0' && *(offset
+ 1) == ',') {
84 *value
= g_renew(char, *value
, capacity
+ length
+ 1);
85 strncpy(*value
+ capacity
, p
, length
);
86 (*value
)[capacity
+ length
] = '\0';
88 if (*offset
== '\0' ||
89 *(offset
+ 1) != ',') {
93 p
+= (offset
- p
) + 2;
99 static void parse_option_bool(const char *name
, const char *value
, bool *ret
,
102 if (!strcmp(value
, "on")) {
104 } else if (!strcmp(value
, "off")) {
107 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
,
108 name
, "'on' or 'off'");
112 static void parse_option_number(const char *name
, const char *value
,
113 uint64_t *ret
, Error
**errp
)
118 err
= qemu_strtou64(value
, NULL
, 0, &number
);
119 if (err
== -ERANGE
) {
120 error_setg(errp
, "Value '%s' is too large for parameter '%s'",
125 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, name
, "a number");
131 static const QemuOptDesc
*find_desc_by_name(const QemuOptDesc
*desc
,
136 for (i
= 0; desc
[i
].name
!= NULL
; i
++) {
137 if (strcmp(desc
[i
].name
, name
) == 0) {
145 void parse_option_size(const char *name
, const char *value
,
146 uint64_t *ret
, Error
**errp
)
151 err
= qemu_strtosz(value
, NULL
, &size
);
152 if (err
== -ERANGE
) {
153 error_setg(errp
, "Value '%s' is out of range for parameter '%s'",
158 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, name
,
159 "a non-negative number below 2^64");
160 error_append_hint(errp
, "Optional suffix k, M, G, T, P or E means"
161 " kilo-, mega-, giga-, tera-, peta-\n"
162 "and exabytes, respectively.\n");
168 static const char *opt_type_to_string(enum QemuOptType type
)
171 case QEMU_OPT_STRING
:
174 return "bool (on/off)";
175 case QEMU_OPT_NUMBER
:
181 g_assert_not_reached();
185 * Print the list of options available in the given list. If
186 * @print_caption is true, a caption (including the list name, if it
187 * exists) is printed. The options itself will be indented, so
188 * @print_caption should only be set to false if the caller prints its
189 * own custom caption (so that the indentation makes sense).
191 void qemu_opts_print_help(QemuOptsList
*list
, bool print_caption
)
195 GPtrArray
*array
= g_ptr_array_new();
199 while (desc
&& desc
->name
) {
200 GString
*str
= g_string_new(NULL
);
201 g_string_append_printf(str
, " %s=<%s>", desc
->name
,
202 opt_type_to_string(desc
->type
));
205 g_string_append_printf(str
, "%*s", 24 - (int)str
->len
, "");
207 g_string_append_printf(str
, " - %s", desc
->help
);
209 g_ptr_array_add(array
, g_string_free(str
, false));
213 g_ptr_array_sort(array
, (GCompareFunc
)qemu_pstrcmp0
);
214 if (print_caption
&& array
->len
> 0) {
216 printf("%s options:\n", list
->name
);
218 printf("Options:\n");
220 } else if (array
->len
== 0) {
222 printf("There are no options for %s.\n", list
->name
);
224 printf("No options available.\n");
227 for (i
= 0; i
< array
->len
; i
++) {
228 printf("%s\n", (char *)array
->pdata
[i
]);
230 g_ptr_array_set_free_func(array
, g_free
);
231 g_ptr_array_free(array
, true);
234 /* ------------------------------------------------------------------ */
236 QemuOpt
*qemu_opt_find(QemuOpts
*opts
, const char *name
)
240 QTAILQ_FOREACH_REVERSE(opt
, &opts
->head
, next
) {
241 if (strcmp(opt
->name
, name
) != 0)
248 static void qemu_opt_del(QemuOpt
*opt
)
250 QTAILQ_REMOVE(&opt
->opts
->head
, opt
, next
);
256 /* qemu_opt_set allows many settings for the same option.
257 * This function deletes all settings for an option.
259 static void qemu_opt_del_all(QemuOpts
*opts
, const char *name
)
261 QemuOpt
*opt
, *next_opt
;
263 QTAILQ_FOREACH_SAFE(opt
, &opts
->head
, next
, next_opt
) {
264 if (!strcmp(opt
->name
, name
)) {
270 const char *qemu_opt_get(QemuOpts
*opts
, const char *name
)
273 const QemuOptDesc
*desc
;
279 opt
= qemu_opt_find(opts
, name
);
281 desc
= find_desc_by_name(opts
->list
->desc
, name
);
282 if (desc
&& desc
->def_value_str
) {
283 return desc
->def_value_str
;
286 return opt
? opt
->str
: NULL
;
289 void qemu_opt_iter_init(QemuOptsIter
*iter
, QemuOpts
*opts
, const char *name
)
292 iter
->opt
= QTAILQ_FIRST(&opts
->head
);
296 const char *qemu_opt_iter_next(QemuOptsIter
*iter
)
298 QemuOpt
*ret
= iter
->opt
;
300 while (ret
&& !g_str_equal(iter
->name
, ret
->name
)) {
301 ret
= QTAILQ_NEXT(ret
, next
);
304 iter
->opt
= ret
? QTAILQ_NEXT(ret
, next
) : NULL
;
305 return ret
? ret
->str
: NULL
;
308 /* Get a known option (or its default) and remove it from the list
309 * all in one action. Return a malloced string of the option value.
310 * Result must be freed by caller with g_free().
312 char *qemu_opt_get_del(QemuOpts
*opts
, const char *name
)
315 const QemuOptDesc
*desc
;
322 opt
= qemu_opt_find(opts
, name
);
324 desc
= find_desc_by_name(opts
->list
->desc
, name
);
325 if (desc
&& desc
->def_value_str
) {
326 str
= g_strdup(desc
->def_value_str
);
332 qemu_opt_del_all(opts
, name
);
336 bool qemu_opt_has_help_opt(QemuOpts
*opts
)
340 QTAILQ_FOREACH_REVERSE(opt
, &opts
->head
, next
) {
341 if (is_help_option(opt
->name
)) {
348 static bool qemu_opt_get_bool_helper(QemuOpts
*opts
, const char *name
,
349 bool defval
, bool del
)
352 const QemuOptDesc
*desc
;
359 opt
= qemu_opt_find(opts
, name
);
361 desc
= find_desc_by_name(opts
->list
->desc
, name
);
362 if (desc
&& desc
->def_value_str
) {
363 parse_option_bool(name
, desc
->def_value_str
, &ret
, &error_abort
);
367 assert(opt
->desc
&& opt
->desc
->type
== QEMU_OPT_BOOL
);
368 ret
= opt
->value
.boolean
;
370 qemu_opt_del_all(opts
, name
);
375 bool qemu_opt_get_bool(QemuOpts
*opts
, const char *name
, bool defval
)
377 return qemu_opt_get_bool_helper(opts
, name
, defval
, false);
380 bool qemu_opt_get_bool_del(QemuOpts
*opts
, const char *name
, bool defval
)
382 return qemu_opt_get_bool_helper(opts
, name
, defval
, true);
385 static uint64_t qemu_opt_get_number_helper(QemuOpts
*opts
, const char *name
,
386 uint64_t defval
, bool del
)
389 const QemuOptDesc
*desc
;
390 uint64_t ret
= defval
;
396 opt
= qemu_opt_find(opts
, name
);
398 desc
= find_desc_by_name(opts
->list
->desc
, name
);
399 if (desc
&& desc
->def_value_str
) {
400 parse_option_number(name
, desc
->def_value_str
, &ret
, &error_abort
);
404 assert(opt
->desc
&& opt
->desc
->type
== QEMU_OPT_NUMBER
);
405 ret
= opt
->value
.uint
;
407 qemu_opt_del_all(opts
, name
);
412 uint64_t qemu_opt_get_number(QemuOpts
*opts
, const char *name
, uint64_t defval
)
414 return qemu_opt_get_number_helper(opts
, name
, defval
, false);
417 uint64_t qemu_opt_get_number_del(QemuOpts
*opts
, const char *name
,
420 return qemu_opt_get_number_helper(opts
, name
, defval
, true);
423 static uint64_t qemu_opt_get_size_helper(QemuOpts
*opts
, const char *name
,
424 uint64_t defval
, bool del
)
427 const QemuOptDesc
*desc
;
428 uint64_t ret
= defval
;
434 opt
= qemu_opt_find(opts
, name
);
436 desc
= find_desc_by_name(opts
->list
->desc
, name
);
437 if (desc
&& desc
->def_value_str
) {
438 parse_option_size(name
, desc
->def_value_str
, &ret
, &error_abort
);
442 assert(opt
->desc
&& opt
->desc
->type
== QEMU_OPT_SIZE
);
443 ret
= opt
->value
.uint
;
445 qemu_opt_del_all(opts
, name
);
450 uint64_t qemu_opt_get_size(QemuOpts
*opts
, const char *name
, uint64_t defval
)
452 return qemu_opt_get_size_helper(opts
, name
, defval
, false);
455 uint64_t qemu_opt_get_size_del(QemuOpts
*opts
, const char *name
,
458 return qemu_opt_get_size_helper(opts
, name
, defval
, true);
461 static void qemu_opt_parse(QemuOpt
*opt
, Error
**errp
)
463 if (opt
->desc
== NULL
)
466 switch (opt
->desc
->type
) {
467 case QEMU_OPT_STRING
:
471 parse_option_bool(opt
->name
, opt
->str
, &opt
->value
.boolean
, errp
);
473 case QEMU_OPT_NUMBER
:
474 parse_option_number(opt
->name
, opt
->str
, &opt
->value
.uint
, errp
);
477 parse_option_size(opt
->name
, opt
->str
, &opt
->value
.uint
, errp
);
484 static bool opts_accepts_any(const QemuOpts
*opts
)
486 return opts
->list
->desc
[0].name
== NULL
;
489 int qemu_opt_unset(QemuOpts
*opts
, const char *name
)
491 QemuOpt
*opt
= qemu_opt_find(opts
, name
);
493 assert(opts_accepts_any(opts
));
503 static void opt_set(QemuOpts
*opts
, const char *name
, char *value
,
504 bool prepend
, bool *help_wanted
, Error
**errp
)
507 const QemuOptDesc
*desc
;
508 Error
*local_err
= NULL
;
510 desc
= find_desc_by_name(opts
->list
->desc
, name
);
511 if (!desc
&& !opts_accepts_any(opts
)) {
513 error_setg(errp
, QERR_INVALID_PARAMETER
, name
);
514 if (help_wanted
&& is_help_option(name
)) {
520 opt
= g_malloc0(sizeof(*opt
));
521 opt
->name
= g_strdup(name
);
524 QTAILQ_INSERT_HEAD(&opts
->head
, opt
, next
);
526 QTAILQ_INSERT_TAIL(&opts
->head
, opt
, next
);
530 qemu_opt_parse(opt
, &local_err
);
532 error_propagate(errp
, local_err
);
537 void qemu_opt_set(QemuOpts
*opts
, const char *name
, const char *value
,
540 opt_set(opts
, name
, g_strdup(value
), false, NULL
, errp
);
543 void qemu_opt_set_bool(QemuOpts
*opts
, const char *name
, bool val
,
547 const QemuOptDesc
*desc
;
549 desc
= find_desc_by_name(opts
->list
->desc
, name
);
550 if (!desc
&& !opts_accepts_any(opts
)) {
551 error_setg(errp
, QERR_INVALID_PARAMETER
, name
);
555 opt
= g_malloc0(sizeof(*opt
));
556 opt
->name
= g_strdup(name
);
559 opt
->value
.boolean
= !!val
;
560 opt
->str
= g_strdup(val
? "on" : "off");
561 QTAILQ_INSERT_TAIL(&opts
->head
, opt
, next
);
564 void qemu_opt_set_number(QemuOpts
*opts
, const char *name
, int64_t val
,
568 const QemuOptDesc
*desc
;
570 desc
= find_desc_by_name(opts
->list
->desc
, name
);
571 if (!desc
&& !opts_accepts_any(opts
)) {
572 error_setg(errp
, QERR_INVALID_PARAMETER
, name
);
576 opt
= g_malloc0(sizeof(*opt
));
577 opt
->name
= g_strdup(name
);
580 opt
->value
.uint
= val
;
581 opt
->str
= g_strdup_printf("%" PRId64
, val
);
582 QTAILQ_INSERT_TAIL(&opts
->head
, opt
, next
);
586 * For each member of @opts, call @func(@opaque, name, value, @errp).
587 * @func() may store an Error through @errp, but must return non-zero then.
588 * When @func() returns non-zero, break the loop and return that value.
589 * Return zero when the loop completes.
591 int qemu_opt_foreach(QemuOpts
*opts
, qemu_opt_loopfunc func
, void *opaque
,
597 QTAILQ_FOREACH(opt
, &opts
->head
, next
) {
598 rc
= func(opaque
, opt
->name
, opt
->str
, errp
);
602 assert(!errp
|| !*errp
);
607 QemuOpts
*qemu_opts_find(QemuOptsList
*list
, const char *id
)
611 QTAILQ_FOREACH(opts
, &list
->head
, next
) {
612 if (!opts
->id
&& !id
) {
615 if (opts
->id
&& id
&& !strcmp(opts
->id
, id
)) {
622 QemuOpts
*qemu_opts_create(QemuOptsList
*list
, const char *id
,
623 int fail_if_exists
, Error
**errp
)
625 QemuOpts
*opts
= NULL
;
628 if (!id_wellformed(id
)) {
629 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "id",
631 error_append_hint(errp
, "Identifiers consist of letters, digits, "
632 "'-', '.', '_', starting with a letter.\n");
635 opts
= qemu_opts_find(list
, id
);
637 if (fail_if_exists
&& !list
->merge_lists
) {
638 error_setg(errp
, "Duplicate ID '%s' for %s", id
, list
->name
);
644 } else if (list
->merge_lists
) {
645 opts
= qemu_opts_find(list
, NULL
);
650 opts
= g_malloc0(sizeof(*opts
));
651 opts
->id
= g_strdup(id
);
653 loc_save(&opts
->loc
);
654 QTAILQ_INIT(&opts
->head
);
655 QTAILQ_INSERT_TAIL(&list
->head
, opts
, next
);
659 void qemu_opts_reset(QemuOptsList
*list
)
661 QemuOpts
*opts
, *next_opts
;
663 QTAILQ_FOREACH_SAFE(opts
, &list
->head
, next
, next_opts
) {
668 void qemu_opts_loc_restore(QemuOpts
*opts
)
670 loc_restore(&opts
->loc
);
673 void qemu_opts_set(QemuOptsList
*list
, const char *id
,
674 const char *name
, const char *value
, Error
**errp
)
678 opts
= qemu_opts_create(list
, id
, 1, errp
);
682 qemu_opt_set(opts
, name
, value
, errp
);
685 const char *qemu_opts_id(QemuOpts
*opts
)
690 /* The id string will be g_free()d by qemu_opts_del */
691 void qemu_opts_set_id(QemuOpts
*opts
, char *id
)
696 void qemu_opts_del(QemuOpts
*opts
)
705 opt
= QTAILQ_FIRST(&opts
->head
);
710 QTAILQ_REMOVE(&opts
->list
->head
, opts
, next
);
715 /* print value, escaping any commas in value */
716 static void escaped_print(const char *value
)
720 for (ptr
= value
; *ptr
; ++ptr
) {
728 void qemu_opts_print(QemuOpts
*opts
, const char *separator
)
731 QemuOptDesc
*desc
= opts
->list
->desc
;
732 const char *sep
= "";
735 printf("id=%s", opts
->id
); /* passed id_wellformed -> no commas */
739 if (desc
[0].name
== NULL
) {
740 QTAILQ_FOREACH(opt
, &opts
->head
, next
) {
741 printf("%s%s=", sep
, opt
->name
);
742 escaped_print(opt
->str
);
747 for (; desc
&& desc
->name
; desc
++) {
749 opt
= qemu_opt_find(opts
, desc
->name
);
751 value
= opt
? opt
->str
: desc
->def_value_str
;
755 if (desc
->type
== QEMU_OPT_STRING
) {
756 printf("%s%s=", sep
, desc
->name
);
757 escaped_print(value
);
758 } else if ((desc
->type
== QEMU_OPT_SIZE
||
759 desc
->type
== QEMU_OPT_NUMBER
) && opt
) {
760 printf("%s%s=%" PRId64
, sep
, desc
->name
, opt
->value
.uint
);
762 printf("%s%s=%s", sep
, desc
->name
, value
);
768 static const char *get_opt_name_value(const char *params
,
769 const char *firstname
,
770 char **name
, char **value
)
772 const char *p
, *pe
, *pc
;
774 pe
= strchr(params
, '=');
775 pc
= strchr(params
, ',');
777 if (!pe
|| (pc
&& pc
< pe
)) {
778 /* found "foo,more" */
780 /* implicitly named first option */
781 *name
= g_strdup(firstname
);
782 p
= get_opt_value(params
, value
);
784 /* option without value, must be a flag */
785 p
= get_opt_name(params
, name
, ',');
786 if (strncmp(*name
, "no", 2) == 0) {
787 memmove(*name
, *name
+ 2, strlen(*name
+ 2) + 1);
788 *value
= g_strdup("off");
790 *value
= g_strdup("on");
794 /* found "foo=bar,more" */
795 p
= get_opt_name(params
, name
, '=');
798 p
= get_opt_value(p
, value
);
801 assert(!*p
|| *p
== ',');
808 static void opts_do_parse(QemuOpts
*opts
, const char *params
,
809 const char *firstname
, bool prepend
,
810 bool *help_wanted
, Error
**errp
)
812 Error
*local_err
= NULL
;
813 char *option
, *value
;
816 for (p
= params
; *p
;) {
817 p
= get_opt_name_value(p
, firstname
, &option
, &value
);
820 if (!strcmp(option
, "id")) {
826 opt_set(opts
, option
, value
, prepend
, help_wanted
, &local_err
);
829 error_propagate(errp
, local_err
);
835 static char *opts_parse_id(const char *params
)
840 for (p
= params
; *p
;) {
841 p
= get_opt_name_value(p
, NULL
, &name
, &value
);
842 if (!strcmp(name
, "id")) {
853 bool has_help_option(const char *params
)
859 for (p
= params
; *p
;) {
860 p
= get_opt_name_value(p
, NULL
, &name
, &value
);
861 ret
= is_help_option(name
);
873 * Store options parsed from @params into @opts.
874 * If @firstname is non-null, the first key=value in @params may omit
875 * key=, and is treated as if key was @firstname.
876 * On error, store an error object through @errp if non-null.
878 void qemu_opts_do_parse(QemuOpts
*opts
, const char *params
,
879 const char *firstname
, Error
**errp
)
881 opts_do_parse(opts
, params
, firstname
, false, NULL
, errp
);
884 static QemuOpts
*opts_parse(QemuOptsList
*list
, const char *params
,
885 bool permit_abbrev
, bool defaults
,
886 bool *help_wanted
, Error
**errp
)
888 const char *firstname
;
889 char *id
= opts_parse_id(params
);
891 Error
*local_err
= NULL
;
893 assert(!permit_abbrev
|| list
->implied_opt_name
);
894 firstname
= permit_abbrev
? list
->implied_opt_name
: NULL
;
897 * This code doesn't work for defaults && !list->merge_lists: when
898 * params has no id=, and list has an element with !opts->id, it
899 * appends a new element instead of returning the existing opts.
900 * However, we got no use for this case. Guard against possible
901 * (if unlikely) future misuse:
903 assert(!defaults
|| list
->merge_lists
);
904 opts
= qemu_opts_create(list
, id
, !defaults
, &local_err
);
907 error_propagate(errp
, local_err
);
911 opts_do_parse(opts
, params
, firstname
, defaults
, help_wanted
, &local_err
);
913 error_propagate(errp
, local_err
);
922 * Create a QemuOpts in @list and with options parsed from @params.
923 * If @permit_abbrev, the first key=value in @params may omit key=,
924 * and is treated as if key was @list->implied_opt_name.
925 * On error, store an error object through @errp if non-null.
926 * Return the new QemuOpts on success, null pointer on error.
928 QemuOpts
*qemu_opts_parse(QemuOptsList
*list
, const char *params
,
929 bool permit_abbrev
, Error
**errp
)
931 return opts_parse(list
, params
, permit_abbrev
, false, NULL
, errp
);
935 * Create a QemuOpts in @list and with options parsed from @params.
936 * If @permit_abbrev, the first key=value in @params may omit key=,
937 * and is treated as if key was @list->implied_opt_name.
938 * Report errors with error_report_err(). This is inappropriate in
939 * QMP context. Do not use this function there!
940 * Return the new QemuOpts on success, null pointer on error.
942 QemuOpts
*qemu_opts_parse_noisily(QemuOptsList
*list
, const char *params
,
947 bool help_wanted
= false;
949 opts
= opts_parse(list
, params
, permit_abbrev
, false, &help_wanted
, &err
);
952 qemu_opts_print_help(list
, true);
955 error_report_err(err
);
961 void qemu_opts_set_defaults(QemuOptsList
*list
, const char *params
,
966 opts
= opts_parse(list
, params
, permit_abbrev
, true, NULL
, NULL
);
970 static void qemu_opts_from_qdict_entry(QemuOpts
*opts
,
971 const QDictEntry
*entry
,
974 const char *key
= qdict_entry_key(entry
);
975 QObject
*obj
= qdict_entry_value(entry
);
976 char buf
[32], *tmp
= NULL
;
979 if (!strcmp(key
, "id")) {
983 switch (qobject_type(obj
)) {
985 value
= qstring_get_str(qobject_to(QString
, obj
));
988 tmp
= qnum_to_string(qobject_to(QNum
, obj
));
992 pstrcpy(buf
, sizeof(buf
),
993 qbool_get_bool(qobject_to(QBool
, obj
)) ? "on" : "off");
1000 qemu_opt_set(opts
, key
, value
, errp
);
1005 * Create QemuOpts from a QDict.
1006 * Use value of key "id" as ID if it exists and is a QString. Only
1007 * QStrings, QNums and QBools are copied. Entries with other types
1008 * are silently ignored.
1010 QemuOpts
*qemu_opts_from_qdict(QemuOptsList
*list
, const QDict
*qdict
,
1013 Error
*local_err
= NULL
;
1015 const QDictEntry
*entry
;
1017 opts
= qemu_opts_create(list
, qdict_get_try_str(qdict
, "id"), 1, errp
);
1022 assert(opts
!= NULL
);
1024 for (entry
= qdict_first(qdict
);
1026 entry
= qdict_next(qdict
, entry
)) {
1027 qemu_opts_from_qdict_entry(opts
, entry
, &local_err
);
1029 error_propagate(errp
, local_err
);
1030 qemu_opts_del(opts
);
1039 * Adds all QDict entries to the QemuOpts that can be added and removes them
1040 * from the QDict. When this function returns, the QDict contains only those
1041 * entries that couldn't be added to the QemuOpts.
1043 void qemu_opts_absorb_qdict(QemuOpts
*opts
, QDict
*qdict
, Error
**errp
)
1045 const QDictEntry
*entry
, *next
;
1047 entry
= qdict_first(qdict
);
1049 while (entry
!= NULL
) {
1050 Error
*local_err
= NULL
;
1052 next
= qdict_next(qdict
, entry
);
1054 if (find_desc_by_name(opts
->list
->desc
, entry
->key
)) {
1055 qemu_opts_from_qdict_entry(opts
, entry
, &local_err
);
1057 error_propagate(errp
, local_err
);
1060 qdict_del(qdict
, entry
->key
);
1068 * Convert from QemuOpts to QDict. The QDict values are of type QString.
1070 * If @list is given, only add those options to the QDict that are contained in
1071 * the list. If @del is true, any options added to the QDict are removed from
1072 * the QemuOpts, otherwise they remain there.
1074 * If two options in @opts have the same name, they are processed in order
1075 * so that the last one wins (consistent with the reverse iteration in
1076 * qemu_opt_find()), but all of them are deleted if @del is true.
1078 * TODO We'll want to use types appropriate for opt->desc->type, but
1079 * this is enough for now.
1081 QDict
*qemu_opts_to_qdict_filtered(QemuOpts
*opts
, QDict
*qdict
,
1082 QemuOptsList
*list
, bool del
)
1084 QemuOpt
*opt
, *next
;
1087 qdict
= qdict_new();
1090 qdict_put_str(qdict
, "id", opts
->id
);
1092 QTAILQ_FOREACH_SAFE(opt
, &opts
->head
, next
, next
) {
1096 for (desc
= list
->desc
; desc
->name
; desc
++) {
1097 if (!strcmp(desc
->name
, opt
->name
)) {
1106 qdict_put_str(qdict
, opt
->name
, opt
->str
);
1114 /* Copy all options in a QemuOpts to the given QDict. See
1115 * qemu_opts_to_qdict_filtered() for details. */
1116 QDict
*qemu_opts_to_qdict(QemuOpts
*opts
, QDict
*qdict
)
1118 return qemu_opts_to_qdict_filtered(opts
, qdict
, NULL
, false);
1121 /* Validate parsed opts against descriptions where no
1122 * descriptions were provided in the QemuOptsList.
1124 void qemu_opts_validate(QemuOpts
*opts
, const QemuOptDesc
*desc
, Error
**errp
)
1127 Error
*local_err
= NULL
;
1129 assert(opts_accepts_any(opts
));
1131 QTAILQ_FOREACH(opt
, &opts
->head
, next
) {
1132 opt
->desc
= find_desc_by_name(desc
, opt
->name
);
1134 error_setg(errp
, QERR_INVALID_PARAMETER
, opt
->name
);
1138 qemu_opt_parse(opt
, &local_err
);
1140 error_propagate(errp
, local_err
);
1147 * For each member of @list, call @func(@opaque, member, @errp).
1148 * Call it with the current location temporarily set to the member's.
1149 * @func() may store an Error through @errp, but must return non-zero then.
1150 * When @func() returns non-zero, break the loop and return that value.
1151 * Return zero when the loop completes.
1153 int qemu_opts_foreach(QemuOptsList
*list
, qemu_opts_loopfunc func
,
1154 void *opaque
, Error
**errp
)
1160 loc_push_none(&loc
);
1161 QTAILQ_FOREACH(opts
, &list
->head
, next
) {
1162 loc_restore(&opts
->loc
);
1163 rc
= func(opaque
, opts
, errp
);
1167 assert(!errp
|| !*errp
);
1173 static size_t count_opts_list(QemuOptsList
*list
)
1175 QemuOptDesc
*desc
= NULL
;
1176 size_t num_opts
= 0;
1183 while (desc
&& desc
->name
) {
1191 void qemu_opts_free(QemuOptsList
*list
)
1196 /* Realloc dst option list and append options from an option list (list)
1197 * to it. dst could be NULL or a malloced list.
1198 * The lifetime of dst must be shorter than the input list because the
1199 * QemuOptDesc->name, ->help, and ->def_value_str strings are shared.
1201 QemuOptsList
*qemu_opts_append(QemuOptsList
*dst
,
1204 size_t num_opts
, num_dst_opts
;
1206 bool need_init
= false;
1207 bool need_head_update
;
1213 /* If dst is NULL, after realloc, some area of dst should be initialized
1214 * before adding options to it.
1218 need_head_update
= true;
1220 /* Moreover, even if dst is not NULL, the realloc may move it to a
1221 * different address in which case we may get a stale tail pointer
1223 need_head_update
= QTAILQ_EMPTY(&dst
->head
);
1226 num_opts
= count_opts_list(dst
);
1227 num_dst_opts
= num_opts
;
1228 num_opts
+= count_opts_list(list
);
1229 dst
= g_realloc(dst
, sizeof(QemuOptsList
) +
1230 (num_opts
+ 1) * sizeof(QemuOptDesc
));
1233 dst
->implied_opt_name
= NULL
;
1234 dst
->merge_lists
= false;
1236 if (need_head_update
) {
1237 QTAILQ_INIT(&dst
->head
);
1239 dst
->desc
[num_dst_opts
].name
= NULL
;
1241 /* append list->desc to dst->desc */
1244 while (desc
&& desc
->name
) {
1245 if (find_desc_by_name(dst
->desc
, desc
->name
) == NULL
) {
1246 dst
->desc
[num_dst_opts
++] = *desc
;
1247 dst
->desc
[num_dst_opts
].name
= NULL
;