blob: 26ea248062d86727a6fd333ef3ed9bd53b1141bf [file] [log] [blame]
Peter Maydellaafd7582016-01-29 17:49:55 +00001#include "qemu/osdep.h"
Markus Armbrustere688df62018-02-01 12:18:31 +01002#include "qapi/error.h"
Gerd Hoffmann7282a032009-07-31 12:25:35 +02003#include "qemu-common.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +01004#include "qemu/error-report.h"
5#include "qemu/option.h"
6#include "qemu/config-file.h"
Amos Kong1f8f9872013-04-25 17:50:35 +08007#include "qmp-commands.h"
Gerd Hoffmann7282a032009-07-31 12:25:35 +02008
Gerd Hoffmann1ceaefb2015-05-29 14:37:54 +02009static QemuOptsList *vm_config_groups[48];
Kevin Wolfc5f30142016-10-06 11:33:17 +020010static QemuOptsList *drive_config_groups[5];
Gerd Hoffmannd058fe02009-07-31 12:25:36 +020011
Luiz Capitulino2ac20612012-03-28 14:14:17 -030012static QemuOptsList *find_list(QemuOptsList **lists, const char *group,
13 Error **errp)
Gerd Hoffmannd058fe02009-07-31 12:25:36 +020014{
Gerd Hoffmannddc97852009-10-14 10:39:25 +020015 int i;
Gerd Hoffmannd058fe02009-07-31 12:25:36 +020016
17 for (i = 0; lists[i] != NULL; i++) {
18 if (strcmp(lists[i]->name, group) == 0)
19 break;
20 }
21 if (lists[i] == NULL) {
Cole Robinsonf231b882014-03-21 19:42:26 -040022 error_setg(errp, "There is no option group '%s'", group);
Gerd Hoffmannddc97852009-10-14 10:39:25 +020023 }
24 return lists[i];
25}
26
Kevin Wolf490b6482010-03-05 18:21:56 +010027QemuOptsList *qemu_find_opts(const char *group)
28{
Luiz Capitulino2ac20612012-03-28 14:14:17 -030029 QemuOptsList *ret;
30 Error *local_err = NULL;
31
32 ret = find_list(vm_config_groups, group, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +010033 if (local_err) {
Markus Armbruster565f65d2015-02-12 13:55:05 +010034 error_report_err(local_err);
Luiz Capitulino2ac20612012-03-28 14:14:17 -030035 }
36
37 return ret;
Kevin Wolf490b6482010-03-05 18:21:56 +010038}
39
Paolo Bonzinie96e5ae2014-03-06 10:39:24 +010040QemuOpts *qemu_find_opts_singleton(const char *group)
41{
42 QemuOptsList *list;
43 QemuOpts *opts;
44
45 list = qemu_find_opts(group);
46 assert(list);
47 opts = qemu_opts_find(list, NULL);
48 if (!opts) {
49 opts = qemu_opts_create(list, NULL, 0, &error_abort);
50 }
51 return opts;
52}
53
Amos Kong1f8f9872013-04-25 17:50:35 +080054static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc)
55{
56 CommandLineParameterInfoList *param_list = NULL, *entry;
57 CommandLineParameterInfo *info;
58 int i;
59
60 for (i = 0; desc[i].name != NULL; i++) {
61 info = g_malloc0(sizeof(*info));
62 info->name = g_strdup(desc[i].name);
63
64 switch (desc[i].type) {
65 case QEMU_OPT_STRING:
66 info->type = COMMAND_LINE_PARAMETER_TYPE_STRING;
67 break;
68 case QEMU_OPT_BOOL:
69 info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN;
70 break;
71 case QEMU_OPT_NUMBER:
72 info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER;
73 break;
74 case QEMU_OPT_SIZE:
75 info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE;
76 break;
77 }
78
79 if (desc[i].help) {
80 info->has_help = true;
81 info->help = g_strdup(desc[i].help);
82 }
Chunyan Liue36af942014-06-05 17:20:43 +080083 if (desc[i].def_value_str) {
84 info->has_q_default = true;
85 info->q_default = g_strdup(desc[i].def_value_str);
86 }
Amos Kong1f8f9872013-04-25 17:50:35 +080087
88 entry = g_malloc0(sizeof(*entry));
89 entry->value = info;
90 entry->next = param_list;
91 param_list = entry;
92 }
93
94 return param_list;
95}
96
Amos Kong968854c2013-11-09 12:15:47 +080097/* remove repeated entry from the info list */
98static void cleanup_infolist(CommandLineParameterInfoList *head)
99{
100 CommandLineParameterInfoList *pre_entry, *cur, *del_entry;
101
102 cur = head;
103 while (cur->next) {
104 pre_entry = head;
105 while (pre_entry != cur->next) {
106 if (!strcmp(pre_entry->value->name, cur->next->value->name)) {
107 del_entry = cur->next;
108 cur->next = cur->next->next;
Marc-André Lureaub11e20f2018-01-04 17:05:18 +0100109 del_entry->next = NULL;
110 qapi_free_CommandLineParameterInfoList(del_entry);
Amos Kong968854c2013-11-09 12:15:47 +0800111 break;
112 }
113 pre_entry = pre_entry->next;
114 }
115 cur = cur->next;
116 }
117}
118
119/* merge the description items of two parameter infolists */
120static void connect_infolist(CommandLineParameterInfoList *head,
121 CommandLineParameterInfoList *new)
122{
123 CommandLineParameterInfoList *cur;
124
125 cur = head;
126 while (cur->next) {
127 cur = cur->next;
128 }
129 cur->next = new;
130}
131
132/* access all the local QemuOptsLists for drive option */
133static CommandLineParameterInfoList *get_drive_infolist(void)
134{
135 CommandLineParameterInfoList *head = NULL, *cur;
136 int i;
137
138 for (i = 0; drive_config_groups[i] != NULL; i++) {
139 if (!head) {
140 head = query_option_descs(drive_config_groups[i]->desc);
141 } else {
142 cur = query_option_descs(drive_config_groups[i]->desc);
143 connect_infolist(head, cur);
144 }
145 }
146 cleanup_infolist(head);
147
148 return head;
149}
150
Marcel Apfelbaum0a7cf212015-04-01 19:47:21 +0300151/* restore machine options that are now machine's properties */
152static QemuOptsList machine_opts = {
153 .merge_lists = true,
154 .head = QTAILQ_HEAD_INITIALIZER(machine_opts.head),
155 .desc = {
156 {
157 .name = "type",
158 .type = QEMU_OPT_STRING,
159 .help = "emulated machine"
160 },{
161 .name = "accel",
162 .type = QEMU_OPT_STRING,
163 .help = "accelerator list",
164 },{
165 .name = "kernel_irqchip",
166 .type = QEMU_OPT_BOOL,
167 .help = "use KVM in-kernel irqchip",
168 },{
169 .name = "kvm_shadow_mem",
170 .type = QEMU_OPT_SIZE,
171 .help = "KVM shadow MMU size",
172 },{
173 .name = "kernel",
174 .type = QEMU_OPT_STRING,
175 .help = "Linux kernel image file",
176 },{
177 .name = "initrd",
178 .type = QEMU_OPT_STRING,
179 .help = "Linux initial ramdisk file",
180 },{
181 .name = "append",
182 .type = QEMU_OPT_STRING,
183 .help = "Linux kernel command line",
184 },{
185 .name = "dtb",
186 .type = QEMU_OPT_STRING,
187 .help = "Linux kernel device tree file",
188 },{
189 .name = "dumpdtb",
190 .type = QEMU_OPT_STRING,
191 .help = "Dump current dtb to a file and quit",
192 },{
193 .name = "phandle_start",
194 .type = QEMU_OPT_NUMBER,
195 .help = "The first phandle ID we may generate dynamically",
196 },{
197 .name = "dt_compatible",
198 .type = QEMU_OPT_STRING,
199 .help = "Overrides the \"compatible\" property of the dt root node",
200 },{
201 .name = "dump-guest-core",
202 .type = QEMU_OPT_BOOL,
203 .help = "Include guest memory in a core dump",
204 },{
205 .name = "mem-merge",
206 .type = QEMU_OPT_BOOL,
207 .help = "enable/disable memory merge support",
208 },{
209 .name = "usb",
210 .type = QEMU_OPT_BOOL,
211 .help = "Set on/off to enable/disable usb",
212 },{
213 .name = "firmware",
214 .type = QEMU_OPT_STRING,
215 .help = "firmware image",
216 },{
217 .name = "iommu",
218 .type = QEMU_OPT_BOOL,
219 .help = "Set on/off to enable/disable Intel IOMMU (VT-d)",
220 },{
221 .name = "suppress-vmdesc",
222 .type = QEMU_OPT_BOOL,
223 .help = "Set on to disable self-describing migration",
Tony Krowiak5bcfa0c2015-10-12 11:36:21 -0400224 },{
225 .name = "aes-key-wrap",
226 .type = QEMU_OPT_BOOL,
227 .help = "enable/disable AES key wrapping using the CPACF wrapping key",
228 },{
229 .name = "dea-key-wrap",
230 .type = QEMU_OPT_BOOL,
231 .help = "enable/disable DEA key wrapping using the CPACF wrapping key",
Farhan Ali55597162016-12-15 13:44:29 -0500232 },{
233 .name = "loadparm",
234 .type = QEMU_OPT_STRING,
235 .help = "Up to 8 chars in set of [A-Za-z0-9. ](lower case chars"
236 " converted to upper case) to pass to machine"
237 " loader, boot manager, and guest kernel",
Marcel Apfelbaum0a7cf212015-04-01 19:47:21 +0300238 },
239 { /* End of list */ }
240 }
241};
242
Amos Kong1f8f9872013-04-25 17:50:35 +0800243CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option,
244 const char *option,
245 Error **errp)
246{
247 CommandLineOptionInfoList *conf_list = NULL, *entry;
248 CommandLineOptionInfo *info;
249 int i;
250
251 for (i = 0; vm_config_groups[i] != NULL; i++) {
252 if (!has_option || !strcmp(option, vm_config_groups[i]->name)) {
253 info = g_malloc0(sizeof(*info));
254 info->option = g_strdup(vm_config_groups[i]->name);
Amos Kong968854c2013-11-09 12:15:47 +0800255 if (!strcmp("drive", vm_config_groups[i]->name)) {
256 info->parameters = get_drive_infolist();
Marcel Apfelbaum0a7cf212015-04-01 19:47:21 +0300257 } else if (!strcmp("machine", vm_config_groups[i]->name)) {
258 info->parameters = query_option_descs(machine_opts.desc);
Amos Kong968854c2013-11-09 12:15:47 +0800259 } else {
260 info->parameters =
261 query_option_descs(vm_config_groups[i]->desc);
262 }
Amos Kong1f8f9872013-04-25 17:50:35 +0800263 entry = g_malloc0(sizeof(*entry));
264 entry->value = info;
265 entry->next = conf_list;
266 conf_list = entry;
267 }
268 }
269
270 if (conf_list == NULL) {
271 error_setg(errp, "invalid option name: %s", option);
272 }
273
274 return conf_list;
275}
276
Luiz Capitulino60d56662012-03-28 14:16:37 -0300277QemuOptsList *qemu_find_opts_err(const char *group, Error **errp)
278{
279 return find_list(vm_config_groups, group, errp);
280}
281
Amos Kong968854c2013-11-09 12:15:47 +0800282void qemu_add_drive_opts(QemuOptsList *list)
283{
284 int entries, i;
285
286 entries = ARRAY_SIZE(drive_config_groups);
287 entries--; /* keep list NULL terminated */
288 for (i = 0; i < entries; i++) {
289 if (drive_config_groups[i] == NULL) {
290 drive_config_groups[i] = list;
291 return;
292 }
293 }
294 fprintf(stderr, "ran out of space in drive_config_groups");
295 abort();
296}
297
Gerd Hoffmanndfe795e2010-08-20 13:52:00 +0200298void qemu_add_opts(QemuOptsList *list)
299{
300 int entries, i;
301
302 entries = ARRAY_SIZE(vm_config_groups);
303 entries--; /* keep list NULL terminated */
304 for (i = 0; i < entries; i++) {
305 if (vm_config_groups[i] == NULL) {
306 vm_config_groups[i] = list;
307 return;
308 }
309 }
310 fprintf(stderr, "ran out of space in vm_config_groups");
311 abort();
312}
313
Gerd Hoffmannddc97852009-10-14 10:39:25 +0200314int qemu_set_option(const char *str)
315{
Markus Armbrusterf43e47d2015-02-12 17:52:20 +0100316 Error *local_err = NULL;
Gerd Hoffmannddc97852009-10-14 10:39:25 +0200317 char group[64], id[64], arg[64];
318 QemuOptsList *list;
319 QemuOpts *opts;
320 int rc, offset;
321
322 rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
323 if (rc < 3 || str[offset] != '=') {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100324 error_report("can't parse: \"%s\"", str);
Gerd Hoffmannd058fe02009-07-31 12:25:36 +0200325 return -1;
326 }
327
Markus Armbruster304329e2010-02-10 20:09:14 +0100328 list = qemu_find_opts(group);
Gerd Hoffmannddc97852009-10-14 10:39:25 +0200329 if (list == NULL) {
330 return -1;
331 }
332
333 opts = qemu_opts_find(list, id);
Gerd Hoffmannd058fe02009-07-31 12:25:36 +0200334 if (!opts) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100335 error_report("there is no %s \"%s\" defined",
336 list->name, id);
Gerd Hoffmannd058fe02009-07-31 12:25:36 +0200337 return -1;
338 }
339
Markus Armbrusterf43e47d2015-02-12 17:52:20 +0100340 qemu_opt_set(opts, arg, str + offset + 1, &local_err);
341 if (local_err) {
342 error_report_err(local_err);
Gerd Hoffmannd058fe02009-07-31 12:25:36 +0200343 return -1;
344 }
345 return 0;
346}
347
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200348struct ConfigWriteData {
349 QemuOptsList *list;
350 FILE *fp;
351};
352
Markus Armbruster71df1d82015-03-12 08:40:25 +0100353static int config_write_opt(void *opaque, const char *name, const char *value,
354 Error **errp)
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200355{
356 struct ConfigWriteData *data = opaque;
357
358 fprintf(data->fp, " %s = \"%s\"\n", name, value);
359 return 0;
360}
361
Markus Armbruster28d0de72015-03-13 13:35:14 +0100362static int config_write_opts(void *opaque, QemuOpts *opts, Error **errp)
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200363{
364 struct ConfigWriteData *data = opaque;
365 const char *id = qemu_opts_id(opts);
366
367 if (id) {
368 fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id);
369 } else {
370 fprintf(data->fp, "[%s]\n", data->list->name);
371 }
Markus Armbruster71df1d82015-03-12 08:40:25 +0100372 qemu_opt_foreach(opts, config_write_opt, data, NULL);
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200373 fprintf(data->fp, "\n");
374 return 0;
375}
376
377void qemu_config_write(FILE *fp)
378{
379 struct ConfigWriteData data = { .fp = fp };
Kevin Wolf490b6482010-03-05 18:21:56 +0100380 QemuOptsList **lists = vm_config_groups;
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200381 int i;
382
383 fprintf(fp, "# qemu config file\n\n");
384 for (i = 0; lists[i] != NULL; i++) {
385 data.list = lists[i];
Markus Armbruster28d0de72015-03-13 13:35:14 +0100386 qemu_opts_foreach(data.list, config_write_opts, &data, NULL);
Gerd Hoffmann9d993392009-10-14 10:39:26 +0200387 }
388}
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200389
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300390/* Returns number of config groups on success, -errno on error */
Kevin Wolf490b6482010-03-05 18:21:56 +0100391int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200392{
393 char line[1024], group[64], id[64], arg[64], value[1024];
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100394 Location loc;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200395 QemuOptsList *list = NULL;
Luiz Capitulino2ac20612012-03-28 14:14:17 -0300396 Error *local_err = NULL;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200397 QemuOpts *opts = NULL;
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300398 int res = -EINVAL, lno = 0;
399 int count = 0;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200400
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100401 loc_push_none(&loc);
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200402 while (fgets(line, sizeof(line), fp) != NULL) {
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100403 loc_set_file(fname, ++lno);
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200404 if (line[0] == '\n') {
405 /* skip empty lines */
406 continue;
407 }
408 if (line[0] == '#') {
409 /* comment */
410 continue;
411 }
412 if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) {
413 /* group with id */
Luiz Capitulino2ac20612012-03-28 14:14:17 -0300414 list = find_list(lists, group, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100415 if (local_err) {
Markus Armbruster565f65d2015-02-12 13:55:05 +0100416 error_report_err(local_err);
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100417 goto out;
Luiz Capitulino2ac20612012-03-28 14:14:17 -0300418 }
Luiz Capitulino8be7e7e2012-03-20 15:51:57 -0300419 opts = qemu_opts_create(list, id, 1, NULL);
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300420 count++;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200421 continue;
422 }
423 if (sscanf(line, "[%63[^]]]", group) == 1) {
424 /* group without id */
Luiz Capitulino2ac20612012-03-28 14:14:17 -0300425 list = find_list(lists, group, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100426 if (local_err) {
Markus Armbruster565f65d2015-02-12 13:55:05 +0100427 error_report_err(local_err);
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100428 goto out;
Luiz Capitulino2ac20612012-03-28 14:14:17 -0300429 }
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -0800430 opts = qemu_opts_create(list, NULL, 0, &error_abort);
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300431 count++;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200432 continue;
433 }
Eduardo Habkostd9f7e292015-04-08 14:57:31 -0300434 value[0] = '\0';
435 if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 ||
436 sscanf(line, " %63s = \"\"", arg) == 1) {
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200437 /* arg = value */
438 if (opts == NULL) {
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100439 error_report("no group defined");
440 goto out;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200441 }
Markus Armbrusterf43e47d2015-02-12 17:52:20 +0100442 qemu_opt_set(opts, arg, value, &local_err);
443 if (local_err) {
444 error_report_err(local_err);
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100445 goto out;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200446 }
447 continue;
448 }
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100449 error_report("parse error");
450 goto out;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200451 }
Markus Armbrusteref825162010-02-18 19:56:01 +0100452 if (ferror(fp)) {
453 error_report("error reading file");
454 goto out;
455 }
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300456 res = count;
Markus Armbrustercf5a65a2010-02-18 19:48:33 +0100457out:
458 loc_pop(&loc);
459 return res;
Gerd Hoffmann42262ba2009-10-14 10:39:27 +0200460}
Kevin Wolfdcfb0932010-03-05 17:25:55 +0100461
462int qemu_read_config_file(const char *filename)
463{
464 FILE *f = fopen(filename, "r");
Kevin Wolf019e78b2010-05-17 10:36:47 +0200465 int ret;
466
Kevin Wolfdcfb0932010-03-05 17:25:55 +0100467 if (f == NULL) {
468 return -errno;
469 }
470
Kevin Wolf019e78b2010-05-17 10:36:47 +0200471 ret = qemu_config_parse(f, vm_config_groups, filename);
Kevin Wolfdcfb0932010-03-05 17:25:55 +0100472 fclose(f);
Eduardo Habkoste5766d62017-10-03 23:50:42 -0300473 return ret;
Kevin Wolfdcfb0932010-03-05 17:25:55 +0100474}
Max Reitzadf5c442013-12-20 19:28:05 +0100475
476static void config_parse_qdict_section(QDict *options, QemuOptsList *opts,
477 Error **errp)
478{
479 QemuOpts *subopts;
480 QDict *subqdict;
481 QList *list = NULL;
482 Error *local_err = NULL;
483 size_t orig_size, enum_size;
484 char *prefix;
485
486 prefix = g_strdup_printf("%s.", opts->name);
487 qdict_extract_subqdict(options, &subqdict, prefix);
488 g_free(prefix);
489 orig_size = qdict_size(subqdict);
490 if (!orig_size) {
491 goto out;
492 }
493
494 subopts = qemu_opts_create(opts, NULL, 0, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100495 if (local_err) {
Max Reitzadf5c442013-12-20 19:28:05 +0100496 error_propagate(errp, local_err);
497 goto out;
498 }
499
500 qemu_opts_absorb_qdict(subopts, subqdict, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100501 if (local_err) {
Max Reitzadf5c442013-12-20 19:28:05 +0100502 error_propagate(errp, local_err);
503 goto out;
504 }
505
506 enum_size = qdict_size(subqdict);
507 if (enum_size < orig_size && enum_size) {
508 error_setg(errp, "Unknown option '%s' for [%s]",
509 qdict_first(subqdict)->key, opts->name);
510 goto out;
511 }
512
513 if (enum_size) {
514 /* Multiple, enumerated sections */
515 QListEntry *list_entry;
516 unsigned i = 0;
517
518 /* Not required anymore */
519 qemu_opts_del(subopts);
520
521 qdict_array_split(subqdict, &list);
522 if (qdict_size(subqdict)) {
523 error_setg(errp, "Unused option '%s' for [%s]",
524 qdict_first(subqdict)->key, opts->name);
525 goto out;
526 }
527
528 QLIST_FOREACH_ENTRY(list, list_entry) {
529 QDict *section = qobject_to_qdict(qlist_entry_obj(list_entry));
530 char *opt_name;
531
Max Reitzae39c4b2014-02-21 19:11:39 +0100532 if (!section) {
533 error_setg(errp, "[%s] section (index %u) does not consist of "
534 "keys", opts->name, i);
535 goto out;
536 }
537
Max Reitzadf5c442013-12-20 19:28:05 +0100538 opt_name = g_strdup_printf("%s.%u", opts->name, i++);
539 subopts = qemu_opts_create(opts, opt_name, 1, &local_err);
540 g_free(opt_name);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100541 if (local_err) {
Max Reitzadf5c442013-12-20 19:28:05 +0100542 error_propagate(errp, local_err);
543 goto out;
544 }
545
546 qemu_opts_absorb_qdict(subopts, section, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100547 if (local_err) {
Max Reitzadf5c442013-12-20 19:28:05 +0100548 error_propagate(errp, local_err);
549 qemu_opts_del(subopts);
550 goto out;
551 }
552
553 if (qdict_size(section)) {
554 error_setg(errp, "[%s] section doesn't support the option '%s'",
555 opts->name, qdict_first(section)->key);
556 qemu_opts_del(subopts);
557 goto out;
558 }
559 }
560 }
561
562out:
563 QDECREF(subqdict);
564 QDECREF(list);
565}
566
567void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists,
568 Error **errp)
569{
570 int i;
571 Error *local_err = NULL;
572
573 for (i = 0; lists[i]; i++) {
574 config_parse_qdict_section(options, lists[i], &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100575 if (local_err) {
Max Reitzadf5c442013-12-20 19:28:05 +0100576 error_propagate(errp, local_err);
577 return;
578 }
579 }
580}