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