[qemu.git] / hw / core / machine.c

/*
 * QEMU Machine
 *
 * Copyright (C) 2014 Red Hat Inc
 *
 * Authors:
 *   Marcel Apfelbaum <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "hw/boards.h"
#include "qapi-visit.h"
#include "qapi/visitor.h"
#include "hw/sysbus.h"
#include "sysemu/sysemu.h"
#include "qemu/error-report.h"

static char *machine_get_accel(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->accel);
}

static void machine_set_accel(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->accel);
    ms->accel = g_strdup(value);
}

static void machine_set_kernel_irqchip(Object *obj, Visitor *v,
                                       void *opaque, const char *name,
                                       Error **errp)
{
    Error *err = NULL;
    MachineState *ms = MACHINE(obj);
    OnOffSplit mode;

    visit_type_OnOffSplit(v, &mode, name, &err);
    if (err) {
        error_propagate(errp, err);
        return;
    } else {
        switch (mode) {
        case ON_OFF_SPLIT_ON:
            ms->kernel_irqchip_allowed = true;
            ms->kernel_irqchip_required = true;
            ms->kernel_irqchip_split = false;
            break;
        case ON_OFF_SPLIT_OFF:
            ms->kernel_irqchip_allowed = false;
            ms->kernel_irqchip_required = false;
            ms->kernel_irqchip_split = false;
            break;
        case ON_OFF_SPLIT_SPLIT:
            ms->kernel_irqchip_allowed = true;
            ms->kernel_irqchip_required = true;
            ms->kernel_irqchip_split = true;
            break;
        default:
            abort();
        }
    }
}

static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
                                       void *opaque, const char *name,
                                       Error **errp)
{
    MachineState *ms = MACHINE(obj);
    int64_t value = ms->kvm_shadow_mem;

    visit_type_int(v, &value, name, errp);
}

static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
                                       void *opaque, const char *name,
                                       Error **errp)
{
    MachineState *ms = MACHINE(obj);
    Error *error = NULL;
    int64_t value;

    visit_type_int(v, &value, name, &error);
    if (error) {
        error_propagate(errp, error);
        return;
    }

    ms->kvm_shadow_mem = value;
}

static char *machine_get_kernel(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->kernel_filename);
}

static void machine_set_kernel(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->kernel_filename);
    ms->kernel_filename = g_strdup(value);
}

static char *machine_get_initrd(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->initrd_filename);
}

static void machine_set_initrd(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->initrd_filename);
    ms->initrd_filename = g_strdup(value);
}

static char *machine_get_append(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->kernel_cmdline);
}

static void machine_set_append(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->kernel_cmdline);
    ms->kernel_cmdline = g_strdup(value);
}

static char *machine_get_dtb(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->dtb);
}

static void machine_set_dtb(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->dtb);
    ms->dtb = g_strdup(value);
}

static char *machine_get_dumpdtb(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->dumpdtb);
}

static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->dumpdtb);
    ms->dumpdtb = g_strdup(value);
}

static void machine_get_phandle_start(Object *obj, Visitor *v,
                                       void *opaque, const char *name,
                                       Error **errp)
{
    MachineState *ms = MACHINE(obj);
    int64_t value = ms->phandle_start;

    visit_type_int(v, &value, name, errp);
}

static void machine_set_phandle_start(Object *obj, Visitor *v,
                                       void *opaque, const char *name,
                                       Error **errp)
{
    MachineState *ms = MACHINE(obj);
    Error *error = NULL;
    int64_t value;

    visit_type_int(v, &value, name, &error);
    if (error) {
        error_propagate(errp, error);
        return;
    }

    ms->phandle_start = value;
}

static char *machine_get_dt_compatible(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->dt_compatible);
}

static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->dt_compatible);
    ms->dt_compatible = g_strdup(value);
}

static bool machine_get_dump_guest_core(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->dump_guest_core;
}

static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->dump_guest_core = value;
}

static bool machine_get_mem_merge(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->mem_merge;
}

static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->mem_merge = value;
}

static bool machine_get_usb(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->usb;
}

static void machine_set_usb(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->usb = value;
    ms->usb_disabled = !value;
}

static bool machine_get_igd_gfx_passthru(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->igd_gfx_passthru;
}

static void machine_set_igd_gfx_passthru(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->igd_gfx_passthru = value;
}

static char *machine_get_firmware(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return g_strdup(ms->firmware);
}

static void machine_set_firmware(Object *obj, const char *value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->firmware);
    ms->firmware = g_strdup(value);
}

static bool machine_get_iommu(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->iommu;
}

static void machine_set_iommu(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->iommu = value;
}

static void machine_set_suppress_vmdesc(Object *obj, bool value, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->suppress_vmdesc = value;
}

static bool machine_get_suppress_vmdesc(Object *obj, Error **errp)
{
    MachineState *ms = MACHINE(obj);

    return ms->suppress_vmdesc;
}

static int error_on_sysbus_device(SysBusDevice *sbdev, void *opaque)
{
    error_report("Option '-device %s' cannot be handled by this machine",
                 object_class_get_name(object_get_class(OBJECT(sbdev))));
    exit(1);
}

static void machine_init_notify(Notifier *notifier, void *data)
{
    Object *machine = qdev_get_machine();
    ObjectClass *oc = object_get_class(machine);
    MachineClass *mc = MACHINE_CLASS(oc);

    if (mc->has_dynamic_sysbus) {
        /* Our machine can handle dynamic sysbus devices, we're all good */
        return;
    }

    /*
     * Loop through all dynamically created devices and check whether there
     * are sysbus devices among them. If there are, error out.
     */
    foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL);
}

