Commit 6b1b1440 authored by Marcel Apfelbaum's avatar Marcel Apfelbaum Committed by Andreas Färber
Browse files

machine: Make -machine opts properties of MachineState 



Make machine's QemuOpts QOM properties of /machine. The properties
are automatically filled in. This opens the possibility to create
opts per machine rather than global.

Signed-off-by: default avatarMarcel Apfelbaum <marcel.a@redhat.com>
Acked-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Acked-by: default avatarMichael Roth <mdroth@linux.vnet.ibm.com>
Signed-off-by: default avatarAndreas Färber <afaerber@suse.de>
parent a199b2b6

hw/core/machine.c

+280 −0
Original line number Diff line number Diff line
@@ -11,6 +11,284 @@ 
 */



#include "hw/boards.h"

#include "qapi/visitor.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);



    ms->accel = g_strdup(value);

}



static bool machine_get_kernel_irqchip(Object *obj, Error **errp)

{

    MachineState *ms = MACHINE(obj);



    return ms->kernel_irqchip;

}



static void machine_set_kernel_irqchip(Object *obj, bool value, Error **errp)

{

    MachineState *ms = MACHINE(obj);



    ms->kernel_irqchip = value;

}



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);



    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);



    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);



    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);



    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);



    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);



    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;

}



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);



    ms->firmware = g_strdup(value);

}



static void machine_initfn(Object *obj)

{

    object_property_add_str(obj, "accel",

                            machine_get_accel, machine_set_accel, NULL);

    object_property_add_bool(obj, "kernel_irqchip",

                             machine_get_kernel_irqchip,

                             machine_set_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_add_str(obj, "kernel",

                            machine_get_kernel, machine_set_kernel, NULL);

    object_property_add_str(obj, "initrd",

                            machine_get_initrd, machine_set_initrd, NULL);

    object_property_add_str(obj, "append",

                            machine_get_append, machine_set_append, NULL);

    object_property_add_str(obj, "dtb",

                            machine_get_dtb, machine_set_dtb, NULL);

    object_property_add_str(obj, "dumpdtb",

                            machine_get_dumpdtb, machine_set_dumpdtb, NULL);

    object_property_add(obj, "phandle_start", "int",

                        machine_get_phandle_start,

                        machine_set_phandle_start,

                        NULL, NULL, NULL);

    object_property_add_str(obj, "dt_compatible",

                            machine_get_dt_compatible,

                            machine_set_dt_compatible,

                            NULL);

    object_property_add_bool(obj, "dump-guest-core",

                             machine_get_dump_guest_core,

                             machine_set_dump_guest_core,

                             NULL);

    object_property_add_bool(obj, "mem-merge",

                             machine_get_mem_merge, machine_set_mem_merge, NULL);

    object_property_add_bool(obj, "usb", machine_get_usb, machine_set_usb, NULL);

    object_property_add_str(obj, "firmware",

                            machine_get_firmware, machine_set_firmware, NULL);

}



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);

}



static const TypeInfo machine_info = {

    .name = TYPE_MACHINE,
@@ -18,6 +296,8 @@ static const TypeInfo machine_info = { 
    .abstract = true,

    .class_size = sizeof(MachineClass),

    .instance_size = sizeof(MachineState),

    .instance_init = machine_initfn,

    .instance_finalize = machine_finalize,

};



static void machine_register_types(void)

include/hw/boards.h

+3 −3
Original line number Diff line number Diff line
@@ -114,9 +114,9 @@ struct MachineState { 


    ram_addr_t ram_size;

    const char *boot_order;

    const char *kernel_filename;

    const char *kernel_cmdline;

    const char *initrd_filename;

    char *kernel_filename;

    char *kernel_cmdline;

    char *initrd_filename;

    const char *cpu_model;

};

vl.c

+8 −3
Original line number Diff line number Diff line
@@ -4220,6 +4220,13 @@ int main(int argc, char **argv, char **envp) 
        exit(0);

    }



    machine_opts = qemu_get_machine_opts();

    if (qemu_opt_foreach(machine_opts, object_set_property, current_machine,

                         1) < 0) {

        object_unref(OBJECT(current_machine));

        exit(1);

    }



    configure_accelerator(machine_class);



    if (qtest_chrdev) {
@@ -4264,6 +4271,7 @@ int main(int argc, char **argv, char **envp) 


    if (!kernel_cmdline) {

        kernel_cmdline = "";

        current_machine->kernel_cmdline = (char *)kernel_cmdline;

    }



    linux_boot = (kernel_filename != NULL);
@@ -4428,9 +4436,6 @@ int main(int argc, char **argv, char **envp) 


    current_machine->ram_size = ram_size;

    current_machine->boot_order = boot_order;

    current_machine->kernel_filename = kernel_filename;

    current_machine->kernel_cmdline = kernel_cmdline;

    current_machine->initrd_filename = initrd_filename;

    current_machine->cpu_model = cpu_model;



    machine_class->init(current_machine);