]>
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, |
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, |
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 | } |
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 | } |
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); |
369 | assert(g_str_has_suffix(cname, TYPE_MACHINE_SUFFIX)); | |
98cec76a EH |
370 | mc->name = g_strndup(cname, |
371 | strlen(cname) - strlen(TYPE_MACHINE_SUFFIX)); | |
dcb3d601 EH |
372 | } |
373 | } | |
374 | ||
6b1b1440 MA |
375 | static void machine_initfn(Object *obj) |
376 | { | |
33cd52b5 AG |
377 | MachineState *ms = MACHINE(obj); |
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", |
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", |
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", |
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", |
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", |
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", |
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, |
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, |
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, |
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) |