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