1pub mod accel;
2pub mod acpitable;
3pub mod action;
4pub mod addfs;
5pub mod audio;
6pub mod audiodev;
7pub mod blockdev;
8pub mod boot;
9pub mod chardev;
10pub mod common;
11pub mod compact;
12pub mod cpu;
13pub mod cpu_flags;
14pub mod cpu_type;
15pub mod device;
16pub mod display;
17pub mod drive;
18pub mod fsdev;
19pub mod fw_cfg;
20pub mod global;
21pub mod icount;
22pub mod incoming;
23pub mod iscsi;
24pub mod machine;
25pub mod machine_type;
26pub mod memory;
27pub mod mon;
28pub mod msg;
29pub mod name;
30pub mod netdev;
31pub mod numa;
32pub mod object;
33pub mod overcommit;
34pub mod plugin;
35pub mod rtc;
36pub mod runwith;
37pub mod sandbox;
38pub mod serial;
39pub mod set;
40pub mod smbios;
41pub mod smp;
42pub mod spice;
43pub mod to_command;
44pub mod tpmdev;
45pub mod trace;
46pub mod usb;
47pub mod vga;
48pub mod virtfs;
49pub mod vnc;
50
51use std::path::PathBuf;
52
53use bon::Builder;
54
55use crate::accel::Accel;
56use crate::acpitable::AcpiTable;
57use crate::action::{Action, WatchdogAction};
58use crate::addfs::AddFd;
59use crate::audio::Audio;
60use crate::audiodev::AudioDev;
61use crate::blockdev::BlockDev;
62use crate::boot::Boot;
63use crate::chardev::CharDev;
64use crate::compact::Compact;
65use crate::cpu::CpuX86;
66use crate::device::Device;
67use crate::display::QemuDisplay;
68use crate::drive::Drive;
69use crate::fsdev::FsDev;
70use crate::fw_cfg::FwCfg;
71use crate::global::Global;
72use crate::icount::Icount;
73use crate::incoming::Incoming;
74use crate::iscsi::Iscsi;
75use crate::machine::MachineForX86;
76use crate::memory::Memory;
77use crate::mon::Mon;
78use crate::msg::Msg;
79use crate::name::Name;
80use crate::netdev::NetDev;
81use crate::numa::NUMA;
82use crate::object::Object;
83use crate::overcommit::Overcommit;
84use crate::plugin::Plugin;
85use crate::rtc::Rtc;
86use crate::runwith::RunWith;
87use crate::sandbox::Sandbox;
88use crate::serial::SpecialDevice;
89use crate::set::Set;
90use crate::smbios::Smbios;
91use crate::smp::SMP;
92use crate::spice::Spice;
93use crate::to_command::{ToArg, ToCommand};
94use crate::tpmdev::TpmDev;
95use crate::trace::Trace;
96use crate::usb::USBDevice;
97use crate::vga::VGA;
98use crate::virtfs::Virtfs;
99use crate::vnc::VNC;
100
101#[derive(Builder)]
102pub struct QemuInstanceForX86_64 {
103 pub qemu_binary: PathBuf,
104
105 pub machine: Option<MachineForX86>,
106 pub cpu: Option<CpuX86>,
107 pub accel: Option<Accel>,
108 pub smp: Option<SMP>,
109 pub numa: Option<Vec<NUMA>>,
110 pub add_fd: Option<AddFd>,
111 pub set: Option<Vec<Set>>,
112 pub global: Option<Vec<Global>>,
113 pub boot: Option<Boot>,
114 pub m: Option<Memory>,
115 pub mem_path: Option<PathBuf>,
116 pub mem_prealloc: Option<bool>,
117 pub k: Option<String>,
118 pub audio: Option<Audio>,
119 pub audiodev: Option<AudioDev>,
120 pub device: Option<Vec<Device>>,
121 pub name: Option<Name>,
122 pub uuid: Option<String>,
123 pub fda: Option<PathBuf>,
124 pub fdb: Option<PathBuf>,
125 pub hda: Option<PathBuf>,
126 pub hdb: Option<PathBuf>,
127 pub hdc: Option<PathBuf>,
128 pub hdd: Option<PathBuf>,
129 pub cdrom: Option<PathBuf>,
130 pub blockdev: Option<Vec<BlockDev>>,
131 pub drive: Option<Vec<Drive>>,
132 pub mdtblock: Option<PathBuf>,
133 pub sd: Option<PathBuf>,
134 pub snapshot: Option<bool>,
135 pub fsdev: Option<FsDev>,
136 pub virtfs: Option<Virtfs>,
137 pub iscsi: Option<Iscsi>,
138 pub usb: Option<bool>,
139 pub usbdevice: Option<USBDevice>,
140 pub display: Option<QemuDisplay>,
141 pub nographic: Option<bool>,
142 pub spice: Option<Spice>,
143 pub vga: Option<VGA>,
144 pub full_screen: Option<bool>,
145 pub g: Option<(usize, usize, Option<usize>)>,
146 pub vnc: Option<VNC>,
147 pub win2k_hack: Option<bool>,
148 pub no_fd_bootchk: Option<bool>,
149 pub acpitable: Option<AcpiTable>,
150 pub smbios: Option<Vec<Smbios>>,
151 pub netdev: Option<Vec<NetDev>>,
152 pub chardev: Option<Vec<CharDev>>,
153 pub tpmdev: Option<TpmDev>,
154 pub bios: Option<PathBuf>,
155 pub pflash: Option<PathBuf>,
156 pub kernel: Option<PathBuf>,
157 pub shim: Option<PathBuf>,
158 pub append: Option<String>,
159 pub initrd: Option<PathBuf>,
160 pub dtb: Option<PathBuf>,
161 pub compact: Option<Compact>,
162 pub fw_cfg: Option<FwCfg>,
163 pub serial: Option<SpecialDevice>,
164 pub parallel: Option<Vec<SpecialDevice>>,
165 pub monitor: Option<SpecialDevice>,
166 pub qmp: Option<SpecialDevice>,
167 pub qmp_pretty: Option<SpecialDevice>,
168 pub mon: Option<Vec<Mon>>,
169 pub debugcon: Option<CharDev>,
170 pub pidfile: Option<PathBuf>,
171 pub preconfig: Option<bool>,
172 pub big_s: Option<bool>,
173 pub overcommit: Option<Overcommit>,
174 pub gdb: Option<SpecialDevice>,
175 pub s: Option<bool>,
176 pub d: Option<Vec<String>>,
177 pub big_d: Option<PathBuf>,
178 pub dfilter: Option<Vec<String>>,
179 pub seed: Option<usize>,
180 pub big_l: Option<PathBuf>,
181 pub enable_kvm: Option<bool>,
182 pub xen_id: Option<String>,
183 pub xen_attach: Option<bool>,
184 pub xen_domid_restrict: Option<bool>,
185 pub no_reboot: Option<bool>,
186 pub no_shutdown: Option<bool>,
187 pub action: Option<Action>,
188 pub loadvm: Option<String>,
189 pub daemonize: Option<bool>,
190 pub option_rom: Option<PathBuf>,
191 pub rtc: Option<Rtc>,
192 pub icount: Option<Icount>,
193 pub watchdog_action: Option<WatchdogAction>,
194 pub echr: Option<String>,
195 pub incoming: Option<Vec<Incoming>>,
196 pub only_migratable: Option<bool>,
197 pub nodefaults: Option<bool>,
198 pub sandbox: Option<Sandbox>,
199 pub readconfig: Option<PathBuf>,
200 pub no_user_config: Option<bool>,
201 pub trace: Option<Trace>,
202 pub plugin: Option<Plugin>,
203 pub run_with: Option<RunWith>,
204 pub msg: Option<Msg>,
205 pub dump_vmstate: Option<PathBuf>,
206 pub enable_sync_profile: Option<bool>,
207 pub perfmap: Option<PathBuf>,
208 pub jitdump: Option<PathBuf>,
209 pub object: Option<Vec<Object>>,
210}
211
212impl ToCommand for QemuInstanceForX86_64 {
213 fn to_command(&self) -> Vec<String> {
214 let mut cmd = vec![];
215
216 cmd.push(self.qemu_binary.display().to_string());
217
218 if let Some(machine) = &self.machine {
219 cmd.append(&mut machine.to_command());
220 }
221 if let Some(cpu) = &self.cpu {
222 cmd.append(&mut cpu.to_command());
223 }
224 if let Some(accel) = &self.accel {
225 cmd.append(&mut accel.to_command());
226 }
227 if let Some(smp) = &self.smp {
228 cmd.append(&mut smp.to_command());
229 }
230 if let Some(numas) = &self.numa {
231 for numa in numas {
232 cmd.append(&mut numa.to_command());
233 }
234 }
235 if let Some(add_fd) = &self.add_fd {
236 cmd.append(&mut add_fd.to_command());
237 }
238 if let Some(sets) = &self.set {
239 for set in sets {
240 cmd.append(&mut set.to_command());
241 }
242 }
243 if let Some(globals) = &self.global {
244 for global in globals {
245 cmd.append(&mut global.to_command());
246 }
247 }
248 if let Some(boot) = &self.boot {
249 cmd.append(&mut boot.to_command());
250 }
251 if let Some(m) = &self.m {
252 cmd.append(&mut m.to_command());
253 }
254 if let Some(path) = &self.mem_path {
255 cmd.push("-mem-path".to_string());
256 cmd.push(path.display().to_string());
257 }
258 if let Some(state) = self.mem_prealloc
259 && state
260 {
261 cmd.push("-mem-prealloc".to_string());
262 }
263 if let Some(lang) = &self.k {
264 cmd.push("-k".to_string());
265 cmd.push(lang.to_string());
266 }
267 if let Some(audio) = &self.audio {
268 cmd.append(&mut audio.to_command());
269 }
270 if let Some(audiodev) = &self.audiodev {
271 cmd.append(&mut audiodev.to_command());
272 }
273 if let Some(devices) = &self.device {
274 for device in devices {
275 cmd.append(&mut device.to_command());
276 }
277 }
278 if let Some(name) = &self.name {
279 cmd.append(&mut name.to_command());
280 }
281 if let Some(uuid) = &self.uuid {
282 cmd.push("-uuid".to_string());
283 cmd.push(uuid.to_string());
284 }
285 if let Some(fda) = &self.fda {
286 cmd.push("-fda".to_string());
287 cmd.push(fda.display().to_string());
288 }
289 if let Some(fdb) = &self.fdb {
290 cmd.push("-fdb".to_string());
291 cmd.push(fdb.display().to_string());
292 }
293 if let Some(hda) = &self.hda {
294 cmd.push("-hda".to_string());
295 cmd.push(hda.display().to_string());
296 }
297 if let Some(hdb) = &self.hdb {
298 cmd.push("-hdb".to_string());
299 cmd.push(hdb.display().to_string());
300 }
301 if let Some(hdc) = &self.hdc {
302 cmd.push("-hdc".to_string());
303 cmd.push(hdc.display().to_string());
304 }
305 if let Some(hdd) = &self.hdd {
306 cmd.push("-hdd".to_string());
307 cmd.push(hdd.display().to_string());
308 }
309 if let Some(cdrom) = &self.cdrom {
310 cmd.push("-cdrom".to_string());
311 cmd.push(cdrom.display().to_string());
312 }
313 if let Some(blockdevs) = &self.blockdev {
314 for blockdev in blockdevs {
315 cmd.append(&mut blockdev.to_command());
316 }
317 }
318 if let Some(drives) = &self.drive {
319 for drive in drives {
320 cmd.append(&mut drive.to_command());
321 }
322 }
323 if let Some(mdtblock) = &self.mdtblock {
324 cmd.push("-mtdblock".to_string());
325 cmd.push(mdtblock.display().to_string());
326 }
327 if let Some(sd) = &self.sd {
328 cmd.push("-sd".to_string());
329 cmd.push(sd.display().to_string());
330 }
331 if let Some(state) = &self.snapshot
332 && *state
333 {
334 cmd.push("-snapshot".to_string());
335 }
336 if let Some(fsdev) = &self.fsdev {
337 cmd.append(&mut fsdev.to_command());
338 }
339 if let Some(virtfs) = &self.virtfs {
340 cmd.append(&mut virtfs.to_command());
341 }
342 if let Some(iscsi) = &self.iscsi {
343 cmd.append(&mut iscsi.to_command());
344 }
345 if let Some(state) = &self.usb
346 && *state
347 {
348 cmd.push("-usb".to_string());
349 }
350 if let Some(usbdevice) = &self.usbdevice {
351 cmd.append(&mut usbdevice.to_command());
352 }
353 if let Some(display) = &self.display {
354 cmd.append(&mut display.to_command());
355 }
356 if let Some(state) = &self.nographic
357 && *state
358 {
359 cmd.push("-nographic".to_string());
360 }
361 if let Some(spice) = &self.spice {
362 cmd.append(&mut spice.to_command());
363 }
364 if let Some(vga) = &self.vga {
365 cmd.append(&mut vga.to_command());
366 }
367 if let Some(full_screen) = &self.full_screen
368 && *full_screen
369 {
370 cmd.push("-full-screen".to_string());
371 }
372 if let Some((w, h, d)) = &self.g {
373 cmd.push("-g".to_string());
374 let mut dimensions = format!("{}x{}", w, h);
375
376 if let Some(d) = d {
377 dimensions.push_str(format!("x{}", &d.to_string()).as_str());
378 }
379 cmd.push(dimensions);
380 }
381 if let Some(vnc) = &self.vnc {
382 cmd.append(&mut vnc.to_command());
383 }
384 if let Some(win2k_hack) = &self.win2k_hack
385 && *win2k_hack
386 {
387 cmd.push("-win2k-hack".to_string());
388 }
389 if let Some(no_fd_bootchk) = &self.no_fd_bootchk
390 && *no_fd_bootchk
391 {
392 cmd.push("-no-fd-bootchk".to_string());
393 }
394 if let Some(acpitable) = &self.acpitable {
395 cmd.append(&mut acpitable.to_command());
396 }
397 if let Some(smbioss) = &self.smbios {
398 for smbios in smbioss {
399 cmd.append(&mut smbios.to_command());
400 }
401 }
402 if let Some(netdevs) = &self.netdev {
403 for netdev in netdevs {
404 cmd.append(&mut netdev.to_command());
405 }
406 }
407 if let Some(chardevs) = &self.chardev {
408 for chardev in chardevs {
409 cmd.append(&mut chardev.to_command());
410 }
411 }
412 if let Some(tpmdev) = &self.tpmdev {
413 cmd.append(&mut tpmdev.to_command());
414 }
415 if let Some(bios) = &self.bios {
416 cmd.push("-bios".to_string());
417 cmd.push(bios.display().to_string());
418 }
419 if let Some(pflash) = &self.pflash {
420 cmd.push("-pflash".to_string());
421 cmd.push(pflash.display().to_string());
422 }
423 if let Some(kernel) = &self.kernel {
424 cmd.push("-kernel".to_string());
425 cmd.push(kernel.display().to_string());
426 }
427 if let Some(shim) = &self.shim {
428 cmd.push("-shim".to_string());
429 cmd.push(shim.display().to_string());
430 }
431 if let Some(append) = &self.append {
432 cmd.push("-append".to_string());
433 cmd.push(append.clone());
434 }
435 if let Some(initrd) = &self.initrd {
436 cmd.push("-initrd".to_string());
437 cmd.push(initrd.display().to_string());
438 }
439 if let Some(dtb) = &self.dtb {
440 cmd.push("-dtb".to_string());
441 cmd.push(dtb.display().to_string());
442 }
443 if let Some(compact) = &self.compact {
444 cmd.append(&mut compact.to_command());
445 }
446 if let Some(fw_cfg) = &self.fw_cfg {
447 cmd.append(&mut fw_cfg.to_command());
448 }
449 if let Some(serial) = &self.serial {
450 cmd.push("-serial".to_string());
451 cmd.append(&mut serial.to_command());
452 }
453 if let Some(parallels) = &self.parallel {
454 for parallel in parallels {
455 cmd.push("-parallel".to_string());
456 cmd.append(&mut parallel.to_command());
457 }
458 }
459 if let Some(monitor) = &self.monitor {
460 cmd.push("-monitor".to_string());
461 cmd.append(&mut monitor.to_command());
462 }
463 if let Some(qmp) = &self.qmp {
464 cmd.push("-qmp".to_string());
465 cmd.append(&mut qmp.to_command());
466 }
467 if let Some(qmp_pretty) = &self.qmp_pretty {
468 cmd.push("-qmp-pretty".to_string());
469 cmd.append(&mut qmp_pretty.to_command());
470 }
471 if let Some(mons) = &self.mon {
472 for mon in mons {
473 cmd.append(&mut mon.to_command());
474 }
475 }
476 if let Some(debugcon) = &self.debugcon {
477 cmd.push("-debugcon".to_string());
478 cmd.append(&mut debugcon.to_command());
479 }
480 if let Some(pidfile) = &self.pidfile {
481 cmd.push("-pidfile".to_string());
482 cmd.push(pidfile.display().to_string());
483 }
484 if let Some(preconfig) = &self.preconfig
485 && *preconfig
486 {
487 cmd.push("--preconfig".to_string());
488 }
489 if let Some(s) = &self.big_s
490 && *s
491 {
492 cmd.push("-S".to_string());
493 }
494 if let Some(overcommit) = &self.overcommit {
495 cmd.append(&mut overcommit.to_command());
496 }
497 if let Some(gdb) = &self.gdb {
498 cmd.push("-gdb".to_string());
499 cmd.append(&mut gdb.to_command());
500 }
501 if let Some(s) = &self.s
502 && *s
503 {
504 cmd.push("-s".to_string());
505 }
506 if let Some(d) = &self.d {
507 cmd.push("-d".to_string());
508 cmd.push(d.join(","));
509 }
510 if let Some(big_d) = &self.big_d {
511 cmd.push("-D".to_string());
512 cmd.push(big_d.display().to_string());
513 }
514 if let Some(dfilter) = &self.dfilter {
515 cmd.push("-dfilter".to_string());
516 cmd.push(dfilter.join(","));
517 }
518 if let Some(seed) = &self.seed {
519 cmd.push("-seed".to_string());
520 cmd.push(seed.to_string());
521 }
522 if let Some(seed) = &self.seed {
523 cmd.push("-seed".to_string());
524 cmd.push(seed.to_string());
525 }
526 if let Some(l) = &self.big_l {
527 cmd.push("-L".to_string());
528 cmd.push(l.display().to_string());
529 }
530 if let Some(enable_kvm) = &self.enable_kvm
531 && *enable_kvm
532 {
533 cmd.push("-enable-kvm".to_string());
534 }
535 if let Some(xen_id) = &self.xen_id {
536 cmd.push("-xen-id".to_string());
537 cmd.push(xen_id.to_string());
538 }
539 if let Some(xen_attach) = &self.xen_attach
540 && *xen_attach
541 {
542 cmd.push("-xen-attach".to_string());
543 }
544 if let Some(xen_domid_restrict) = &self.xen_domid_restrict
545 && *xen_domid_restrict
546 {
547 cmd.push("-xen-domid-restrict".to_string());
548 }
549 if let Some(no_reboot) = &self.no_reboot
550 && *no_reboot
551 {
552 cmd.push("-no-reboot".to_string());
553 }
554 if let Some(no_shutdown) = &self.no_shutdown
555 && *no_shutdown
556 {
557 cmd.push("-no-shutdown".to_string());
558 }
559 if let Some(action) = &self.action {
560 cmd.append(&mut action.to_command());
561 }
562 if let Some(loadvm) = &self.loadvm {
563 cmd.push("-loadvm".to_string());
564 cmd.push(loadvm.to_string());
565 }
566 if let Some(daemonize) = &self.daemonize
567 && *daemonize
568 {
569 cmd.push("-daemonize".to_string());
570 }
571 if let Some(option_rom) = &self.option_rom {
572 cmd.push("-option-rom".to_string());
573 cmd.push(option_rom.display().to_string());
574 }
575 if let Some(rtc) = &self.rtc {
576 cmd.append(&mut rtc.to_command());
577 }
578 if let Some(icount) = &self.icount {
579 cmd.append(&mut icount.to_command());
580 }
581 if let Some(watchdog_action) = &self.watchdog_action {
582 cmd.push("-watchdog-action".to_string());
583 cmd.push(watchdog_action.to_arg().to_string());
584 }
585 if let Some(echr) = &self.echr {
586 cmd.push("-echr".to_string());
587 cmd.push(echr.to_string());
588 }
589 if let Some(incomings) = &self.incoming {
590 for incoming in incomings {
591 cmd.append(&mut incoming.to_command());
592 }
593 }
594 if let Some(only_migratable) = &self.only_migratable
595 && *only_migratable
596 {
597 cmd.push("-only-migratable".to_string());
598 }
599 if let Some(nodefaults) = &self.nodefaults
600 && *nodefaults
601 {
602 cmd.push("-nodefaults".to_string());
603 }
604 if let Some(sandbox) = &self.sandbox {
605 cmd.append(&mut sandbox.to_command());
606 }
607 if let Some(readconfig) = &self.readconfig {
608 cmd.push("-readconfig".to_string());
609 cmd.push(readconfig.display().to_string());
610 }
611 if let Some(no_user_config) = &self.no_user_config
612 && *no_user_config
613 {
614 cmd.push("-no-user-config".to_string());
615 }
616 if let Some(trace) = &self.trace {
617 cmd.append(&mut trace.to_command());
618 }
619 if let Some(plugin) = &self.plugin {
620 cmd.append(&mut plugin.to_command());
621 }
622 if let Some(run_with) = &self.run_with {
623 cmd.append(&mut run_with.to_command());
624 }
625 if let Some(msg) = &self.msg {
626 cmd.append(&mut msg.to_command());
627 }
628 if let Some(dump_vmstate) = &self.dump_vmstate {
629 cmd.push("-dump-vmstate".to_string());
630 cmd.push(dump_vmstate.display().to_string());
631 }
632 if let Some(enable_sync_profile) = &self.enable_sync_profile
633 && *enable_sync_profile
634 {
635 cmd.push("-enable-sync-profile".to_string());
636 }
637 if let Some(perfmap) = &self.perfmap {
638 cmd.push("-perfmap".to_string());
639 cmd.push(perfmap.display().to_string());
640 }
641 if let Some(jitdump) = &self.jitdump {
642 cmd.push("-jitdump".to_string());
643 cmd.push(jitdump.display().to_string());
644 }
645 if let Some(objects) = &self.object {
646 for object in objects {
647 cmd.append(&mut object.to_command());
648 }
649 }
650 cmd
651 }
652}