]>
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" | |
6b1b1440 | 14 | #include "qapi/visitor.h" |
33cd52b5 AG |
15 | #include "hw/sysbus.h" |
16 | #include "sysemu/sysemu.h" | |
17 | #include "qemu/error-report.h" | |
6b1b1440 MA |
18 | |
19 | static char *machine_get_accel(Object *obj, Error **errp) | |
20 | { | |
21 | MachineState *ms = MACHINE(obj); | |
22 | ||
23 | return g_strdup(ms->accel); | |
24 | } | |
25 | ||
26 | static void machine_set_accel(Object *obj, const char *value, Error **errp) | |
27 | { | |
28 | MachineState *ms = MACHINE(obj); | |
29 | ||
556068ee | 30 | g_free(ms->accel); |
6b1b1440 MA |
31 | ms->accel = g_strdup(value); |
32 | } | |
33 | ||
6b1b1440 MA |
34 | static void machine_set_kernel_irqchip(Object *obj, bool value, Error **errp) |
35 | { | |
36 | MachineState *ms = MACHINE(obj); | |
37 | ||
d8870d02 MA |
38 | ms->kernel_irqchip_allowed = value; |
39 | ms->kernel_irqchip_required = value; | |
6b1b1440 MA |
40 | } |
41 | ||
42 | static void machine_get_kvm_shadow_mem(Object *obj, Visitor *v, | |
43 | void *opaque, const char *name, | |
44 | Error **errp) | |
45 | { | |
46 | MachineState *ms = MACHINE(obj); | |
47 | int64_t value = ms->kvm_shadow_mem; | |
48 | ||
49 | visit_type_int(v, &value, name, errp); | |
50 | } | |
51 | ||
52 | static void machine_set_kvm_shadow_mem(Object *obj, Visitor *v, | |
53 | void *opaque, const char *name, | |
54 | Error **errp) | |
55 | { | |
56 | MachineState *ms = MACHINE(obj); | |
57 | Error *error = NULL; | |
58 | int64_t value; | |
59 | ||
60 | visit_type_int(v, &value, name, &error); | |
61 | if (error) { | |
62 | error_propagate(errp, error); | |
63 | return; | |
64 | } | |
65 | ||
66 | ms->kvm_shadow_mem = value; | |
67 | } | |
68 | ||
69 | static char *machine_get_kernel(Object *obj, Error **errp) | |
70 | { | |
71 | MachineState *ms = MACHINE(obj); | |
72 | ||
73 | return g_strdup(ms->kernel_filename); | |
74 | } | |
75 | ||
76 | static void machine_set_kernel(Object *obj, const char *value, Error **errp) | |
77 | { | |
78 | MachineState *ms = MACHINE(obj); | |
79 | ||
556068ee | 80 | g_free(ms->kernel_filename); |
6b1b1440 MA |
81 | ms->kernel_filename = g_strdup(value); |
82 | } | |
83 | ||
84 | static char *machine_get_initrd(Object *obj, Error **errp) | |
85 | { | |
86 | MachineState *ms = MACHINE(obj); | |
87 | ||
88 | return g_strdup(ms->initrd_filename); | |
89 | } | |
90 | ||
91 | static void machine_set_initrd(Object *obj, const char *value, Error **errp) | |
92 | { | |
93 | MachineState *ms = MACHINE(obj); | |
94 | ||
556068ee | 95 | g_free(ms->initrd_filename); |
6b1b1440 MA |
96 | ms->initrd_filename = g_strdup(value); |
97 | } | |
98 | ||
99 | static char *machine_get_append(Object *obj, Error **errp) | |
100 | { | |
101 | MachineState *ms = MACHINE(obj); | |
102 | ||
103 | return g_strdup(ms->kernel_cmdline); | |
104 | } | |
105 | ||
106 | static void machine_set_append(Object *obj, const char *value, Error **errp) | |
107 | { | |
108 | MachineState *ms = MACHINE(obj); | |
109 | ||
556068ee | 110 | g_free(ms->kernel_cmdline); |
6b1b1440 MA |
111 | ms->kernel_cmdline = g_strdup(value); |
112 | } | |
113 | ||
114 | static char *machine_get_dtb(Object *obj, Error **errp) | |
115 | { | |
116 | MachineState *ms = MACHINE(obj); | |
117 | ||
118 | return g_strdup(ms->dtb); | |
119 | } | |
120 | ||
121 | static void machine_set_dtb(Object *obj, const char *value, Error **errp) | |
122 | { | |
123 | MachineState *ms = MACHINE(obj); | |
124 | ||
556068ee | 125 | g_free(ms->dtb); |
6b1b1440 MA |
126 | ms->dtb = g_strdup(value); |
127 | } | |
128 | ||
129 | static char *machine_get_dumpdtb(Object *obj, Error **errp) | |
130 | { | |
131 | MachineState *ms = MACHINE(obj); | |
132 | ||
133 | return g_strdup(ms->dumpdtb); | |
134 | } | |
135 | ||
136 | static void machine_set_dumpdtb(Object *obj, const char *value, Error **errp) | |
137 | { | |
138 | MachineState *ms = MACHINE(obj); | |
139 | ||
556068ee | 140 | g_free(ms->dumpdtb); |
6b1b1440 MA |
141 | ms->dumpdtb = g_strdup(value); |
142 | } | |
143 | ||
144 | static void machine_get_phandle_start(Object *obj, Visitor *v, | |
145 | void *opaque, const char *name, | |
146 | Error **errp) | |
147 | { | |
148 | MachineState *ms = MACHINE(obj); | |
149 | int64_t value = ms->phandle_start; | |
150 | ||
151 | visit_type_int(v, &value, name, errp); | |
152 | } | |
153 | ||
154 | static void machine_set_phandle_start(Object *obj, Visitor *v, | |
155 | void *opaque, const char *name, | |
156 | Error **errp) | |
157 | { | |
158 | MachineState *ms = MACHINE(obj); | |
159 | Error *error = NULL; | |
160 | int64_t value; | |
161 | ||
162 | visit_type_int(v, &value, name, &error); | |
163 | if (error) { | |
164 | error_propagate(errp, error); | |
165 | return; | |
166 | } | |
167 | ||
168 | ms->phandle_start = value; | |
169 | } | |
170 | ||
171 | static char *machine_get_dt_compatible(Object *obj, Error **errp) | |
172 | { | |
173 | MachineState *ms = MACHINE(obj); | |
174 | ||
175 | return g_strdup(ms->dt_compatible); | |
176 | } | |
177 | ||
178 | static void machine_set_dt_compatible(Object *obj, const char *value, Error **errp) | |
179 | { | |
180 | MachineState *ms = MACHINE(obj); | |
181 | ||
556068ee | 182 | g_free(ms->dt_compatible); |
6b1b1440 MA |
183 | ms->dt_compatible = g_strdup(value); |
184 | } | |
185 | ||
186 | static bool machine_get_dump_guest_core(Object *obj, Error **errp) | |
187 | { | |
188 | MachineState *ms = MACHINE(obj); | |
189 | ||
190 | return ms->dump_guest_core; | |
191 | } | |
192 | ||
193 | static void machine_set_dump_guest_core(Object *obj, bool value, Error **errp) | |
194 | { | |
195 | MachineState *ms = MACHINE(obj); | |
196 | ||
197 | ms->dump_guest_core = value; | |
198 | } | |
199 | ||
200 | static bool machine_get_mem_merge(Object *obj, Error **errp) | |
201 | { | |
202 | MachineState *ms = MACHINE(obj); | |
203 | ||
204 | return ms->mem_merge; | |
205 | } | |
206 | ||
207 | static void machine_set_mem_merge(Object *obj, bool value, Error **errp) | |
208 | { | |
209 | MachineState *ms = MACHINE(obj); | |
210 | ||
211 | ms->mem_merge = value; | |
212 | } | |
213 | ||
214 | static bool machine_get_usb(Object *obj, Error **errp) | |
215 | { | |
216 | MachineState *ms = MACHINE(obj); | |
217 | ||
218 | return ms->usb; | |
219 | } | |
220 | ||
221 | static void machine_set_usb(Object *obj, bool value, Error **errp) | |
222 | { | |
223 | MachineState *ms = MACHINE(obj); | |
224 | ||
225 | ms->usb = value; | |
226 | } | |
227 | ||
228 | static char *machine_get_firmware(Object *obj, Error **errp) | |
229 | { | |
230 | MachineState *ms = MACHINE(obj); | |
231 | ||
232 | return g_strdup(ms->firmware); | |
233 | } | |
234 | ||
235 | static void machine_set_firmware(Object *obj, const char *value, Error **errp) | |
236 | { | |
237 | MachineState *ms = MACHINE(obj); | |
238 | ||
556068ee | 239 | g_free(ms->firmware); |
6b1b1440 MA |
240 | ms->firmware = g_strdup(value); |
241 | } | |
242 | ||
a52a7fdf LT |
243 | static bool machine_get_iommu(Object *obj, Error **errp) |
244 | { | |
245 | MachineState *ms = MACHINE(obj); | |
246 | ||
247 | return ms->iommu; | |
248 | } | |
249 | ||
250 | static void machine_set_iommu(Object *obj, bool value, Error **errp) | |
251 | { | |
252 | MachineState *ms = MACHINE(obj); | |
253 | ||
254 | ms->iommu = value; | |
255 | } | |
256 | ||
33cd52b5 AG |
257 | static int error_on_sysbus_device(SysBusDevice *sbdev, void *opaque) |
258 | { | |
259 | error_report("Option '-device %s' cannot be handled by this machine", | |
260 | object_class_get_name(object_get_class(OBJECT(sbdev)))); | |
261 | exit(1); | |
262 | } | |
263 | ||
264 | static void machine_init_notify(Notifier *notifier, void *data) | |
265 | { | |
266 | Object *machine = qdev_get_machine(); | |
267 | ObjectClass *oc = object_get_class(machine); | |
268 | MachineClass *mc = MACHINE_CLASS(oc); | |
269 | ||
270 | if (mc->has_dynamic_sysbus) { | |
271 | /* Our machine can handle dynamic sysbus devices, we're all good */ | |
272 | return; | |
273 | } | |
274 | ||
275 | /* | |
276 | * Loop through all dynamically created devices and check whether there | |
277 | * are sysbus devices among them. If there are, error out. | |
278 | */ | |
279 | foreach_dynamic_sysbus_device(error_on_sysbus_device, NULL); | |
280 | } | |
281 | ||
6b1b1440 MA |
282 | static void machine_initfn(Object *obj) |
283 | { | |
33cd52b5 AG |
284 | MachineState *ms = MACHINE(obj); |
285 | ||
d8870d02 MA |
286 | ms->kernel_irqchip_allowed = true; |
287 | ||
6b1b1440 MA |
288 | object_property_add_str(obj, "accel", |
289 | machine_get_accel, machine_set_accel, NULL); | |
49d2e648 MA |
290 | object_property_set_description(obj, "accel", |
291 | "Accelerator list", | |
292 | NULL); | |
b0ddb8bf | 293 | object_property_add_bool(obj, "kernel-irqchip", |
d8870d02 | 294 | NULL, |
6b1b1440 MA |
295 | machine_set_kernel_irqchip, |
296 | NULL); | |
49d2e648 MA |
297 | object_property_set_description(obj, "kernel-irqchip", |
298 | "Use KVM in-kernel irqchip", | |
299 | NULL); | |
b0ddb8bf | 300 | object_property_add(obj, "kvm-shadow-mem", "int", |
6b1b1440 MA |
301 | machine_get_kvm_shadow_mem, |
302 | machine_set_kvm_shadow_mem, | |
303 | NULL, NULL, NULL); | |
49d2e648 MA |
304 | object_property_set_description(obj, "kvm-shadow-mem", |
305 | "KVM shadow MMU size", | |
306 | NULL); | |
6b1b1440 MA |
307 | object_property_add_str(obj, "kernel", |
308 | machine_get_kernel, machine_set_kernel, NULL); | |
49d2e648 MA |
309 | object_property_set_description(obj, "kernel", |
310 | "Linux kernel image file", | |
311 | NULL); | |
6b1b1440 MA |
312 | object_property_add_str(obj, "initrd", |
313 | machine_get_initrd, machine_set_initrd, NULL); | |
49d2e648 MA |
314 | object_property_set_description(obj, "initrd", |
315 | "Linux initial ramdisk file", | |
316 | NULL); | |
6b1b1440 MA |
317 | object_property_add_str(obj, "append", |
318 | machine_get_append, machine_set_append, NULL); | |
49d2e648 MA |
319 | object_property_set_description(obj, "append", |
320 | "Linux kernel command line", | |
321 | NULL); | |
6b1b1440 MA |
322 | object_property_add_str(obj, "dtb", |
323 | machine_get_dtb, machine_set_dtb, NULL); | |
49d2e648 MA |
324 | object_property_set_description(obj, "dtb", |
325 | "Linux kernel device tree file", | |
326 | NULL); | |
6b1b1440 MA |
327 | object_property_add_str(obj, "dumpdtb", |
328 | machine_get_dumpdtb, machine_set_dumpdtb, NULL); | |
49d2e648 MA |
329 | object_property_set_description(obj, "dumpdtb", |
330 | "Dump current dtb to a file and quit", | |
331 | NULL); | |
b0ddb8bf | 332 | object_property_add(obj, "phandle-start", "int", |
6b1b1440 MA |
333 | machine_get_phandle_start, |
334 | machine_set_phandle_start, | |
335 | NULL, NULL, NULL); | |
49d2e648 MA |
336 | object_property_set_description(obj, "phandle-start", |
337 | "The first phandle ID we may generate dynamically", | |
338 | NULL); | |
b0ddb8bf | 339 | object_property_add_str(obj, "dt-compatible", |
6b1b1440 MA |
340 | machine_get_dt_compatible, |
341 | machine_set_dt_compatible, | |
342 | NULL); | |
49d2e648 MA |
343 | object_property_set_description(obj, "dt-compatible", |
344 | "Overrides the \"compatible\" property of the dt root node", | |
345 | NULL); | |
6b1b1440 MA |
346 | object_property_add_bool(obj, "dump-guest-core", |
347 | machine_get_dump_guest_core, | |
348 | machine_set_dump_guest_core, | |
349 | NULL); | |
49d2e648 MA |
350 | object_property_set_description(obj, "dump-guest-core", |
351 | "Include guest memory in a core dump", | |
352 | NULL); | |
6b1b1440 | 353 | object_property_add_bool(obj, "mem-merge", |
ac40aa15 LT |
354 | machine_get_mem_merge, |
355 | machine_set_mem_merge, NULL); | |
49d2e648 MA |
356 | object_property_set_description(obj, "mem-merge", |
357 | "Enable/disable memory merge support", | |
358 | NULL); | |
ac40aa15 LT |
359 | object_property_add_bool(obj, "usb", |
360 | machine_get_usb, | |
361 | machine_set_usb, NULL); | |
49d2e648 MA |
362 | object_property_set_description(obj, "usb", |
363 | "Set on/off to enable/disable usb", | |
364 | NULL); | |
6b1b1440 | 365 | object_property_add_str(obj, "firmware", |
ac40aa15 LT |
366 | machine_get_firmware, |
367 | machine_set_firmware, NULL); | |
49d2e648 MA |
368 | object_property_set_description(obj, "firmware", |
369 | "Firmware image", | |
370 | NULL); | |
a52a7fdf LT |
371 | object_property_add_bool(obj, "iommu", |
372 | machine_get_iommu, | |
373 | machine_set_iommu, NULL); | |
49d2e648 MA |
374 | object_property_set_description(obj, "iommu", |
375 | "Set on/off to enable/disable Intel IOMMU (VT-d)", | |
376 | NULL); | |
33cd52b5 AG |
377 | |
378 | /* Register notifier when init is done for sysbus sanity checks */ | |
379 | ms->sysbus_notifier.notify = machine_init_notify; | |
380 | qemu_add_machine_init_done_notifier(&ms->sysbus_notifier); | |
6b1b1440 MA |
381 | } |
382 | ||
383 | static void machine_finalize(Object *obj) | |
384 | { | |
385 | MachineState *ms = MACHINE(obj); | |
386 | ||
387 | g_free(ms->accel); | |
388 | g_free(ms->kernel_filename); | |
389 | g_free(ms->initrd_filename); | |
390 | g_free(ms->kernel_cmdline); | |
391 | g_free(ms->dtb); | |
392 | g_free(ms->dumpdtb); | |
393 | g_free(ms->dt_compatible); | |
394 | g_free(ms->firmware); | |
395 | } | |
36d20cb2 | 396 | |
5e97b623 MA |
397 | bool machine_usb(MachineState *machine) |
398 | { | |
399 | return machine->usb; | |
400 | } | |
401 | ||
8caff636 MA |
402 | bool machine_iommu(MachineState *machine) |
403 | { | |
404 | return machine->iommu; | |
405 | } | |
406 | ||
d8870d02 MA |
407 | bool machine_kernel_irqchip_allowed(MachineState *machine) |
408 | { | |
409 | return machine->kernel_irqchip_allowed; | |
410 | } | |
411 | ||
412 | bool machine_kernel_irqchip_required(MachineState *machine) | |
413 | { | |
414 | return machine->kernel_irqchip_required; | |
415 | } | |
416 | ||
36d20cb2 MA |
417 | static const TypeInfo machine_info = { |
418 | .name = TYPE_MACHINE, | |
419 | .parent = TYPE_OBJECT, | |
420 | .abstract = true, | |
421 | .class_size = sizeof(MachineClass), | |
422 | .instance_size = sizeof(MachineState), | |
6b1b1440 MA |
423 | .instance_init = machine_initfn, |
424 | .instance_finalize = machine_finalize, | |
36d20cb2 MA |
425 | }; |
426 | ||
427 | static void machine_register_types(void) | |
428 | { | |
429 | type_register_static(&machine_info); | |
430 | } | |
431 | ||
432 | type_init(machine_register_types) |