qemu-config.c

   1 #include "qemu-common.h"
   2 #include "qemu-error.h"
   3 #include "qemu-option.h"
   4 #include "qemu-config.h"
   5 #include "hw/qdev.h"
   6
   7 static QemuOptsList qemu_drive_opts = {
   8     .name = "drive",
   9     .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
  10     .desc = {
  11         {
  12             .name = "bus",
  13             .type = QEMU_OPT_NUMBER,
  14             .help = "bus number",
  15         },{
  16             .name = "unit",
  17             .type = QEMU_OPT_NUMBER,
  18             .help = "unit number (i.e. lun for scsi)",
  19         },{
  20             .name = "if",
  21             .type = QEMU_OPT_STRING,
  22             .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
  23         },{
  24             .name = "index",
  25             .type = QEMU_OPT_NUMBER,
  26             .help = "index number",
  27         },{
  28             .name = "cyls",
  29             .type = QEMU_OPT_NUMBER,
  30             .help = "number of cylinders (ide disk geometry)",
  31         },{
  32             .name = "heads",
  33             .type = QEMU_OPT_NUMBER,
  34             .help = "number of heads (ide disk geometry)",
  35         },{
  36             .name = "secs",
  37             .type = QEMU_OPT_NUMBER,
  38             .help = "number of sectors (ide disk geometry)",
  39         },{
  40             .name = "trans",
  41             .type = QEMU_OPT_STRING,
  42             .help = "chs translation (auto, lba. none)",
  43         },{
  44             .name = "media",
  45             .type = QEMU_OPT_STRING,
  46             .help = "media type (disk, cdrom)",
  47         },{
  48             .name = "snapshot",
  49             .type = QEMU_OPT_BOOL,
  50             .help = "enable/disable snapshot mode",
  51         },{
  52             .name = "file",
  53             .type = QEMU_OPT_STRING,
  54             .help = "disk image",
  55         },{
  56             .name = "cache",
  57             .type = QEMU_OPT_STRING,
  58             .help = "host cache usage (none, writeback, writethrough, "
  59                     "directsync, unsafe)",
  60         },{
  61             .name = "aio",
  62             .type = QEMU_OPT_STRING,
  63             .help = "host AIO implementation (threads, native)",
  64         },{
  65             .name = "format",
  66             .type = QEMU_OPT_STRING,
  67             .help = "disk format (raw, qcow2, ...)",
  68         },{
  69             .name = "serial",
  70             .type = QEMU_OPT_STRING,
  71             .help = "disk serial number",
  72         },{
  73             .name = "rerror",
  74             .type = QEMU_OPT_STRING,
  75             .help = "read error action",
  76         },{
  77             .name = "werror",
  78             .type = QEMU_OPT_STRING,
  79             .help = "write error action",
  80         },{
  81             .name = "addr",
  82             .type = QEMU_OPT_STRING,
  83             .help = "pci address (virtio only)",
  84         },{
  85             .name = "readonly",
  86             .type = QEMU_OPT_BOOL,
  87             .help = "open drive file as read-only",
  88         },
  89         { /* end of list */ }
  90     },
  91 };
  92
  93 static QemuOptsList qemu_chardev_opts = {
  94     .name = "chardev",
  95     .implied_opt_name = "backend",
  96     .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
  97     .desc = {
  98         {
  99             .name = "backend",
 100             .type = QEMU_OPT_STRING,
 101         },{
 102             .name = "path",
 103             .type = QEMU_OPT_STRING,
 104         },{
 105             .name = "host",
 106             .type = QEMU_OPT_STRING,
 107         },{
 108             .name = "port",
 109             .type = QEMU_OPT_STRING,
 110         },{
 111             .name = "localaddr",
 112             .type = QEMU_OPT_STRING,
 113         },{
 114             .name = "localport",
 115             .type = QEMU_OPT_STRING,
 116         },{
 117             .name = "to",
 118             .type = QEMU_OPT_NUMBER,
 119         },{
 120             .name = "ipv4",
 121             .type = QEMU_OPT_BOOL,
 122         },{
 123             .name = "ipv6",
 124             .type = QEMU_OPT_BOOL,
 125         },{
 126             .name = "wait",
 127             .type = QEMU_OPT_BOOL,
 128         },{
 129             .name = "server",
 130             .type = QEMU_OPT_BOOL,
 131         },{
 132             .name = "delay",
 133             .type = QEMU_OPT_BOOL,
 134         },{
 135             .name = "telnet",
 136             .type = QEMU_OPT_BOOL,
 137         },{
 138             .name = "width",
 139             .type = QEMU_OPT_NUMBER,
 140         },{
 141             .name = "height",
 142             .type = QEMU_OPT_NUMBER,
 143         },{
 144             .name = "cols",
 145             .type = QEMU_OPT_NUMBER,
 146         },{
 147             .name = "rows",
 148             .type = QEMU_OPT_NUMBER,
 149         },{
 150             .name = "mux",
 151             .type = QEMU_OPT_BOOL,
 152         },{
 153             .name = "signal",
 154             .type = QEMU_OPT_BOOL,
 155         },{
 156             .name = "name",
 157             .type = QEMU_OPT_STRING,
 158         },{
 159             .name = "debug",
 160             .type = QEMU_OPT_NUMBER,
 161         },
 162         { /* end of list */ }
 163     },
 164 };
 165
 166 QemuOptsList qemu_fsdev_opts = {
 167     .name = "fsdev",
 168     .implied_opt_name = "fstype",
 169     .head = QTAILQ_HEAD_INITIALIZER(qemu_fsdev_opts.head),
 170     .desc = {
 171         {
 172             .name = "fstype",
 173             .type = QEMU_OPT_STRING,
 174         }, {
 175             .name = "path",
 176             .type = QEMU_OPT_STRING,
 177         }, {
 178             .name = "security_model",
 179             .type = QEMU_OPT_STRING,
 180         },
 181         { /*End of list */ }
 182     },
 183 };
 184
 185 QemuOptsList qemu_virtfs_opts = {
 186     .name = "virtfs",
 187     .implied_opt_name = "fstype",
 188     .head = QTAILQ_HEAD_INITIALIZER(qemu_virtfs_opts.head),
 189     .desc = {
 190         {
 191             .name = "fstype",
 192             .type = QEMU_OPT_STRING,
 193         }, {
 194             .name = "path",
 195             .type = QEMU_OPT_STRING,
 196         }, {
 197             .name = "mount_tag",
 198             .type = QEMU_OPT_STRING,
 199         }, {
 200             .name = "security_model",
 201             .type = QEMU_OPT_STRING,
 202         },
 203
 204         { /*End of list */ }
 205     },
 206 };
 207
 208 static QemuOptsList qemu_device_opts = {
 209     .name = "device",
 210     .implied_opt_name = "driver",
 211     .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
 212     .desc = {
 213         /*
 214          * no elements => accept any
 215          * sanity checking will happen later
 216          * when setting device properties
 217          */
 218         { /* end of list */ }
 219     },
 220 };
 221
 222 static QemuOptsList qemu_netdev_opts = {
 223     .name = "netdev",
 224     .implied_opt_name = "type",
 225     .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
 226     .desc = {
 227         /*
 228          * no elements => accept any params
 229          * validation will happen later
 230          */
 231         { /* end of list */ }
 232     },
 233 };
 234
 235 static QemuOptsList qemu_net_opts = {
 236     .name = "net",
 237     .implied_opt_name = "type",
 238     .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
 239     .desc = {
 240         /*
 241          * no elements => accept any params
 242          * validation will happen later
 243          */
 244         { /* end of list */ }
 245     },
 246 };
 247
 248 static QemuOptsList qemu_rtc_opts = {
 249     .name = "rtc",
 250     .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
 251     .desc = {
 252         {
 253             .name = "base",
 254             .type = QEMU_OPT_STRING,
 255         },{
 256             .name = "clock",
 257             .type = QEMU_OPT_STRING,
 258         },{
 259             .name = "driftfix",
 260             .type = QEMU_OPT_STRING,
 261         },
 262         { /* end of list */ }
 263     },
 264 };
 265
 266 static QemuOptsList qemu_global_opts = {
 267     .name = "global",
 268     .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
 269     .desc = {
 270         {
 271             .name = "driver",
 272             .type = QEMU_OPT_STRING,
 273         },{
 274             .name = "property",
 275             .type = QEMU_OPT_STRING,
 276         },{
 277             .name = "value",
 278             .type = QEMU_OPT_STRING,
 279         },
 280         { /* end of list */ }
 281     },
 282 };
 283
 284 static QemuOptsList qemu_mon_opts = {
 285     .name = "mon",
 286     .implied_opt_name = "chardev",
 287     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
 288     .desc = {
 289         {
 290             .name = "mode",
 291             .type = QEMU_OPT_STRING,
 292         },{
 293             .name = "chardev",
 294             .type = QEMU_OPT_STRING,
 295         },{
 296             .name = "default",
 297             .type = QEMU_OPT_BOOL,
 298         },{
 299             .name = "pretty",
 300             .type = QEMU_OPT_BOOL,
 301         },
 302         { /* end of list */ }
 303     },
 304 };
 305
 306 #ifdef CONFIG_SIMPLE_TRACE
 307 static QemuOptsList qemu_trace_opts = {
 308     .name = "trace",
 309     .implied_opt_name = "trace",
 310     .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
 311     .desc = {
 312         {
 313             .name = "file",
 314             .type = QEMU_OPT_STRING,
 315         },
 316         { /* end of list */ }
 317     },
 318 };
 319 #endif
 320
 321 static QemuOptsList qemu_cpudef_opts = {
 322     .name = "cpudef",
 323     .head = QTAILQ_HEAD_INITIALIZER(qemu_cpudef_opts.head),
 324     .desc = {
 325         {
 326             .name = "name",
 327             .type = QEMU_OPT_STRING,
 328         },{
 329             .name = "level",
 330             .type = QEMU_OPT_NUMBER,
 331         },{
 332             .name = "vendor",
 333             .type = QEMU_OPT_STRING,
 334         },{
 335             .name = "family",
 336             .type = QEMU_OPT_NUMBER,
 337         },{
 338             .name = "model",
 339             .type = QEMU_OPT_NUMBER,
 340         },{
 341             .name = "stepping",
 342             .type = QEMU_OPT_NUMBER,
 343         },{
 344             .name = "feature_edx",      /* cpuid 0000_0001.edx */
 345             .type = QEMU_OPT_STRING,
 346         },{
 347             .name = "feature_ecx",      /* cpuid 0000_0001.ecx */
 348             .type = QEMU_OPT_STRING,
 349         },{
 350             .name = "extfeature_edx",   /* cpuid 8000_0001.edx */
 351             .type = QEMU_OPT_STRING,
 352         },{
 353             .name = "extfeature_ecx",   /* cpuid 8000_0001.ecx */
 354             .type = QEMU_OPT_STRING,
 355         },{
 356             .name = "xlevel",
 357             .type = QEMU_OPT_NUMBER,
 358         },{
 359             .name = "model_id",
 360             .type = QEMU_OPT_STRING,
 361         },{
 362             .name = "vendor_override",
 363             .type = QEMU_OPT_NUMBER,
 364         },
 365         { /* end of list */ }
 366     },
 367 };
 368
 369 QemuOptsList qemu_spice_opts = {
 370     .name = "spice",
 371     .head = QTAILQ_HEAD_INITIALIZER(qemu_spice_opts.head),
 372     .desc = {
 373         {
 374             .name = "port",
 375             .type = QEMU_OPT_NUMBER,
 376         },{
 377             .name = "tls-port",
 378             .type = QEMU_OPT_NUMBER,
 379         },{
 380             .name = "addr",
 381             .type = QEMU_OPT_STRING,
 382         },{
 383             .name = "ipv4",
 384             .type = QEMU_OPT_BOOL,
 385         },{
 386             .name = "ipv6",
 387             .type = QEMU_OPT_BOOL,
 388         },{
 389             .name = "password",
 390             .type = QEMU_OPT_STRING,
 391         },{
 392             .name = "disable-ticketing",
 393             .type = QEMU_OPT_BOOL,
 394         },{
 395             .name = "disable-copy-paste",
 396             .type = QEMU_OPT_BOOL,
 397         },{
 398             .name = "sasl",
 399             .type = QEMU_OPT_BOOL,
 400         },{
 401             .name = "x509-dir",
 402             .type = QEMU_OPT_STRING,
 403         },{
 404             .name = "x509-key-file",
 405             .type = QEMU_OPT_STRING,
 406         },{
 407             .name = "x509-key-password",
 408             .type = QEMU_OPT_STRING,
 409         },{
 410             .name = "x509-cert-file",
 411             .type = QEMU_OPT_STRING,
 412         },{
 413             .name = "x509-cacert-file",
 414             .type = QEMU_OPT_STRING,
 415         },{
 416             .name = "x509-dh-key-file",
 417             .type = QEMU_OPT_STRING,
 418         },{
 419             .name = "tls-ciphers",
 420             .type = QEMU_OPT_STRING,
 421         },{
 422             .name = "tls-channel",
 423             .type = QEMU_OPT_STRING,
 424         },{
 425             .name = "plaintext-channel",
 426             .type = QEMU_OPT_STRING,
 427         },{
 428             .name = "image-compression",
 429             .type = QEMU_OPT_STRING,
 430         },{
 431             .name = "jpeg-wan-compression",
 432             .type = QEMU_OPT_STRING,
 433         },{
 434             .name = "zlib-glz-wan-compression",
 435             .type = QEMU_OPT_STRING,
 436         },{
 437             .name = "streaming-video",
 438             .type = QEMU_OPT_STRING,
 439         },{
 440             .name = "agent-mouse",
 441             .type = QEMU_OPT_BOOL,
 442         },{
 443             .name = "playback-compression",
 444             .type = QEMU_OPT_BOOL,
 445         },
 446         { /* end of list */ }
 447     },
 448 };
 449
 450 QemuOptsList qemu_option_rom_opts = {
 451     .name = "option-rom",
 452     .implied_opt_name = "romfile",
 453     .head = QTAILQ_HEAD_INITIALIZER(qemu_option_rom_opts.head),
 454     .desc = {
 455         {
 456             .name = "bootindex",
 457             .type = QEMU_OPT_NUMBER,
 458         }, {
 459             .name = "romfile",
 460             .type = QEMU_OPT_STRING,
 461         },
 462         { /* end of list */ }
 463     },
 464 };
 465
 466 static QemuOptsList qemu_machine_opts = {
 467     .name = "machine",
 468     .implied_opt_name = "type",
 469     .head = QTAILQ_HEAD_INITIALIZER(qemu_machine_opts.head),
 470     .desc = {
 471         {
 472             .name = "type",
 473             .type = QEMU_OPT_STRING,
 474             .help = "emulated machine"
 475         }, {
 476             .name = "accel",
 477             .type = QEMU_OPT_STRING,
 478             .help = "accelerator list",
 479         },
 480         { /* End of list */ }
 481     },
 482 };
 483
 484 QemuOptsList qemu_boot_opts = {
 485     .name = "boot-opts",
 486     .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
 487     .desc = {
 488         /* the three names below are not used now */
 489         {
 490             .name = "order",
 491             .type = QEMU_OPT_STRING,
 492         }, {
 493             .name = "once",
 494             .type = QEMU_OPT_STRING,
 495         }, {
 496             .name = "menu",
 497             .type = QEMU_OPT_STRING,
 498         /* following are really used */
 499         }, {
 500             .name = "splash",
 501             .type = QEMU_OPT_STRING,
 502         }, {
 503             .name = "splash-time",
 504             .type = QEMU_OPT_STRING,
 505         },
 506         { /*End of list */ }
 507     },
 508 };
 509
 510 static QemuOptsList *vm_config_groups[32] = {
 511     &qemu_drive_opts,
 512     &qemu_chardev_opts,
 513     &qemu_device_opts,
 514     &qemu_netdev_opts,
 515     &qemu_net_opts,
 516     &qemu_rtc_opts,
 517     &qemu_global_opts,
 518     &qemu_mon_opts,
 519     &qemu_cpudef_opts,
 520 #ifdef CONFIG_SIMPLE_TRACE
 521     &qemu_trace_opts,
 522 #endif
 523     &qemu_option_rom_opts,
 524     &qemu_machine_opts,
 525     &qemu_boot_opts,
 526     NULL,
 527 };
 528
 529 static QemuOptsList *find_list(QemuOptsList **lists, const char *group)
 530 {
 531     int i;
 532
 533     for (i = 0; lists[i] != NULL; i++) {
 534         if (strcmp(lists[i]->name, group) == 0)
 535             break;
 536     }
 537     if (lists[i] == NULL) {
 538         error_report("there is no option group \"%s\"", group);
 539     }
 540     return lists[i];
 541 }
 542
 543 QemuOptsList *qemu_find_opts(const char *group)
 544 {
 545     return find_list(vm_config_groups, group);
 546 }
 547
 548 void qemu_add_opts(QemuOptsList *list)
 549 {
 550     int entries, i;
 551
 552     entries = ARRAY_SIZE(vm_config_groups);
 553     entries--; /* keep list NULL terminated */
 554     for (i = 0; i < entries; i++) {
 555         if (vm_config_groups[i] == NULL) {
 556             vm_config_groups[i] = list;
 557             return;
 558         }
 559     }
 560     fprintf(stderr, "ran out of space in vm_config_groups");
 561     abort();
 562 }
 563
 564 int qemu_set_option(const char *str)
 565 {
 566     char group[64], id[64], arg[64];
 567     QemuOptsList *list;
 568     QemuOpts *opts;
 569     int rc, offset;
 570
 571     rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
 572     if (rc < 3 || str[offset] != '=') {
 573         error_report("can't parse: \"%s\"", str);
 574         return -1;
 575     }
 576
 577     list = qemu_find_opts(group);
 578     if (list == NULL) {
 579         return -1;
 580     }
 581
 582     opts = qemu_opts_find(list, id);
 583     if (!opts) {
 584         error_report("there is no %s \"%s\" defined",
 585                      list->name, id);
 586         return -1;
 587     }
 588
 589     if (qemu_opt_set(opts, arg, str+offset+1) == -1) {
 590         return -1;
 591     }
 592     return 0;
 593 }
 594
 595 int qemu_global_option(const char *str)
 596 {
 597     char driver[64], property[64];
 598     QemuOpts *opts;
 599     int rc, offset;
 600
 601     rc = sscanf(str, "%63[^.].%63[^=]%n", driver, property, &offset);
 602     if (rc < 2 || str[offset] != '=') {
 603         error_report("can't parse: \"%s\"", str);
 604         return -1;
 605     }
 606
 607     opts = qemu_opts_create(&qemu_global_opts, NULL, 0);
 608     qemu_opt_set(opts, "driver", driver);
 609     qemu_opt_set(opts, "property", property);
 610     qemu_opt_set(opts, "value", str+offset+1);
 611     return 0;
 612 }
 613
 614 struct ConfigWriteData {
 615     QemuOptsList *list;
 616     FILE *fp;
 617 };
 618
 619 static int config_write_opt(const char *name, const char *value, void *opaque)
 620 {
 621     struct ConfigWriteData *data = opaque;
 622
 623     fprintf(data->fp, "  %s = \"%s\"\n", name, value);
 624     return 0;
 625 }
 626
 627 static int config_write_opts(QemuOpts *opts, void *opaque)
 628 {
 629     struct ConfigWriteData *data = opaque;
 630     const char *id = qemu_opts_id(opts);
 631
 632     if (id) {
 633         fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id);
 634     } else {
 635         fprintf(data->fp, "[%s]\n", data->list->name);
 636     }
 637     qemu_opt_foreach(opts, config_write_opt, data, 0);
 638     fprintf(data->fp, "\n");
 639     return 0;
 640 }
 641
 642 void qemu_config_write(FILE *fp)
 643 {
 644     struct ConfigWriteData data = { .fp = fp };
 645     QemuOptsList **lists = vm_config_groups;
 646     int i;
 647
 648     fprintf(fp, "# qemu config file\n\n");
 649     for (i = 0; lists[i] != NULL; i++) {
 650         data.list = lists[i];
 651         qemu_opts_foreach(data.list, config_write_opts, &data, 0);
 652     }
 653 }
 654
 655 int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
 656 {
 657     char line[1024], group[64], id[64], arg[64], value[1024];
 658     Location loc;
 659     QemuOptsList *list = NULL;
 660     QemuOpts *opts = NULL;
 661     int res = -1, lno = 0;
 662
 663     loc_push_none(&loc);
 664     while (fgets(line, sizeof(line), fp) != NULL) {
 665         loc_set_file(fname, ++lno);
 666         if (line[0] == '\n') {
 667             /* skip empty lines */
 668             continue;
 669         }
 670         if (line[0] == '#') {
 671             /* comment */
 672             continue;
 673         }
 674         if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) {
 675             /* group with id */
 676             list = find_list(lists, group);
 677             if (list == NULL)
 678                 goto out;
 679             opts = qemu_opts_create(list, id, 1);
 680             continue;
 681         }
 682         if (sscanf(line, "[%63[^]]]", group) == 1) {
 683             /* group without id */
 684             list = find_list(lists, group);
 685             if (list == NULL)
 686                 goto out;
 687             opts = qemu_opts_create(list, NULL, 0);
 688             continue;
 689         }
 690         if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2) {
 691             /* arg = value */
 692             if (opts == NULL) {
 693                 error_report("no group defined");
 694                 goto out;
 695             }
 696             if (qemu_opt_set(opts, arg, value) != 0) {
 697                 goto out;
 698             }
 699             continue;
 700         }
 701         error_report("parse error");
 702         goto out;
 703     }
 704     if (ferror(fp)) {
 705         error_report("error reading file");
 706         goto out;
 707     }
 708     res = 0;
 709 out:
 710     loc_pop(&loc);
 711     return res;
 712 }
 713
 714 int qemu_read_config_file(const char *filename)
 715 {
 716     FILE *f = fopen(filename, "r");
 717     int ret;
 718
 719     if (f == NULL) {
 720         return -errno;
 721     }
 722
 723     ret = qemu_config_parse(f, vm_config_groups, filename);
 724     fclose(f);
 725
 726     if (ret == 0) {
 727         return 0;
 728     } else {
 729         return -EINVAL;
 730     }
 731 }