feat(aweos): implement real end-user runtime toward 30 readiness

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: AWEOS CI Pipeline
 
 on:
   push:
-    branches: [ main, master ]
+    branches: [ main, master, 'feat/**' ]
   pull_request:
     branches: [ main, master ]
 
@@ -16,31 +16,58 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-
       - name: Install Rust Toolchain
         run: |
           rustup show
           rustup target add x86_64-unknown-none
           rustup target add x86_64-unknown-uefi
-
       - name: Check Workspace Compilation
         run: cargo check --workspace --all-targets
-
       - name: Run Workspace Tests
-        run: cargo test --workspace
-
+        run: cargo test --workspace --all-targets
       - name: Validate Formatting
         run: cargo fmt --all --check
-
+      - name: Validate Clippy
+        run: cargo clippy --workspace --all-targets -- -D warnings
+      - name: Install QEMU and Xvfb
+        run: sudo apt-get update && sudo apt-get install -y qemu-system-x86 xvfb
       - name: Build Boot Images
         run: ./scripts/build-images.sh
-
       - name: Verify Image Artifacts
         run: |
           test -f dist/aweos-x86_64.iso
           test -f dist/aweos-x86_64.img
           test -f dist/aweos-uefi.img
           test -f dist/aweos-bios.img
-          test -f build/aweos-x86_64.iso
-          test -f build/aweos-x86_64.img
-          echo "All boot artifacts successfully generated and verified."
+      - name: Headless QEMU Smoke Test
+        timeout-minutes: 3
+        run: |
+          qemu-system-x86_64 --version
+          set +e
+          timeout 30s qemu-system-x86_64 -display none -serial stdio -no-reboot -no-shutdown -kernel target/x86_64-unknown-none/debug/aweos > qemu-serial.log 2>&1
+          status=$?
+          set -e
+          cat qemu-serial.log
+          test $status -eq 124 || test $status -eq 0
+          grep -q "AWEOS: kernel state = RUNNING" qemu-serial.log
+          grep -q "AWEOS: entering Ring 3" qemu-serial.log
+          grep -q "AWEOS: persistent initd/appd/storage/UI runtime control plane started" qemu-serial.log
+      - name: Graphical QEMU Startup Smoke Test
+        timeout-minutes: 3
+        run: |
+          set +e
+          timeout 30s xvfb-run -a qemu-system-x86_64 -display gtk -serial file:qemu-graphical.log -no-reboot -no-shutdown -kernel target/x86_64-unknown-none/debug/aweos
+          status=$?
+          set -e
+          cat qemu-graphical.log || true
+          test $status -eq 124 || test $status -eq 0
+          grep -q "AWEOS: kernel state = RUNNING" qemu-graphical.log
+      - name: Upload QEMU Evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: aweos-qemu-evidence
+          path: |
+            qemu-serial.log
+            qemu-graphical.log
+          if-no-files-found: warn

kernel/Cargo.toml

@@ -10,3 +10,9 @@ path = "src/lib.rs"
 [dependencies]
 awe-boot-protocol = { workspace = true }
 awe-ayui = { workspace = true }
+awe-initd = { workspace = true }
+awe-appd = { workspace = true }
+awe-driverd = { workspace = true }
+awe-netd = { workspace = true }
+awe-storaged = { workspace = true }
+awe-securityd = { workspace = true }

kernel/src/arch/x86_64/input.rs

