memory: Don't dump disabled regions
[qemu/ar7.git] / qemu-option.c
blob27891e74e7c5713aacd902f2dda417097885edfd
1 /*
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
23 * THE SOFTWARE.
26 #include <stdio.h>
27 #include <string.h>
29 #include "qemu-common.h"
30 #include "qemu-error.h"
31 #include "qemu-objects.h"
32 #include "error.h"
33 #include "qerror.h"
34 #include "qemu-option-internal.h"
37 * Extracts the name of an option from the parameter string (p points at the
38 * first byte of the option name)
40 * The option name is delimited by delim (usually , or =) or the string end
41 * and is copied into buf. If the option name is longer than buf_size, it is
42 * truncated. buf is always zero terminated.
44 * The return value is the position of the delimiter/zero byte after the option
45 * name in p.
47 const char *get_opt_name(char *buf, int buf_size, const char *p, char delim)
49 char *q;
51 q = buf;
52 while (*p != '\0' && *p != delim) {
53 if (q && (q - buf) < buf_size - 1)
54 *q++ = *p;
55 p++;
57 if (q)
58 *q = '\0';
60 return p;
64 * Extracts the value of an option from the parameter string p (p points at the
65 * first byte of the option value)
67 * This function is comparable to get_opt_name with the difference that the
68 * delimiter is fixed to be comma which starts a new option. To specify an
69 * option value that contains commas, double each comma.
71 const char *get_opt_value(char *buf, int buf_size, const char *p)
73 char *q;
75 q = buf;
76 while (*p != '\0') {
77 if (*p == ',') {
78 if (*(p + 1) != ',')
79 break;
80 p++;
82 if (q && (q - buf) < buf_size - 1)
83 *q++ = *p;
84 p++;
86 if (q)
87 *q = '\0';
89 return p;
92 int get_next_param_value(char *buf, int buf_size,
93 const char *tag, const char **pstr)
95 const char *p;
96 char option[128];
98 p = *pstr;
99 for(;;) {
100 p = get_opt_name(option, sizeof(option), p, '=');
101 if (*p != '=')
102 break;
103 p++;
104 if (!strcmp(tag, option)) {
105 *pstr = get_opt_value(buf, buf_size, p);
106 if (**pstr == ',') {
107 (*pstr)++;
109 return strlen(buf);
110 } else {
111 p = get_opt_value(NULL, 0, p);
113 if (*p != ',')
114 break;
115 p++;
117 return 0;
120 int get_param_value(char *buf, int buf_size,
121 const char *tag, const char *str)
123 return get_next_param_value(buf, buf_size, tag, &str);
126 int check_params(char *buf, int buf_size,
127 const char * const *params, const char *str)
129 const char *p;
130 int i;
132 p = str;
133 while (*p != '\0') {
134 p = get_opt_name(buf, buf_size, p, '=');
135 if (*p != '=') {
136 return -1;
138 p++;
139 for (i = 0; params[i] != NULL; i++) {
140 if (!strcmp(params[i], buf)) {
141 break;
144 if (params[i] == NULL) {
145 return -1;
147 p = get_opt_value(NULL, 0, p);
148 if (*p != ',') {
149 break;
151 p++;
153 return 0;
157 * Searches an option list for an option with the given name
159 QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list,
160 const char *name)
162 while (list && list->name) {
163 if (!strcmp(list->name, name)) {
164 return list;
166 list++;
169 return NULL;
172 static void parse_option_bool(const char *name, const char *value, bool *ret,
173 Error **errp)
175 if (value != NULL) {
176 if (!strcmp(value, "on")) {
177 *ret = 1;
178 } else if (!strcmp(value, "off")) {
179 *ret = 0;
180 } else {
181 error_set(errp,QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'");
183 } else {
184 *ret = 1;
188 static void parse_option_number(const char *name, const char *value,
189 uint64_t *ret, Error **errp)
191 char *postfix;
192 uint64_t number;
194 if (value != NULL) {
195 number = strtoull(value, &postfix, 0);
196 if (*postfix != '\0') {
197 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
198 return;
200 *ret = number;
201 } else {
202 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
206 static void parse_option_size(const char *name, const char *value,
207 uint64_t *ret, Error **errp)
209 char *postfix;
210 double sizef;
212 if (value != NULL) {
213 sizef = strtod(value, &postfix);
214 switch (*postfix) {
215 case 'T':
216 sizef *= 1024;
217 /* fall through */
218 case 'G':
219 sizef *= 1024;
220 /* fall through */
221 case 'M':
222 sizef *= 1024;
223 /* fall through */
224 case 'K':
225 case 'k':
226 sizef *= 1024;
227 /* fall through */
228 case 'b':
229 case '\0':
230 *ret = (uint64_t) sizef;
231 break;
232 default:
233 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size");
234 error_printf_unless_qmp("You may use k, M, G or T suffixes for "
235 "kilobytes, megabytes, gigabytes and terabytes.\n");
236 return;
238 } else {
239 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name, "a size");
244 * Sets the value of a parameter in a given option list. The parsing of the
245 * value depends on the type of option:
247 * OPT_FLAG (uses value.n):
248 * If no value is given, the flag is set to 1.
249 * Otherwise the value must be "on" (set to 1) or "off" (set to 0)
251 * OPT_STRING (uses value.s):
252 * value is strdup()ed and assigned as option value
254 * OPT_SIZE (uses value.n):
255 * The value is converted to an integer. Suffixes for kilobytes etc. are
256 * allowed (powers of 1024).
258 * Returns 0 on succes, -1 in error cases
260 int set_option_parameter(QEMUOptionParameter *list, const char *name,
261 const char *value)
263 bool flag;
264 Error *local_err = NULL;
266 // Find a matching parameter
267 list = get_option_parameter(list, name);
268 if (list == NULL) {
269 fprintf(stderr, "Unknown option '%s'\n", name);
270 return -1;
273 // Process parameter
274 switch (list->type) {
275 case OPT_FLAG:
276 parse_option_bool(name, value, &flag, &local_err);
277 if (!error_is_set(&local_err)) {
278 list->value.n = flag;
280 break;
282 case OPT_STRING:
283 if (value != NULL) {
284 list->value.s = g_strdup(value);
285 } else {
286 fprintf(stderr, "Option '%s' needs a parameter\n", name);
287 return -1;
289 break;
291 case OPT_SIZE:
292 parse_option_size(name, value, &list->value.n, &local_err);
293 break;
295 default:
296 fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name);
297 return -1;
300 if (error_is_set(&local_err)) {
301 qerror_report_err(local_err);
302 error_free(local_err);
303 return -1;
306 return 0;
310 * Sets the given parameter to an integer instead of a string.
311 * This function cannot be used to set string options.
313 * Returns 0 on success, -1 in error cases
315 int set_option_parameter_int(QEMUOptionParameter *list, const char *name,
316 uint64_t value)
318 // Find a matching parameter
319 list = get_option_parameter(list, name);
320 if (list == NULL) {
321 fprintf(stderr, "Unknown option '%s'\n", name);
322 return -1;
325 // Process parameter
326 switch (list->type) {
327 case OPT_FLAG:
328 case OPT_NUMBER:
329 case OPT_SIZE:
330 list->value.n = value;
331 break;
333 default:
334 return -1;
337 return 0;
341 * Frees a option list. If it contains strings, the strings are freed as well.
343 void free_option_parameters(QEMUOptionParameter *list)
345 QEMUOptionParameter *cur = list;
347 while (cur && cur->name) {
348 if (cur->type == OPT_STRING) {
349 g_free(cur->value.s);
351 cur++;
354 g_free(list);
358 * Count valid options in list
360 static size_t count_option_parameters(QEMUOptionParameter *list)
362 size_t num_options = 0;
364 while (list && list->name) {
365 num_options++;
366 list++;
369 return num_options;
373 * Append an option list (list) to an option list (dest).
375 * If dest is NULL, a new copy of list is created.
377 * Returns a pointer to the first element of dest (or the newly allocated copy)
379 QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest,
380 QEMUOptionParameter *list)
382 size_t num_options, num_dest_options;
384 num_options = count_option_parameters(dest);
385 num_dest_options = num_options;
387 num_options += count_option_parameters(list);
389 dest = g_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter));
390 dest[num_dest_options].name = NULL;
392 while (list && list->name) {
393 if (get_option_parameter(dest, list->name) == NULL) {
394 dest[num_dest_options++] = *list;
395 dest[num_dest_options].name = NULL;
397 list++;
400 return dest;
404 * Parses a parameter string (param) into an option list (dest).
406 * list is the template option list. If dest is NULL, a new copy of list is
407 * created. If list is NULL, this function fails.
409 * A parameter string consists of one or more parameters, separated by commas.
410 * Each parameter consists of its name and possibly of a value. In the latter
411 * case, the value is delimited by an = character. To specify a value which
412 * contains commas, double each comma so it won't be recognized as the end of
413 * the parameter.
415 * For more details of the parsing see above.
417 * Returns a pointer to the first element of dest (or the newly allocated copy)
418 * or NULL in error cases
420 QEMUOptionParameter *parse_option_parameters(const char *param,
421 QEMUOptionParameter *list, QEMUOptionParameter *dest)
423 QEMUOptionParameter *allocated = NULL;
424 char name[256];
425 char value[256];
426 char *param_delim, *value_delim;
427 char next_delim;
429 if (list == NULL) {
430 return NULL;
433 if (dest == NULL) {
434 dest = allocated = append_option_parameters(NULL, list);
437 while (*param) {
439 // Find parameter name and value in the string
440 param_delim = strchr(param, ',');
441 value_delim = strchr(param, '=');
443 if (value_delim && (value_delim < param_delim || !param_delim)) {
444 next_delim = '=';
445 } else {
446 next_delim = ',';
447 value_delim = NULL;
450 param = get_opt_name(name, sizeof(name), param, next_delim);
451 if (value_delim) {
452 param = get_opt_value(value, sizeof(value), param + 1);
454 if (*param != '\0') {
455 param++;
458 // Set the parameter
459 if (set_option_parameter(dest, name, value_delim ? value : NULL)) {
460 goto fail;
464 return dest;
466 fail:
467 // Only free the list if it was newly allocated
468 free_option_parameters(allocated);
469 return NULL;
473 * Prints all options of a list that have a value to stdout
475 void print_option_parameters(QEMUOptionParameter *list)
477 while (list && list->name) {
478 switch (list->type) {
479 case OPT_STRING:
480 if (list->value.s != NULL) {
481 printf("%s='%s' ", list->name, list->value.s);
483 break;
484 case OPT_FLAG:
485 printf("%s=%s ", list->name, list->value.n ? "on" : "off");
486 break;
487 case OPT_SIZE:
488 case OPT_NUMBER:
489 printf("%s=%" PRId64 " ", list->name, list->value.n);
490 break;
491 default:
492 printf("%s=(unknown type) ", list->name);
493 break;
495 list++;
500 * Prints an overview of all available options
502 void print_option_help(QEMUOptionParameter *list)
504 printf("Supported options:\n");
505 while (list && list->name) {
506 printf("%-16s %s\n", list->name,
507 list->help ? list->help : "No description available");
508 list++;
512 /* ------------------------------------------------------------------ */
514 static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
516 QemuOpt *opt;
518 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
519 if (strcmp(opt->name, name) != 0)
520 continue;
521 return opt;
523 return NULL;
526 const char *qemu_opt_get(QemuOpts *opts, const char *name)
528 QemuOpt *opt = qemu_opt_find(opts, name);
529 return opt ? opt->str : NULL;
532 bool qemu_opt_has_help_opt(QemuOpts *opts)
534 QemuOpt *opt;
536 QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) {
537 if (is_help_option(opt->name)) {
538 return true;
541 return false;
544 bool qemu_opt_get_bool(QemuOpts *opts, const char *name, bool defval)
546 QemuOpt *opt = qemu_opt_find(opts, name);
548 if (opt == NULL)
549 return defval;
550 assert(opt->desc && opt->desc->type == QEMU_OPT_BOOL);
551 return opt->value.boolean;
554 uint64_t qemu_opt_get_number(QemuOpts *opts, const char *name, uint64_t defval)
556 QemuOpt *opt = qemu_opt_find(opts, name);
558 if (opt == NULL)
559 return defval;
560 assert(opt->desc && opt->desc->type == QEMU_OPT_NUMBER);
561 return opt->value.uint;
564 uint64_t qemu_opt_get_size(QemuOpts *opts, const char *name, uint64_t defval)
566 QemuOpt *opt = qemu_opt_find(opts, name);
568 if (opt == NULL)
569 return defval;
570 assert(opt->desc && opt->desc->type == QEMU_OPT_SIZE);
571 return opt->value.uint;
574 static void qemu_opt_parse(QemuOpt *opt, Error **errp)
576 if (opt->desc == NULL)
577 return;
579 switch (opt->desc->type) {
580 case QEMU_OPT_STRING:
581 /* nothing */
582 return;
583 case QEMU_OPT_BOOL:
584 parse_option_bool(opt->name, opt->str, &opt->value.boolean, errp);
585 break;
586 case QEMU_OPT_NUMBER:
587 parse_option_number(opt->name, opt->str, &opt->value.uint, errp);
588 break;
589 case QEMU_OPT_SIZE:
590 parse_option_size(opt->name, opt->str, &opt->value.uint, errp);
591 break;
592 default:
593 abort();
597 static void qemu_opt_del(QemuOpt *opt)
599 QTAILQ_REMOVE(&opt->opts->head, opt, next);
600 g_free((/* !const */ char*)opt->name);
601 g_free((/* !const */ char*)opt->str);
602 g_free(opt);
605 static void opt_set(QemuOpts *opts, const char *name, const char *value,
606 bool prepend, Error **errp)
608 QemuOpt *opt;
609 const QemuOptDesc *desc = opts->list->desc;
610 Error *local_err = NULL;
611 int i;
613 for (i = 0; desc[i].name != NULL; i++) {
614 if (strcmp(desc[i].name, name) == 0) {
615 break;
618 if (desc[i].name == NULL) {
619 if (i == 0) {
620 /* empty list -> allow any */;
621 } else {
622 error_set(errp, QERR_INVALID_PARAMETER, name);
623 return;
627 opt = g_malloc0(sizeof(*opt));
628 opt->name = g_strdup(name);
629 opt->opts = opts;
630 if (prepend) {
631 QTAILQ_INSERT_HEAD(&opts->head, opt, next);
632 } else {
633 QTAILQ_INSERT_TAIL(&opts->head, opt, next);
635 if (desc[i].name != NULL) {
636 opt->desc = desc+i;
638 if (value) {
639 opt->str = g_strdup(value);
641 qemu_opt_parse(opt, &local_err);
642 if (error_is_set(&local_err)) {
643 error_propagate(errp, local_err);
644 qemu_opt_del(opt);
648 int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
650 Error *local_err = NULL;
652 opt_set(opts, name, value, false, &local_err);
653 if (error_is_set(&local_err)) {
654 qerror_report_err(local_err);
655 error_free(local_err);
656 return -1;
659 return 0;
662 void qemu_opt_set_err(QemuOpts *opts, const char *name, const char *value,
663 Error **errp)
665 opt_set(opts, name, value, false, errp);
668 int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val)
670 QemuOpt *opt;
671 const QemuOptDesc *desc = opts->list->desc;
672 int i;
674 for (i = 0; desc[i].name != NULL; i++) {
675 if (strcmp(desc[i].name, name) == 0) {
676 break;
679 if (desc[i].name == NULL) {
680 if (i == 0) {
681 /* empty list -> allow any */;
682 } else {
683 qerror_report(QERR_INVALID_PARAMETER, name);
684 return -1;
688 opt = g_malloc0(sizeof(*opt));
689 opt->name = g_strdup(name);
690 opt->opts = opts;
691 QTAILQ_INSERT_TAIL(&opts->head, opt, next);
692 if (desc[i].name != NULL) {
693 opt->desc = desc+i;
695 opt->value.boolean = !!val;
696 return 0;
699 int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
700 int abort_on_failure)
702 QemuOpt *opt;
703 int rc = 0;
705 QTAILQ_FOREACH(opt, &opts->head, next) {
706 rc = func(opt->name, opt->str, opaque);
707 if (abort_on_failure && rc != 0)
708 break;
710 return rc;
713 QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)
715 QemuOpts *opts;
717 QTAILQ_FOREACH(opts, &list->head, next) {
718 if (!opts->id) {
719 if (!id) {
720 return opts;
722 continue;
724 if (strcmp(opts->id, id) != 0) {
725 continue;
727 return opts;
729 return NULL;
732 static int id_wellformed(const char *id)
734 int i;
736 if (!qemu_isalpha(id[0])) {
737 return 0;
739 for (i = 1; id[i]; i++) {
740 if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) {
741 return 0;
744 return 1;
747 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id,
748 int fail_if_exists, Error **errp)
750 QemuOpts *opts = NULL;
752 if (id) {
753 if (!id_wellformed(id)) {
754 error_set(errp,QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
755 error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n");
756 return NULL;
758 opts = qemu_opts_find(list, id);
759 if (opts != NULL) {
760 if (fail_if_exists && !list->merge_lists) {
761 error_set(errp, QERR_DUPLICATE_ID, id, list->name);
762 return NULL;
763 } else {
764 return opts;
767 } else if (list->merge_lists) {
768 opts = qemu_opts_find(list, NULL);
769 if (opts) {
770 return opts;
773 opts = g_malloc0(sizeof(*opts));
774 if (id) {
775 opts->id = g_strdup(id);
777 opts->list = list;
778 loc_save(&opts->loc);
779 QTAILQ_INIT(&opts->head);
780 QTAILQ_INSERT_TAIL(&list->head, opts, next);
781 return opts;
784 void qemu_opts_reset(QemuOptsList *list)
786 QemuOpts *opts, *next_opts;
788 QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) {
789 qemu_opts_del(opts);
793 void qemu_opts_loc_restore(QemuOpts *opts)
795 loc_restore(&opts->loc);
798 int qemu_opts_set(QemuOptsList *list, const char *id,
799 const char *name, const char *value)
801 QemuOpts *opts;
802 Error *local_err = NULL;
804 opts = qemu_opts_create(list, id, 1, &local_err);
805 if (error_is_set(&local_err)) {
806 qerror_report_err(local_err);
807 error_free(local_err);
808 return -1;
810 return qemu_opt_set(opts, name, value);
813 const char *qemu_opts_id(QemuOpts *opts)
815 return opts->id;
818 void qemu_opts_del(QemuOpts *opts)
820 QemuOpt *opt;
822 for (;;) {
823 opt = QTAILQ_FIRST(&opts->head);
824 if (opt == NULL)
825 break;
826 qemu_opt_del(opt);
828 QTAILQ_REMOVE(&opts->list->head, opts, next);
829 g_free(opts->id);
830 g_free(opts);
833 int qemu_opts_print(QemuOpts *opts, void *dummy)
835 QemuOpt *opt;
837 fprintf(stderr, "%s: %s:", opts->list->name,
838 opts->id ? opts->id : "<noid>");
839 QTAILQ_FOREACH(opt, &opts->head, next) {
840 fprintf(stderr, " %s=\"%s\"", opt->name, opt->str);
842 fprintf(stderr, "\n");
843 return 0;
846 static int opts_do_parse(QemuOpts *opts, const char *params,
847 const char *firstname, bool prepend)
849 char option[128], value[1024];
850 const char *p,*pe,*pc;
851 Error *local_err = NULL;
853 for (p = params; *p != '\0'; p++) {
854 pe = strchr(p, '=');
855 pc = strchr(p, ',');
856 if (!pe || (pc && pc < pe)) {
857 /* found "foo,more" */
858 if (p == params && firstname) {
859 /* implicitly named first option */
860 pstrcpy(option, sizeof(option), firstname);
861 p = get_opt_value(value, sizeof(value), p);
862 } else {
863 /* option without value, probably a flag */
864 p = get_opt_name(option, sizeof(option), p, ',');
865 if (strncmp(option, "no", 2) == 0) {
866 memmove(option, option+2, strlen(option+2)+1);
867 pstrcpy(value, sizeof(value), "off");
868 } else {
869 pstrcpy(value, sizeof(value), "on");
872 } else {
873 /* found "foo=bar,more" */
874 p = get_opt_name(option, sizeof(option), p, '=');
875 if (*p != '=') {
876 break;
878 p++;
879 p = get_opt_value(value, sizeof(value), p);
881 if (strcmp(option, "id") != 0) {
882 /* store and parse */
883 opt_set(opts, option, value, prepend, &local_err);
884 if (error_is_set(&local_err)) {
885 qerror_report_err(local_err);
886 error_free(local_err);
887 return -1;
890 if (*p != ',') {
891 break;
894 return 0;
897 int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname)
899 return opts_do_parse(opts, params, firstname, false);
902 static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
903 int permit_abbrev, bool defaults)
905 const char *firstname;
906 char value[1024], *id = NULL;
907 const char *p;
908 QemuOpts *opts;
909 Error *local_err = NULL;
911 assert(!permit_abbrev || list->implied_opt_name);
912 firstname = permit_abbrev ? list->implied_opt_name : NULL;
914 if (strncmp(params, "id=", 3) == 0) {
915 get_opt_value(value, sizeof(value), params+3);
916 id = value;
917 } else if ((p = strstr(params, ",id=")) != NULL) {
918 get_opt_value(value, sizeof(value), p+4);
919 id = value;
921 if (defaults) {
922 if (!id && !QTAILQ_EMPTY(&list->head)) {
923 opts = qemu_opts_find(list, NULL);
924 } else {
925 opts = qemu_opts_create(list, id, 0, &local_err);
927 } else {
928 opts = qemu_opts_create(list, id, 1, &local_err);
930 if (opts == NULL) {
931 if (error_is_set(&local_err)) {
932 qerror_report_err(local_err);
933 error_free(local_err);
935 return NULL;
938 if (opts_do_parse(opts, params, firstname, defaults) != 0) {
939 qemu_opts_del(opts);
940 return NULL;
943 return opts;
946 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
947 int permit_abbrev)
949 return opts_parse(list, params, permit_abbrev, false);
952 void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
953 int permit_abbrev)
955 QemuOpts *opts;
957 opts = opts_parse(list, params, permit_abbrev, true);
958 assert(opts);
961 typedef struct OptsFromQDictState {
962 QemuOpts *opts;
963 Error **errp;
964 } OptsFromQDictState;
966 static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
968 OptsFromQDictState *state = opaque;
969 char buf[32];
970 const char *value;
971 int n;
973 if (!strcmp(key, "id") || error_is_set(state->errp)) {
974 return;
977 switch (qobject_type(obj)) {
978 case QTYPE_QSTRING:
979 value = qstring_get_str(qobject_to_qstring(obj));
980 break;
981 case QTYPE_QINT:
982 n = snprintf(buf, sizeof(buf), "%" PRId64,
983 qint_get_int(qobject_to_qint(obj)));
984 assert(n < sizeof(buf));
985 value = buf;
986 break;
987 case QTYPE_QFLOAT:
988 n = snprintf(buf, sizeof(buf), "%.17g",
989 qfloat_get_double(qobject_to_qfloat(obj)));
990 assert(n < sizeof(buf));
991 value = buf;
992 break;
993 case QTYPE_QBOOL:
994 pstrcpy(buf, sizeof(buf),
995 qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off");
996 value = buf;
997 break;
998 default:
999 return;
1002 qemu_opt_set_err(state->opts, key, value, state->errp);
1006 * Create QemuOpts from a QDict.
1007 * Use value of key "id" as ID if it exists and is a QString.
1008 * Only QStrings, QInts, QFloats and QBools are copied. Entries with
1009 * other types are silently ignored.
1011 QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
1012 Error **errp)
1014 OptsFromQDictState state;
1015 Error *local_err = NULL;
1016 QemuOpts *opts;
1018 opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1,
1019 &local_err);
1020 if (error_is_set(&local_err)) {
1021 error_propagate(errp, local_err);
1022 return NULL;
1025 assert(opts != NULL);
1027 state.errp = &local_err;
1028 state.opts = opts;
1029 qdict_iter(qdict, qemu_opts_from_qdict_1, &state);
1030 if (error_is_set(&local_err)) {
1031 error_propagate(errp, local_err);
1032 qemu_opts_del(opts);
1033 return NULL;
1036 return opts;
1040 * Convert from QemuOpts to QDict.
1041 * The QDict values are of type QString.
1042 * TODO We'll want to use types appropriate for opt->desc->type, but
1043 * this is enough for now.
1045 QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
1047 QemuOpt *opt;
1048 QObject *val;
1050 if (!qdict) {
1051 qdict = qdict_new();
1053 if (opts->id) {
1054 qdict_put(qdict, "id", qstring_from_str(opts->id));
1056 QTAILQ_FOREACH(opt, &opts->head, next) {
1057 val = QOBJECT(qstring_from_str(opt->str));
1058 qdict_put_obj(qdict, opt->name, val);
1060 return qdict;
1063 /* Validate parsed opts against descriptions where no
1064 * descriptions were provided in the QemuOptsList.
1066 void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp)
1068 QemuOpt *opt;
1069 Error *local_err = NULL;
1071 assert(opts->list->desc[0].name == NULL);
1073 QTAILQ_FOREACH(opt, &opts->head, next) {
1074 int i;
1076 for (i = 0; desc[i].name != NULL; i++) {
1077 if (strcmp(desc[i].name, opt->name) == 0) {
1078 break;
1081 if (desc[i].name == NULL) {
1082 error_set(errp, QERR_INVALID_PARAMETER, opt->name);
1083 return;
1086 opt->desc = &desc[i];
1088 qemu_opt_parse(opt, &local_err);
1089 if (error_is_set(&local_err)) {
1090 error_propagate(errp, local_err);
1091 return;
1096 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
1097 int abort_on_failure)
1099 Location loc;
1100 QemuOpts *opts;
1101 int rc = 0;
1103 loc_push_none(&loc);
1104 QTAILQ_FOREACH(opts, &list->head, next) {
1105 loc_restore(&opts->loc);
1106 rc |= func(opts, opaque);
1107 if (abort_on_failure && rc != 0)
1108 break;
1110 loc_pop(&loc);
1111 return rc;