hw/core/machine.c

   1 /*
   2  * QEMU Machine
   3  *
   4  * Copyright (C) 2014 Red Hat Inc
   5  *
   6  * Authors:
   7  *   Marcel Apfelbaum <marcel.a@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "hw/boards.h"
  15 #include "qapi/error.h"
  16 #include "qapi-visit.h"
  17 #include "qapi/visitor.h"
  18 #include "hw/sysbus.h"
  19 #include "sysemu/sysemu.h"
  20 #include "qemu/error-report.h"
  21 #include "qemu/cutils.h"
  22
  23 static char *machine_get_accel(Object *obj, Error **errp)
  24 {
  25     MachineState *ms = MACHINE(obj);
  26
  27     return g_strdup(ms->accel);
  28 }
  29
  30 static void machine_set_accel(Object *obj, const char *value, Error **errp)
  31 {
  32     MachineState *ms = MACHINE(obj);
  33
  34     g_free(ms->accel);
  35     ms->accel = g_strdup(value);
  36 }
  37
  38 static void machine_set_kernel_irqchip(Object *obj, Visitor *v,
  39                                        const char *name, void *opaque,
  40                                        Error **errp)
  41 {
  42     Error *err = NULL;
  43     MachineState *ms = MACHINE(obj);
  44     OnOffSplit mode;
  45
  46     visit_type_OnOffSplit(v, name, &mode, &err);
  47     if (err) {
  48         error_propagate(errp, err);
  49         return;
  50     } else {
  51         switch (mode) {
  52         case ON_OFF_SPLIT_ON:
  53             ms->kernel_irqchip_allowed = true;
  54             ms->kernel_irqchip_required = true;
  55             ms->kernel_irqchip_split = false;
  56             break;
  57         case ON_OFF_SPLIT_OFF:
  58             ms->kernel_irqchip_allowed = false;
  59             ms->kernel_irqchip_required = false;
  60             ms->kernel_irqchip_split = false;
  61             break;
  62         case ON_OFF_SPLIT_SPLIT:
  63             ms->kernel_irqchip_allowed = true;
  64             ms->kernel_irqchip_required = true;
  65             ms->kernel_irqchip_split = true;
  66             break;
  67         default:
  68             /* The value was checked in visit_type_OnOffSplit() above. If
  69              * we get here, then something is wrong in QEMU.
  70              */
  71             abort();
  72         }
  73     }
  74 }
  75
  76 static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
  77                                        const char *name, void *opaque,
  78                                        Error **errp)
  79 {
  80     MachineState *ms = MACHINE(obj);
  81     int64_t value = ms->kvm_shadow_mem;
  82
  83     visit_type_int(v, name, &value, errp);
  84 }
  85
  86 static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
  87                                        const char *name, void *opaque,
  88                                        Error **errp)
  89 {
  90     MachineState *ms = MACHINE(obj);
  91     Error *error = NULL;
  92     int64_t value;
  93
  94     visit_type_int(v, name, &value, &error);
  95     if (error) {
  96         error_propagate(errp, error);
  97         return;
  98     }
  99
 100     ms->kvm_shadow_mem = value;
 101 }
 102
 103 static char *machine_get_kernel(Object *obj, Error **errp)
 104 {
 105     MachineState *ms = MACHINE(obj);
 106
 107     return g_strdup(ms->kernel_filename);
 108 }
 109
 110 static void machine_set_kernel(Object *obj, const char *value, Error **errp)
 111 {
 112     MachineState *ms = MACHINE(obj);
 113
 114     g_free(ms->kernel_filename);
 115     ms->kernel_filename = g_strdup(value);
 116 }
 117
 118 static char *machine_get_initrd(Object *obj, Error **errp)
 119 {
 120     MachineState *ms = MACHINE(obj);
 121
 122     return g_strdup(ms->initrd_filename);
 123 }
 124
 125 static void machine_set_initrd(Object *obj, const char *value, Error **errp)
 126 {
 127     MachineState *ms = MACHINE(obj);
 128
 129     g_free(ms->initrd_filename);
 130     ms->initrd_filename = g_strdup(value);
 131 }
 132
 133 static char *machine_get_append(Object *obj, Error **errp)
 134 {
 135     MachineState *ms = MACHINE(obj);
 136
 137     return g_strdup(ms->kernel_cmdline);
 138 }
 139
 140 static void machine_set_append(Object *obj, const char *value, Error **errp)
 141 {
 142     MachineState *ms = MACHINE(obj);
 143
 144     g_free(ms->kernel_cmdline);
 145     ms->kernel_cmdline = g_strdup(value);
 146 }
 147
 148 static char *machine_get_dtb(Object *obj, Error **errp)
 149 {
 150     MachineState *ms = MACHINE(obj);
 151
 152     return g_strdup(ms->dtb);
 153 }
 154
 155 static void machine_set_dtb(Object *obj, const char *value, Error **errp)
 156 {
 157     MachineState *ms = MACHINE(obj);
 158
 159     g_free(ms->dtb);
 160     ms->dtb = g_strdup(value);
 161 }
 162
 163 static char *machine_get_dumpdtb(Object *obj, Error **errp)
 164 {
 165     MachineState *ms = MACHINE(obj);
 166
 167     return g_strdup(ms->dumpdtb);
 168 }
 169
 170 static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
 171 {
 172     MachineState *ms = MACHINE(obj);
 173
 174     g_free(ms->dumpdtb);
 175     ms->dumpdtb = g_strdup(value);
 176 }
 177
 178 static void machine_get_phandle_start(Object *obj, Visitor *v,
 179                                       const char *name, void *opaque,
 180                                       Error **errp)
 181 {
 182     MachineState *ms = MACHINE(obj);
 183     int64_t value = ms->phandle_start;
 184
 185     visit_type_int(v, name, &value, errp);
 186 }
 187
 188 static void machine_set_phandle_start(Object *obj, Visitor *v,
 189                                       const char *name, void *opaque,
 190                                       Error **errp)
 191 {
 192     MachineState *ms = MACHINE(obj);
 193     Error *error = NULL;
 194     int64_t value;
 195
 196     visit_type_int(v, name, &value, &error);
 197     if (error) {
 198         error_propagate(errp, error);
 199         return;
 200     }
 201
 202     ms->phandle_start = value;
 203 }
 204
 205 static char *machine_get_dt_compatible(Object *obj, Error **errp)
 206 {
 207     MachineState *ms = MACHINE(obj);
 208
 209     return g_strdup(ms->dt_compatible);
 210 }
 211
 212 static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
 213 {
 214     MachineState *ms = MACHINE(obj);
 215
 216     g_free(ms->dt_compatible);
 217     ms->dt_compatible = g_strdup(value);
 218 }
 219
 220 static bool machine_get_dump_guest_core(Object *obj, Error **errp)
 221 {
 222     MachineState *ms = MACHINE(obj);
 223
 224     return ms->dump_guest_core;
 225 }
 226
 227 static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
 228 {
 229     MachineState *ms = MACHINE(obj);
 230
 231     ms->dump_guest_core = value;
 232 }
 233
 234 static bool machine_get_mem_merge(Object *obj, Error **errp)
 235 {
 236     MachineState *ms = MACHINE(obj);
 237
 238     return ms->mem_merge;
 239 }
 240
 241 static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
 242 {
 243     MachineState *ms = MACHINE(obj);
 244
 245     ms->mem_merge = value;
 246 }
 247
 248 static bool machine_get_usb(Object *obj, Error **errp)
 249 {
 250     MachineState *ms = MACHINE(obj);
 251
 252     return ms->usb;
 253 }
 254
 255 static void machine_set_usb(Object *obj, bool value, Error **errp)
 256 {
 257     MachineState *ms = MACHINE(obj);
 258
 259     ms->usb = value;
 260     ms->usb_disabled = !value;
 261 }
 262
 263 static bool machine_get_graphics(Object *obj, Error **errp)
 264 {
 265     MachineState *ms = MACHINE(obj);
 266
 267     return ms->enable_graphics;
 268 }
 269
 270 static void machine_set_graphics(Object *obj, bool value, Error **errp)
 271 {
 272     MachineState *ms = MACHINE(obj);
 273
 274     ms->enable_graphics = value;
 275 }
 276
 277 static bool machine_get_igd_gfx_passthru(Object *obj, Error **errp)
 278 {
 279     MachineState *ms = MACHINE(obj);
 280
 281     return ms->igd_gfx_passthru;
 282 }
 283
 284 static void machine_set_igd_gfx_passthru(Object *obj, bool value, Error **errp)
 285 {
 286     MachineState *ms = MACHINE(obj);
 287
 288     ms->igd_gfx_passthru = value;
 289 }
 290
 291 static char *machine_get_firmware(Object *obj, Error **errp)
 292 {
 293     MachineState *ms = MACHINE(obj);
 294
 295     return g_strdup(ms->firmware);
 296 }
 297
 298 static void machine_set_firmware(Object *obj, const char *value, Error **errp)
 299 {
 300     MachineState *ms = MACHINE(obj);
 301
 302     g_free(ms->firmware);
 303     ms->firmware = g_strdup(value);
 304 }
 305
 306 static void machine_set_suppress_vmdesc(Object *obj, bool value, Error **errp)
 307 {
 308     MachineState *ms = MACHINE(obj);
 309
 310     ms->suppress_vmdesc = value;
 311 }
 312
 313 static bool machine_get_suppress_vmdesc(Object *obj, Error **errp)
 314 {
 315     MachineState *ms = MACHINE(obj);
 316
 317     return ms->suppress_vmdesc;
 318 }
 319
 320 static void machine_set_enforce_config_section(Object *obj, bool value,
 321                                              Error **errp)
 322 {
 323     MachineState *ms = MACHINE(obj);
 324
 325     ms->enforce_config_section = value;
 326 }
 327
 328 static bool machine_get_enforce_config_section(Object *obj, Error **errp)
 329 {
 330     MachineState *ms = MACHINE(obj);
 331
 332     return ms->enforce_config_section;
 333 }
 334
 335 static void error_on_sysbus_device(SysBusDevice *sbdev, void *opaque)
 336 {
 337     error_report("Option '-device %s' cannot be handled by this machine",
 338                  object_class_get_name(object_get_class(OBJECT(sbdev))));
 339     exit(1);
 340 }
 341
 342 static void machine_init_notify(Notifier *notifier, void *data)
 343 {
 344     Object *machine = qdev_get_machine();
 345     ObjectClass *oc = object_get_class(machine);
 346     MachineClass *mc = MACHINE_CLASS(oc);
 347
 348     if (mc->has_dynamic_sysbus) {
 349         /* Our machine can handle dynamic sysbus devices, we're all good */
 350         return;
 351     }
 352
 353     /*
 354      * Loop through all dynamically created devices and check whether there
 355      * are sysbus devices among them. If there are, error out.
 356      */
 357     foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL);
 358 }
 359
 360 HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)
 361 {
 362     int i;
 363     Object *cpu;
 364     HotpluggableCPUList *head = NULL;
 365     const char *cpu_type;
 366
 367     cpu = machine->possible_cpus->cpus[0].cpu;
 368     assert(cpu); /* Boot cpu is always present */
 369     cpu_type = object_get_typename(cpu);
 370     for (i = 0; i < machine->possible_cpus->len; i++) {
 371         HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);
 372         HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);
 373
 374         cpu_item->type = g_strdup(cpu_type);
 375         cpu_item->vcpus_count = machine->possible_cpus->cpus[i].vcpus_count;
 376         cpu_item->props = g_memdup(&machine->possible_cpus->cpus[i].props,
 377                                    sizeof(*cpu_item->props));
 378
 379         cpu = machine->possible_cpus->cpus[i].cpu;
 380         if (cpu) {
 381             cpu_item->has_qom_path = true;
 382             cpu_item->qom_path = object_get_canonical_path(cpu);
 383         }
 384         list_item->value = cpu_item;
 385         list_item->next = head;
 386         head = list_item;
 387     }
 388     return head;
 389 }
 390
 391 static void machine_class_init(ObjectClass *oc, void *data)
 392 {
 393     MachineClass *mc = MACHINE_CLASS(oc);
 394
 395     /* Default 128 MB as guest ram size */
 396     mc->default_ram_size = 128 * M_BYTE;
 397     mc->rom_file_has_mr = true;
 398
 399     /* numa node memory size aligned on 8MB by default.
 400      * On Linux, each node's border has to be 8MB aligned
 401      */
 402     mc->numa_mem_align_shift = 23;
 403
 404     object_class_property_add_str(oc, "accel",
 405         machine_get_accel, machine_set_accel, &error_abort);
 406     object_class_property_set_description(oc, "accel",
 407         "Accelerator list", &error_abort);
 408
 409     object_class_property_add(oc, "kernel-irqchip", "OnOffSplit",
 410         NULL, machine_set_kernel_irqchip,
 411         NULL, NULL, &error_abort);
 412     object_class_property_set_description(oc, "kernel-irqchip",
 413         "Configure KVM in-kernel irqchip", &error_abort);
 414
 415     object_class_property_add(oc, "kvm-shadow-mem", "int",
 416         machine_get_kvm_shadow_mem, machine_set_kvm_shadow_mem,
 417         NULL, NULL, &error_abort);
 418     object_class_property_set_description(oc, "kvm-shadow-mem",
 419         "KVM shadow MMU size", &error_abort);
 420
 421     object_class_property_add_str(oc, "kernel",
 422         machine_get_kernel, machine_set_kernel, &error_abort);
 423     object_class_property_set_description(oc, "kernel",
 424         "Linux kernel image file", &error_abort);
 425
 426     object_class_property_add_str(oc, "initrd",
 427         machine_get_initrd, machine_set_initrd, &error_abort);
 428     object_class_property_set_description(oc, "initrd",
 429         "Linux initial ramdisk file", &error_abort);
 430
 431     object_class_property_add_str(oc, "append",
 432         machine_get_append, machine_set_append, &error_abort);
 433     object_class_property_set_description(oc, "append",
 434         "Linux kernel command line", &error_abort);
 435
 436     object_class_property_add_str(oc, "dtb",
 437         machine_get_dtb, machine_set_dtb, &error_abort);
 438     object_class_property_set_description(oc, "dtb",
 439         "Linux kernel device tree file", &error_abort);
 440
 441     object_class_property_add_str(oc, "dumpdtb",
 442         machine_get_dumpdtb, machine_set_dumpdtb, &error_abort);
 443     object_class_property_set_description(oc, "dumpdtb",
 444         "Dump current dtb to a file and quit", &error_abort);
 445
 446     object_class_property_add(oc, "phandle-start", "int",
 447         machine_get_phandle_start, machine_set_phandle_start,
 448         NULL, NULL, &error_abort);
 449     object_class_property_set_description(oc, "phandle-start",
 450             "The first phandle ID we may generate dynamically", &error_abort);
 451
 452     object_class_property_add_str(oc, "dt-compatible",
 453         machine_get_dt_compatible, machine_set_dt_compatible, &error_abort);
 454     object_class_property_set_description(oc, "dt-compatible",
 455         "Overrides the \"compatible\" property of the dt root node",
 456         &error_abort);
 457
 458     object_class_property_add_bool(oc, "dump-guest-core",
 459         machine_get_dump_guest_core, machine_set_dump_guest_core, &error_abort);
 460     object_class_property_set_description(oc, "dump-guest-core",
 461         "Include guest memory in  a core dump", &error_abort);
 462
 463     object_class_property_add_bool(oc, "mem-merge",
 464         machine_get_mem_merge, machine_set_mem_merge, &error_abort);
 465     object_class_property_set_description(oc, "mem-merge",
 466         "Enable/disable memory merge support", &error_abort);
 467
 468     object_class_property_add_bool(oc, "usb",
 469         machine_get_usb, machine_set_usb, &error_abort);
 470     object_class_property_set_description(oc, "usb",
 471         "Set on/off to enable/disable usb", &error_abort);
 472
 473     object_class_property_add_bool(oc, "graphics",
 474         machine_get_graphics, machine_set_graphics, &error_abort);
 475     object_class_property_set_description(oc, "graphics",
 476         "Set on/off to enable/disable graphics emulation", &error_abort);
 477
 478     object_class_property_add_bool(oc, "igd-passthru",
 479         machine_get_igd_gfx_passthru, machine_set_igd_gfx_passthru,
 480         &error_abort);
 481     object_class_property_set_description(oc, "igd-passthru",
 482         "Set on/off to enable/disable igd passthrou", &error_abort);
 483
 484     object_class_property_add_str(oc, "firmware",
 485         machine_get_firmware, machine_set_firmware,
 486         &error_abort);
 487     object_class_property_set_description(oc, "firmware",
 488         "Firmware image", &error_abort);
 489
 490     object_class_property_add_bool(oc, "suppress-vmdesc",
 491         machine_get_suppress_vmdesc, machine_set_suppress_vmdesc,
 492         &error_abort);
 493     object_class_property_set_description(oc, "suppress-vmdesc",
 494         "Set on to disable self-describing migration", &error_abort);
 495
 496     object_class_property_add_bool(oc, "enforce-config-section",
 497         machine_get_enforce_config_section, machine_set_enforce_config_section,
 498         &error_abort);
 499     object_class_property_set_description(oc, "enforce-config-section",
 500         "Set on to enforce configuration section migration", &error_abort);
 501 }
 502
 503 static void machine_class_base_init(ObjectClass *oc, void *data)
 504 {
 505     if (!object_class_is_abstract(oc)) {
 506         MachineClass *mc = MACHINE_CLASS(oc);
 507         const char *cname = object_class_get_name(oc);
 508         assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
 509         mc->name = g_strndup(cname,
 510                             strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
 511     }
 512 }
 513
 514 static void machine_initfn(Object *obj)
 515 {
 516     MachineState *ms = MACHINE(obj);
 517
 518     ms->kernel_irqchip_allowed = true;
 519     ms->kvm_shadow_mem = -1;
 520     ms->dump_guest_core = true;
 521     ms->mem_merge = true;
 522     ms->enable_graphics = true;
 523
 524     /* Register notifier when init is done for sysbus sanity checks */
 525     ms->sysbus_notifier.notify = machine_init_notify;
 526     qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
 527 }
 528
 529 static void machine_finalize(Object *obj)
 530 {
 531     MachineState *ms = MACHINE(obj);
 532
 533     g_free(ms->accel);
 534     g_free(ms->kernel_filename);
 535     g_free(ms->initrd_filename);
 536     g_free(ms->kernel_cmdline);
 537     g_free(ms->dtb);
 538     g_free(ms->dumpdtb);
 539     g_free(ms->dt_compatible);
 540     g_free(ms->firmware);
 541 }
 542
 543 bool machine_usb(MachineState *machine)
 544 {
 545     return machine->usb;
 546 }
 547
 548 bool machine_kernel_irqchip_allowed(MachineState *machine)
 549 {
 550     return machine->kernel_irqchip_allowed;
 551 }
 552
 553 bool machine_kernel_irqchip_required(MachineState *machine)
 554 {
 555     return machine->kernel_irqchip_required;
 556 }
 557
 558 bool machine_kernel_irqchip_split(MachineState *machine)
 559 {
 560     return machine->kernel_irqchip_split;
 561 }
 562
 563 int machine_kvm_shadow_mem(MachineState *machine)
 564 {
 565     return machine->kvm_shadow_mem;
 566 }
 567
 568 int machine_phandle_start(MachineState *machine)
 569 {
 570     return machine->phandle_start;
 571 }
 572
 573 bool machine_dump_guest_core(MachineState *machine)
 574 {
 575     return machine->dump_guest_core;
 576 }
 577
 578 bool machine_mem_merge(MachineState *machine)
 579 {
 580     return machine->mem_merge;
 581 }
 582
 583 static void machine_class_finalize(ObjectClass *klass, void *data)
 584 {
 585     MachineClass *mc = MACHINE_CLASS(klass);
 586
 587     if (mc->compat_props) {
 588         g_array_free(mc->compat_props, true);
 589     }
 590     g_free(mc->name);
 591 }
 592
 593 static void register_compat_prop(const char *driver,
 594                                  const char *property,
 595                                  const char *value)
 596 {
 597     GlobalProperty *p = g_new0(GlobalProperty, 1);
 598     /* Machine compat_props must never cause errors: */
 599     p->errp = &error_abort;
 600     p->driver = driver;
 601     p->property = property;
 602     p->value = value;
 603     qdev_prop_register_global(p);
 604 }
 605
 606 static void machine_register_compat_for_subclass(ObjectClass *oc, void *opaque)
 607 {
 608     GlobalProperty *p = opaque;
 609     register_compat_prop(object_class_get_name(oc), p->property, p->value);
 610 }
 611
 612 void machine_register_compat_props(MachineState *machine)
 613 {
 614     MachineClass *mc = MACHINE_GET_CLASS(machine);
 615     int i;
 616     GlobalProperty *p;
 617     ObjectClass *oc;
 618
 619     if (!mc->compat_props) {
 620         return;
 621     }
 622
 623     for (i = 0; i < mc->compat_props->len; i++) {
 624         p = g_array_index(mc->compat_props, GlobalProperty *, i);
 625         oc = object_class_by_name(p->driver);
 626         if (oc && object_class_is_abstract(oc)) {
 627             /* temporary hack to make sure we do not override
 628              * globals set explicitly on -global: if an abstract class
 629              * is on compat_props, register globals for all its
 630              * non-abstract subtypes instead.
 631              *
 632              * This doesn't solve the problem for cases where
 633              * a non-abstract typename mentioned on compat_props
 634              * has subclasses, like spapr-pci-host-bridge.
 635              */
 636             object_class_foreach(machine_register_compat_for_subclass,
 637                                  p->driver, false, p);
 638         } else {
 639             register_compat_prop(p->driver, p->property, p->value);
 640         }
 641     }
 642 }
 643
 644 static const TypeInfo machine_info = {
 645     .name = TYPE_MACHINE,
 646     .parent = TYPE_OBJECT,
 647     .abstract = true,
 648     .class_size = sizeof(MachineClass),
 649     .class_init    = machine_class_init,
 650     .class_base_init = machine_class_base_init,
 651     .class_finalize = machine_class_finalize,
 652     .instance_size = sizeof(MachineState),
 653     .instance_init = machine_initfn,
 654     .instance_finalize = machine_finalize,
 655 };
 656
 657 static void machine_register_types(void)
 658 {
 659     type_register_static(&machine_info);
 660 }
 661
 662 type_init(machine_register_types)