feat(network): enhance DHCP handling and network stack integration

- Added `stack_available` field to `NetObsChamber` to track network stack status.
- Improved DHCP request handling in `run_dhcp_request` function, including better error handling for NIC registration.
- Refactored DHCP request logic in `activate` and `apply` functions to use the new `run_dhcp_request` function.
- Introduced new network activation module in the bootloader, including functions for network configuration, TCP, and UDP operations.
- Implemented user-space network activation with probing for NIC drivers and registering network stack operations.
- Added functions for managing TCP and UDP sockets, including sending, receiving, and DNS query handling.
- Enhanced state management for network operations, including dynamic allocation of socket handles and DNS queries.
- Updated mouse input handling in `state.rs` to detect button changes more accurately.

Author: T. Andrew Davis

bootloader/src/baremetal.rs

@@ -5,8 +5,8 @@
 
 use core::sync::atomic::{AtomicBool, Ordering};
 use morpheus_display::console::TextConsole;
-use morpheus_network::device::{NetworkDevice, UnifiedNetDevice};
-use morpheus_network::boot::{probe_and_create_driver, ProbeError, ProbeResult};
+
+use crate::baremetal_ops::network;
 
 // TYPES THAT CROSS THE BORDER
 
@@ -51,199 +51,6 @@ static BAREMETAL_MODE: AtomicBool = AtomicBool::new(false);
 
 static mut LIVE_CONSOLE: Option<TextConsole> = None;
 
