]>
Commit | Line | Data |
---|---|---|
1 | #include "qemu/osdep.h" | |
2 | #include "block/qdict.h" /* for qdict_extract_subqdict() */ | |
3 | #include "qapi/error.h" | |
4 | #include "qapi/qapi-commands-misc.h" | |
5 | #include "qapi/qmp/qerror.h" | |
6 | #include "qapi/qmp/qdict.h" | |
7 | #include "qapi/qmp/qlist.h" | |
8 | #include "qemu/error-report.h" | |
9 | #include "qemu/option.h" | |
10 | #include "qemu/config-file.h" | |
11 | ||
12 | static QemuOptsList *vm_config_groups[48]; | |
13 | static QemuOptsList *drive_config_groups[5]; | |
14 | ||
15 | static QemuOptsList *find_list(QemuOptsList **lists, const char *group, | |
16 | Error **errp) | |
17 | { | |
18 | int i; | |
19 | ||
20 | qemu_load_module_for_opts(group); | |
21 | for (i = 0; lists[i] != NULL; i++) { | |
22 | if (strcmp(lists[i]->name, group) == 0) | |
23 | break; | |
24 | } | |
25 | if (lists[i] == NULL) { | |
26 | error_setg(errp, "There is no option group '%s'", group); | |
27 | } | |
28 | return lists[i]; | |
29 | } | |
30 | ||
31 | QemuOptsList *qemu_find_opts(const char *group) | |
32 | { | |
33 | QemuOptsList *ret; | |
34 | Error *local_err = NULL; | |
35 | ||
36 | ret = find_list(vm_config_groups, group, &local_err); | |
37 | if (local_err) { | |
38 | error_report_err(local_err); | |
39 | } | |
40 | ||
41 | return ret; | |
42 | } | |
43 | ||
44 | QemuOpts *qemu_find_opts_singleton(const char *group) | |
45 | { | |
46 | QemuOptsList *list; | |
47 | QemuOpts *opts; | |
48 | ||
49 | list = qemu_find_opts(group); | |
50 | assert(list); | |
51 | opts = qemu_opts_find(list, NULL); | |
52 | if (!opts) { | |
53 | opts = qemu_opts_create(list, NULL, 0, &error_abort); | |
54 | } | |
55 | return opts; | |
56 | } | |
57 | ||
58 | static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc) | |
59 | { | |
60 | CommandLineParameterInfoList *param_list = NULL; | |
61 | CommandLineParameterInfo *info; | |
62 | int i; | |
63 | ||
64 | for (i = 0; desc[i].name != NULL; i++) { | |
65 | info = g_malloc0(sizeof(*info)); | |
66 | info->name = g_strdup(desc[i].name); | |
67 | ||
68 | switch (desc[i].type) { | |
69 | case QEMU_OPT_STRING: | |
70 | info->type = COMMAND_LINE_PARAMETER_TYPE_STRING; | |
71 | break; | |
72 | case QEMU_OPT_BOOL: | |
73 | info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN; | |
74 | break; | |
75 | case QEMU_OPT_NUMBER: | |
76 | info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER; | |
77 | break; | |
78 | case QEMU_OPT_SIZE: | |
79 | info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE; | |
80 | break; | |
81 | } | |
82 | ||
83 | if (desc[i].help) { | |
84 | info->has_help = true; | |
85 | info->help = g_strdup(desc[i].help); | |
86 | } | |
87 | if (desc[i].def_value_str) { | |
88 | info->has_q_default = true; | |
89 | info->q_default = g_strdup(desc[i].def_value_str); | |
90 | } | |
91 | ||
92 | QAPI_LIST_PREPEND(param_list, info); | |
93 | } | |
94 | ||
95 | return param_list; | |
96 | } | |
97 | ||
98 | /* remove repeated entry from the info list */ | |
99 | static void cleanup_infolist(CommandLineParameterInfoList *head) | |
100 | { | |
101 | CommandLineParameterInfoList *pre_entry, *cur, *del_entry; | |
102 | ||
103 | cur = head; | |
104 | while (cur->next) { | |
105 | pre_entry = head; | |
106 | while (pre_entry != cur->next) { | |
107 | if (!strcmp(pre_entry->value->name, cur->next->value->name)) { | |
108 | del_entry = cur->next; | |
109 | cur->next = cur->next->next; | |
110 | del_entry->next = NULL; | |
111 | qapi_free_CommandLineParameterInfoList(del_entry); | |
112 | break; | |
113 | } | |
114 | pre_entry = pre_entry->next; | |
115 | } | |
116 | cur = cur->next; | |
117 | } | |
118 | } | |
119 | ||
120 | /* merge the description items of two parameter infolists */ | |
121 | static void connect_infolist(CommandLineParameterInfoList *head, | |
122 | CommandLineParameterInfoList *new) | |
123 | { | |
124 | CommandLineParameterInfoList *cur; | |
125 | ||
126 | cur = head; | |
127 | while (cur->next) { | |
128 | cur = cur->next; | |
129 | } | |
130 | cur->next = new; | |
131 | } | |
132 | ||
133 | /* access all the local QemuOptsLists for drive option */ | |
134 | static CommandLineParameterInfoList *get_drive_infolist(void) | |
135 | { | |
136 | CommandLineParameterInfoList *head = NULL, *cur; | |
137 | int i; | |
138 | ||
139 | for (i = 0; drive_config_groups[i] != NULL; i++) { | |
140 | if (!head) { | |
141 | head = query_option_descs(drive_config_groups[i]->desc); | |
142 | } else { | |
143 | cur = query_option_descs(drive_config_groups[i]->desc); | |
144 | connect_infolist(head, cur); | |
145 | } | |
146 | } | |
147 | cleanup_infolist(head); | |
148 | ||
149 | return head; | |
150 | } | |
151 | ||
152 | /* restore machine options that are now machine's properties */ | |
153 | static QemuOptsList machine_opts = { | |
154 | .merge_lists = true, | |
155 | .head = QTAILQ_HEAD_INITIALIZER(machine_opts.head), | |
156 | .desc = { | |
157 | { | |
158 | .name = "type", | |
159 | .type = QEMU_OPT_STRING, | |
160 | .help = "emulated machine" | |
161 | },{ | |
162 | .name = "accel", | |
163 | .type = QEMU_OPT_STRING, | |
164 | .help = "accelerator list", | |
165 | },{ | |
166 | .name = "kernel_irqchip", | |
167 | .type = QEMU_OPT_BOOL, | |
168 | .help = "use KVM in-kernel irqchip", | |
169 | },{ | |
170 | .name = "kvm_shadow_mem", | |
171 | .type = QEMU_OPT_SIZE, | |
172 | .help = "KVM shadow MMU size", | |
173 | },{ | |
174 | .name = "kernel", | |
175 | .type = QEMU_OPT_STRING, | |
176 | .help = "Linux kernel image file", | |
177 | },{ | |
178 | .name = "initrd", | |
179 | .type = QEMU_OPT_STRING, | |
180 | .help = "Linux initial ramdisk file", | |
181 | },{ | |
182 | .name = "append", | |
183 | .type = QEMU_OPT_STRING, | |
184 | .help = "Linux kernel command line", | |
185 | },{ | |
186 | .name = "dtb", | |
187 | .type = QEMU_OPT_STRING, | |
188 | .help = "Linux kernel device tree file", | |
189 | },{ | |
190 | .name = "dumpdtb", | |
191 | .type = QEMU_OPT_STRING, | |
192 | .help = "Dump current dtb to a file and quit", | |
193 | },{ | |
194 | .name = "phandle_start", | |
195 | .type = QEMU_OPT_NUMBER, | |
196 | .help = "The first phandle ID we may generate dynamically", | |
197 | },{ | |
198 | .name = "dt_compatible", | |
199 | .type = QEMU_OPT_STRING, | |
200 | .help = "Overrides the \"compatible\" property of the dt root node", | |
201 | },{ | |
202 | .name = "dump-guest-core", | |
203 | .type = QEMU_OPT_BOOL, | |
204 | .help = "Include guest memory in a core dump", | |
205 | },{ | |
206 | .name = "mem-merge", | |
207 | .type = QEMU_OPT_BOOL, | |
208 | .help = "enable/disable memory merge support", | |
209 | },{ | |
210 | .name = "usb", | |
211 | .type = QEMU_OPT_BOOL, | |
212 | .help = "Set on/off to enable/disable usb", | |
213 | },{ | |
214 | .name = "firmware", | |
215 | .type = QEMU_OPT_STRING, | |
216 | .help = "firmware image", | |
217 | },{ | |
218 | .name = "iommu", | |
219 | .type = QEMU_OPT_BOOL, | |
220 | .help = "Set on/off to enable/disable Intel IOMMU (VT-d)", | |
221 | },{ | |
222 | .name = "suppress-vmdesc", | |
223 | .type = QEMU_OPT_BOOL, | |
224 | .help = "Set on to disable self-describing migration", | |
225 | },{ | |
226 | .name = "aes-key-wrap", | |
227 | .type = QEMU_OPT_BOOL, | |
228 | .help = "enable/disable AES key wrapping using the CPACF wrapping key", | |
229 | },{ | |
230 | .name = "dea-key-wrap", | |
231 | .type = QEMU_OPT_BOOL, | |
232 | .help = "enable/disable DEA key wrapping using the CPACF wrapping key", | |
233 | },{ | |
234 | .name = "loadparm", | |
235 | .type = QEMU_OPT_STRING, | |
236 | .help = "Up to 8 chars in set of [A-Za-z0-9. ](lower case chars" | |
237 | " converted to upper case) to pass to machine" | |
238 | " loader, boot manager, and guest kernel", | |
239 | }, | |
240 | { /* End of list */ } | |
241 | } | |
242 | }; | |
243 | ||
244 | CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option, | |
245 | const char *option, | |
246 | Error **errp) | |
247 | { | |
248 | CommandLineOptionInfoList *conf_list = NULL; | |
249 | CommandLineOptionInfo *info; | |
250 | int i; | |
251 | ||
252 | for (i = 0; vm_config_groups[i] != NULL; i++) { | |
253 | if (!has_option || !strcmp(option, vm_config_groups[i]->name)) { | |
254 | info = g_malloc0(sizeof(*info)); | |
255 | info->option = g_strdup(vm_config_groups[i]->name); | |
256 | if (!strcmp("drive", vm_config_groups[i]->name)) { | |
257 | info->parameters = get_drive_infolist(); | |
258 | } else if (!strcmp("machine", vm_config_groups[i]->name)) { | |
259 | info->parameters = query_option_descs(machine_opts.desc); | |
260 | } else { | |
261 | info->parameters = | |
262 | query_option_descs(vm_config_groups[i]->desc); | |
263 | } | |
264 | QAPI_LIST_PREPEND(conf_list, info); | |
265 | } | |
266 | } | |
267 | ||
268 | if (conf_list == NULL) { | |
269 | error_setg(errp, "invalid option name: %s", option); | |
270 | } | |
271 | ||
272 | return conf_list; | |
273 | } | |
274 | ||
275 | QemuOptsList *qemu_find_opts_err(const char *group, Error **errp) | |
276 | { | |
277 | return find_list(vm_config_groups, group, errp); | |
278 | } | |
279 | ||
280 | void qemu_add_drive_opts(QemuOptsList *list) | |
281 | { | |
282 | int entries, i; | |
283 | ||
284 | entries = ARRAY_SIZE(drive_config_groups); | |
285 | entries--; /* keep list NULL terminated */ | |
286 | for (i = 0; i < entries; i++) { | |
287 | if (drive_config_groups[i] == NULL) { | |
288 | drive_config_groups[i] = list; | |
289 | return; | |
290 | } | |
291 | } | |
292 | fprintf(stderr, "ran out of space in drive_config_groups"); | |
293 | abort(); | |
294 | } | |
295 | ||
296 | void qemu_add_opts(QemuOptsList *list) | |
297 | { | |
298 | int entries, i; | |
299 | ||
300 | entries = ARRAY_SIZE(vm_config_groups); | |
301 | entries--; /* keep list NULL terminated */ | |
302 | for (i = 0; i < entries; i++) { | |
303 | if (vm_config_groups[i] == NULL) { | |
304 | vm_config_groups[i] = list; | |
305 | return; | |
306 | } | |
307 | } | |
308 | fprintf(stderr, "ran out of space in vm_config_groups"); | |
309 | abort(); | |
310 | } | |
311 | ||
312 | struct ConfigWriteData { | |
313 | QemuOptsList *list; | |
314 | FILE *fp; | |
315 | }; | |
316 | ||
317 | static int config_write_opt(void *opaque, const char *name, const char *value, | |
318 | Error **errp) | |
319 | { | |
320 | struct ConfigWriteData *data = opaque; | |
321 | ||
322 | fprintf(data->fp, " %s = \"%s\"\n", name, value); | |
323 | return 0; | |
324 | } | |
325 | ||
326 | static int config_write_opts(void *opaque, QemuOpts *opts, Error **errp) | |
327 | { | |
328 | struct ConfigWriteData *data = opaque; | |
329 | const char *id = qemu_opts_id(opts); | |
330 | ||
331 | if (id) { | |
332 | fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id); | |
333 | } else { | |
334 | fprintf(data->fp, "[%s]\n", data->list->name); | |
335 | } | |
336 | qemu_opt_foreach(opts, config_write_opt, data, NULL); | |
337 | fprintf(data->fp, "\n"); | |
338 | return 0; | |
339 | } | |
340 | ||
341 | void qemu_config_write(FILE *fp) | |
342 | { | |
343 | struct ConfigWriteData data = { .fp = fp }; | |
344 | QemuOptsList **lists = vm_config_groups; | |
345 | int i; | |
346 | ||
347 | fprintf(fp, "# qemu config file\n\n"); | |
348 | for (i = 0; lists[i] != NULL; i++) { | |
349 | data.list = lists[i]; | |
350 | qemu_opts_foreach(data.list, config_write_opts, &data, NULL); | |
351 | } | |
352 | } | |
353 | ||
354 | /* Returns number of config groups on success, -errno on error */ | |
355 | static int qemu_config_foreach(FILE *fp, QEMUConfigCB *cb, void *opaque, | |
356 | const char *fname, Error **errp) | |
357 | { | |
358 | char line[1024], prev_group[64], group[64], arg[64], value[1024]; | |
359 | Location loc; | |
360 | Error *local_err = NULL; | |
361 | QDict *qdict = NULL; | |
362 | int res = -EINVAL, lno = 0; | |
363 | int count = 0; | |
364 | ||
365 | loc_push_none(&loc); | |
366 | while (fgets(line, sizeof(line), fp) != NULL) { | |
367 | ++lno; | |
368 | if (line[0] == '\n') { | |
369 | /* skip empty lines */ | |
370 | continue; | |
371 | } | |
372 | if (line[0] == '#') { | |
373 | /* comment */ | |
374 | continue; | |
375 | } | |
376 | if (line[0] == '[') { | |
377 | QDict *prev = qdict; | |
378 | if (sscanf(line, "[%63s \"%63[^\"]\"]", group, value) == 2) { | |
379 | qdict = qdict_new(); | |
380 | qdict_put_str(qdict, "id", value); | |
381 | count++; | |
382 | } else if (sscanf(line, "[%63[^]]]", group) == 1) { | |
383 | qdict = qdict_new(); | |
384 | count++; | |
385 | } | |
386 | if (qdict != prev) { | |
387 | if (prev) { | |
388 | cb(prev_group, prev, opaque, &local_err); | |
389 | qobject_unref(prev); | |
390 | if (local_err) { | |
391 | error_propagate(errp, local_err); | |
392 | goto out; | |
393 | } | |
394 | } | |
395 | strcpy(prev_group, group); | |
396 | continue; | |
397 | } | |
398 | } | |
399 | loc_set_file(fname, lno); | |
400 | value[0] = '\0'; | |
401 | if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 || | |
402 | sscanf(line, " %63s = \"\"", arg) == 1) { | |
403 | /* arg = value */ | |
404 | if (qdict == NULL) { | |
405 | error_setg(errp, "no group defined"); | |
406 | goto out; | |
407 | } | |
408 | qdict_put_str(qdict, arg, value); | |
409 | continue; | |
410 | } | |
411 | error_setg(errp, "parse error"); | |
412 | goto out; | |
413 | } | |
414 | if (ferror(fp)) { | |
415 | loc_pop(&loc); | |
416 | error_setg_errno(errp, errno, "Cannot read config file"); | |
417 | return res; | |
418 | } | |
419 | res = count; | |
420 | out: | |
421 | if (qdict) { | |
422 | cb(group, qdict, opaque, errp); | |
423 | qobject_unref(qdict); | |
424 | } | |
425 | loc_pop(&loc); | |
426 | return res; | |
427 | } | |
428 | ||
429 | void qemu_config_do_parse(const char *group, QDict *qdict, void *opaque, Error **errp) | |
430 | { | |
431 | QemuOptsList **lists = opaque; | |
432 | const char *id = qdict_get_try_str(qdict, "id"); | |
433 | QemuOptsList *list; | |
434 | QemuOpts *opts; | |
435 | const QDictEntry *unrecognized; | |
436 | ||
437 | list = find_list(lists, group, errp); | |
438 | if (!list) { | |
439 | return; | |
440 | } | |
441 | ||
442 | opts = qemu_opts_create(list, id, 1, errp); | |
443 | if (!opts) { | |
444 | return; | |
445 | } | |
446 | if (!qemu_opts_absorb_qdict(opts, qdict, errp)) { | |
447 | qemu_opts_del(opts); | |
448 | return; | |
449 | } | |
450 | unrecognized = qdict_first(qdict); | |
451 | if (unrecognized) { | |
452 | error_setg(errp, QERR_INVALID_PARAMETER, unrecognized->key); | |
453 | qemu_opts_del(opts); | |
454 | } | |
455 | } | |
456 | ||
457 | int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname, Error **errp) | |
458 | { | |
459 | return qemu_config_foreach(fp, qemu_config_do_parse, lists, fname, errp); | |
460 | } | |
461 | ||
462 | int qemu_read_config_file(const char *filename, QEMUConfigCB *cb, Error **errp) | |
463 | { | |
464 | FILE *f = fopen(filename, "r"); | |
465 | int ret; | |
466 | ||
467 | if (f == NULL) { | |
468 | error_setg_file_open(errp, errno, filename); | |
469 | return -errno; | |
470 | } | |
471 | ||
472 | ret = qemu_config_foreach(f, cb, vm_config_groups, filename, errp); | |
473 | fclose(f); | |
474 | return ret; | |
475 | } | |
476 | ||
477 | static void config_parse_qdict_section(QDict *options, QemuOptsList *opts, | |
478 | Error **errp) | |
479 | { | |
480 | QemuOpts *subopts; | |
481 | QDict *subqdict; | |
482 | QList *list = 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, errp); | |
495 | if (!subopts) { | |
496 | goto out; | |
497 | } | |
498 | ||
499 | if (!qemu_opts_absorb_qdict(subopts, subqdict, errp)) { | |
500 | goto out; | |
501 | } | |
502 | ||
503 | enum_size = qdict_size(subqdict); | |
504 | if (enum_size < orig_size && enum_size) { | |
505 | error_setg(errp, "Unknown option '%s' for [%s]", | |
506 | qdict_first(subqdict)->key, opts->name); | |
507 | goto out; | |
508 | } | |
509 | ||
510 | if (enum_size) { | |
511 | /* Multiple, enumerated sections */ | |
512 | QListEntry *list_entry; | |
513 | unsigned i = 0; | |
514 | ||
515 | /* Not required anymore */ | |
516 | qemu_opts_del(subopts); | |
517 | ||
518 | qdict_array_split(subqdict, &list); | |
519 | if (qdict_size(subqdict)) { | |
520 | error_setg(errp, "Unused option '%s' for [%s]", | |
521 | qdict_first(subqdict)->key, opts->name); | |
522 | goto out; | |
523 | } | |
524 | ||
525 | QLIST_FOREACH_ENTRY(list, list_entry) { | |
526 | QDict *section = qobject_to(QDict, qlist_entry_obj(list_entry)); | |
527 | char *opt_name; | |
528 | ||
529 | if (!section) { | |
530 | error_setg(errp, "[%s] section (index %u) does not consist of " | |
531 | "keys", opts->name, i); | |
532 | goto out; | |
533 | } | |
534 | ||
535 | opt_name = g_strdup_printf("%s.%u", opts->name, i++); | |
536 | subopts = qemu_opts_create(opts, opt_name, 1, errp); | |
537 | g_free(opt_name); | |
538 | if (!subopts) { | |
539 | goto out; | |
540 | } | |
541 | ||
542 | if (!qemu_opts_absorb_qdict(subopts, section, errp)) { | |
543 | qemu_opts_del(subopts); | |
544 | goto out; | |
545 | } | |
546 | ||
547 | if (qdict_size(section)) { | |
548 | error_setg(errp, "[%s] section doesn't support the option '%s'", | |
549 | opts->name, qdict_first(section)->key); | |
550 | qemu_opts_del(subopts); | |
551 | goto out; | |
552 | } | |
553 | } | |
554 | } | |
555 | ||
556 | out: | |
557 | qobject_unref(subqdict); | |
558 | qobject_unref(list); | |
559 | } | |
560 | ||
561 | void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists, | |
562 | Error **errp) | |
563 | { | |
564 | int i; | |
565 | Error *local_err = NULL; | |
566 | ||
567 | for (i = 0; lists[i]; i++) { | |
568 | config_parse_qdict_section(options, lists[i], &local_err); | |
569 | if (local_err) { | |
570 | error_propagate(errp, local_err); | |
571 | return; | |
572 | } | |
573 | } | |
574 | } |