static void machine_class_init(ObjectClass *oc, void *data)
{
    MachineClass *mc = MACHINE_CLASS(oc);

    /* Default 128 MB as guest ram size */
    mc->default_ram_size = 128 * M_BYTE;
    mc->rom_file_has_mr = true;
}

static void machine_class_base_init(ObjectClass *oc, void *data)
{
    if (!object_class_is_abstract(oc)) {
        MachineClass *mc = MACHINE_CLASS(oc);
        const char *cname = object_class_get_name(oc);
        assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
        mc->name = g_strndup(cname,
                            strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
    }
}

static void machine_initfn(Object *obj)
{
    MachineState *ms = MACHINE(obj);

    ms->kernel_irqchip_allowed = true;
    ms->kvm_shadow_mem = -1;
    ms->dump_guest_core = true;
    ms->mem_merge = true;

    object_property_add_str(obj, "accel",
                            machine_get_accel, machine_set_accel, NULL);
    object_property_set_description(obj, "accel",
                                    "Accelerator list",
                                    NULL);
    object_property_add(obj, "kernel-irqchip", "OnOffSplit",
                        NULL,
                        machine_set_kernel_irqchip,
                        NULL, NULL, NULL);
    object_property_set_description(obj, "kernel-irqchip",
                                    "Configure KVM in-kernel irqchip",
                                    NULL);
    object_property_add(obj, "kvm-shadow-mem", "int",
                        machine_get_kvm_shadow_mem,
                        machine_set_kvm_shadow_mem,
                        NULL, NULL, NULL);
    object_property_set_description(obj, "kvm-shadow-mem",
                                    "KVM shadow MMU size",
                                    NULL);
    object_property_add_str(obj, "kernel",
                            machine_get_kernel, machine_set_kernel, NULL);
    object_property_set_description(obj, "kernel",
                                    "Linux kernel image file",
                                    NULL);
    object_property_add_str(obj, "initrd",
                            machine_get_initrd, machine_set_initrd, NULL);
    object_property_set_description(obj, "initrd",
                                    "Linux initial ramdisk file",
                                    NULL);
    object_property_add_str(obj, "append",
                            machine_get_append, machine_set_append, NULL);
    object_property_set_description(obj, "append",
                                    "Linux kernel command line",
                                    NULL);
    object_property_add_str(obj, "dtb",
                            machine_get_dtb, machine_set_dtb, NULL);
    object_property_set_description(obj, "dtb",
                                    "Linux kernel device tree file",
                                    NULL);
    object_property_add_str(obj, "dumpdtb",
                            machine_get_dumpdtb, machine_set_dumpdtb, NULL);
    object_property_set_description(obj, "dumpdtb",
                                    "Dump current dtb to a file and quit",
                                    NULL);
    object_property_add(obj, "phandle-start", "int",
                        machine_get_phandle_start,
                        machine_set_phandle_start,
                        NULL, NULL, NULL);
    object_property_set_description(obj, "phandle-start",
                                    "The first phandle ID we may generate dynamically",
                                    NULL);
    object_property_add_str(obj, "dt-compatible",
                            machine_get_dt_compatible,
                            machine_set_dt_compatible,
                            NULL);
    object_property_set_description(obj, "dt-compatible",
                                    "Overrides the \"compatible\" property of the dt root node",
                                    NULL);
    object_property_add_bool(obj, "dump-guest-core",
                             machine_get_dump_guest_core,
                             machine_set_dump_guest_core,
                             NULL);
    object_property_set_description(obj, "dump-guest-core",
                                    "Include guest memory in  a core dump",
                                    NULL);
    object_property_add_bool(obj, "mem-merge",
                             machine_get_mem_merge,
                             machine_set_mem_merge, NULL);
    object_property_set_description(obj, "mem-merge",
                                    "Enable/disable memory merge support",
                                    NULL);
    object_property_add_bool(obj, "usb",
                             machine_get_usb,
                             machine_set_usb, NULL);
    object_property_set_description(obj, "usb",
                                    "Set on/off to enable/disable usb",
                                    NULL);
    object_property_add_bool(obj, "igd-passthru",
                             machine_get_igd_gfx_passthru,
                             machine_set_igd_gfx_passthru, NULL);
    object_property_set_description(obj, "igd-passthru",
                                    "Set on/off to enable/disable igd passthrou",
                                    NULL);
    object_property_add_str(obj, "firmware",
                            machine_get_firmware,
                            machine_set_firmware, NULL);
    object_property_set_description(obj, "firmware",
                                    "Firmware image",
                                    NULL);
    object_property_add_bool(obj, "iommu",
                             machine_get_iommu,
                             machine_set_iommu, NULL);
    object_property_set_description(obj, "iommu",
                                    "Set on/off to enable/disable Intel IOMMU (VT-d)",
                                    NULL);
    object_property_add_bool(obj, "suppress-vmdesc",
                             machine_get_suppress_vmdesc,
                             machine_set_suppress_vmdesc, NULL);
    object_property_set_description(obj, "suppress-vmdesc",
                                    "Set on to disable self-describing migration",
                                    NULL);

    /* Register notifier when init is done for sysbus sanity checks */
    ms->sysbus_notifier.notify = machine_init_notify;
    qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
}

static void machine_finalize(Object *obj)
{
    MachineState *ms = MACHINE(obj);

    g_free(ms->accel);
    g_free(ms->kernel_filename);
    g_free(ms->initrd_filename);
    g_free(ms->kernel_cmdline);
    g_free(ms->dtb);
    g_free(ms->dumpdtb);
    g_free(ms->dt_compatible);
    g_free(ms->firmware);
}

bool machine_usb(MachineState *machine)
{
    return machine->usb;
}

bool machine_kernel_irqchip_allowed(MachineState *machine)
{
    return machine->kernel_irqchip_allowed;
}

bool machine_kernel_irqchip_required(MachineState *machine)
{
    return machine->kernel_irqchip_required;
}

bool machine_kernel_irqchip_split(MachineState *machine)
{
    return machine->kernel_irqchip_split;
}

int machine_kvm_shadow_mem(MachineState *machine)
{
    return machine->kvm_shadow_mem;
}

int machine_phandle_start(MachineState *machine)
{
    return machine->phandle_start;
}

bool machine_dump_guest_core(MachineState *machine)
{
    return machine->dump_guest_core;
}

bool machine_mem_merge(MachineState *machine)
{
    return machine->mem_merge;
}

static const TypeInfo machine_info = {
    .name = TYPE_MACHINE,
    .parent = TYPE_OBJECT,
    .abstract = true,
    .class_size = sizeof(MachineClass),
    .class_init    = machine_class_init,
    .class_base_init = machine_class_base_init,
    .instance_size = sizeof(MachineState),
    .instance_init = machine_initfn,
    .instance_finalize = machine_finalize,
};

static void machine_register_types(void)
{
    type_register_static(&machine_info);
}

type_init(machine_register_types)
Commit	Line	Data
36d20cb2 MA	1	/*
	2	* QEMU Machine
	3	*
	4	* Copyright (C) 2014 Red Hat Inc
	5	*
	6	* Authors:
	7	* Marcel Apfelbaum <[email protected]>
	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 "hw/boards.h"
32c18a2d	14	#include "qapi-visit.h"
6b1b1440	15	#include "qapi/visitor.h"
33cd52b5 AG	16	#include "hw/sysbus.h"
	17	#include "sysemu/sysemu.h"
	18	#include "qemu/error-report.h"
6b1b1440 MA	19
	20	static char machine_get_accel(Object obj, Error **errp)
	21	{
	22	MachineState *ms = MACHINE(obj);
	23
	24	return g_strdup(ms->accel);
	25	}
	26
	27	static void machine_set_accel(Object obj, const char value, Error **errp)
	28	{
	29	MachineState *ms = MACHINE(obj);
	30
556068ee	31	g_free(ms->accel);
6b1b1440 MA	32	ms->accel = g_strdup(value);
	33	}
	34
32c18a2d MG	35	static void machine_set_kernel_irqchip(Object obj, Visitor v,
	36	void opaque, const char name,
	37	Error **errp)
6b1b1440	38	{
32c18a2d	39	Error *err = NULL;
6b1b1440	40	MachineState *ms = MACHINE(obj);
32c18a2d	41	OnOffSplit mode;
6b1b1440	42
32c18a2d MG	43	visit_type_OnOffSplit(v, &mode, name, &err);
	44	if (err) {
	45	error_propagate(errp, err);
	46	return;
	47	} else {
	48	switch (mode) {
	49	case ON_OFF_SPLIT_ON:
	50	ms->kernel_irqchip_allowed = true;
	51	ms->kernel_irqchip_required = true;
	52	ms->kernel_irqchip_split = false;
	53	break;
	54	case ON_OFF_SPLIT_OFF:
	55	ms->kernel_irqchip_allowed = false;
	56	ms->kernel_irqchip_required = false;
	57	ms->kernel_irqchip_split = false;
	58	break;
	59	case ON_OFF_SPLIT_SPLIT:
	60	ms->kernel_irqchip_allowed = true;
	61	ms->kernel_irqchip_required = true;
	62	ms->kernel_irqchip_split = true;
	63	break;
	64	default:
	65	abort();
	66	}
	67	}
6b1b1440 MA	68	}
	69
	70	static void machine_get_kvm_shadow_mem(Object obj, Visitor v,
	71	void opaque, const char name,
	72	Error **errp)
	73	{
	74	MachineState *ms = MACHINE(obj);
	75	int64_t value = ms->kvm_shadow_mem;
	76
	77	visit_type_int(v, &value, name, errp);
	78	}
	79
	80	static void machine_set_kvm_shadow_mem(Object obj, Visitor v,
	81	void opaque, const char name,
	82	Error **errp)
	83	{
	84	MachineState *ms = MACHINE(obj);
	85	Error *error = NULL;
	86	int64_t value;
	87
	88	visit_type_int(v, &value, name, &error);
	89	if (error) {
	90	error_propagate(errp, error);
	91	return;
	92	}
	93
	94	ms->kvm_shadow_mem = value;
	95	}
	96
	97	static char machine_get_kernel(Object obj, Error **errp)
	98	{
	99	MachineState *ms = MACHINE(obj);
	100
	101	return g_strdup(ms->kernel_filename);
	102	}
	103
	104	static void machine_set_kernel(Object obj, const char value, Error **errp)
	105	{
	106	MachineState *ms = MACHINE(obj);
	107
556068ee	108	g_free(ms->kernel_filename);
6b1b1440 MA	109	ms->kernel_filename = g_strdup(value);
	110	}
	111
	112	static char machine_get_initrd(Object obj, Error **errp)
	113	{
	114	MachineState *ms = MACHINE(obj);
	115
	116	return g_strdup(ms->initrd_filename);
	117	}
	118
	119	static void machine_set_initrd(Object obj, const char value, Error **errp)
	120	{
	121	MachineState *ms = MACHINE(obj);
	122
556068ee	123	g_free(ms->initrd_filename);
6b1b1440 MA	124	ms->initrd_filename = g_strdup(value);
	125	}
	126
	127	static char machine_get_append(Object obj, Error **errp)
	128	{
	129	MachineState *ms = MACHINE(obj);
	130
	131	return g_strdup(ms->kernel_cmdline);
	132	}
	133
	134	static void machine_set_append(Object obj, const char value, Error **errp)
	135	{
	136	MachineState *ms = MACHINE(obj);
	137
556068ee	138	g_free(ms->kernel_cmdline);
6b1b1440 MA	139	ms->kernel_cmdline = g_strdup(value);
	140	}
	141
	142	static char machine_get_dtb(Object obj, Error **errp)
	143	{
	144	MachineState *ms = MACHINE(obj);
	145
	146	return g_strdup(ms->dtb);
	147	}
	148
	149	static void machine_set_dtb(Object obj, const char value, Error **errp)
	150	{
	151	MachineState *ms = MACHINE(obj);
	152
556068ee	153	g_free(ms->dtb);
6b1b1440 MA	154	ms->dtb = g_strdup(value);
	155	}
	156
	157	static char machine_get_dumpdtb(Object obj, Error **errp)
	158	{
	159	MachineState *ms = MACHINE(obj);
	160
	161	return g_strdup(ms->dumpdtb);
	162	}
	163
	164	static void machine_set_dumpdtb(Object obj, const char value, Error **errp)
	165	{
	166	MachineState *ms = MACHINE(obj);
	167
556068ee	168	g_free(ms->dumpdtb);
6b1b1440 MA	169	ms->dumpdtb = g_strdup(value);
	170	}
	171
	172	static void machine_get_phandle_start(Object obj, Visitor v,
	173	void opaque, const char name,
	174	Error **errp)
	175	{
	176	MachineState *ms = MACHINE(obj);
	177	int64_t value = ms->phandle_start;
	178
	179	visit_type_int(v, &value, name, errp);
	180	}
	181
	182	static void machine_set_phandle_start(Object obj, Visitor v,
	183	void opaque, const char name,
	184	Error **errp)
	185	{
	186	MachineState *ms = MACHINE(obj);
	187	Error *error = NULL;
	188	int64_t value;
	189
	190	visit_type_int(v, &value, name, &error);
	191	if (error) {
	192	error_propagate(errp, error);
	193	return;
	194	}
	195
	196	ms->phandle_start = value;
	197	}
	198
	199	static char machine_get_dt_compatible(Object obj, Error **errp)
	200	{
	201	MachineState *ms = MACHINE(obj);
	202
	203	return g_strdup(ms->dt_compatible);
	204	}
	205
	206	static void machine_set_dt_compatible(Object obj, const char value, Error **errp)
	207	{
	208	MachineState *ms = MACHINE(obj);
	209
556068ee	210	g_free(ms->dt_compatible);
6b1b1440 MA	211	ms->dt_compatible = g_strdup(value);
	212	}
	213
	214	static bool machine_get_dump_guest_core(Object obj, Error *errp)
	215	{
	216	MachineState *ms = MACHINE(obj);
	217
	218	return ms->dump_guest_core;
	219	}
	220
	221	static void machine_set_dump_guest_core(Object obj, bool value, Error *errp)
	222	{
	223	MachineState *ms = MACHINE(obj);
	224
	225	ms->dump_guest_core = value;
	226	}
	227
	228	static bool machine_get_mem_merge(Object obj, Error *errp)
	229	{
	230	MachineState *ms = MACHINE(obj);
	231
	232	return ms->mem_merge;
	233	}
	234
	235	static void machine_set_mem_merge(Object obj, bool value, Error *errp)
	236	{
	237	MachineState *ms = MACHINE(obj);
	238
	239	ms->mem_merge = value;
	240	}
	241
	242	static bool machine_get_usb(Object obj, Error *errp)
	243	{
	244	MachineState *ms = MACHINE(obj);
	245
	246	return ms->usb;
	247	}
	248
	249	static void machine_set_usb(Object obj, bool value, Error *errp)
	250	{
	251	MachineState *ms = MACHINE(obj);
	252
	253	ms->usb = value;
c6e76503	254	ms->usb_disabled = !value;
6b1b1440 MA	255	}
6b1b1440 MA	256
79814179 TC	257	static bool machine_get_igd_gfx_passthru(Object obj, Error *errp)
	258	{
	259	MachineState *ms = MACHINE(obj);
	260
	261	return ms->igd_gfx_passthru;
	262	}
	263
	264	static void machine_set_igd_gfx_passthru(Object obj, bool value, Error *errp)
	265	{
	266	MachineState *ms = MACHINE(obj);
	267
	268	ms->igd_gfx_passthru = value;
	269	}
	270
6b1b1440 MA	271	static char machine_get_firmware(Object obj, Error **errp)
	272	{
	273	MachineState *ms = MACHINE(obj);
	274
	275	return g_strdup(ms->firmware);
	276	}
	277
	278	static void machine_set_firmware(Object obj, const char value, Error **errp)
	279	{
	280	MachineState *ms = MACHINE(obj);
	281
556068ee	282	g_free(ms->firmware);
6b1b1440 MA	283	ms->firmware = g_strdup(value);
	284	}
	285
a52a7fdf LT	286	static bool machine_get_iommu(Object obj, Error *errp)
	287	{
	288	MachineState *ms = MACHINE(obj);
	289
	290	return ms->iommu;
	291	}
	292
	293	static void machine_set_iommu(Object obj, bool value, Error *errp)
	294	{
	295	MachineState *ms = MACHINE(obj);
	296
	297	ms->iommu = value;
	298	}
	299
9850c604 AG	300	static void machine_set_suppress_vmdesc(Object obj, bool value, Error *errp)
	301	{
	302	MachineState *ms = MACHINE(obj);
	303
	304	ms->suppress_vmdesc = value;
	305	}
	306
	307	static bool machine_get_suppress_vmdesc(Object obj, Error *errp)
	308	{
	309	MachineState *ms = MACHINE(obj);
	310
	311	return ms->suppress_vmdesc;
	312	}
	313
33cd52b5 AG	314	static int error_on_sysbus_device(SysBusDevice sbdev, void opaque)
	315	{
	316	error_report("Option '-device %s' cannot be handled by this machine",
	317	object_class_get_name(object_get_class(OBJECT(sbdev))));
	318	exit(1);
	319	}
	320
	321	static void machine_init_notify(Notifier notifier, void data)
	322	{
	323	Object *machine = qdev_get_machine();
	324	ObjectClass *oc = object_get_class(machine);
	325	MachineClass *mc = MACHINE_CLASS(oc);
	326
	327	if (mc->has_dynamic_sysbus) {
	328	/* Our machine can handle dynamic sysbus devices, we're all good */
	329	return;
	330	}
	331
	332	/*
	333	* Loop through all dynamically created devices and check whether there
	334	* are sysbus devices among them. If there are, error out.
	335	*/
	336	foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL);
	337	}
	338
