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