[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 "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;
}

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 <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 "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;
	345	}
	346
dcb3d601 EH	347	static void machine_class_base_init(ObjectClass oc, void data)
	348	{
	349	if (!object_class_is_abstract(oc)) {
98cec76a	350	MachineClass *mc = MACHINE_CLASS(oc);
dcb3d601 EH	351	const char *cname = object_class_get_name(oc);
dcb3d601 EH	352	assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX));
98cec76a EH	353	mc->name = g_strndup(cname,
98cec76a EH	354	strlen(cname) - strlen(TYPE_MACHINE_SUFFIX));
dcb3d601 EH	355	}
	356	}
	357
6b1b1440 MA	358	static void machine_initfn(Object *obj)
6b1b1440 MA	359	{
33cd52b5 AG	360	MachineState *ms = MACHINE(obj);
33cd52b5 AG	361
d8870d02	362	ms->kernel_irqchip_allowed = true;
4689b77b	363	ms->kvm_shadow_mem = -1;
47c8ca53	364	ms->dump_guest_core = true;
75cc7f01	365	ms->mem_merge = true;
d8870d02	366
6b1b1440 MA	367	object_property_add_str(obj, "accel",
6b1b1440 MA	368	machine_get_accel, machine_set_accel, NULL);
49d2e648 MA	369	object_property_set_description(obj, "accel",
	370	"Accelerator list",
	371	NULL);
32c18a2d MG	372	object_property_add(obj, "kernel-irqchip", "OnOffSplit",
	373	NULL,
	374	machine_set_kernel_irqchip,
	375	NULL, NULL, NULL);
49d2e648	376	object_property_set_description(obj, "kernel-irqchip",
32c18a2d	377	"Configure KVM in-kernel irqchip",
49d2e648	378	NULL);
b0ddb8bf	379	object_property_add(obj, "kvm-shadow-mem", "int",
6b1b1440 MA	380	machine_get_kvm_shadow_mem,
	381	machine_set_kvm_shadow_mem,
	382	NULL, NULL, NULL);
49d2e648 MA	383	object_property_set_description(obj, "kvm-shadow-mem",
	384	"KVM shadow MMU size",
	385	NULL);
6b1b1440 MA	386	object_property_add_str(obj, "kernel",
6b1b1440 MA	387	machine_get_kernel, machine_set_kernel, NULL);
49d2e648 MA	388	object_property_set_description(obj, "kernel",
	389	"Linux kernel image file",
	390	NULL);
6b1b1440 MA	391	object_property_add_str(obj, "initrd",
6b1b1440 MA	392	machine_get_initrd, machine_set_initrd, NULL);
49d2e648 MA	393	object_property_set_description(obj, "initrd",
	394	"Linux initial ramdisk file",
	395	NULL);
6b1b1440 MA	396	object_property_add_str(obj, "append",
6b1b1440 MA	397	machine_get_append, machine_set_append, NULL);
49d2e648 MA	398	object_property_set_description(obj, "append",
	399	"Linux kernel command line",
	400	NULL);
6b1b1440 MA	401	object_property_add_str(obj, "dtb",
6b1b1440 MA	402	machine_get_dtb, machine_set_dtb, NULL);
49d2e648 MA	403	object_property_set_description(obj, "dtb",
	404	"Linux kernel device tree file",
	405	NULL);
6b1b1440 MA	406	object_property_add_str(obj, "dumpdtb",
6b1b1440 MA	407	machine_get_dumpdtb, machine_set_dumpdtb, NULL);
49d2e648 MA	408	object_property_set_description(obj, "dumpdtb",
	409	"Dump current dtb to a file and quit",
	410	NULL);
b0ddb8bf	411	object_property_add(obj, "phandle-start", "int",
6b1b1440 MA	412	machine_get_phandle_start,
	413	machine_set_phandle_start,
	414	NULL, NULL, NULL);
49d2e648 MA	415	object_property_set_description(obj, "phandle-start",
	416	"The first phandle ID we may generate dynamically",
	417	NULL);
b0ddb8bf	418	object_property_add_str(obj, "dt-compatible",
6b1b1440 MA	419	machine_get_dt_compatible,
	420	machine_set_dt_compatible,
	421	NULL);
49d2e648 MA	422	object_property_set_description(obj, "dt-compatible",
	423	"Overrides the \"compatible\" property of the dt root node",
	424	NULL);
6b1b1440 MA	425	object_property_add_bool(obj, "dump-guest-core",
	426	machine_get_dump_guest_core,
	427	machine_set_dump_guest_core,
	428	NULL);
49d2e648 MA	429	object_property_set_description(obj, "dump-guest-core",
	430	"Include guest memory in a core dump",
	431	NULL);
6b1b1440	432	object_property_add_bool(obj, "mem-merge",
ac40aa15 LT	433	machine_get_mem_merge,
ac40aa15 LT	434	machine_set_mem_merge, NULL);
49d2e648 MA	435	object_property_set_description(obj, "mem-merge",
	436	"Enable/disable memory merge support",
	437	NULL);
ac40aa15 LT	438	object_property_add_bool(obj, "usb",
	439	machine_get_usb,
	440	machine_set_usb, NULL);
49d2e648 MA	441	object_property_set_description(obj, "usb",
	442	"Set on/off to enable/disable usb",
	443	NULL);
79814179 TC	444	object_property_add_bool(obj, "igd-passthru",
	445	machine_get_igd_gfx_passthru,
	446	machine_set_igd_gfx_passthru, NULL);
	447	object_property_set_description(obj, "igd-passthru",
	448	"Set on/off to enable/disable igd passthrou",
	449	NULL);
6b1b1440	450	object_property_add_str(obj, "firmware",
ac40aa15 LT	451	machine_get_firmware,
ac40aa15 LT	452	machine_set_firmware, NULL);
49d2e648 MA	453	object_property_set_description(obj, "firmware",
	454	"Firmware image",
	455	NULL);
a52a7fdf LT	456	object_property_add_bool(obj, "iommu",
	457	machine_get_iommu,
	458	machine_set_iommu, NULL);
49d2e648 MA	459	object_property_set_description(obj, "iommu",
	460	"Set on/off to enable/disable Intel IOMMU (VT-d)",
	461	NULL);
9850c604 AG	462	object_property_add_bool(obj, "suppress-vmdesc",
	463	machine_get_suppress_vmdesc,
	464	machine_set_suppress_vmdesc, NULL);
	465	object_property_set_description(obj, "suppress-vmdesc",
	466	"Set on to disable self-describing migration",
	467	NULL);
33cd52b5 AG	468
	469	/* Register notifier when init is done for sysbus sanity checks */
	470	ms->sysbus_notifier.notify = machine_init_notify;
	471	qemu_add_machine_init_done_notifier(&ms->sysbus_notifier);
6b1b1440 MA	472	}
	473
	474	static void machine_finalize(Object *obj)
	475	{
	476	MachineState *ms = MACHINE(obj);
	477
	478	g_free(ms->accel);
	479	g_free(ms->kernel_filename);
	480	g_free(ms->initrd_filename);
	481	g_free(ms->kernel_cmdline);
	482	g_free(ms->dtb);
	483	g_free(ms->dumpdtb);
	484	g_free(ms->dt_compatible);
	485	g_free(ms->firmware);
	486	}
