Refactor network state machine and implement GPT preparation and manifest writing

- Updated `InitState` to transition to `GptPrepState` instead of `DhcpState`.
- Added `GptPrepState` for handling GPT partition creation and verification of disk space.
- Introduced `LinkWaitState` to manage PHY link establishment before DHCP.
- Created `ManifestState` for writing ISO manifest after download, supporting FAT32 and raw sector modes.
- Added `TimeoutConfig` struct for managing timeouts based on TSC frequency.
- Implemented standalone functions for manifest regeneration and writing.
- Documented driver reset contract to ensure proper initialization and state management.

Author: T. Andrew Davis

core/src/net/error.rs

@@ -30,7 +30,7 @@ pub enum NetInitError {
     InvalidConfig,
     /// Operation timed out.
     Timeout,
-    /// API is deprecated - use post-EBS bare_metal_main() instead.
+    /// API is deprecated - use post-EBS download_with_config() instead.
     Deprecated,
 }
 
@@ -50,7 +50,7 @@ impl NetInitError {
             Self::StackInit => "Network stack initialization failed",
             Self::InvalidConfig => "Invalid network configuration",
             Self::Timeout => "Operation timed out",
-            Self::Deprecated => "API deprecated - use post-EBS bare_metal_main()",
+            Self::Deprecated => "API deprecated - use post-EBS download_with_config()",
         }
     }
 }

core/src/net/init.rs

@@ -3,17 +3,18 @@
 //! # DEPRECATED
 //!
 //! This module is deprecated. Network initialization now happens **post-ExitBootServices**
-//! using the bare-metal network stack directly in `morpheus_network::mainloop::bare_metal_main`.
+//! using the modular state machine in `morpheus_network::mainloop::orchestrator`.
 //!
 //! The old flow (this module):
 //! 1. Initialize in UEFI environment
 //! 2. Use factory pattern to detect/create devices
 //!
 //! The new flow:
-//! 1. Bootstrap displays menu, user selects ISO
+//! 1. hwinit normalizes hardware (bus mastering, DMA policy, etc)
 //! 2. ExitBootServices is called
-//! 3. Bare-metal stack initializes VirtIO directly
-//! 4. HTTP download proceeds
+//! 3. Network crate initializes its own drivers
+//! 4. `download_with_config()` runs the state machine
+//! 5. State flow: Init → GptPrep → LinkWait → DHCP → DNS → Connect → HTTP → Manifest → Done
 //!
 //! This stub is kept for API compatibility with existing imports.
 
@@ -26,7 +27,7 @@ use super::status::NetworkStatus;
 ///
 /// This type is kept for API compatibility but `NetworkInit::initialize()`
 /// always returns an error directing callers to use post-EBS flow.
