1use crate::args::accel::Accel;
2use crate::args::acpitable::AcpiTable;
3use crate::args::action::{Action, WatchdogAction};
4use crate::args::addfs::AddFd;
5use crate::args::audio::Audio;
6use crate::args::audiodev::AudioDev;
7use crate::args::blockdev::BlockDev;
8use crate::args::boot::Boot;
9use crate::args::chardev::CharDev;
10use crate::args::compact::Compact;
11use crate::args::device::Device;
12use crate::args::display::QemuDisplay;
13use crate::args::drive::Drive;
14use crate::args::fsdev::FsDev;
15use crate::args::fw_cfg::FwCfg;
16use crate::args::g::G;
17use crate::args::global::Global;
18use crate::args::icount::Icount;
19use crate::args::incoming::Incoming;
20use crate::args::iscsi::Iscsi;
21use crate::args::memory::Memory;
22use crate::args::mon::Mon;
23use crate::args::msg::Msg;
24use crate::args::name::Name;
25use crate::args::netdev::NetDev;
26use crate::args::numa::NUMA;
27use crate::args::object::Object;
28use crate::args::overcommit::Overcommit;
29use crate::args::plugin::Plugin;
30use crate::args::rtc::Rtc;
31use crate::args::runwith::RunWith;
32use crate::args::sandbox::Sandbox;
33use crate::args::serial::SpecialDevice;
34use crate::args::set::Set;
35use crate::args::smbios::Smbios;
36use crate::args::smp::SMP;
37use crate::args::spice::Spice;
38use crate::args::tpmdev::TpmDev;
39use crate::args::trace::Trace;
40use crate::args::usb::USBDevice;
41use crate::args::vga::VGA;
42use crate::args::virtfs::Virtfs;
43use crate::args::vnc::VNC;
44use crate::parsers::{
45 ARG_ACCEL, ARG_ACPITABLE, ARG_ACTION, ARG_ADD_FD, ARG_APPEND, ARG_AUDIO, ARG_AUDIODEV, ARG_BIG_D, ARG_BIG_S, ARG_BIOS, ARG_BLOCKDEV, ARG_BOOT, ARG_CDROM, ARG_CHARDEV, ARG_CHROOT, ARG_COMPAT,
46 ARG_CPU, ARG_DAEMONIZE, ARG_DEBUGCON, ARG_DEVICE, ARG_DFILTER, ARG_DISPLAY, ARG_DRIVE, ARG_DTB, ARG_DUMP_VMSTATE, ARG_ECHR, ARG_ENABLE_KVM, ARG_ENABLE_SYNC_PROFILE, ARG_FDA, ARG_FDB, ARG_FSDEV,
47 ARG_FULL_SCREEN, ARG_FW_CFG, ARG_G, ARG_GDB, ARG_GLOBAL, ARG_HDA, ARG_HDB, ARG_HDC, ARG_HDD, ARG_ICOUNT, ARG_INCOMING, ARG_INITRD, ARG_ISCSI, ARG_JITDUMP, ARG_K, ARG_KERNEL, ARG_L, ARG_LITTLE_D,
48 ARG_LITTLE_S, ARG_LOADVM, ARG_MACHINE, ARG_MEM_PATH, ARG_MEM_PREALLOC, ARG_MEMORY, ARG_MON, ARG_MONITOR, ARG_MSG, ARG_MTDBLOCK, ARG_NAME, ARG_NETDEV, ARG_NO_FD_BOOTCHK, ARG_NO_REBOOT,
49 ARG_NO_SHUTDOWN, ARG_NO_USER_CONFIG, ARG_NODEFAULTS, ARG_NOGRAPHIC, ARG_NUMA, ARG_OBJECT, ARG_ONLY_MIGRATABLE, ARG_OPTION_ROM, ARG_OVERCOMMIT, ARG_PARALLEL, ARG_PERFMAP, ARG_PFLASH, ARG_PIDFILE,
50 ARG_PLUGIN, ARG_PRECONFIG, ARG_QMP, ARG_QMP_PRETTY, ARG_READCONFIG, ARG_RTC, ARG_RUN_WITH, ARG_RUNAS, ARG_SANDBOX, ARG_SD, ARG_SEED, ARG_SERIAL, ARG_SET, ARG_SHIM, ARG_SMBIOS, ARG_SMP,
51 ARG_SNAPSHOT, ARG_SPICE, ARG_TPMDEV, ARG_TRACE, ARG_USB, ARG_USBDEVICE, ARG_UUID, ARG_VGA, ARG_VIRTFS, ARG_VNC, ARG_WATCHDOG_ACTION, ARG_WIN2K_HACK, ARG_XEN_ATTACH, ARG_XEN_DOMID_RESTRICT,
52 ARG_XEN_ID,
53};
54use crate::shell_string::ShellString;
55use crate::{QEMU_BIN_AARCH64, QEMU_BIN_X86_64, QUuid, QemuCommand, QemuInstanceBase, QemuInstanceForAarch64, QemuInstanceForX86_64};
56use std::path::PathBuf;
57use std::str::FromStr;
58use winnow::Result;
59
60#[macro_export]
62macro_rules! ff {
63 ($a:expr,$b:ident,$c:ty,$d:expr) => {
64 match $a.next() {
65 None => {
66 return Err(format!("Argument {} expected a token to parse, none found", $b));
67 }
68 Some(v) => match v.parse::<$c>() {
69 Ok(p) => {
70 $d = Some(p);
71 }
72 Err(parse_err) => {
73 return Err(format!("While trying to parse $b an error was seen: {}", parse_err));
74 }
75 },
76 }
77 };
78}
79#[macro_export]
80macro_rules! ffs {
81 ($a:expr,$b:ident,$c:ty,$d:expr) => {
82 match $a.next() {
83 None => {
84 return Err(format!("Argument {} expected a token to parse, none found", $b));
85 }
86 Some(v) => match v.parse::<$c>() {
87 Ok(p) => match $d {
88 Some(ref mut vs) => vs.push(p),
89 None => {
90 $d = Some(vec![p]);
91 }
92 },
93 Err(parse_err) => {
94 return Err(format!("While trying to parse $b an error was seen: {}", parse_err));
95 }
96 },
97 }
98 };
99}
100
101fn parse_common_qemu_args<Machine: FromStr, Cpu: FromStr>(q: &mut QemuInstanceBase<Machine, Cpu>, tokens: impl IntoIterator<Item = String>) -> Result<(), String>
102where
103 <Cpu as FromStr>::Err: std::fmt::Display,
104 <Machine as FromStr>::Err: std::fmt::Display,
105{
106 let mut tokens = tokens.into_iter();
107 while let Some(token) = tokens.next() {
108 match token.as_str() {
109 ARG_CPU => ff!(tokens, ARG_CPU, Cpu, q.cpu),
111 ARG_MACHINE => ff!(tokens, ARG_MACHINE, Machine, q.machine),
112 ARG_ACCEL => ff!(tokens, ARG_ACCEL, Accel, q.accel),
114 ARG_SMP => ff!(tokens, ARG_SMP, SMP, q.smp),
115 ARG_NUMA => ffs!(tokens, ARG_NUMA, NUMA, q.numa),
116 ARG_ADD_FD => ff!(tokens, ARG_ADD_FD, AddFd, q.add_fd),
117 ARG_SET => ffs!(tokens, ARG_SET, Set, q.set),
118 ARG_GLOBAL => ffs!(tokens, ARG_GLOBAL, Global, q.global),
119 ARG_BOOT => ff!(tokens, ARG_BOOT, Boot, q.boot),
120 ARG_MEMORY => ff!(tokens, ARG_MEMORY, Memory, q.m),
121 ARG_MEM_PATH => ff!(tokens, ARG_MEM_PATH, PathBuf, q.mem_path),
122 ARG_MEM_PREALLOC => q.mem_prealloc = Some(true),
123 ARG_K => ff!(tokens, ARG_K, String, q.k),
124 ARG_AUDIO => ff!(tokens, ARG_AUDIO, Audio, q.audio),
125 ARG_AUDIODEV => ff!(tokens, ARG_AUDIODEV, AudioDev, q.audiodev),
126 ARG_DEVICE => ffs!(tokens, ARG_DEVICE, Device, q.device),
127 ARG_NAME => ff!(tokens, ARG_NAME, Name, q.name),
128 ARG_UUID => ff!(tokens, ARG_UUID, newtype_uuid::TypedUuid<QUuid>, q.uuid),
129 ARG_FDA => ff!(tokens, ARG_FDA, PathBuf, q.fda),
130 ARG_FDB => ff!(tokens, ARG_FDB, PathBuf, q.fdb),
131 ARG_HDA => ff!(tokens, ARG_HDA, PathBuf, q.hda),
132 ARG_HDB => ff!(tokens, ARG_HDB, PathBuf, q.hdb),
133 ARG_HDC => ff!(tokens, ARG_HDC, PathBuf, q.hdc),
134 ARG_HDD => ff!(tokens, ARG_HDD, PathBuf, q.hdd),
135 ARG_CDROM => ff!(tokens, ARG_CDROM, PathBuf, q.cdrom),
136 ARG_BLOCKDEV => ffs!(tokens, ARG_BLOCKDEV, BlockDev, q.blockdev),
137 ARG_DRIVE => ffs!(tokens, ARG_DRIVE, Drive, q.drive),
138 ARG_MTDBLOCK => ff!(tokens, ARG_MTDBLOCK, PathBuf, q.mdtblock),
139 ARG_SD => ff!(tokens, ARG_SD, PathBuf, q.sd),
140 ARG_SNAPSHOT => q.snapshot = Some(true),
141 ARG_FSDEV => ff!(tokens, ARG_FSDEV, FsDev, q.fsdev),
142 ARG_VIRTFS => ff!(tokens, ARG_VIRTFS, Virtfs, q.virtfs),
143 ARG_ISCSI => ff!(tokens, ARG_ISCSI, Iscsi, q.iscsi),
144 ARG_USB => q.usb = Some(true),
145 ARG_USBDEVICE => ff!(tokens, ARG_USBDEVICE, USBDevice, q.usbdevice),
146 ARG_DISPLAY => ff!(tokens, ARG_DISPLAY, QemuDisplay, q.display),
147 ARG_NOGRAPHIC => q.nographic = Some(true),
148 ARG_SPICE => ff!(tokens, ARG_SPICE, Spice, q.spice),
149 ARG_VGA => ff!(tokens, ARG_VGA, VGA, q.vga),
150 ARG_FULL_SCREEN => q.full_screen = Some(true),
151 ARG_G => ff!(tokens, ARG_G, G, q.g),
152 ARG_VNC => ff!(tokens, ARG_VNC, VNC, q.vnc),
153 ARG_WIN2K_HACK => q.win2k_hack = Some(true),
154 ARG_NO_FD_BOOTCHK => q.no_fd_bootchk = Some(true),
155 ARG_ACPITABLE => ff!(tokens, ARG_ACPITABLE, AcpiTable, q.acpitable),
156 ARG_SMBIOS => ffs!(tokens, ARG_SMBIOS, Smbios, q.smbios),
157 ARG_NETDEV => ffs!(tokens, ARG_NETDEV, NetDev, q.netdev),
158 ARG_CHARDEV => ffs!(tokens, ARG_CHARDEV, CharDev, q.chardev),
159 ARG_TPMDEV => ff!(tokens, ARG_TPMDEV, TpmDev, q.tpmdev),
160 ARG_BIOS => ff!(tokens, ARG_BIOS, PathBuf, q.bios),
161 ARG_PFLASH => ff!(tokens, ARG_PFLASH, PathBuf, q.pflash),
162 ARG_KERNEL => ff!(tokens, ARG_KERNEL, PathBuf, q.kernel),
163 ARG_SHIM => ff!(tokens, ARG_SHIM, PathBuf, q.shim),
164 ARG_APPEND => ff!(tokens, ARG_APPEND, ShellString, q.append),
165 ARG_INITRD => ff!(tokens, ARG_INITRD, PathBuf, q.initrd),
166 ARG_DTB => ff!(tokens, ARG_DTB, PathBuf, q.dtb),
167 ARG_COMPAT => ff!(tokens, ARG_COMPAT, Compact, q.compact),
168 ARG_FW_CFG => ff!(tokens, ARG_FW_CFG, FwCfg, q.fw_cfg),
169 ARG_SERIAL => ff!(tokens, ARG_SERIAL, SpecialDevice, q.serial),
170 ARG_PARALLEL => ffs!(tokens, ARG_PARALLEL, SpecialDevice, q.parallel),
171 ARG_MONITOR => ff!(tokens, ARG_MONITOR, SpecialDevice, q.monitor),
172 ARG_QMP => ff!(tokens, ARG_QMP, SpecialDevice, q.qmp),
173 ARG_QMP_PRETTY => ff!(tokens, ARG_QMP_PRETTY, SpecialDevice, q.qmp_pretty),
174 ARG_MON => ffs!(tokens, ARG_MON, Mon, q.mon),
175 ARG_DEBUGCON => ff!(tokens, ARG_DEBUGCON, CharDev, q.debugcon),
176 ARG_PIDFILE => ff!(tokens, ARG_PIDFILE, PathBuf, q.pidfile),
177 ARG_PRECONFIG => q.preconfig = Some(true),
178 ARG_BIG_S => q.big_s = Some(true),
179 ARG_OVERCOMMIT => ff!(tokens, ARG_OVERCOMMIT, Overcommit, q.overcommit),
180 ARG_GDB => ff!(tokens, ARG_GDB, SpecialDevice, q.gdb),
181 ARG_LITTLE_S => q.s = Some(true),
182 ARG_LITTLE_D => ffs!(tokens, ARG_LITTLE_D, String, q.d),
183 ARG_BIG_D => ff!(tokens, ARG_BIG_D, PathBuf, q.big_d),
184 ARG_DFILTER => ffs!(tokens, ARG_DFILTER, String, q.dfilter),
185 ARG_SEED => ff!(tokens, ARG_SEED, usize, q.seed),
186 ARG_L => ff!(tokens, ARG_L, PathBuf, q.big_l),
187 ARG_ENABLE_KVM => q.enable_kvm = Some(true),
188 ARG_XEN_ID => ff!(tokens, ARG_XEN_ID, String, q.xen_id),
189 ARG_XEN_ATTACH => q.xen_attach = Some(true),
190 ARG_XEN_DOMID_RESTRICT => q.xen_domid_restrict = Some(true),
191 ARG_NO_REBOOT => q.no_reboot = Some(true),
192 ARG_NO_SHUTDOWN => q.no_shutdown = Some(true),
193 ARG_ACTION => ff!(tokens, ARG_ACTION, Action, q.action),
194 ARG_LOADVM => ff!(tokens, ARG_LOADVM, String, q.loadvm),
195 ARG_DAEMONIZE => q.daemonize = Some(true),
196 ARG_OPTION_ROM => ff!(tokens, ARG_OPTION_ROM, PathBuf, q.option_rom),
197 ARG_RTC => ff!(tokens, ARG_RTC, Rtc, q.rtc),
198 ARG_ICOUNT => ff!(tokens, ARG_ICOUNT, Icount, q.icount),
199 ARG_WATCHDOG_ACTION => ff!(tokens, ARG_WATCHDOG_ACTION, WatchdogAction, q.watchdog_action),
200 ARG_ECHR => ff!(tokens, ARG_ECHR, String, q.echr),
201 ARG_INCOMING => ffs!(tokens, ARG_INCOMING, Incoming, q.incoming),
202 ARG_ONLY_MIGRATABLE => q.only_migratable = Some(true),
203 ARG_NODEFAULTS => q.nodefaults = Some(true),
204 ARG_SANDBOX => ff!(tokens, ARG_SANDBOX, Sandbox, q.sandbox),
205 ARG_READCONFIG => ff!(tokens, ARG_READCONFIG, PathBuf, q.readconfig),
206 ARG_NO_USER_CONFIG => q.no_user_config = Some(true),
207 ARG_TRACE => ff!(tokens, ARG_TRACE, Trace, q.trace),
208 ARG_PLUGIN => ff!(tokens, ARG_PLUGIN, Plugin, q.plugin),
209 ARG_RUNAS => ff!(tokens, ARG_RUNAS, String, q.runas),
210 ARG_RUN_WITH => ff!(tokens, ARG_RUN_WITH, RunWith, q.run_with),
211 ARG_CHROOT => ff!(tokens, ARG_CHROOT, PathBuf, q.chroot),
212 ARG_MSG => ff!(tokens, ARG_MSG, Msg, q.msg),
213 ARG_DUMP_VMSTATE => ff!(tokens, ARG_DUMP_VMSTATE, PathBuf, q.dump_vmstate),
214 ARG_ENABLE_SYNC_PROFILE => q.enable_sync_profile = Some(true),
215 ARG_PERFMAP => ff!(tokens, ARG_PERFMAP, PathBuf, q.perfmap),
216 ARG_JITDUMP => ff!(tokens, ARG_JITDUMP, PathBuf, q.jitdump),
217 ARG_OBJECT => ffs!(tokens, ARG_OBJECT, Object, q.object),
218 other => {
219 return Err(format!("unsupported argument: {other}"));
220 }
221 }
222 }
223 Ok(())
224}
225
226fn _parse_qemu_command_line<Machine: std::str::FromStr, Cpu: std::str::FromStr>(bin_name: &str, s: &str, q: &mut QemuInstanceBase<Machine, Cpu>) -> Result<(), String>
227where
228 <Cpu as FromStr>::Err: std::fmt::Display,
229 <Machine as FromStr>::Err: std::fmt::Display,
230{
231 let mut tokens = shellish_parse::parse(s, shellish_parse::ParseOptions::new()).map_err(|e| e.to_string())?.into_iter();
232
233 let binary = tokens.next();
234 match binary {
235 None => {
236 return Err(String::from("No next token for determining binary name"));
237 }
238 Some(path) => {
239 if path.contains(bin_name) {
240 q.qemu_binary = PathBuf::from(path);
241 } else {
242 return Err(format!("{} not found in string {}", bin_name, path));
243 }
244 }
245 }
246
247 parse_common_qemu_args(q, tokens)?;
248
249 Ok(())
250}
251
252impl FromStr for QemuInstanceForX86_64 {
253 type Err = String;
254
255 fn from_str(s: &str) -> Result<Self, Self::Err> {
256 let mut q = QemuInstanceBase::builder().qemu_binary(PathBuf::from("")).build();
257 _parse_qemu_command_line(QEMU_BIN_X86_64, s, &mut q)?;
258 Ok(q)
259 }
260}
261
262impl FromStr for QemuInstanceForAarch64 {
263 type Err = String;
264
265 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
266 let mut q = QemuInstanceBase::builder().qemu_binary(PathBuf::from("")).build();
267 _parse_qemu_command_line(QEMU_BIN_AARCH64, s, &mut q)?;
268 Ok(q)
269 }
270}
271
272pub fn parse_qemu_command_line(cmd: &str) -> Result<QemuCommand, String> {
273 match cmd.split_once(" ") {
274 None => Err(String::from("No next token for determining binary name")),
275 Some((bin, _rest)) => {
276 if bin.ends_with(QEMU_BIN_AARCH64) {
277 return QemuInstanceForAarch64::from_str(cmd).map(QemuCommand::Aarch64);
278 }
279 if bin.ends_with(QEMU_BIN_X86_64) {
280 return QemuInstanceForX86_64::from_str(cmd).map(QemuCommand::X86_64);
281 }
282 Err(format!("binary {} is an unsupported architecture", bin))
283 }
284 }
285}