[ffx][emu] Assign host ports when using qemu

This adds assigning the host port to a port that is forwarded out of the
guest. Older versions of QEMU automatically assigned an unused port to
complete the mappings, however QEMU 9 does not do this and so
ffx does this as part staging the instance.

Bug: 384957072
Change-Id: I2f9ad920459e1c4dfa6caa781a9f47aceb1c4225
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/1178082
Commit-Queue: Clayton Wilkinson <[email protected]>
Reviewed-by: Casey Dahlin <[email protected]>

Author: claywilkinson

src/developer/ffx/plugins/emulator/engines/BUILD.gn

@@ -27,6 +27,7 @@ if (is_host) {
       "//src/developer/ffx/lib/emulator_instance:lib",
       "//src/developer/ffx/lib/errors:lib",
       "//src/developer/ffx/lib/fho:lib",
+      "//src/developer/ffx/lib/port_picker:lib",
       "//src/developer/ffx/lib/ssh:lib",
       "//src/developer/ffx/lib/target:lib",
       "//src/developer/ffx/plugins/emulator/common:ffx_emulator_common",

src/developer/ffx/plugins/emulator/engines/src/lib.rs

@@ -18,7 +18,8 @@ use emulator_instance::{
 };
 use errors::ffx_bail;
 use ffx_emulator_config::EmulatorEngine;
-use fho::{bug, return_user_error, Result};
+use fho::{bug, return_bug, return_user_error, Result};
+use port_picker::{is_free_tcp_port, pick_unused_port};
 use qemu_based::crosvm::CrosvmEngine;
 use qemu_based::femu::FemuEngine;
 use qemu_based::qemu::QemuEngine;
@@ -207,3 +208,50 @@ pub fn process_flags_from_str(text: &str, emu_config: &EmulatorConfiguration) ->
     arg_templates::process_flags_from_str(text, emu_config)
         .map_err(|e| bug!("Error processing flags: {e}"))
 }
+
+#[allow(dead_code)]
+/// Ensures all ports are mapped with available port values, assigning free ports any that are
+/// missing, and making sure there are no conflicts within the map.
+pub(crate) fn finalize_port_mapping(emu_config: &mut EmulatorConfiguration) -> Result<()> {
+    let port_map = &mut emu_config.host.port_map;
+    let mut used_ports = Vec::new();
+    for (name, port) in port_map {
+        if let Some(value) = port.host {
+            if is_free_tcp_port(value).is_some() && !used_ports.contains(&value) {
+                // This port is good, so we claim it to make sure there are no conflicts later.
+                used_ports.push(value);
+            } else {
+                return_user_error!("Host port {} was mapped to multiple guest ports.", value);
+            }
+        } else {
+            tracing::warn!(
+                "No host-side port specified for '{:?}', a host port will be dynamically \
+                assigned. Check `ffx emu show {}` to see which port is assigned.",
+                name,
+                emu_config.runtime.name
+            );
+
+            // There have been some incidents in automated tests of the same port
+            // being returned multiple times.
+            // So we'll try multiple times and avoid duplicates.
+            for _ in 0..10 {
+                if let Some(value) = pick_unused_port() {
+                    if !used_ports.contains(&value) {
+                        port.host = Some(value);
+                        used_ports.push(value);
+                        break;
+                    } else {
+                        tracing::warn!("pick unused port returned: {} multiple times\n", value);
+                    }
+                } else {
+                    tracing::warn!("pick unused port returned: None\n");
+                }
+            }
+            if !port.host.is_some() {
+                return_bug!("Unable to assign a host port for '{}'. Terminating emulation.", name);
+            }
+        }
+    }
+    tracing::debug!("Port map finalized: {:?}\n", &emu_config.host.port_map);
+    Ok(())
+}

src/developer/ffx/plugins/emulator/engines/src/qemu_based/mod.rs

@@ -583,7 +583,10 @@ pub(crate) trait QemuBasedEngine: EmulatorEngine {
             // Capture the port mappings for user mode networking.
             let now = fuchsia_async::MonotonicInstant::now();
             match self.read_port_mappings().await {
-                Ok(_) => (),
+                Ok(_) => {
+                    tracing::debug!("Writing updated mappings");
+                    self.save_to_disk().await?;
+                }
                 Err(e) => {
                     if self.is_running().await {
                         return Err(e);
@@ -905,8 +908,6 @@ pub(crate) trait QemuBasedEngine: EmulatorEngine {
                         if modified
                             && !self.emu_config().host.port_map.values().any(|m| m.host.is_none())
                         {
-                            tracing::debug!("Writing updated mappings");
-                            self.save_to_disk().await?;
                             return Ok(());
                         }
                     } else {

src/developer/ffx/plugins/emulator/engines/src/qemu_based/qemu/mod.rs

@@ -12,7 +12,8 @@ use crate::qemu_based::QemuBasedEngine;
 use async_trait::async_trait;
 use emulator_instance::{
     write_to_disk, CpuArchitecture, EmulatorConfiguration, EmulatorInstanceData,
-    EmulatorInstanceInfo, EmulatorInstances, EngineState, EngineType, PointingDevice,
+    EmulatorInstanceInfo, EmulatorInstances, EngineState, EngineType, NetworkingMode,
+    PointingDevice,
 };
 use ffx_config::EnvironmentContext;
 use ffx_emulator_common::config::QEMU_TOOL;
@@ -62,6 +63,14 @@ impl EmulatorEngine for QemuEngine {
     }
 
     async fn stage(&mut self) -> Result<()> {
+        // QEMU 9+ does not support auto-assignment of host port
+        // when forwarding guest ports mapped via user networking.
+        // So we need to assign any missing host ports now, before
+        // continuing to stage the instance.
+        if self.emu_config().host.networking == NetworkingMode::User {
+            crate::finalize_port_mapping(self.emu_config_mut())?;
+        }
+
         let result = <Self as QemuBasedEngine>::stage(&mut self)
             .await
             .and_then(|()| self.validate_staging());