1 #include "qemu/osdep.h" 2 #include "qapi/error.h" 3 #include "qapi/qmp/qlist.h" 4 #include "qemu-common.h" 5 #include "qemu/error-report.h" 6 #include "qemu/option.h" 7 #include "qemu/config-file.h" 8 #include "qmp-commands.h" 9 10 static QemuOptsList *vm_config_groups[48]; 11 static QemuOptsList *drive_config_groups[5]; 12 13 static QemuOptsList *find_list(QemuOptsList **lists, const char *group, 14 Error **errp) 15 { 16 int i; 17 18 for (i = 0; lists[i] != NULL; i++) { 19 if (strcmp(lists[i]->name, group) == 0) 20 break; 21 } 22 if (lists[i] == NULL) { 23 error_setg(errp, "There is no option group '%s'", group); 24 } 25 return lists[i]; 26 } 27 28 QemuOptsList *qemu_find_opts(const char *group) 29 { 30 QemuOptsList *ret; 31 Error *local_err = NULL; 32 33 ret = find_list(vm_config_groups, group, &local_err); 34 if (local_err) { 35 error_report_err(local_err); 36 } 37 38 return ret; 39 } 40 41 QemuOpts *qemu_find_opts_singleton(const char *group) 42 { 43 QemuOptsList *list; 44 QemuOpts *opts; 45 46 list = qemu_find_opts(group); 47 assert(list); 48 opts = qemu_opts_find(list, NULL); 49 if (!opts) { 50 opts = qemu_opts_create(list, NULL, 0, &error_abort); 51 } 52 return opts; 53 } 54 55 static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc) 56 { 57 CommandLineParameterInfoList *param_list = NULL, *entry; 58 CommandLineParameterInfo *info; 59 int i; 60 61 for (i = 0; desc[i].name != NULL; i++) { 62 info = g_malloc0(sizeof(*info)); 63 info->name = g_strdup(desc[i].name); 64 65 switch (desc[i].type) { 66 case QEMU_OPT_STRING: 67 info->type = COMMAND_LINE_PARAMETER_TYPE_STRING; 68 break; 69 case QEMU_OPT_BOOL: 70 info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN; 71 break; 72 case QEMU_OPT_NUMBER: 73 info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER; 74 break; 75 case QEMU_OPT_SIZE: 76 info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE; 77 break; 78 } 79 80 if (desc[i].help) { 81 info->has_help = true; 82 info->help = g_strdup(desc[i].help); 83 } 84 if (desc[i].def_value_str) { 85 info->has_q_default = true; 86 info->q_default = g_strdup(desc[i].def_value_str); 87 } 88 89 entry = g_malloc0(sizeof(*entry)); 90 entry->value = info; 91 entry->next = param_list; 92 param_list = entry; 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, *entry; 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 entry = g_malloc0(sizeof(*entry)); 265 entry->value = info; 266 entry->next = conf_list; 267 conf_list = entry; 268 } 269 } 270 271 if (conf_list == NULL) { 272 error_setg(errp, "invalid option name: %s", option); 273 } 274 275 return conf_list; 276 } 277 278 QemuOptsList *qemu_find_opts_err(const char *group, Error **errp) 279 { 280 return find_list(vm_config_groups, group, errp); 281 } 282 283 void qemu_add_drive_opts(QemuOptsList *list) 284 { 285 int entries, i; 286 287 entries = ARRAY_SIZE(drive_config_groups); 288 entries--; /* keep list NULL terminated */ 289 for (i = 0; i < entries; i++) { 290 if (drive_config_groups[i] == NULL) { 291 drive_config_groups[i] = list; 292 return; 293 } 294 } 295 fprintf(stderr, "ran out of space in drive_config_groups"); 296 abort(); 297 } 298 299 void qemu_add_opts(QemuOptsList *list) 300 { 301 int entries, i; 302 303 entries = ARRAY_SIZE(vm_config_groups); 304 entries--; /* keep list NULL terminated */ 305 for (i = 0; i < entries; i++) { 306 if (vm_config_groups[i] == NULL) { 307 vm_config_groups[i] = list; 308 return; 309 } 310 } 311 fprintf(stderr, "ran out of space in vm_config_groups"); 312 abort(); 313 } 314 315 int qemu_set_option(const char *str) 316 { 317 Error *local_err = NULL; 318 char group[64], id[64], arg[64]; 319 QemuOptsList *list; 320 QemuOpts *opts; 321 int rc, offset; 322 323 rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset); 324 if (rc < 3 || str[offset] != '=') { 325 error_report("can't parse: \"%s\"", str); 326 return -1; 327 } 328 329 list = qemu_find_opts(group); 330 if (list == NULL) { 331 return -1; 332 } 333 334 opts = qemu_opts_find(list, id); 335 if (!opts) { 336 error_report("there is no %s \"%s\" defined", 337 list->name, id); 338 return -1; 339 } 340 341 qemu_opt_set(opts, arg, str + offset + 1, &local_err); 342 if (local_err) { 343 error_report_err(local_err); 344 return -1; 345 } 346 return 0; 347 } 348 349 struct ConfigWriteData { 350 QemuOptsList *list; 351 FILE *fp; 352 }; 353 354 static int config_write_opt(void *opaque, const char *name, const char *value, 355 Error **errp) 356 { 357 struct ConfigWriteData *data = opaque; 358 359 fprintf(data->fp, " %s = \"%s\"\n", name, value); 360 return 0; 361 } 362 363 static int config_write_opts(void *opaque, QemuOpts *opts, Error **errp) 364 { 365 struct ConfigWriteData *data = opaque; 366 const char *id = qemu_opts_id(opts); 367 368 if (id) { 369 fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id); 370 } else { 371 fprintf(data->fp, "[%s]\n", data->list->name); 372 } 373 qemu_opt_foreach(opts, config_write_opt, data, NULL); 374 fprintf(data->fp, "\n"); 375 return 0; 376 } 377 378 void qemu_config_write(FILE *fp) 379 { 380 struct ConfigWriteData data = { .fp = fp }; 381 QemuOptsList **lists = vm_config_groups; 382 int i; 383 384 fprintf(fp, "# qemu config file\n\n"); 385 for (i = 0; lists[i] != NULL; i++) { 386 data.list = lists[i]; 387 qemu_opts_foreach(data.list, config_write_opts, &data, NULL); 388 } 389 } 390 391 /* Returns number of config groups on success, -errno on error */ 392 int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname) 393 { 394 char line[1024], group[64], id[64], arg[64], value[1024]; 395 Location loc; 396 QemuOptsList *list = NULL; 397 Error *local_err = NULL; 398 QemuOpts *opts = NULL; 399 int res = -EINVAL, lno = 0; 400 int count = 0; 401 402 loc_push_none(&loc); 403 while (fgets(line, sizeof(line), fp) != NULL) { 404 loc_set_file(fname, ++lno); 405 if (line[0] == '\n') { 406 /* skip empty lines */ 407 continue; 408 } 409 if (line[0] == '#') { 410 /* comment */ 411 continue; 412 } 413 if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) { 414 /* group with id */ 415 list = find_list(lists, group, &local_err); 416 if (local_err) { 417 error_report_err(local_err); 418 goto out; 419 } 420 opts = qemu_opts_create(list, id, 1, NULL); 421 count++; 422 continue; 423 } 424 if (sscanf(line, "[%63[^]]]", group) == 1) { 425 /* group without id */ 426 list = find_list(lists, group, &local_err); 427 if (local_err) { 428 error_report_err(local_err); 429 goto out; 430 } 431 opts = qemu_opts_create(list, NULL, 0, &error_abort); 432 count++; 433 continue; 434 } 435 value[0] = '\0'; 436 if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 || 437 sscanf(line, " %63s = \"\"", arg) == 1) { 438 /* arg = value */ 439 if (opts == NULL) { 440 error_report("no group defined"); 441 goto out; 442 } 443 qemu_opt_set(opts, arg, value, &local_err); 444 if (local_err) { 445 error_report_err(local_err); 446 goto out; 447 } 448 continue; 449 } 450 error_report("parse error"); 451 goto out; 452 } 453 if (ferror(fp)) { 454 error_report("error reading file"); 455 goto out; 456 } 457 res = count; 458 out: 459 loc_pop(&loc); 460 return res; 461 } 462 463 int qemu_read_config_file(const char *filename) 464 { 465 FILE *f = fopen(filename, "r"); 466 int ret; 467 468 if (f == NULL) { 469 return -errno; 470 } 471 472 ret = qemu_config_parse(f, vm_config_groups, filename); 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 Error *local_err = NULL; 484 size_t orig_size, enum_size; 485 char *prefix; 486 487 prefix = g_strdup_printf("%s.", opts->name); 488 qdict_extract_subqdict(options, &subqdict, prefix); 489 g_free(prefix); 490 orig_size = qdict_size(subqdict); 491 if (!orig_size) { 492 goto out; 493 } 494 495 subopts = qemu_opts_create(opts, NULL, 0, &local_err); 496 if (local_err) { 497 error_propagate(errp, local_err); 498 goto out; 499 } 500 501 qemu_opts_absorb_qdict(subopts, subqdict, &local_err); 502 if (local_err) { 503 error_propagate(errp, local_err); 504 goto out; 505 } 506 507 enum_size = qdict_size(subqdict); 508 if (enum_size < orig_size && enum_size) { 509 error_setg(errp, "Unknown option '%s' for [%s]", 510 qdict_first(subqdict)->key, opts->name); 511 goto out; 512 } 513 514 if (enum_size) { 515 /* Multiple, enumerated sections */ 516 QListEntry *list_entry; 517 unsigned i = 0; 518 519 /* Not required anymore */ 520 qemu_opts_del(subopts); 521 522 qdict_array_split(subqdict, &list); 523 if (qdict_size(subqdict)) { 524 error_setg(errp, "Unused option '%s' for [%s]", 525 qdict_first(subqdict)->key, opts->name); 526 goto out; 527 } 528 529 QLIST_FOREACH_ENTRY(list, list_entry) { 530 QDict *section = qobject_to_qdict(qlist_entry_obj(list_entry)); 531 char *opt_name; 532 533 if (!section) { 534 error_setg(errp, "[%s] section (index %u) does not consist of " 535 "keys", opts->name, i); 536 goto out; 537 } 538 539 opt_name = g_strdup_printf("%s.%u", opts->name, i++); 540 subopts = qemu_opts_create(opts, opt_name, 1, &local_err); 541 g_free(opt_name); 542 if (local_err) { 543 error_propagate(errp, local_err); 544 goto out; 545 } 546 547 qemu_opts_absorb_qdict(subopts, section, &local_err); 548 if (local_err) { 549 error_propagate(errp, local_err); 550 qemu_opts_del(subopts); 551 goto out; 552 } 553 554 if (qdict_size(section)) { 555 error_setg(errp, "[%s] section doesn't support the option '%s'", 556 opts->name, qdict_first(section)->key); 557 qemu_opts_del(subopts); 558 goto out; 559 } 560 } 561 } 562 563 out: 564 QDECREF(subqdict); 565 QDECREF(list); 566 } 567 568 void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists, 569 Error **errp) 570 { 571 int i; 572 Error *local_err = NULL; 573 574 for (i = 0; lists[i]; i++) { 575 config_parse_qdict_section(options, lists[i], &local_err); 576 if (local_err) { 577 error_propagate(errp, local_err); 578 return; 579 } 580 } 581 } 582