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/zerod/src/main.rs

@@ -0,0 +1,35 @@
+use redox_scheme::Socket;
+
+use scheme::ZeroScheme;
+use scheme_utils::Blocking;
+
+mod scheme;
+
+enum Ty {
+    Null,
+    Zero,
+}
+
+fn main() {
+    daemon::SchemeDaemon::new(daemon);
+}
+
+fn daemon(daemon: daemon::SchemeDaemon) -> ! {
+    let ty = match &*std::env::args().nth(1).unwrap() {
+        "null" => Ty::Null,
+        "zero" => Ty::Zero,
+        _ => panic!("needs to be called with either null or zero as argument"),
+    };
+
+    let socket = Socket::create().expect("zerod: failed to create zero scheme");
+    let mut zero_scheme = ZeroScheme(ty);
+    let zero_handler = Blocking::new(&socket, 16);
+
+    let _ = daemon.ready_sync_scheme(&socket, &mut zero_scheme);
+
+    libredox::call::setrens(0, 0).expect("zerod: failed to enter null namespace");
+
+    zero_handler
+        .process_requests_blocking(zero_scheme)
+        .expect("zerod: failed to process events from zero scheme");
+}

recipes/core/base/zerod/src/scheme.rs

@@ -0,0 +1,87 @@
+use redox_scheme::scheme::SchemeSync;
+use redox_scheme::{CallerCtx, OpenResult};
+use scheme_utils::FpathWriter;
+use syscall::{error::*, schemev2::NewFdFlags, MODE_CHR};
+
+use crate::Ty;
+
+pub struct ZeroScheme(pub Ty);
+
+const SCHEME_ROOT_ID: usize = 1;
+
+impl SchemeSync for ZeroScheme {
+    fn scheme_root(&mut self) -> Result<usize> {
+        Ok(SCHEME_ROOT_ID)
+    }
+    fn openat(
+        &mut self,
+        dirfd: usize,
+        _path: &str,
+        _flags: usize,
+        _fcntl_flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<OpenResult> {
+        if dirfd != SCHEME_ROOT_ID {
+            return Err(Error::new(EACCES));
+        }
+        Ok(OpenResult::ThisScheme {
+            number: 0,
+            flags: NewFdFlags::empty(),
+        })
+    }
+    fn read(
+        &mut self,
+        _id: usize,
+        buf: &mut [u8],
+        _offset: u64,
+        _flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<usize> {
+        match self.0 {
+            Ty::Null => Ok(0),
+            Ty::Zero => {
+                buf.fill(0);
+                Ok(buf.len())
+            }
+        }
+    }
+
+    fn write(
+        &mut self,
+        _id: usize,
+        buf: &[u8],
+        _offset: u64,
+        _flags: u32,
+        _ctx: &CallerCtx,
+    ) -> Result<usize> {
+        Ok(buf.len())
+    }
+
+    fn fcntl(&mut self, _id: usize, _cmd: usize, _arg: usize, _ctx: &CallerCtx) -> Result<usize> {
+        Ok(0)
+    }
+    fn fsize(&mut self, _id: usize, _ctx: &CallerCtx) -> Result<u64> {
+        Ok(0)
+    }
+    fn ftruncate(&mut self, _id: usize, _len: u64, _ctx: &CallerCtx) -> Result<()> {
+        Ok(())
+    }
+
+    fn fpath(&mut self, _id: usize, buf: &mut [u8], _ctx: &CallerCtx) -> Result<usize> {
+        FpathWriter::with(buf, "zero", |_| Ok(()))
+    }
+
+    fn fsync(&mut self, _id: usize, _ctx: &CallerCtx) -> Result<()> {
+        Ok(())
+    }
+
+    fn fstat(&mut self, _id: usize, stat: &mut syscall::Stat, _ctx: &CallerCtx) -> Result<()> {
+        stat.st_mode = 0o666 | MODE_CHR;
+        stat.st_size = 0;
+        stat.st_blocks = 0;
+        stat.st_blksize = 4096;
+        stat.st_nlink = 1;
+
+        Ok(())
+    }
+}