1 #include "qemu/osdep.h"
2 #include "qemu-common.h"
3 #include "qemu/error-report.h"
4 #include "qemu/option.h"
5 #include "qemu/config-file.h"
6 #include "qmp-commands.h"
8 static QemuOptsList
*vm_config_groups
[48];
9 static QemuOptsList
*drive_config_groups
[5];
11 static QemuOptsList
*find_list(QemuOptsList
**lists
, const char *group
,
16 for (i
= 0; lists
[i
] != NULL
; i
++) {
17 if (strcmp(lists
[i
]->name
, group
) == 0)
20 if (lists
[i
] == NULL
) {
21 error_setg(errp
, "There is no option group '%s'", group
);
26 QemuOptsList
*qemu_find_opts(const char *group
)
29 Error
*local_err
= NULL
;
31 ret
= find_list(vm_config_groups
, group
, &local_err
);
33 error_report_err(local_err
);
39 QemuOpts
*qemu_find_opts_singleton(const char *group
)
44 list
= qemu_find_opts(group
);
46 opts
= qemu_opts_find(list
, NULL
);
48 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
53 static CommandLineParameterInfoList
*query_option_descs(const QemuOptDesc
*desc
)
55 CommandLineParameterInfoList
*param_list
= NULL
, *entry
;
56 CommandLineParameterInfo
*info
;
59 for (i
= 0; desc
[i
].name
!= NULL
; i
++) {
60 info
= g_malloc0(sizeof(*info
));
61 info
->name
= g_strdup(desc
[i
].name
);
63 switch (desc
[i
].type
) {
65 info
->type
= COMMAND_LINE_PARAMETER_TYPE_STRING
;
68 info
->type
= COMMAND_LINE_PARAMETER_TYPE_BOOLEAN
;
71 info
->type
= COMMAND_LINE_PARAMETER_TYPE_NUMBER
;
74 info
->type
= COMMAND_LINE_PARAMETER_TYPE_SIZE
;
79 info
->has_help
= true;
80 info
->help
= g_strdup(desc
[i
].help
);
82 if (desc
[i
].def_value_str
) {
83 info
->has_q_default
= true;
84 info
->q_default
= g_strdup(desc
[i
].def_value_str
);
87 entry
= g_malloc0(sizeof(*entry
));
89 entry
->next
= param_list
;
96 /* remove repeated entry from the info list */
97 static void cleanup_infolist(CommandLineParameterInfoList
*head
)
99 CommandLineParameterInfoList
*pre_entry
, *cur
, *del_entry
;
104 while (pre_entry
!= cur
->next
) {
105 if (!strcmp(pre_entry
->value
->name
, cur
->next
->value
->name
)) {
106 del_entry
= cur
->next
;
107 cur
->next
= cur
->next
->next
;
108 del_entry
->next
= NULL
;
109 qapi_free_CommandLineParameterInfoList(del_entry
);
112 pre_entry
= pre_entry
->next
;
118 /* merge the description items of two parameter infolists */
119 static void connect_infolist(CommandLineParameterInfoList
*head
,
120 CommandLineParameterInfoList
*new)
122 CommandLineParameterInfoList
*cur
;
131 /* access all the local QemuOptsLists for drive option */
132 static CommandLineParameterInfoList
*get_drive_infolist(void)
134 CommandLineParameterInfoList
*head
= NULL
, *cur
;
137 for (i
= 0; drive_config_groups
[i
] != NULL
; i
++) {
139 head
= query_option_descs(drive_config_groups
[i
]->desc
);
141 cur
= query_option_descs(drive_config_groups
[i
]->desc
);
142 connect_infolist(head
, cur
);
145 cleanup_infolist(head
);
150 /* restore machine options that are now machine's properties */
151 static QemuOptsList machine_opts
= {
153 .head
= QTAILQ_HEAD_INITIALIZER(machine_opts
.head
),
157 .type
= QEMU_OPT_STRING
,
158 .help
= "emulated machine"
161 .type
= QEMU_OPT_STRING
,
162 .help
= "accelerator list",
164 .name
= "kernel_irqchip",
165 .type
= QEMU_OPT_BOOL
,
166 .help
= "use KVM in-kernel irqchip",
168 .name
= "kvm_shadow_mem",
169 .type
= QEMU_OPT_SIZE
,
170 .help
= "KVM shadow MMU size",
173 .type
= QEMU_OPT_STRING
,
174 .help
= "Linux kernel image file",
177 .type
= QEMU_OPT_STRING
,
178 .help
= "Linux initial ramdisk file",
181 .type
= QEMU_OPT_STRING
,
182 .help
= "Linux kernel command line",
185 .type
= QEMU_OPT_STRING
,
186 .help
= "Linux kernel device tree file",
189 .type
= QEMU_OPT_STRING
,
190 .help
= "Dump current dtb to a file and quit",
192 .name
= "phandle_start",
193 .type
= QEMU_OPT_NUMBER
,
194 .help
= "The first phandle ID we may generate dynamically",
196 .name
= "dt_compatible",
197 .type
= QEMU_OPT_STRING
,
198 .help
= "Overrides the \"compatible\" property of the dt root node",
200 .name
= "dump-guest-core",
201 .type
= QEMU_OPT_BOOL
,
202 .help
= "Include guest memory in a core dump",
205 .type
= QEMU_OPT_BOOL
,
206 .help
= "enable/disable memory merge support",
209 .type
= QEMU_OPT_BOOL
,
210 .help
= "Set on/off to enable/disable usb",
213 .type
= QEMU_OPT_STRING
,
214 .help
= "firmware image",
217 .type
= QEMU_OPT_BOOL
,
218 .help
= "Set on/off to enable/disable Intel IOMMU (VT-d)",
220 .name
= "suppress-vmdesc",
221 .type
= QEMU_OPT_BOOL
,
222 .help
= "Set on to disable self-describing migration",
224 .name
= "aes-key-wrap",
225 .type
= QEMU_OPT_BOOL
,
226 .help
= "enable/disable AES key wrapping using the CPACF wrapping key",
228 .name
= "dea-key-wrap",
229 .type
= QEMU_OPT_BOOL
,
230 .help
= "enable/disable DEA key wrapping using the CPACF wrapping key",
233 .type
= QEMU_OPT_STRING
,
234 .help
= "Up to 8 chars in set of [A-Za-z0-9. ](lower case chars"
235 " converted to upper case) to pass to machine"
236 " loader, boot manager, and guest kernel",
238 { /* End of list */ }
242 CommandLineOptionInfoList
*qmp_query_command_line_options(bool has_option
,
246 CommandLineOptionInfoList
*conf_list
= NULL
, *entry
;
247 CommandLineOptionInfo
*info
;
250 for (i
= 0; vm_config_groups
[i
] != NULL
; i
++) {
251 if (!has_option
|| !strcmp(option
, vm_config_groups
[i
]->name
)) {
252 info
= g_malloc0(sizeof(*info
));
253 info
->option
= g_strdup(vm_config_groups
[i
]->name
);
254 if (!strcmp("drive", vm_config_groups
[i
]->name
)) {
255 info
->parameters
= get_drive_infolist();
256 } else if (!strcmp("machine", vm_config_groups
[i
]->name
)) {
257 info
->parameters
= query_option_descs(machine_opts
.desc
);
260 query_option_descs(vm_config_groups
[i
]->desc
);
262 entry
= g_malloc0(sizeof(*entry
));
264 entry
->next
= conf_list
;
269 if (conf_list
== NULL
) {
270 error_setg(errp
, "invalid option name: %s", option
);
276 QemuOptsList
*qemu_find_opts_err(const char *group
, Error
**errp
)
278 return find_list(vm_config_groups
, group
, errp
);
281 void qemu_add_drive_opts(QemuOptsList
*list
)
285 entries
= ARRAY_SIZE(drive_config_groups
);
286 entries
--; /* keep list NULL terminated */
287 for (i
= 0; i
< entries
; i
++) {
288 if (drive_config_groups
[i
] == NULL
) {
289 drive_config_groups
[i
] = list
;
293 fprintf(stderr
, "ran out of space in drive_config_groups");
297 void qemu_add_opts(QemuOptsList
*list
)
301 entries
= ARRAY_SIZE(vm_config_groups
);
302 entries
--; /* keep list NULL terminated */
303 for (i
= 0; i
< entries
; i
++) {
304 if (vm_config_groups
[i
] == NULL
) {
305 vm_config_groups
[i
] = list
;
309 fprintf(stderr
, "ran out of space in vm_config_groups");
313 int qemu_set_option(const char *str
)
315 Error
*local_err
= NULL
;
316 char group
[64], id
[64], arg
[64];
321 rc
= sscanf(str
, "%63[^.].%63[^.].%63[^=]%n", group
, id
, arg
, &offset
);
322 if (rc
< 3 || str
[offset
] != '=') {
323 error_report("can't parse: \"%s\"", str
);
327 list
= qemu_find_opts(group
);
332 opts
= qemu_opts_find(list
, id
);
334 error_report("there is no %s \"%s\" defined",
339 qemu_opt_set(opts
, arg
, str
+ offset
+ 1, &local_err
);
341 error_report_err(local_err
);
347 struct ConfigWriteData
{
352 static int config_write_opt(void *opaque
, const char *name
, const char *value
,
355 struct ConfigWriteData
*data
= opaque
;
357 fprintf(data
->fp
, " %s = \"%s\"\n", name
, value
);
361 static int config_write_opts(void *opaque
, QemuOpts
*opts
, Error
**errp
)
363 struct ConfigWriteData
*data
= opaque
;
364 const char *id
= qemu_opts_id(opts
);
367 fprintf(data
->fp
, "[%s \"%s\"]\n", data
->list
->name
, id
);
369 fprintf(data
->fp
, "[%s]\n", data
->list
->name
);
371 qemu_opt_foreach(opts
, config_write_opt
, data
, NULL
);
372 fprintf(data
->fp
, "\n");
376 void qemu_config_write(FILE *fp
)
378 struct ConfigWriteData data
= { .fp
= fp
};
379 QemuOptsList
**lists
= vm_config_groups
;
382 fprintf(fp
, "# qemu config file\n\n");
383 for (i
= 0; lists
[i
] != NULL
; i
++) {
384 data
.list
= lists
[i
];
385 qemu_opts_foreach(data
.list
, config_write_opts
, &data
, NULL
);
389 /* Returns number of config groups on success, -errno on error */
390 int qemu_config_parse(FILE *fp
, QemuOptsList
**lists
, const char *fname
)
392 char line
[1024], group
[64], id
[64], arg
[64], value
[1024];
394 QemuOptsList
*list
= NULL
;
395 Error
*local_err
= NULL
;
396 QemuOpts
*opts
= NULL
;
397 int res
= -EINVAL
, lno
= 0;
401 while (fgets(line
, sizeof(line
), fp
) != NULL
) {
402 loc_set_file(fname
, ++lno
);
403 if (line
[0] == '\n') {
404 /* skip empty lines */
407 if (line
[0] == '#') {
411 if (sscanf(line
, "[%63s \"%63[^\"]\"]", group
, id
) == 2) {
413 list
= find_list(lists
, group
, &local_err
);
415 error_report_err(local_err
);
418 opts
= qemu_opts_create(list
, id
, 1, NULL
);
422 if (sscanf(line
, "[%63[^]]]", group
) == 1) {
423 /* group without id */
424 list
= find_list(lists
, group
, &local_err
);
426 error_report_err(local_err
);
429 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
434 if (sscanf(line
, " %63s = \"%1023[^\"]\"", arg
, value
) == 2 ||
435 sscanf(line
, " %63s = \"\"", arg
) == 1) {
438 error_report("no group defined");
441 qemu_opt_set(opts
, arg
, value
, &local_err
);
443 error_report_err(local_err
);
448 error_report("parse error");
452 error_report("error reading file");
461 int qemu_read_config_file(const char *filename
)
463 FILE *f
= fopen(filename
, "r");
470 ret
= qemu_config_parse(f
, vm_config_groups
, filename
);
475 static void config_parse_qdict_section(QDict
*options
, QemuOptsList
*opts
,
481 Error
*local_err
= NULL
;
482 size_t orig_size
, enum_size
;
485 prefix
= g_strdup_printf("%s.", opts
->name
);
486 qdict_extract_subqdict(options
, &subqdict
, prefix
);
488 orig_size
= qdict_size(subqdict
);
493 subopts
= qemu_opts_create(opts
, NULL
, 0, &local_err
);
495 error_propagate(errp
, local_err
);
499 qemu_opts_absorb_qdict(subopts
, subqdict
, &local_err
);
501 error_propagate(errp
, local_err
);
505 enum_size
= qdict_size(subqdict
);
506 if (enum_size
< orig_size
&& enum_size
) {
507 error_setg(errp
, "Unknown option '%s' for [%s]",
508 qdict_first(subqdict
)->key
, opts
->name
);
513 /* Multiple, enumerated sections */
514 QListEntry
*list_entry
;
517 /* Not required anymore */
518 qemu_opts_del(subopts
);
520 qdict_array_split(subqdict
, &list
);
521 if (qdict_size(subqdict
)) {
522 error_setg(errp
, "Unused option '%s' for [%s]",
523 qdict_first(subqdict
)->key
, opts
->name
);
527 QLIST_FOREACH_ENTRY(list
, list_entry
) {
528 QDict
*section
= qobject_to_qdict(qlist_entry_obj(list_entry
));
532 error_setg(errp
, "[%s] section (index %u) does not consist of "
533 "keys", opts
->name
, i
);
537 opt_name
= g_strdup_printf("%s.%u", opts
->name
, i
++);
538 subopts
= qemu_opts_create(opts
, opt_name
, 1, &local_err
);
541 error_propagate(errp
, local_err
);
545 qemu_opts_absorb_qdict(subopts
, section
, &local_err
);
547 error_propagate(errp
, local_err
);
548 qemu_opts_del(subopts
);
552 if (qdict_size(section
)) {
553 error_setg(errp
, "[%s] section doesn't support the option '%s'",
554 opts
->name
, qdict_first(section
)->key
);
555 qemu_opts_del(subopts
);
566 void qemu_config_parse_qdict(QDict
*options
, QemuOptsList
**lists
,
570 Error
*local_err
= NULL
;
572 for (i
= 0; lists
[i
]; i
++) {
573 config_parse_qdict_section(options
, lists
[i
], &local_err
);
575 error_propagate(errp
, local_err
);