-#[deprecated(note = "Network init moved to post-EBS. Use bare_metal_main() instead.")]
+#[deprecated(note = "Network init moved to post-EBS. Use download_with_config() instead.")]
 pub struct NetworkInitResult {
     /// Network status with IP info.
     pub status: NetworkStatus,
@@ -35,17 +36,17 @@ pub struct NetworkInitResult {
 /// Network initialization orchestrator (DEPRECATED).
 ///
 /// Network initialization is now handled post-ExitBootServices by
-/// `morpheus_network::mainloop::bare_metal_main()`.
-#[deprecated(note = "Network init moved to post-EBS. Use bare_metal_main() instead.")]
+/// `morpheus_network::mainloop::orchestrator::download_with_config()`.
+#[deprecated(note = "Network init moved to post-EBS. Use download_with_config() instead.")]
 pub struct NetworkInit;
 
 #[allow(deprecated)]
 impl NetworkInit {
     /// Perform complete network initialization (DEPRECATED).
     ///
     /// **Always returns error** - network init is now post-EBS.
-    /// Use `morpheus_network::mainloop::bare_metal_main()` after ExitBootServices.
-    #[deprecated(note = "Network init moved to post-EBS. Use bare_metal_main() instead.")]
+    /// Use `morpheus_network::mainloop::download_with_config()` after ExitBootServices.
+    #[deprecated(note = "Network init moved to post-EBS. Use download_with_config() instead.")]
     pub fn initialize(
         _config: &InitConfig,
         _get_time_ms: fn() -> u64,
@@ -57,7 +58,7 @@ impl NetworkInit {
     /// Initialize with display polling (DEPRECATED).
     ///
     /// **Always returns error** - network init is now post-EBS.
-    #[deprecated(note = "Network init moved to post-EBS. Use bare_metal_main() instead.")]
+    #[deprecated(note = "Network init moved to post-EBS. Use download_with_config() instead.")]
     pub fn initialize_with_poll<F>(
         _config: &InitConfig,
         _get_time_ms: fn() -> u64,

network/README.md

@@ -1,101 +1,117 @@
 # MorpheusX Network Stack
 
-HTTP client for downloading ISOs and other files in the UEFI bootloader environment.
+Bare-metal HTTP client for post-ExitBootServices execution.
 
+## Architecture
 
-
-### Design Principles
-
-1. **Platform Abstraction**: `HttpClient` trait allows multiple implementations
-3. **No External Deps**: Everything built on primitives
-5. **Error Handling**: Comprehensive error types for network operations
-
-## Usage
-
-### Basic Download
-
-```rust
-use morpheus_network::{UefiHttpClient, DownloadManager};
-
-// Create UEFI HTTP client
-let mut client = UefiHttpClient::new(boot_services)?;
-
-// Create download manager
-let mut downloader = DownloadManager::new(&mut client);
-
-// Download a file
-let data = downloader.download_to_memory("http://example.com/file.iso")?;
 ```
-
-### Download with Progress
-
-```rust
-fn progress_callback(downloaded: usize, total: Option<usize>) {
-    if let Some(total) = total {
-        let percent = (downloaded * 100) / total;
-        println!("Progress: {}%", percent);
-    }
-}
-
-let data = downloader.download_with_progress(
-    "http://example.com/large-file.iso",
-    progress_callback
-)?;
+┌──────────────────────────────────────────────────────────────┐
+│                    Entry Point                               │
+│  mainloop::download_with_config(&mut driver, config, ...)    │
+└──────────────────────────────────────────────────────────────┘
+                             │
+                             ▼
+┌──────────────────────────────────────────────────────────────┐
+│                    State Machine                             │
+│  Init → GptPrep → LinkWait → DHCP → DNS → Connect → HTTP     │
+└──────────────────────────────────────────────────────────────┘
+                             │
+                             ▼
+┌──────────────────────────────────────────────────────────────┐
+│                    NetworkDriver Trait                       │
+│  transmit(), receive(), mac_address(), link_up()             │
+└──────────────────────────────────────────────────────────────┘
+                             │
+              ┌──────────────┴──────────────┐
+              ▼                             ▼
+┌─────────────────────────┐   ┌─────────────────────────┐
+│     VirtioNetDriver     │   │     E1000eDriver        │
+│     (QEMU, KVM)         │   │     (Real Hardware)     │
+└─────────────────────────┘   └─────────────────────────┘
+              │                             │
+              └──────────────┬──────────────┘
+                             ▼
+┌──────────────────────────────────────────────────────────────┐
+│                    ASM Layer (network/asm/)                  │
+│  MMIO read/write, TSC, barriers, cache ops                   │
+└──────────────────────────────────────────────────────────────┘
 ```
 
-### Check File Size
+## Usage
 
 ```rust
-if let Some(size) = downloader.get_file_size("http://example.com/file.iso")? {
-    println!("File size: {} bytes", size);
+use morpheus_network::mainloop::{download_with_config, DownloadConfig, DownloadResult};
+use morpheus_network::boot::probe::{probe_and_create_driver, ProbeResult};
+
+// 1. Probe PCI and create driver (brutal reset happens during driver::new())
+let driver = match probe_and_create_driver(&dma, tsc_freq)? {
+    ProbeResult::Intel(d) => UnifiedNetworkDriver::Intel(d),
+    ProbeResult::VirtIO(d) => UnifiedNetworkDriver::VirtIO(d),
+};
+
+// 2. Configure download
+let config = DownloadConfig::full(
+    "http://example.com/image.iso",
+    start_sector,
+    0,  // offset
+    esp_lba,
+    partition_uuid,
+    "image.iso",
+);
+
+// 3. Execute download with optional disk write
+let result = download_with_config(&mut driver, config, Some(blk_device), tsc_freq);
+
+match result {
+    DownloadResult::Success { bytes_downloaded, bytes_written } => { /* done */ }
+    DownloadResult::Failed { reason } => { /* handle error */ }
 }
 ```
 
-## Implementation 
+## Preconditions
 
-### See /docs/
+Before calling network functions:
 
-## Error Handling
+1. **ExitBootServices completed** - No UEFI runtime
+2. **hwinit has run** - Platform normalized (bus mastering, DMA, cache coherency)
+3. **DMA region allocated** - Identity-mapped, cache-coherent
 
-All operations return `Result<T, NetworkError>`:
+## Driver Reset Contract
 
-```rust
-match downloader.download_to_memory(url) {
-    Ok(data) => { /* success */ },
-    Err(NetworkError::ProtocolNotAvailable) => {
-        // UEFI firmware doesn't support HTTP
-    },
-    Err(NetworkError::HttpError(404)) => {
-        // File not found
-    },
-    Err(e) => {
-        // Other error
-    }
-}
-```
+All drivers perform **brutal reset** on init:
 
-## Testing
+- Mask and clear all interrupts
+- Disable RX/TX with quiescence polling
+- Full device reset with timeout
+- Wait for EEPROM auto-read
+- Clear all descriptor pointers
+- Disable loopback explicitly
+- Rebuild queues from scratch
 
-Test in QEMU with OVMF UEFI firmware:
-```bash
-cd testing
-./run.sh
-```
-
-Ensure QEMU has network configured:
-```bash
--netdev user,id=net0 \
--device e1000,netdev=net0
-```
+See `driver/RESET_CONTRACT.md` for details.
 
-## Future: ARM Support
+## Modules
 
-When adding ARM64 support:
-- Same UEFI protocols work on ARM
-- No code changes needed in abstraction layer
-- May need arch-specific optimizations for large transfers
+| Module | Purpose |
+|--------|---------|
+| `mainloop` | State machine orchestration, entry point |
+| `driver` | NetworkDriver trait, VirtIO, Intel e1000e |
+| `boot` | Device probing, driver creation helpers |
+| `asm` | Assembly bindings (MMIO, PIO, TSC) |
+| `dma` | DMA buffer management |
+| `time` | TSC-based timing |
 
-## References
+## State Machine
 
-- UEFI Specification 2.10, Section 28.7 (EFI HTTP Protocol)
+| State | Description |
+|-------|-------------|
+| Init | Initialize smoltcp interface |
+| GptPrep | Prepare GPT if writing to disk |
+| LinkWait | Wait for link up |
+| DHCP | Obtain IP address |
+| DNS | Resolve hostname |
+| Connect | TCP connection |
+| HTTP | HTTP GET and streaming receive |
+| Manifest | Write manifest to disk |
+| Done | Reboot |
 - UEFI Specification 2.10, Section 11.1 (EFI Service Binding Protocol)

network/src/alloc_heap.rs

@@ -22,8 +22,8 @@
 //! # Usage
 //!
 //! ```ignore
-//! // In bare_metal_main, before any allocations:
-//! unsafe { crate::alloc::init_heap(); }
+//! // Early in post-EBS execution, before any allocations:
+//! unsafe { morpheus_network::alloc_heap::init_heap(); }
 //!
 //! // Now Vec, Box, String all work:
 //! let v = vec![1, 2, 3];