@@ -0,0 +1,104 @@
+#![no_std]
+
+use core::sync::atomic::{AtomicBool, AtomicU8, AtomicUsize, AtomicU64, Ordering};
+use crate::drivers::{KeyCode, Ps2Event};
+
+pub const CAPACITY: usize = 128;
+static HEAD: AtomicUsize = AtomicUsize::new(0);
+static TAIL: AtomicUsize = AtomicUsize::new(0);
+static QUEUE: [AtomicU64; CAPACITY] = [const { AtomicU64::new(0) }; CAPACITY];
+static KB_EXTENDED: AtomicBool = AtomicBool::new(false);
+static KB_BREAK: AtomicBool = AtomicBool::new(false);
+static MOUSE_INDEX: AtomicU8 = AtomicU8::new(0);
+static MOUSE_0: AtomicU8 = AtomicU8::new(0);
+static MOUSE_1: AtomicU8 = AtomicU8::new(0);
+static MOUSE_2: AtomicU8 = AtomicU8::new(0);
+
+fn enqueue(encoded: u64) -> bool {
+    let tail = TAIL.load(Ordering::Relaxed);
+    let next = (tail + 1) % CAPACITY;
+    if next == HEAD.load(Ordering::Acquire) { return false; }
+    QUEUE[tail].store(encoded, Ordering::Release);
+    TAIL.store(next, Ordering::Release);
+    true
+}
+
+pub fn dequeue() -> Option<Ps2Event> {
+    let head = HEAD.load(Ordering::Relaxed);
+    if head == TAIL.load(Ordering::Acquire) { return None; }
+    let encoded = QUEUE[head].load(Ordering::Acquire);
+    HEAD.store((head + 1) % CAPACITY, Ordering::Release);
+    if encoded >> 63 == 0 {
+        let code = (encoded & 0xffff) as u8;
+        let pressed = ((encoded >> 16) & 1) != 0;
+        Some(Ps2Event::Key { code: map_key(code), pressed })
+    } else {
+        let dx = (encoded as u16) as i16;
+        let dy = ((encoded >> 16) as u16) as i16;
+        let buttons = ((encoded >> 32) & 0xff) as u8;
+        Some(Ps2Event::Pointer { dx, dy, buttons })
+    }
+}
+
+fn map_key(code: u8) -> KeyCode {
+    match code {
+        0x01 => KeyCode::Escape, 0x0D => KeyCode::Tab, 0x1C => KeyCode::Enter,
+        0x0E => KeyCode::Backspace, 0x39 => KeyCode::Space, 0x4B => KeyCode::Left,
+        0x4D => KeyCode::Right, 0x48 => KeyCode::Up, 0x50 => KeyCode::Down,
+        other => KeyCode::Unknown(other),
+    }
+}
+
+pub fn irq_keyboard_byte(byte: u8) -> bool {
+    match byte {
+        0xE0 => { KB_EXTENDED.store(true, Ordering::Relaxed); false }
+        0xF0 => { KB_BREAK.store(true, Ordering::Relaxed); false }
+        code => {
+            let extended = KB_EXTENDED.swap(false, Ordering::Relaxed);
+            let pressed = !KB_BREAK.swap(false, Ordering::Relaxed);
+            let code = if extended { code } else { code };
+            let mut encoded = code as u64;
+            if pressed { encoded |= 1 << 16; }
+            enqueue(encoded)
+        }
+    }
+}
+
+pub fn irq_mouse_byte(byte: u8) -> bool {
+    let index = MOUSE_INDEX.load(Ordering::Relaxed) as usize;
+    if index == 0 && byte & 0x08 == 0 { return false; }
+    match index {
+        0 => MOUSE_0.store(byte, Ordering::Relaxed),
+        1 => MOUSE_1.store(byte, Ordering::Relaxed),
+        2 => MOUSE_2.store(byte, Ordering::Relaxed),
+        _ => return false,
+    }
+    if index < 2 { MOUSE_INDEX.store((index + 1) as u8, Ordering::Relaxed); return false; }
+    MOUSE_INDEX.store(0, Ordering::Relaxed);
+    let flags = MOUSE_0.load(Ordering::Relaxed);
+    if flags & 0xC0 != 0 { return false; }
+    let raw_x = MOUSE_1.load(Ordering::Relaxed) as i16;
+    let raw_y = MOUSE_2.load(Ordering::Relaxed) as i16;
+    let dx = if flags & 0x10 != 0 { raw_x - 256 } else { raw_x };
+    let dy_raw = if flags & 0x20 != 0 { raw_y - 256 } else { raw_y };
+    let dy = -dy_raw;
+    let encoded = (dx as u16 as u64) | ((dy as u16 as u64) << 16) | (((flags & 7) as u64) << 32) | (1u64 << 63);
+    enqueue(encoded)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn keyboard_irq_generates_decoded_event() {
+        assert!(irq_keyboard_byte(0x1C));
+        assert_eq!(dequeue(), Some(Ps2Event::Key { code: KeyCode::Enter, pressed: true }));
+        irq_keyboard_byte(0xF0); irq_keyboard_byte(0x1C);
+        assert_eq!(dequeue(), Some(Ps2Event::Key { code: KeyCode::Enter, pressed: false }));
+    }
+    #[test]
+    fn mouse_irq_generates_signed_event() {
+        assert!(!irq_mouse_byte(0x09)); assert!(!irq_mouse_byte(0xFE)); assert!(irq_mouse_byte(0x02));
+        assert_eq!(dequeue(), Some(Ps2Event::Pointer { dx: -2, dy: -2, buttons: 1 }));
+    }
+}

