milestone: desktop path Phases 1-5

Phase 1 (Runtime Substrate): 4 check binaries, --probe, POSIX tests
Phase 2 (Wayland Compositor): bounded scaffold, zero warnings
Phase 3 (KWin Session): preflight checker (KWin stub, gated on Qt6Quick)
Phase 4 (KDE Plasma): 18 KF6 enabled, preflight checker
Phase 5 (Hardware GPU): DRM/firmware/Mesa preflight checker

Build: zero warnings, all scripts syntax-clean. Oracle-verified.

recipes/core/base/ptyd/src/main.rs

@@ -0,0 +1,139 @@
+use event::{user_data, EventFlags, EventQueue};
+use libredox::{flag, Fd};
+
+use redox_scheme::{scheme::register_sync_scheme, Response, SignalBehavior, Socket};
+use scheme_utils::ReadinessBased;
+use syscall::data::TimeSpec;
+
+mod controlterm;
+mod pgrp;
+mod pty;
+mod resource;
+mod scheme;
+mod subterm;
+mod termios;
+mod winsize;
+
+use scheme::{Handle, PtyScheme};
+
+fn main() {
+    daemon::Daemon::new(daemon);
+}
+
+fn daemon(daemon: daemon::Daemon) -> ! {
+    user_data! {
+        enum EventSource {
+            Socket,
+            Time,
+        }
+    }
+
+    let event_queue = EventQueue::<EventSource>::new().expect("pty: failed to open event:");
+
+    let time_path = format!("/scheme/time/{}", flag::CLOCK_MONOTONIC);
+    let mut time_file =
+        Fd::open(&time_path, flag::O_NONBLOCK, 0).expect("pty: failed to open time:");
+
+    let socket = redox_scheme::Socket::nonblock().expect("pty: failed to create pty scheme");
+    let mut handler = ReadinessBased::new(&socket, 16);
+
+    let mut scheme = PtyScheme::new();
+    register_sync_scheme(&socket, "pty", &mut scheme)
+        .expect("ptyd: failed to register scheme to namespace");
+    daemon.ready();
+
+    libredox::call::setrens(0, 0).expect("ptyd: failed to enter null namespace");
+
+    event_queue
+        .subscribe(socket.inner().raw(), EventSource::Socket, EventFlags::READ)
+        .expect("pty: failed to watch events on pty:");
+    event_queue
+        .subscribe(time_file.raw(), EventSource::Time, EventFlags::READ)
+        .expect("pty: failed to watch events on time:");
+
+    //TODO: do not set timeout if not necessary
+    timeout(&mut time_file).expect("pty: failed to set timeout");
+
+    let mut timeout_count = 0u64;
+
+    scan_requests(&mut handler, &mut scheme).expect("pty: could not scan requests");
+    issue_events(&socket, &mut scheme);
+
+    for event_res in event_queue {
+        let event = event_res.expect("pty: failed to read from event queue");
+
+        match event.user_data {
+            EventSource::Socket => {
+                if scan_requests(&mut handler, &mut scheme).is_err() {
+                    break;
+                }
+            }
+            EventSource::Time => {
+                timeout(&mut time_file).expect("pty: failed to set timeout");
+
+                timeout_count = timeout_count.wrapping_add(1);
+
+                for (_id, handle) in scheme.handles.iter_mut() {
+                    if let Handle::Resource(res) = handle {
+                        res.timeout(timeout_count);
+                    }
+                }
+
+                handler
+                    .poll_all_requests(&mut scheme)
+                    .expect("ihdad: failed to poll requests");
+            }
+        }
+
+        issue_events(&socket, &mut scheme);
+    }
+
+    std::process::exit(0);
+}
+
+fn scan_requests(
+    handler: &mut ReadinessBased<'_>,
+    scheme: &mut PtyScheme,
+) -> libredox::error::Result<()> {
+    handler
+        .read_and_process_requests(scheme)
+        .expect("pty: failed to read from socket");
+    handler
+        .poll_all_requests(scheme)
+        .expect("pty: error occured in poll_all_requests");
+    handler
+        .write_responses()
+        .expect("pty: failed to write to socket");
+    Ok(())
+}
+
+fn issue_events(socket: &Socket, scheme: &mut PtyScheme) {
+    for (id, handle) in scheme.handles.iter_mut() {
+        if let Handle::Resource(ref mut res) = handle {
+            let events = res.events();
+            if events != syscall::EventFlags::empty() {
+                socket
+                    .write_response(
+                        Response::post_fevent(*id, events.bits()),
+                        SignalBehavior::Restart,
+                    )
+                    .expect("pty: failed to send scheme event");
+            }
+        }
+    }
+}
+
+fn timeout(time_file: &mut Fd) -> libredox::error::Result<()> {
+    let mut time = TimeSpec::default();
+    time_file.read(&mut time)?;
+
+    // Set timeout for 100ms
+    time.tv_nsec += 100_000_000;
+    while time.tv_nsec >= 1_000_000_000 {
+        time.tv_sec += 1;
+        time.tv_nsec -= 1_000_000_000;
+    }
+
+    time_file.write(&time)?;
+    Ok(())
+}