hw/core/machine.c

   1 /*
   2  * QEMU Machine
   3  *
   4  * Copyright (C) 2014 Red Hat Inc
   5  *
   6  * Authors:
   7  *   Marcel Apfelbaum <marcel.a@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "hw/boards.h"
  14 #include "qapi/visitor.h"
  15
  16 static char *machine_get_accel(Object *obj, Error **errp)
  17 {
  18     MachineState *ms = MACHINE(obj);
  19
  20     return g_strdup(ms->accel);
  21 }
  22
  23 static void machine_set_accel(Object *obj, const char *value, Error **errp)
  24 {
  25     MachineState *ms = MACHINE(obj);
  26
  27     g_free(ms->accel);
  28     ms->accel = g_strdup(value);
  29 }
  30
  31 static bool machine_get_kernel_irqchip(Object *obj, Error **errp)
  32 {
  33     MachineState *ms = MACHINE(obj);
  34
  35     return ms->kernel_irqchip;
  36 }
  37
  38 static void machine_set_kernel_irqchip(Object *obj, bool value, Error **errp)
  39 {
  40     MachineState *ms = MACHINE(obj);
  41
  42     ms->kernel_irqchip = value;
  43 }
  44
  45 static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v,
  46                                        void *opaque, const char *name,
  47                                        Error **errp)
  48 {
  49     MachineState *ms = MACHINE(obj);
  50     int64_t value = ms->kvm_shadow_mem;
  51
  52     visit_type_int(v, &value, name, errp);
  53 }
  54
  55 static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v,
  56                                        void *opaque, const char *name,
  57                                        Error **errp)
  58 {
  59     MachineState *ms = MACHINE(obj);
  60     Error *error = NULL;
  61     int64_t value;
  62
  63     visit_type_int(v, &value, name, &error);
  64     if (error) {
  65         error_propagate(errp, error);
  66         return;
  67     }
  68
  69     ms->kvm_shadow_mem = value;
  70 }
  71
  72 static char *machine_get_kernel(Object *obj, Error **errp)
  73 {
  74     MachineState *ms = MACHINE(obj);
  75
  76     return g_strdup(ms->kernel_filename);
  77 }
  78
  79 static void machine_set_kernel(Object *obj, const char *value, Error **errp)
  80 {
  81     MachineState *ms = MACHINE(obj);
  82
  83     g_free(ms->kernel_filename);
  84     ms->kernel_filename = g_strdup(value);
  85 }
  86
  87 static char *machine_get_initrd(Object *obj, Error **errp)
  88 {
  89     MachineState *ms = MACHINE(obj);
  90
  91     return g_strdup(ms->initrd_filename);
  92 }
  93
  94 static void machine_set_initrd(Object *obj, const char *value, Error **errp)
  95 {
  96     MachineState *ms = MACHINE(obj);
  97
  98     g_free(ms->initrd_filename);
  99     ms->initrd_filename = g_strdup(value);
 100 }
 101
 102 static char *machine_get_append(Object *obj, Error **errp)
 103 {
 104     MachineState *ms = MACHINE(obj);
 105
 106     return g_strdup(ms->kernel_cmdline);
 107 }
 108
 109 static void machine_set_append(Object *obj, const char *value, Error **errp)
 110 {
 111     MachineState *ms = MACHINE(obj);
 112
 113     g_free(ms->kernel_cmdline);
 114     ms->kernel_cmdline = g_strdup(value);
 115 }
 116
 117 static char *machine_get_dtb(Object *obj, Error **errp)
 118 {
 119     MachineState *ms = MACHINE(obj);
 120
 121     return g_strdup(ms->dtb);
 122 }
 123
 124 static void machine_set_dtb(Object *obj, const char *value, Error **errp)
 125 {
 126     MachineState *ms = MACHINE(obj);
 127
 128     g_free(ms->dtb);
 129     ms->dtb = g_strdup(value);
 130 }
 131
 132 static char *machine_get_dumpdtb(Object *obj, Error **errp)
 133 {
 134     MachineState *ms = MACHINE(obj);
 135
 136     return g_strdup(ms->dumpdtb);
 137 }
 138
 139 static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp)
 140 {
 141     MachineState *ms = MACHINE(obj);
 142
 143     g_free(ms->dumpdtb);
 144     ms->dumpdtb = g_strdup(value);
 145 }
 146
 147 static void machine_get_phandle_start(Object *obj, Visitor *v,
 148                                        void *opaque, const char *name,
 149                                        Error **errp)
 150 {
 151     MachineState *ms = MACHINE(obj);
 152     int64_t value = ms->phandle_start;
 153
 154     visit_type_int(v, &value, name, errp);
 155 }
 156
 157 static void machine_set_phandle_start(Object *obj, Visitor *v,
 158                                        void *opaque, const char *name,
 159                                        Error **errp)
 160 {
 161     MachineState *ms = MACHINE(obj);
 162     Error *error = NULL;
 163     int64_t value;
 164
 165     visit_type_int(v, &value, name, &error);
 166     if (error) {
 167         error_propagate(errp, error);
 168         return;
 169     }
 170
 171     ms->phandle_start = value;
 172 }
 173
 174 static char *machine_get_dt_compatible(Object *obj, Error **errp)
 175 {
 176     MachineState *ms = MACHINE(obj);
 177
 178     return g_strdup(ms->dt_compatible);
 179 }
 180
 181 static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp)
 182 {
 183     MachineState *ms = MACHINE(obj);
 184
 185     g_free(ms->dt_compatible);
 186     ms->dt_compatible = g_strdup(value);
 187 }
 188
 189 static bool machine_get_dump_guest_core(Object *obj, Error **errp)
 190 {
 191     MachineState *ms = MACHINE(obj);
 192
 193     return ms->dump_guest_core;
 194 }
 195
 196 static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp)
 197 {
 198     MachineState *ms = MACHINE(obj);
 199
 200     ms->dump_guest_core = value;
 201 }
 202
 203 static bool machine_get_mem_merge(Object *obj, Error **errp)
 204 {
 205     MachineState *ms = MACHINE(obj);
 206
 207     return ms->mem_merge;
 208 }
 209
 210 static void machine_set_mem_merge(Object *obj, bool value, Error **errp)
 211 {
 212     MachineState *ms = MACHINE(obj);
 213
 214     ms->mem_merge = value;
 215 }
 216
 217 static bool machine_get_usb(Object *obj, Error **errp)
 218 {
 219     MachineState *ms = MACHINE(obj);
 220
 221     return ms->usb;
 222 }
 223
 224 static void machine_set_usb(Object *obj, bool value, Error **errp)
 225 {
 226     MachineState *ms = MACHINE(obj);
 227
 228     ms->usb = value;
 229 }
 230
 231 static char *machine_get_firmware(Object *obj, Error **errp)
 232 {
 233     MachineState *ms = MACHINE(obj);
 234
 235     return g_strdup(ms->firmware);
 236 }
 237
 238 static void machine_set_firmware(Object *obj, const char *value, Error **errp)
 239 {
 240     MachineState *ms = MACHINE(obj);
 241
 242     g_free(ms->firmware);
 243     ms->firmware = g_strdup(value);
 244 }
 245
 246 static bool machine_get_iommu(Object *obj, Error **errp)
 247 {
 248     MachineState *ms = MACHINE(obj);
 249
 250     return ms->iommu;
 251 }
 252
 253 static void machine_set_iommu(Object *obj, bool value, Error **errp)
 254 {
 255     MachineState *ms = MACHINE(obj);
 256
 257     ms->iommu = value;
 258 }
 259
 260 static void machine_initfn(Object *obj)
 261 {
 262     object_property_add_str(obj, "accel",
 263                             machine_get_accel, machine_set_accel, NULL);
 264     object_property_add_bool(obj, "kernel-irqchip",
 265                              machine_get_kernel_irqchip,
 266                              machine_set_kernel_irqchip,
 267                              NULL);
 268     object_property_add(obj, "kvm-shadow-mem", "int",
 269                         machine_get_kvm_shadow_mem,
 270                         machine_set_kvm_shadow_mem,
 271                         NULL, NULL, NULL);
 272     object_property_add_str(obj, "kernel",
 273                             machine_get_kernel, machine_set_kernel, NULL);
 274     object_property_add_str(obj, "initrd",
 275                             machine_get_initrd, machine_set_initrd, NULL);
 276     object_property_add_str(obj, "append",
 277                             machine_get_append, machine_set_append, NULL);
 278     object_property_add_str(obj, "dtb",
 279                             machine_get_dtb, machine_set_dtb, NULL);
 280     object_property_add_str(obj, "dumpdtb",
 281                             machine_get_dumpdtb, machine_set_dumpdtb, NULL);
 282     object_property_add(obj, "phandle-start", "int",
 283                         machine_get_phandle_start,
 284                         machine_set_phandle_start,
 285                         NULL, NULL, NULL);
 286     object_property_add_str(obj, "dt-compatible",
 287                             machine_get_dt_compatible,
 288                             machine_set_dt_compatible,
 289                             NULL);
 290     object_property_add_bool(obj, "dump-guest-core",
 291                              machine_get_dump_guest_core,
 292                              machine_set_dump_guest_core,
 293                              NULL);
 294     object_property_add_bool(obj, "mem-merge",
 295                              machine_get_mem_merge,
 296                              machine_set_mem_merge, NULL);
 297     object_property_add_bool(obj, "usb",
 298                              machine_get_usb,
 299                              machine_set_usb, NULL);
 300     object_property_add_str(obj, "firmware",
 301                             machine_get_firmware,
 302                             machine_set_firmware, NULL);
 303     object_property_add_bool(obj, "iommu",
 304                              machine_get_iommu,
 305                              machine_set_iommu, NULL);
 306 }
 307
 308 static void machine_finalize(Object *obj)
 309 {
 310     MachineState *ms = MACHINE(obj);
 311
 312     g_free(ms->accel);
 313     g_free(ms->kernel_filename);
 314     g_free(ms->initrd_filename);
 315     g_free(ms->kernel_cmdline);
 316     g_free(ms->dtb);
 317     g_free(ms->dumpdtb);
 318     g_free(ms->dt_compatible);
 319     g_free(ms->firmware);
 320 }
 321
 322 static const TypeInfo machine_info = {
 323     .name = TYPE_MACHINE,
 324     .parent = TYPE_OBJECT,
 325     .abstract = true,
 326     .class_size = sizeof(MachineClass),
 327     .instance_size = sizeof(MachineState),
 328     .instance_init = machine_initfn,
 329     .instance_finalize = machine_finalize,
 330 };
 331
 332 static void machine_register_types(void)
 333 {
 334     type_register_static(&machine_info);
 335 }
 336
 337 type_init(machine_register_types)