-// userspace-activated networking state. offline by default until requested.
-static mut USER_NET_DRIVER: Option<UnifiedNetDevice> = None;
-static mut USER_NET_DMA: Option<morpheus_network::dma::DmaRegion> = None;
-static mut USER_NET_TSC_FREQ: u64 = 0;
-
-unsafe fn log_pci_network_candidates() {
-    let mut found = 0u32;
-    for bus in 0..=255u8 {
-        for dev in 0..32u8 {
-            for func in 0..8u8 {
-                let addr = morpheus_hwinit::PciAddr::new(bus, dev, func);
-                let vendor = morpheus_hwinit::pci_cfg_read16(addr, 0x00);
-                if vendor == 0xFFFF {
-                    if func == 0 {
-                        break;
-                    }
-                    continue;
-                }
-
-                let class = morpheus_hwinit::pci_cfg_read8(addr, 0x0B);
-                let subclass = morpheus_hwinit::pci_cfg_read8(addr, 0x0A);
-                if class != 0x02 {
-                    if func == 0 {
-                        let header = morpheus_hwinit::pci_cfg_read8(addr, 0x0E);
-                        if (header & 0x80) == 0 {
-                            break;
-                        }
-                    }
-                    continue;
-                }
-
-                let device = morpheus_hwinit::pci_cfg_read16(addr, 0x02);
-                found = found.wrapping_add(1);
-                morpheus_hwinit::serial::puts("[INFO] [NET] pci net candidate bdf=");
-                morpheus_hwinit::serial::put_hex64(((bus as u64) << 16) | ((dev as u64) << 8) | func as u64);
-                morpheus_hwinit::serial::puts(" ven=");
-                morpheus_hwinit::serial::put_hex64(vendor as u64);
-                morpheus_hwinit::serial::puts(" dev=");
-                morpheus_hwinit::serial::put_hex64(device as u64);
-                morpheus_hwinit::serial::puts(" sub=");
-                morpheus_hwinit::serial::put_hex64(subclass as u64);
-                morpheus_hwinit::serial::puts("\n");
-
-                if func == 0 {
-                    let header = morpheus_hwinit::pci_cfg_read8(addr, 0x0E);
-                    if (header & 0x80) == 0 {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    if found == 0 {
-        morpheus_hwinit::serial::log_warn("NET", 953, "pci scan found zero class-0x02 devices");
-    } else {
-        morpheus_hwinit::serial::log_info("NET", 954, "pci net candidates logged");
-    }
-}
-
-#[inline]
-unsafe fn user_net_driver_mut() -> Option<&'static mut UnifiedNetDevice> {
-    USER_NET_DRIVER.as_mut()
-}
-
-unsafe fn user_net_tx(frame: *const u8, len: usize) -> i64 {
-    let Some(driver) = user_net_driver_mut() else {
-        return -1;
-    };
-    let frame = core::slice::from_raw_parts(frame, len);
-    if driver.transmit(frame).is_ok() {
-        0
-    } else {
-        -1
-    }
-}
-
-unsafe fn user_net_rx(buf: *mut u8, buf_len: usize) -> i64 {
-    let Some(driver) = user_net_driver_mut() else {
-        return -1;
-    };
-    let buf = core::slice::from_raw_parts_mut(buf, buf_len);
-    match driver.receive(buf) {
-        Ok(Some(n)) => n as i64,
-        Ok(None) => 0,
-        Err(_) => -1,
-    }
-}
-
-unsafe fn user_net_link_up() -> i64 {
-    let Some(driver) = user_net_driver_mut() else {
-        return 0;
-    };
-    driver.link_up() as i64
-}
-
-unsafe fn user_net_mac(out: *mut u8) -> i64 {
-    let Some(driver) = user_net_driver_mut() else {
-        return -1;
-    };
-    let mac = driver.mac_address();
-    core::ptr::copy_nonoverlapping(mac.as_ptr(), out, 6);
-    0
-}
-
-unsafe fn user_net_refill() -> i64 {
-    let Some(driver) = user_net_driver_mut() else {
-        return -1;
-    };
-    driver.refill_rx_queue();
-    driver.collect_tx_completions();
-    0
-}
-
-unsafe fn user_net_ctrl(_cmd: u32, _arg: u64) -> i64 {
-    // full NIC control routing can be added later per-driver.
-    -1
-}
-
-unsafe fn activate_network_from_userspace() -> i64 {
-    morpheus_hwinit::serial::log_info("NET", 940, "userspace activation requested");
-
-    if USER_NET_DRIVER.is_some() {
-        morpheus_hwinit::serial::log_info("NET", 941, "already active");
-        return 1;
-    }
-
-    let Some(dma) = USER_NET_DMA.as_ref() else {
-        morpheus_hwinit::serial::log_error("NET", 942, "activation failed: dma unavailable");
-        return -1;
-    };
-    let tsc_freq = USER_NET_TSC_FREQ;
-
-    morpheus_hwinit::serial::log_info("NET", 943, "probing NIC via network::probe_and_create_driver");
-    let driver = match probe_and_create_driver(dma, tsc_freq) {
-        Ok(ProbeResult::VirtIO(v)) => {
-            morpheus_hwinit::serial::log_info("NET", 949, "probe selected virtio NIC");
-            UnifiedNetDevice::VirtIO(v)
-        }
-        Ok(ProbeResult::Intel(i)) => {
-            morpheus_hwinit::serial::log_info("NET", 951, "probe selected intel NIC");
-            UnifiedNetDevice::Intel(i)
-        }
-        Err(ProbeError::NoDevice) => {
-            morpheus_hwinit::serial::log_error("NET", 944, "probe failed: no supported NIC detected");
-            log_pci_network_candidates();
-            return -2;
-        }
-        Err(ProbeError::VirtioInitFailed) => {
-            morpheus_hwinit::serial::log_error("NET", 950, "virtio init failed");
-            return -3;
-        }
-        Err(ProbeError::IntelInitFailed) => {
-            morpheus_hwinit::serial::log_error("NET", 952, "intel init failed");
-            return -3;
-        }
-        Err(ProbeError::DeviceNotResponding) => {
-            morpheus_hwinit::serial::log_error("NET", 955, "nic mmio not responding");
-            return -4;
-        }
-        Err(ProbeError::BarMappingFailed) => {
-            morpheus_hwinit::serial::log_error("NET", 956, "nic bar mapping failure");
-            return -5;
-        }
-    };
-
-    morpheus_hwinit::serial::log_ok("NET", 945, "driver initialized");
-
-    USER_NET_DRIVER = Some(driver);
-
-    morpheus_hwinit::serial::log_info("NET", 946, "registering NIC ops");
-    morpheus_hwinit::register_nic(morpheus_hwinit::NicOps {
-        tx: Some(user_net_tx),
-        rx: Some(user_net_rx),
-        link_up: Some(user_net_link_up),
-        mac: Some(user_net_mac),
-        refill: Some(user_net_refill),
-        ctrl: Some(user_net_ctrl),
-    });
-
-    // prime descriptor maintenance immediately.
-    let _ = user_net_refill();
-
-    let link_now = user_net_link_up();
-    if link_now != 0 {
-        morpheus_hwinit::serial::log_ok("NET", 947, "activation complete: link up");
-    } else {
-        morpheus_hwinit::serial::log_info("NET", 948, "activation complete: link down");
-    }
-
-    0
-}
-
 /// Called by the hwinit serial hook for every byte emitted via `puts()`.
 /// Writes directly to the TextConsole backed by the GOP framebuffer.
 pub unsafe fn live_console_putc(b: u8) {
@@ -483,13 +290,11 @@ pub unsafe fn enter_baremetal(config: BaremetalEntryConfig) -> ! {
     };
 
     // userspace network activation hook. we stay offline by default.
-    USER_NET_DMA = Some(morpheus_network::dma::DmaRegion::new(
+    network::init_userspace_network_activation(morpheus_network::dma::DmaRegion::new(
         platform.dma().cpu_base(),
         platform.dma().bus_base(),
         platform.dma().size(),
-    ));
-    USER_NET_TSC_FREQ = platform.tsc_freq();
-    morpheus_hwinit::register_net_activation(activate_network_from_userspace);
+    ), platform.tsc_freq());
 
     // persistent storage — try to mount a real block device
     crate::storage::init_persistent_storage(platform.dma(), platform.tsc_freq());

bootloader/src/baremetal_ops/mod.rs

@@ -0,0 +1 @@
+pub mod network;

bootloader/src/baremetal_ops/network/activate.rs

@@ -0,0 +1,115 @@
+use morpheus_network::boot::{probe_and_create_driver, ProbeError, ProbeResult};
+use morpheus_network::device::UnifiedNetDevice;
+use morpheus_network::stack::{NetConfig, NetInterface};
+
+use super::{config, nic, state, tcp, udp_dns};
+
+unsafe fn activate_network_from_userspace() -> i64 {
+    morpheus_hwinit::serial::log_info("NET", 940, "userspace activation requested");
+
+    if state::has_driver() {
+        morpheus_hwinit::serial::log_info("NET", 941, "already active");
+        return 1;
+    }
+
+    let Some((dma, tsc_freq)) = state::activation_context() else {
+        morpheus_hwinit::serial::log_error("NET", 942, "activation failed: dma unavailable");
+        return -1;
+    };
+
+    morpheus_hwinit::serial::log_info("NET", 943, "probing NIC via network::probe_and_create_driver");
+    let driver = match probe_and_create_driver(dma, tsc_freq) {
+        Ok(ProbeResult::VirtIO(v)) => {
+            morpheus_hwinit::serial::log_info("NET", 949, "probe selected virtio NIC");
+            UnifiedNetDevice::VirtIO(v)
+        }
+        Ok(ProbeResult::Intel(i)) => {
+            morpheus_hwinit::serial::log_info("NET", 951, "probe selected intel NIC");
+            UnifiedNetDevice::Intel(i)
+        }
+        Err(ProbeError::NoDevice) => {
+            morpheus_hwinit::serial::log_error("NET", 944, "probe failed: no supported NIC detected");
+            nic::log_pci_network_candidates();
+            return -2;
+        }
+        Err(ProbeError::VirtioInitFailed) => {
+            morpheus_hwinit::serial::log_error("NET", 950, "virtio init failed");
+            return -3;
+        }
+        Err(ProbeError::IntelInitFailed) => {
+            morpheus_hwinit::serial::log_error("NET", 952, "intel init failed");
+            return -3;
+        }
+        Err(ProbeError::DeviceNotResponding) => {
+            morpheus_hwinit::serial::log_error("NET", 955, "nic mmio not responding");
+            return -4;
+        }
+        Err(ProbeError::BarMappingFailed) => {
+            morpheus_hwinit::serial::log_error("NET", 956, "nic bar mapping failure");
+            return -5;
+        }
+    };
+
+    morpheus_hwinit::serial::log_ok("NET", 945, "driver initialized");
+
+    let stack = NetInterface::new(driver, NetConfig::dhcp());
+    state::clear_net_handle_tables();
+    state::set_stack(stack);
+
+    morpheus_hwinit::serial::log_info("NET", 946, "registering NIC ops");
+    morpheus_hwinit::register_nic(morpheus_hwinit::NicOps {
+        tx: Some(nic::user_net_tx),
+        rx: Some(nic::user_net_rx),
+        link_up: Some(nic::user_net_link_up),
+        mac: Some(nic::user_net_mac),
+        refill: Some(nic::user_net_refill),
+        ctrl: Some(nic::user_net_ctrl),
+    });
+
+    morpheus_hwinit::serial::log_info("NET", 957, "registering net stack ops");
+    morpheus_hwinit::register_net_stack(morpheus_hwinit::NetStackOps {
+        tcp_socket: Some(tcp::net_tcp_socket_impl),
+        tcp_connect: Some(tcp::net_tcp_connect_impl),
+        tcp_send: Some(tcp::net_tcp_send_impl),
+        tcp_recv: Some(tcp::net_tcp_recv_impl),
+        tcp_close: Some(tcp::net_tcp_close_impl),
+        tcp_state: Some(tcp::net_tcp_state_impl),
+        tcp_listen: Some(tcp::net_tcp_listen_impl),
+        tcp_accept: Some(tcp::net_tcp_accept_impl),
+        tcp_shutdown: Some(tcp::net_tcp_shutdown_impl),
+        tcp_nodelay: Some(tcp::net_tcp_nodelay_impl),
+        tcp_keepalive: Some(tcp::net_tcp_keepalive_impl),
+        udp_socket: Some(udp_dns::net_udp_socket_impl),
+        udp_send_to: Some(udp_dns::net_udp_send_to_impl),
+        udp_recv_from: Some(udp_dns::net_udp_recv_from_impl),
+        udp_close: Some(udp_dns::net_udp_close_impl),
+        dns_start: Some(udp_dns::net_dns_start_impl),
+        dns_result: Some(udp_dns::net_dns_result_impl),
+        dns_set_servers: Some(udp_dns::net_dns_set_servers_impl),
+        cfg_get: Some(config::net_cfg_get),
+        cfg_dhcp: Some(config::net_cfg_dhcp),
+        cfg_static_ip: Some(config::net_cfg_static_ip),
+        cfg_hostname: Some(config::net_cfg_hostname),
+        poll_drive: Some(config::net_poll_drive),
+        poll_stats: Some(config::net_poll_stats),
+    });
+
+    let _ = nic::user_net_refill();
+
+    let link_now = nic::user_net_link_up();
+    if link_now != 0 {
+        morpheus_hwinit::serial::log_ok("NET", 947, "activation complete: link up");
+    } else {
+        morpheus_hwinit::serial::log_info("NET", 948, "activation complete: link down");
+    }
+
+    0
+}
+
+pub(super) unsafe fn init_userspace_network_activation(
+    dma: morpheus_network::dma::DmaRegion,
+    tsc_freq: u64,
+) {
+    state::set_activation_context(dma, tsc_freq);
+    morpheus_hwinit::register_net_activation(activate_network_from_userspace);
+}