kernel/src/arch/x86_64/interrupts.rs

@@ -3,51 +3,36 @@
 use super::idt::Idt;
 
 pub const TIMER_VECTOR: u8 = 32;
+pub const KEYBOARD_VECTOR: u8 = 33;
+pub const MOUSE_VECTOR: u8 = 44;
 
-/// Remaps the 8259 PIC so IRQs 0..15 land on IDT vectors 32..47.
 pub unsafe fn init_pic() {
     unsafe {
         use super::{io_in8, io_out8};
-
-        // Save masks
         let mask1 = io_in8(0x21);
         let mask2 = io_in8(0xA1);
-
-        // ICW1: Start initialization in cascade mode
         io_out8(0x20, 0x11);
         io_out8(0xA0, 0x11);
-
-        // ICW2: Vector offsets (32 for master, 40 for slave)
         io_out8(0x21, 0x20);
         io_out8(0xA1, 0x28);
-
-        // ICW3: Cascade setup
         io_out8(0x21, 0x04);
         io_out8(0xA1, 0x02);
-
-        // ICW4: 8086 mode
         io_out8(0x21, 0x01);
         io_out8(0xA1, 0x01);
-
-        // Restore masks (or unmask IRQ0 timer & IRQ1 keyboard)
-        io_out8(0x21, mask1 & !0x01); // unmask IRQ0 (timer)
-        io_out8(0xA1, mask2);
+        // Enable IRQ0 timer, IRQ1 keyboard, and IRQ2 cascade for slave IRQ12 mouse.
+        io_out8(0x21, mask1 & !0x07);
+        io_out8(0xA1, mask2 & !0x10);
     }
 }
 
 pub unsafe fn pic_send_eoi(irq: u8) {
     unsafe {
         use super::io_out8;
-        if irq >= 8 {
-            io_out8(0xA0, 0x20);
-        }
+        if irq >= 8 { io_out8(0xA0, 0x20); }
         io_out8(0x20, 0x20);
     }
 }
 
-/// Installs the minimal early interrupt surface. The timer handler remains an
-/// explicit ABI boundary so scheduler code can be attached without changing
-/// IDT construction.
 pub fn install_early_interrupts(idt: &mut Idt, code_selector: u16, timer_handler: u64) {
     idt.set_handler(TIMER_VECTOR, timer_handler, code_selector);
 }
@@ -56,12 +41,17 @@ pub fn install_early_interrupts(idt: &mut Idt, code_selector: u16, timer_handler
 mod tests {
     use super::*;
     extern "C" fn timer() {}
-
+    #[test]
+    fn vectors_match_pic_remap() {
+        assert_eq!(TIMER_VECTOR, 32);
+        assert_eq!(KEYBOARD_VECTOR, 33);
+        assert_eq!(MOUSE_VECTOR, 44);
+    }
     #[test]
     fn timer_vector_is_installed() {
         let mut idt = Idt::new();
         install_early_interrupts(&mut idt, 0x08, timer as *const () as usize as u64);
         assert!(idt.is_present(TIMER_VECTOR));
-        assert!(!idt.is_present(33));
+        assert!(!idt.is_present(KEYBOARD_VECTOR));
     }
-}
+}