076b35b5 ND	339	static void machine_class_init(ObjectClass oc, void data)
	340	{
	341	MachineClass *mc = MACHINE_CLASS(oc);
	342
	343	/* Default 128 MB as guest ram size */
	344	mc->default_ram_size = 128 * M_BYTE;
71ae9e94	345	mc->rom_file_has_mr = true;
076b35b5 ND	346	}
076b35b5 ND	347
dcb3d601 EH	348	static void machine_class_base_init(ObjectClass oc, void data)
	349	{
	350	if (!object_class_is_abstract(oc)) {
98cec76a	351	MachineClass *mc = MACHINE_CLASS(oc);
dcb3d601 EH	352	const char *cname = object_class_get_name(oc);
dcb3d601 EH	353	assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
98cec76a EH	354	mc->name = g_strndup(cname,
98cec76a EH	355	strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
dcb3d601 EH	356	}
	357	}
	358
6b1b1440 MA	359	static void machine_initfn(Object *obj)
6b1b1440 MA	360	{
33cd52b5 AG	361	MachineState *ms = MACHINE(obj);
33cd52b5 AG	362
d8870d02	363	ms->kernel_irqchip_allowed = true;
4689b77b	364	ms->kvm_shadow_mem = -1;
47c8ca53	365	ms->dump_guest_core = true;
75cc7f01	366	ms->mem_merge = true;
d8870d02	367
6b1b1440 MA	368	object_property_add_str(obj, "accel",
6b1b1440 MA	369	machine_get_accel, machine_set_accel, NULL);
49d2e648 MA	370	object_property_set_description(obj, "accel",
	371	"Accelerator list",
	372	NULL);
32c18a2d MG	373	object_property_add(obj, "kernel-irqchip", "OnOffSplit",
	374	NULL,
	375	machine_set_kernel_irqchip,
	376	NULL, NULL, NULL);
49d2e648	377	object_property_set_description(obj, "kernel-irqchip",
32c18a2d	378	"Configure KVM in-kernel irqchip",
49d2e648	379	NULL);
b0ddb8bf	380	object_property_add(obj, "kvm-shadow-mem", "int",
6b1b1440 MA	381	machine_get_kvm_shadow_mem,
	382	machine_set_kvm_shadow_mem,
	383	NULL, NULL, NULL);
49d2e648 MA	384	object_property_set_description(obj, "kvm-shadow-mem",
	385	"KVM shadow MMU size",
	386	NULL);
6b1b1440 MA	387	object_property_add_str(obj, "kernel",
6b1b1440 MA	388	machine_get_kernel, machine_set_kernel, NULL);
49d2e648 MA	389	object_property_set_description(obj, "kernel",
	390	"Linux kernel image file",
	391	NULL);
6b1b1440 MA	392	object_property_add_str(obj, "initrd",
6b1b1440 MA	393	machine_get_initrd, machine_set_initrd, NULL);
49d2e648 MA	394	object_property_set_description(obj, "initrd",
	395	"Linux initial ramdisk file",
	396	NULL);
6b1b1440 MA	397	object_property_add_str(obj, "append",
6b1b1440 MA	398	machine_get_append, machine_set_append, NULL);
49d2e648 MA	399	object_property_set_description(obj, "append",
	400	"Linux kernel command line",
	401	NULL);
6b1b1440 MA	402	object_property_add_str(obj, "dtb",
6b1b1440 MA	403	machine_get_dtb, machine_set_dtb, NULL);
49d2e648 MA	404	object_property_set_description(obj, "dtb",
	405	"Linux kernel device tree file",
	406	NULL);
6b1b1440 MA	407	object_property_add_str(obj, "dumpdtb",
6b1b1440 MA	408	machine_get_dumpdtb, machine_set_dumpdtb, NULL);
49d2e648 MA	409	object_property_set_description(obj, "dumpdtb",
	410	"Dump current dtb to a file and quit",
	411	NULL);
b0ddb8bf	412	object_property_add(obj, "phandle-start", "int",
6b1b1440 MA	413	machine_get_phandle_start,
	414	machine_set_phandle_start,
	415	NULL, NULL, NULL);
49d2e648 MA	416	object_property_set_description(obj, "phandle-start",
	417	"The first phandle ID we may generate dynamically",
	418	NULL);
b0ddb8bf	419	object_property_add_str(obj, "dt-compatible",
6b1b1440 MA	420	machine_get_dt_compatible,
	421	machine_set_dt_compatible,
	422	NULL);
49d2e648 MA	423	object_property_set_description(obj, "dt-compatible",
	424	"Overrides the \"compatible\" property of the dt root node",
	425	NULL);
6b1b1440 MA	426	object_property_add_bool(obj, "dump-guest-core",
	427	machine_get_dump_guest_core,
	428	machine_set_dump_guest_core,
	429	NULL);
49d2e648 MA	430	object_property_set_description(obj, "dump-guest-core",
	431	"Include guest memory in a core dump",
	432	NULL);
6b1b1440	433	object_property_add_bool(obj, "mem-merge",
ac40aa15 LT	434	machine_get_mem_merge,
ac40aa15 LT	435	machine_set_mem_merge, NULL);
49d2e648 MA	436	object_property_set_description(obj, "mem-merge",
	437	"Enable/disable memory merge support",
	438	NULL);
ac40aa15 LT	439	object_property_add_bool(obj, "usb",
	440	machine_get_usb,
	441	machine_set_usb, NULL);
49d2e648 MA	442	object_property_set_description(obj, "usb",
	443	"Set on/off to enable/disable usb",
	444	NULL);
79814179 TC	445	object_property_add_bool(obj, "igd-passthru",
	446	machine_get_igd_gfx_passthru,
	447	machine_set_igd_gfx_passthru, NULL);
	448	object_property_set_description(obj, "igd-passthru",
	449	"Set on/off to enable/disable igd passthrou",
	450	NULL);
6b1b1440	451	object_property_add_str(obj, "firmware",
ac40aa15 LT	452	machine_get_firmware,
ac40aa15 LT	453	machine_set_firmware, NULL);
49d2e648 MA	454	object_property_set_description(obj, "firmware",
	455	"Firmware image",
	456	NULL);
a52a7fdf LT	457	object_property_add_bool(obj, "iommu",
	458	machine_get_iommu,
	459	machine_set_iommu, NULL);
49d2e648 MA	460	object_property_set_description(obj, "iommu",
	461	"Set on/off to enable/disable Intel IOMMU (VT-d)",
	462	NULL);
9850c604 AG	463	object_property_add_bool(obj, "suppress-vmdesc",
	464	machine_get_suppress_vmdesc,
	465	machine_set_suppress_vmdesc, NULL);
	466	object_property_set_description(obj, "suppress-vmdesc",
	467	"Set on to disable self-describing migration",
	468	NULL);
33cd52b5 AG	469
	470	/* Register notifier when init is done for sysbus sanity checks */
	471	ms->sysbus_notifier.notify = machine_init_notify;
	472	qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
6b1b1440 MA	473	}
	474
	475	static void machine_finalize(Object *obj)
	476	{
	477	MachineState *ms = MACHINE(obj);
	478
	479	g_free(ms->accel);
	480	g_free(ms->kernel_filename);
	481	g_free(ms->initrd_filename);
	482	g_free(ms->kernel_cmdline);
	483	g_free(ms->dtb);
	484	g_free(ms->dumpdtb);
	485	g_free(ms->dt_compatible);
	486	g_free(ms->firmware);
	487	}
36d20cb2	488
5e97b623 MA	489	bool machine_usb(MachineState *machine)
	490	{
	491	return machine->usb;
	492	}
	493
d8870d02 MA	494	bool machine_kernel_irqchip_allowed(MachineState *machine)
	495	{
	496	return machine->kernel_irqchip_allowed;
	497	}
	498
	499	bool machine_kernel_irqchip_required(MachineState *machine)
	500	{
	501	return machine->kernel_irqchip_required;
	502	}
	503
32c18a2d MG	504	bool machine_kernel_irqchip_split(MachineState *machine)
	505	{
	506	return machine->kernel_irqchip_split;
	507	}
	508
4689b77b MA	509	int machine_kvm_shadow_mem(MachineState *machine)
	510	{
	511	return machine->kvm_shadow_mem;
	512	}
	513
6cabe7fa MA	514	int machine_phandle_start(MachineState *machine)
	515	{
	516	return machine->phandle_start;
	517	}
	518
47c8ca53 MA	519	bool machine_dump_guest_core(MachineState *machine)
	520	{
	521	return machine->dump_guest_core;
	522	}
	523
75cc7f01 MA	524	bool machine_mem_merge(MachineState *machine)
	525	{
	526	return machine->mem_merge;
	527	}
	528
36d20cb2 MA	529	static const TypeInfo machine_info = {
	530	.name = TYPE_MACHINE,
	531	.parent = TYPE_OBJECT,
	532	.abstract = true,
	533	.class_size = sizeof(MachineClass),
076b35b5	534	.class_init = machine_class_init,
dcb3d601	535	.class_base_init = machine_class_base_init,
36d20cb2	536	.instance_size = sizeof(MachineState),
6b1b1440 MA	537	.instance_init = machine_initfn,
6b1b1440 MA	538	.instance_finalize = machine_finalize,
36d20cb2 MA	539	};
	540
	541	static void machine_register_types(void)
	542	{
	543	type_register_static(&machine_info);
	544	}
	545
	546	type_init(machine_register_types)