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

/*
 * QEMU Machine
 *
 * Copyright (C) 2014 Red Hat Inc
 *
 * Authors:
 *   Marcel Apfelbaum <marcel.a@redhat.com>
 *
 * 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 "qemu/osdep.h"
#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,
                                       const char *name, void *opaque,
                                       Error **errp)
{
    Error *err = NULL;
    MachineState *ms = MACHINE(obj);
    OnOffSplit mode;

    visit_type_OnOffSplit(v, name, &mode, &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,
                                       const char *name, void *opaque,
                                       Error **errp)
{
    MachineState *ms = MACHINE(obj);
    int64_t value = ms->kvm_shadow_mem;

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

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

    visit_type_int(v, name, &value, &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,
                                      const char *name, void *opaque,
                                      Error **errp)
{
    MachineState *ms = MACHINE(obj);
    int64_t value = ms->phandle_start;

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

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

    visit_type_int(v, name, &value, &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 void machine_set_enforce_config_section(Object *obj, bool value,
                                             Error **errp)
{
    MachineState *ms = MACHINE(obj);

    ms->enforce_config_section = value;
}

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

    return ms->enforce_config_section;
}

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