36d20cb2	487
5e97b623 MA	488	bool machine_usb(MachineState *machine)
	489	{
	490	return machine->usb;
	491	}
	492
d8870d02 MA	493	bool machine_kernel_irqchip_allowed(MachineState *machine)
	494	{
	495	return machine->kernel_irqchip_allowed;
	496	}
	497
	498	bool machine_kernel_irqchip_required(MachineState *machine)
	499	{
	500	return machine->kernel_irqchip_required;
	501	}
	502
32c18a2d MG	503	bool machine_kernel_irqchip_split(MachineState *machine)
	504	{
	505	return machine->kernel_irqchip_split;
	506	}
	507
4689b77b MA	508	int machine_kvm_shadow_mem(MachineState *machine)
	509	{
	510	return machine->kvm_shadow_mem;
	511	}
	512
6cabe7fa MA	513	int machine_phandle_start(MachineState *machine)
	514	{
	515	return machine->phandle_start;
	516	}
	517
47c8ca53 MA	518	bool machine_dump_guest_core(MachineState *machine)
	519	{
	520	return machine->dump_guest_core;
	521	}
	522
75cc7f01 MA	523	bool machine_mem_merge(MachineState *machine)
	524	{
	525	return machine->mem_merge;
	526	}
	527
36d20cb2 MA	528	static const TypeInfo machine_info = {
	529	.name = TYPE_MACHINE,
	530	.parent = TYPE_OBJECT,
	531	.abstract = true,
	532	.class_size = sizeof(MachineClass),
076b35b5	533	.class_init = machine_class_init,
dcb3d601	534	.class_base_init = machine_class_base_init,
36d20cb2	535	.instance_size = sizeof(MachineState),
6b1b1440 MA	536	.instance_init = machine_initfn,
6b1b1440 MA	537	.instance_finalize = machine_finalize,
36d20cb2 MA	538	};
	539
	540	static void machine_register_types(void)
	541	{
	542	type_register_static(&machine_info);
	543	}
	544
	545	type_init(machine_register_types)