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