Refactor serial print usage across multiple files to unify imports from the mainloop::serial module

Author: T. Andrew Davis

network/src/driver/intel/e1000e.rs

@@ -6,7 +6,7 @@
 //! Intel 82579 Datasheet, NETWORK_IMPL_GUIDE.md §8
 
 use crate::driver::traits::{DriverInit, NetworkDriver, RxError, TxError};
-use crate::mainloop::bare_metal::serial_println;
+use crate::mainloop::serial::serial_println;
 use crate::types::MacAddress;
 use crate::asm::drivers::intel::{asm_intel_link_status, LinkStatusResult};
 

network/src/driver/intel/init.rs

@@ -38,7 +38,7 @@ use crate::asm::drivers::intel::{
     disable_ulp, toggle_lanphypc, phy_is_accessible, acquire_swflag, release_swflag,
 };
 use crate::dma::DmaRegion;
-use crate::mainloop::bare_metal::{serial_print, serial_println, serial_print_decimal};
+use crate::mainloop::serial::{serial_print, serial_println, serial_print_decimal};
 use crate::types::MacAddress;
 
 use super::regs;
@@ -219,7 +219,7 @@ pub unsafe fn init_e1000e(
     // DEBUG: Read RAL/RAH directly to see what UEFI programmed
     {
         use crate::asm::core::mmio::{read32};
-        use crate::mainloop::bare_metal::serial_print_hex;
+        use crate::mainloop::serial::serial_print_hex;
         let ral = read32(mmio_base + 0x5400);
         let rah = read32(mmio_base + 0x5404);
         serial_print("  [DEBUG] RAL0=0x");

network/src/driver/unified.rs

@@ -14,7 +14,7 @@
 use crate::boot::handoff::{BootHandoff, NIC_TYPE_INTEL, NIC_TYPE_VIRTIO};
 
 // Use the known-working serial functions from bare_metal
-use crate::mainloop::bare_metal::{serial_print, serial_println};
+use crate::mainloop::serial::{serial_print, serial_println};
 
 use crate::driver::intel::{E1000eConfig, E1000eDriver, E1000eError};
 use crate::driver::traits::{NetworkDriver, RxError, TxError};

network/src/mainloop/context.rs

@@ -6,6 +6,8 @@
 use smoltcp::iface::SocketHandle;
 use smoltcp::wire::IpAddress;
 
+use crate::device::UnifiedBlockDevice;
+
 /// Timeout configuration for network operations.
 #[derive(Clone, Copy)]
 pub struct Timeouts {
@@ -38,16 +40,61 @@ impl Timeouts {
     }
 }
 
-/// Configuration for the download operation.
+/// Full download configuration.
 #[derive(Clone)]
 pub struct DownloadConfig<'a> {
     /// URL to download
     pub url: &'a str,
+    /// Write to disk?
+    pub write_to_disk: bool,
+    /// Target start sector for ISO
+    pub target_start_sector: u64,
+    /// Sector for manifest (raw write)
+    pub manifest_sector: u64,
+    /// ESP start LBA (for FAT32 manifest)
+    pub esp_start_lba: u64,
+    /// Partition UUID
+    pub partition_uuid: [u8; 16],
+    /// ISO name for manifest
+    pub iso_name: &'a str,
+    /// Expected ISO size (0 = unknown)
+    pub expected_size: u64,
 }
 
 impl<'a> DownloadConfig<'a> {
-    pub fn new(url: &'a str) -> Self {
-        Self { url }
+    /// Simple config for download-only (no disk write).
+    pub fn download_only(url: &'a str) -> Self {
+        Self {
+            url,
+            write_to_disk: false,
+            target_start_sector: 0,
+            manifest_sector: 0,
+            esp_start_lba: 0,
+            partition_uuid: [0u8; 16],
+            iso_name: "",
+            expected_size: 0,
+        }
+    }
+
+    /// Full config for download + disk write + manifest.
+    pub fn full(
+        url: &'a str,
+        target_start_sector: u64,
+        manifest_sector: u64,
+        esp_start_lba: u64,
+        partition_uuid: [u8; 16],
+        iso_name: &'a str,
+    ) -> Self {
+        Self {
+            url,
+            write_to_disk: true,
+            target_start_sector,
+            manifest_sector,
+            esp_start_lba,
+            partition_uuid,
+            iso_name,
+            expected_size: 0,
+        }
     }
 }
 
@@ -57,14 +104,16 @@ pub struct Context<'a> {
     pub timeouts: Timeouts,
     /// TSC frequency
     pub tsc_freq: u64,
-    /// Download URL
-    pub url: &'a str,
+    /// Full configuration
+    pub config: DownloadConfig<'a>,
     /// DHCP socket handle
     pub dhcp_handle: Option<SocketHandle>,
     /// DNS socket handle
     pub dns_handle: Option<SocketHandle>,
     /// TCP socket handle
     pub tcp_handle: Option<SocketHandle>,
+    /// Block device for disk writes
+    pub blk_device: Option<UnifiedBlockDevice>,
     /// Resolved IP address (from DNS)
     pub resolved_ip: Option<IpAddress>,
     /// Resolved port
@@ -73,30 +122,57 @@ pub struct Context<'a> {
     pub url_path: &'a str,
     /// Host portion of URL
     pub url_host: &'a str,
-    /// Content-Length from HTTP response (if known)
+    /// Content-Length from HTTP response
     pub content_length: Option<u64>,
-    /// Total bytes downloaded so far
+    /// Total bytes downloaded
     pub bytes_downloaded: u64,
+    /// Total bytes written to disk
+    pub bytes_written: u64,
+    /// Current write sector
+    pub current_write_sector: u64,
+    /// DNS servers from DHCP
+    pub dns_servers: [Option<IpAddress>; 3],
 }
 
 impl<'a> Context<'a> {
     /// Create new context.
-    pub fn new(url: &'a str, tsc_freq: u64) -> Self {
+    pub fn new(config: DownloadConfig<'a>, tsc_freq: u64) -> Self {
+        let start_sector = config.target_start_sector;
         Self {
             timeouts: Timeouts::new(tsc_freq),
             tsc_freq,
-            url,
+            config,
             dhcp_handle: None,
             dns_handle: None,
             tcp_handle: None,
+            blk_device: None,
             resolved_ip: None,
             resolved_port: 80,
             url_path: "",
             url_host: "",
             content_length: None,
             bytes_downloaded: 0,
+            bytes_written: 0,
+            current_write_sector: start_sector,
+            dns_servers: [None; 3],
         }
     }
+
+    /// Set block device for disk writes.
+    pub fn with_block_device(mut self, device: UnifiedBlockDevice) -> Self {
+        self.blk_device = Some(device);
+        self
+    }
+
+    /// Get URL from config.
+    pub fn url(&self) -> &str {
+        self.config.url
+    }
+
+    /// Check if disk write is enabled.
+    pub fn should_write_to_disk(&self) -> bool {
+        self.config.write_to_disk && self.blk_device.is_some()
+    }
 }
 
 /// Read TSC (Time Stamp Counter).

network/src/mainloop/orchestrator.rs

@@ -11,7 +11,7 @@ use smoltcp::wire::{EthernetAddress, HardwareAddress};
 
 use crate::driver::traits::NetworkDriver;
 use crate::mainloop::adapter::SmoltcpAdapter;
-use crate::mainloop::context::Context;
+use crate::mainloop::context::{Context, DownloadConfig};
 use crate::mainloop::serial;
 use crate::mainloop::state::{State, StepResult};
 use crate::mainloop::states::InitState;
@@ -75,7 +75,8 @@ pub fn download<D: NetworkDriver>(
     let tcp_handle = sockets.add(tcp_socket);
 
     // Context
-    let mut ctx = Context::new(url, tsc_freq);
+    let config = DownloadConfig::download_only(url);
+    let mut ctx = Context::new(config, tsc_freq);
     ctx.dhcp_handle = Some(dhcp_handle);
     ctx.tcp_handle = Some(tcp_handle);
 

network/src/mainloop/states/dhcp.rs

@@ -100,12 +100,16 @@ impl<D: NetworkDriver> State<D> for DhcpState {
                         iface.routes_mut().add_default_ipv4_route(router).ok();
                     }
 
+                    // Store DNS servers in context
                     for (i, dns) in config.dns_servers.iter().enumerate() {
                         serial::print("[DHCP] DNS ");
                         serial::print_u32(i as u32);
                         serial::print(": ");
                         serial::print_ipv4(&dns.0);
                         serial::println("");
+                        if i < 3 {
+                            ctx.dns_servers[i] = Some(smoltcp::wire::IpAddress::Ipv4(*dns));
+                        }
                     }
 
                     self.got_ip = true;

network/src/mainloop/states/init.rs

@@ -51,48 +51,57 @@ impl<D: NetworkDriver> State<D> for InitState {
         serial::println("=====================================");
         serial::println("");
 
-        let url = ctx.url;
-        serial::print("[INIT] URL: ");
-        serial::println(url);
-
-        // Parse URL: http://host[:port]/path
-        let url_without_scheme = if url.starts_with("https://") {
-            ctx.resolved_port = 443;
-            &url[8..]
-        } else if url.starts_with("http://") {
-            ctx.resolved_port = 80;
-            &url[7..]
-        } else {
-            serial::println("[INIT] ERROR: URL must start with http:// or https://");
-            return (Box::new(super::FailedState::new("invalid URL scheme")), StepResult::Failed("invalid URL"));
+        // Parse URL by computing indices first, avoiding borrow conflicts.
+        // URL format: scheme://host[:port]/path
+        let (scheme_end, default_port) = {
+            let url = ctx.config.url;
+            if url.starts_with("https://") {
+                (8usize, 443u16)
+            } else if url.starts_with("http://") {
+                (7usize, 80u16)
+            } else {
+                serial::println("[INIT] ERROR: URL must start with http:// or https://");
+                return (Box::new(super::FailedState::new("invalid URL scheme")), StepResult::Failed("invalid URL"));
+            }
         };
 
-        let (host_port, path) = match url_without_scheme.find('/') {
-            Some(idx) => (&url_without_scheme[..idx], &url_without_scheme[idx..]),
-            None => (url_without_scheme, "/"),
+        // Compute indices for host and path
+        let url = ctx.config.url;
+        let rest = &url[scheme_end..];
+        
+        let (host_end, path_start) = match rest.find('/') {
+            Some(idx) => (scheme_end + idx, scheme_end + idx),
+            None => (url.len(), url.len()),
         };
 
-        let host = match host_port.find(':') {
-            Some(idx) => {
-                if let Some(port) = parse_port(&host_port[idx + 1..]) {
-                    ctx.resolved_port = port;
-                }
-                &host_port[..idx]
+        let host_port_slice = &url[scheme_end..host_end];
+        let (host_slice_end, port) = match host_port_slice.find(':') {
+            Some(colon_idx) => {
+                let port_str = &host_port_slice[colon_idx + 1..];
+                let port = parse_port(port_str).unwrap_or(default_port);
+                (scheme_end + colon_idx, port)
             }
-            None => host_port,
+            None => (host_end, default_port),
         };
 
-        // Store parsed URL parts in context
-        ctx.url_host = host;
-        ctx.url_path = path;
+        // Assign using direct indexing
+        ctx.resolved_port = port;
+        ctx.url_host = &ctx.config.url[scheme_end..host_slice_end];
+        ctx.url_path = if path_start < ctx.config.url.len() {
+            &ctx.config.url[path_start..]
+        } else {
+            "/"
+        };
 
+        serial::print("[INIT] URL: ");
+        serial::println(ctx.config.url);
         serial::print("[INIT] Host: ");
-        serial::println(host);
+        serial::println(ctx.url_host);
         serial::print("[INIT] Port: ");
         serial::print_u32(ctx.resolved_port as u32);
         serial::println("");
         serial::print("[INIT] Path: ");
-        serial::println(path);
+        serial::println(ctx.url_path);
         serial::print("[INIT] TSC freq: ");
         serial::print_u32((ctx.tsc_freq / 1_000_000) as u32);
         serial::println(" MHz");

network/src/pci/capability.rs

@@ -311,7 +311,7 @@ impl Iterator for WalkCaps {
 /// Dump all capabilities to serial (uses crate's serial_println if available).
 #[cfg(feature = "serial_debug")]
 pub fn dump_capabilities(addr: PciAddr) {
-    use crate::mainloop::bare_metal::{serial_print, serial_print_hex, serial_println};
+    use crate::mainloop::serial::{serial_print, serial_print_hex, serial_println};
 
     serial_print("PCI ");
     serial_print_hex(addr.bus as u64);