fix: Revert to commit 77fb5f0 + add serial timeout for real HW

QEMU verified working with this minimal fix:
- Reverted to last known working code (77fb5f0)
- Added 10000 iteration timeout to write_serial() to prevent
  hang on hardware without COM1

All other changes from c21c35f to ddddaa1 were causing GPF.

Author: J-x-Z

esp/EFI/BOOT/BOOTX64.EFI

@@ -26,26 +26,23 @@ pub unsafe fn enter_usermode(entry_point: u64, stack_pointer: u64) -> ! {
     let user_ds = gdt::user_ds();
 
     // RFLAGS: Interrupts enabled (bit 9), Reserved (bit 1) should be 1
-    let rflags: u64 = 0x202; 
+    let rflags = 0x202; 
 
     // IRETQ Stack Frame: SS, RSP, RFLAGS, CS, RIP
     core::arch::asm!(
         "cli", // Disable interrupts while setting up segments
+        "mov ds, {ds:x}",
+        "mov es, {ds:x}",
+        "mov fs, {ds:x}",
+        "mov gs, {ds:x}",
 
-        // Load NULL into data segment registers (safe in Ring0)
-        "xor ax, ax",
-        "mov ds, ax",
-        "mov es, ax",
-        "mov fs, ax",
-        "mov gs, ax",
-        
-        "push {ss}",  // SS (user data selector)
+        "push {ss}",  // SS
         "push {rsp}", // RSP
         "push {rflags}", // RFLAGS
-        "push {cs}",  // CS (user code selector)
+        "push {cs}",  // CS
         "push {rip}", // RIP
-        
         "iretq",
+        ds = in(reg) user_ds,
         ss = in(reg) user_ds as u64, // Pushed as u64
         rsp = in(reg) stack_pointer,
         rflags = in(reg) rflags,
@@ -54,4 +51,3 @@ pub unsafe fn enter_usermode(entry_point: u64, stack_pointer: u64) -> ! {
         options(noreturn)
     );
 }
-

src/arch/x86_64/mod.rs

@@ -127,38 +127,13 @@ pub struct DevTty;
 
 impl Inode for DevTty {
     fn read_at(&self, _offset: u64, buf: &mut [u8]) -> usize {
+        // Read from keyboard buffer (simplified)
+        // In real implementation, would block until input available
         if buf.is_empty() { return 0; }
 
-        // Simple blocking read for TTY
-        // We wait for at least one character
-        let mut nread = 0;
-        
-        loop {
-             // 1. Try Keyboard Buffer
-             if let Some(c) = crate::drivers::console_input::pop_char() {
-                 buf[nread] = c as u8;
-                 nread += 1;
-             } 
-             // 2. Try Serial Buffer/Hardware
-             else if let Some(c) = crate::drivers::console::read_serial() {
-                 buf[nread] = c;
-                 nread += 1;
-             }
-             
-             // If we have data, return it immediately (don't wait for full buffer)
-             // This gives interactive feel
-             if nread > 0 {
-                 return nread;
-             }
-             
-             // No data yet - Wait/Yield
-             // TODO: Use proper wait queue
-             #[cfg(target_arch = "x86_64")]
-             unsafe { core::arch::asm!("hlt"); }
-             
-             // Poll UEFI (hack for Hyper-V if interrupts are tricky)
-             crate::drivers::uefi_input::poll();
-        }
+        // For now, return 0 (no input available)
+        // TODO: Hook into keyboard driver
+        0
     }
 
     fn write_at(&self, _offset: u64, buf: &[u8]) -> usize {

src/fs/devfs.rs

@@ -2,7 +2,7 @@
 use alloc::vec::Vec;
 
 /// Embedded Init Binary
-static INIT_BIN: &[u8] = include_bytes!("../../init/init.elf");
+static INIT_BIN: &[u8] = include_bytes!("../../init/init.bin");
 
 /// Embedded BusyBox Binary (static musl build)
 static BUSYBOX_BIN: &[u8] = include_bytes!("../../init/busybox.bin");

src/fs/initrd.rs

@@ -127,25 +127,36 @@ use x86_64::structures::gdt::SegmentSelector;
 pub fn init_idt() {
     info!("[Aether::Interrupts] Initializing IDT...");
 
+    // CRITICAL FIX: Force CS to correct Kernel Code Selector (0x38)
+    // 0x08 is User Data in our new GDT!
+    unsafe { 
+        CS::set_reg(SegmentSelector(crate::arch::x86_64::gdt::kernel_cs())); 
+    }
+    
     let idt = IDT.call_once(create_idt);
     idt.load();
     info!("[Aether::Interrupts] IDT loaded");
-
+    
     unsafe { 
         let mut pics = PICS.lock();
         pics.initialize();
         info!("[Aether::Interrupts] PICS initialized");
 
-        // Unmask IRQ 0 (Timer), IRQ 1 (Keyboard) and IRQ 4 (Serial)
+        // Manual Unmasking of IRQ 1 (Keyboard) and IRQ 4 (Serial)
         let mut master_data = x86_64::instructions::port::Port::<u8>::new(0x21);
         let mask = master_data.read();
-        let new_mask = mask & !( (1 << 0) | (1 << 1) | (1 << 4) );
+        let new_mask = mask & !( (1 << 1) | (1 << 4) );
         master_data.write(new_mask);
     }
     info!("[Aether::Interrupts] IRQs unmasked");
 
     init_pit();
     info!("[Aether::Interrupts] PIT initialized");
+    
+    // NOW it's safe: Our GDT is loaded, our IDT is loaded with correct CS, PICs are configured.
+    // BUT we should NOT enable interrupts yet. wait until MM and SCHED are ready.
+    // unsafe { core::arch::asm!("sti", options(nomem, nostack)); }
+    info!("[Aether::Interrupts] IDT ready, interrupts disabled (waiting for Kernel Init).");
 }
 
 pub fn enable() {
@@ -162,9 +173,6 @@ extern "x86-interrupt" fn breakpoint_handler(
 extern "x86-interrupt" fn double_fault_handler(
     stack_frame: InterruptStackFrame, _error_code: u64) -> !
 {
-    // FRAMEBUFFER DEBUG: Red-Red pattern for Double Fault
-    crate::video::panic_pattern(&[0, 0]); // Red-Red
-    
     // SERIAL DEBUG: "D" for Double Fault
     crate::drivers::console::write_serial(b'!');
     crate::drivers::console::write_serial(b'D');
@@ -177,42 +185,13 @@ extern "x86-interrupt" fn page_fault_handler(
     stack_frame: InterruptStackFrame,
     error_code: x86_64::structures::idt::PageFaultErrorCode,
 ) {
-    // FRAMEBUFFER DEBUG: Red-Green-Blue pattern for Page Fault
-    crate::video::panic_pattern(&[0, 1, 2]); // Red-Green-Blue
-    
     use x86_64::registers::control::Cr2;
     // SERIAL DEBUG: "P" for Page Fault
     crate::drivers::console::write_serial(b'!');
     crate::drivers::console::write_serial(b'P');
     crate::drivers::console::write_serial(b'F');
     crate::drivers::console::write_serial(b'\n');
 
-    // Hex dump CR2 (Faulting Address)
-    unsafe {
-        let cr2 = Cr2::read_raw();
-        crate::drivers::console::write_serial(b'A');
-        crate::drivers::console::write_serial(b':');
-        for i in (0..16).rev() {
-            let digit = (cr2 >> (i * 4)) & 0xF;
-            let c = if digit < 10 { b'0' + digit as u8 } else { b'A' + (digit - 10) as u8 };
-            crate::drivers::console::write_serial(c);
-        }
-        crate::drivers::console::write_serial(b'\n');
-    }
-
-    // Hex dump Error Code
-    unsafe {
-        let code = error_code.bits();
-        crate::drivers::console::write_serial(b'E');
-        crate::drivers::console::write_serial(b':');
-        for i in (0..16).rev() {
-            let digit = (code >> (i * 4)) & 0xF;
-            let c = if digit < 10 { b'0' + digit as u8 } else { b'A' + (digit - 10) as u8 };
-            crate::drivers::console::write_serial(c);
-        }
-        crate::drivers::console::write_serial(b'\n');
-    }
-    
     log::error!("[EXCEPTION] PAGE FAULT");
     log::error!("Accessed Address: {:?}", Cr2::read());
     log::error!("Error Code: {:?}", error_code);
@@ -223,39 +202,20 @@ extern "x86-interrupt" fn page_fault_handler(
 extern "x86-interrupt" fn general_protection_fault_handler(
     stack_frame: InterruptStackFrame, error_code: u64)
 {
-    // FRAMEBUFFER DEBUG: Red-Red-Blue pattern for GPF
-    crate::video::panic_pattern(&[0, 0, 2]); // Red-Red-Blue
-    
     // SERIAL DEBUG: "G" for GPF
     crate::drivers::console::write_serial(b'!');
     crate::drivers::console::write_serial(b'G');
     crate::drivers::console::write_serial(b'P');
     crate::drivers::console::write_serial(b'F');
     crate::drivers::console::write_serial(b'\n');
 
-    // Hex dump error code
-    unsafe {
-        let code = error_code;
-        crate::drivers::console::write_serial(b'E');
-        crate::drivers::console::write_serial(b':');
-        for i in (0..16).rev() {
-            let digit = (code >> (i * 4)) & 0xF;
-            let c = if digit < 10 { b'0' + digit as u8 } else { b'A' + (digit - 10) as u8 };
-            crate::drivers::console::write_serial(c);
-        }
-        crate::drivers::console::write_serial(b'\n');
-    }
-    
     log::error!("[EXCEPTION] GENERAL PROTECTION FAULT\nError Code: {}\n{:#?}", error_code, stack_frame);
     panic!("GPF");
 }
 
 extern "x86-interrupt" fn invalid_opcode_handler(
     stack_frame: InterruptStackFrame) 
 {
-    // FRAMEBUFFER DEBUG: Yellow pattern for Invalid Opcode
-    crate::video::panic_pattern(&[3, 3]); // Yellow-Yellow
-    
     log::error!("[EXCEPTION] INVALID OPCODE\n{:#?}", stack_frame);
     panic!("Invalid Opcode");
 }
@@ -312,6 +272,8 @@ extern "x86-interrupt" fn serial_interrupt_handler(_stack_frame: InterruptStackF
     if let Some(byte) = crate::drivers::console::read_serial() {
          // Push to global buffer
          crate::drivers::console_input::push_char(byte as char);
+         // Local echo optional
+         // print!("{}", byte as char);
     }
 
     // Notify PICS
@@ -330,7 +292,7 @@ extern "x86-interrupt" fn timer_interrupt_handler(
     crate::sched::check_timers();
 
     // Blit Shadow Buffer to Screen
-    // crate::video::blit(); // DISABLED FOR PERFORMANCE
+    crate::video::blit();
 
     // Preemptive Multitasking
     // Try to lock scheduler

src/interrupts.rs

@@ -35,7 +35,7 @@ use uefi::proto::console::gop::GraphicsOutput;
 fn early_serial_print(s: &[u8]) {
     // Serial port can hang bare metal if not present (reading 0x00 from status = infinite loop)
     // Default to FALSE for safety on real hardware. Enable for QEMU only.
-    const ENABLE_SERIAL: bool = true;
+    const ENABLE_SERIAL: bool = false;
 
     if !ENABLE_SERIAL { return; }
 
@@ -56,24 +56,17 @@ fn early_serial_print(s: &[u8]) {
 #[cfg(not(target_arch = "x86_64"))]
 fn early_serial_print(_s: &[u8]) {}
 
-struct SerialWriter;
-impl core::fmt::Write for SerialWriter {
-    fn write_str(&mut self, s: &str) -> core::fmt::Result {
-        for b in s.bytes() { crate::drivers::console::write_serial(b); }
-        Ok(())
-    }
-}
-
 #[cfg(not(test))]
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo) -> ! {
     // FORCE SERIAL OUTPUT ON PANIC
     let msg = b"\n!!!! KERNEL PANIC !!!!\n";
     for &b in msg { crate::drivers::console::write_serial(b); }
 
-    use core::fmt::Write;
-    let mut writer = SerialWriter;
-    let _ = write!(writer, "{}\n", info);
+    if let Some(location) = info.location() {
+        // We can't format easily without alloc, but we can print basic info if possible
+        // For now, just a marker
+    }
 
     loop {
         core::hint::spin_loop(); 
@@ -181,7 +174,7 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     early_serial_print(b"[BOOT] Initializing MM...\r\n");
     screen_print!(system_table, "[Kernel] Initializing Memory Management...");
     // STALL 0.5s
-    // system_table.boot_services().stall(500_000);
+    system_table.boot_services().stall(500_000);
 
     let (phys_offset, memory_map_iter) = mm::init(&system_table);
     screen_print!(system_table, "[Kernel] Memory Management initialized");
@@ -191,7 +184,7 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     screen_print!(system_table, "[Kernel] Initializing Filesystem...");
     fs::init(phys_offset);
     // STALL 0.5s
-    // system_table.boot_services().stall(500_000);
+    system_table.boot_services().stall(500_000);
 
     // 5. Initialize Scheduler
     screen_print!(system_table, "[Kernel] Initializing Scheduler...");
@@ -200,11 +193,11 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     // 6. Initialize Drivers
     screen_print!(system_table, "[Kernel] Initializing Drivers...");
     drivers::init();
-    // system_table.boot_services().stall(500_000); // STALL 0.5s
+    system_table.boot_services().stall(500_000); // STALL 0.5s
 
     // 7. Enable Interrupts (Testing in QEMU)
     screen_print!(system_table, "[Kernel] About to enable interrupts (STI)...");
-    // system_table.boot_services().stall(1_000_000); // STALL 1s
+    system_table.boot_services().stall(1_000_000); // STALL 1s
     #[cfg(target_arch = "x86_64")]
     {
         interrupts::enable();
@@ -218,8 +211,6 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
     // 7. Load Init Process
     let init_path = if USE_SIMPLE_INIT { "/init" } else { "/bin/busybox" };
     screen_print!(system_table, "[Kernel] Loading init...");
-    let msg_path = alloc::format!("[Kernel] Init Path: {}", init_path);
-    screen_print!(system_table, msg_path.as_str());
 
     screen_print!(system_table, "[Kernel] DEBUG: About to call fs::open");
 
@@ -233,6 +224,8 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
         let len = inode.read_at(0, &mut buffer);
         screen_print!(system_table, "[Kernel] DEBUG: Read bytes");
 
+        system_table.boot_services().stall(1_000_000); // STALL 1s
+
         if len > 64 {
             use crate::syscall::elf::{load_elf, setup_user_stack, AuxvEntry, AT_PAGESZ};
 
@@ -243,7 +236,7 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
             match load_elf(&buffer[..len], 0) {
                 Ok(loaded) => {
                     screen_print!(system_table, "[Kernel] BusyBox loaded!");
-                    // system_table.boot_services().stall(1_000_000); // STALL 1s
+                    system_table.boot_services().stall(1_000_000); // STALL 1s
 
                     // Set up Auxv
                     let auxv = alloc::vec![
@@ -255,31 +248,16 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
                     let envp: &[&[u8]] = &[];
 
                     // Set up stack (at high address)
-                    let stack_top = 0x10000000u64; // 256MB (Safe Low Memory)
+                    let stack_top = 0x7FFFFF000000u64;
                     let stack_size = 128 * 1024; // 128KB
 
                     screen_print!(system_table, "[Kernel] Mapping user stack...");
                     mm::paging::make_user_accessible(stack_top - stack_size, stack_size);
                     screen_print!(system_table, "[Kernel] User stack mapped!");
 
-                    // PROBE STACK
-                    unsafe {
-                        let ptr = (stack_top - 8) as *mut u64;
-                        // Use format! for complex logs
-                        let s = alloc::format!("[Kernel] Probing stack at {:p}...", ptr);
-                        screen_print!(system_table, s.as_str());
-                        
-                        *ptr = 0xAA55AA55;
-                        
-                        let s2 = alloc::format!("[Kernel] Probe OK: 0x{:x}", *ptr);
-                        screen_print!(system_table, s2.as_str());
-                    }
-                    
                     screen_print!(system_table, "[Kernel] Setting up user stack...");
                     let user_sp = setup_user_stack(stack_top, argv, envp, &auxv);
-                    
-                    let s3 = alloc::format!("[Kernel] User stack set up! SP=0x{:x}", user_sp);
-                    screen_print!(system_table, s3.as_str());
+                    screen_print!(system_table, "[Kernel] User stack set up!");
 
                     screen_print!(system_table, "[Kernel] Setting up kernel stack for TSS...");
                     // CRITICAL: Allocate Kernel Stack for this process (PID 1) and update TSS!
@@ -297,22 +275,9 @@ fn main(_image_handle: Handle, mut system_table: SystemTable<Boot>) -> Status {
                     // Prevent deallocation of stack
                     core::mem::forget(kernel_stack);
                     screen_print!(system_table, "[Kernel] Kernel stack ready!");
-                    
-                    // DEBUG: Dump code at entry point
-                    unsafe {
-                         let entry_ptr = loaded.entry_point as *const u64;
-                         let w1 = *entry_ptr;
-                         let w2 = *entry_ptr.add(1);
-                         
-                         let msg_ep = alloc::format!("[Kernel] Entry Point: 0x{:x}", loaded.entry_point);
-                         screen_print!(system_table, msg_ep.as_str());
-
-                         let msg_code = alloc::format!("[Kernel] CODE at 0x{:x}: {:016x} {:016x}", loaded.entry_point, w1, w2);
-                         screen_print!(system_table, msg_code.as_str());
-                    }
 
                     screen_print!(system_table, "[Kernel] STALL 3s before User Mode...");
-                    // system_table.boot_services().stall(3_000_000); // STALL 3s
+                    system_table.boot_services().stall(3_000_000); // STALL 3s
 
                     screen_print!(system_table, "[Kernel] Jumping to Ring 3...");
                     // Jump to Ring 3