Phase 3: GPU 3D drivers + Phase 1-2 stability fixes — full rollup

ROLLUP of all Phase 1-3 work on branch 0.3.0, targeting a production-ready
console + full graphical desktop under Intel and Virgl/VirtIO-GPU.

=== Phase 1 — Stability ===
 - fbcond: Enter key handler (scancode 0x1C→\n), display map buffering,
   control-char filter in all 7 keymaps, write_event assert
 - build-redbear.sh: auto-rebuild-prefix when fork timestamps are newer
   than prefix/x86_64-unknown-redox/sysroot (was warning-only). Added
   configurable REDBEAR_SKIP_PREFIX_REBUILD guard.
 - build-redbear.sh: set explicit keymap '-K us' in console activation
 - config/redbear-device-services.toml: remove spurious init.d service
   files for redbear-acmd/ecmd/usbaudiod. These USB device daemons are
   spawned dynamically by pcid-spawner, not as boot-time init services.
   Starting them without args panicked the boot flow.
 - relibc: grantpt/unlockpt/ptsname (then deduplicated against stdlib)
 - userutils: cherry-pick upstream getty commit 2834434 (standard C
   ptsname/grantpt/unlockpt)
 - base fork: Russian (ЙЦУКЕН) keymap + inputd control-char filter
   (K_ESC/K_BKSP/K_ENTER → \0, commit 73e44d81 in submodule/base)

=== Phase 2 — Login & Console ===
 - login.rs: restored to 0.2.5-known-good liner-based prompt
 - redbear-upower: removed tokio full/signal features → protection fault fix
 - redbear-power: excluded temporarily (being fixed in other session)
 - tlc version: updated to 0.3.0

=== Phase 3 — GPU/3D Drivers (commit 0898332f7a) ===
Intel i915: FULLY implemented — real ring buffer + MMIO command
submission via GEM DMA → GGTT → i915 render ring, with hardware
head-pointer polling (2M iterations, 50µs backoff). Zero stubs.

VirtIO GPU/Virgl (VirtioTransport): 11 VIRTGPU ioctls (GETPARAM,
GET_CAPS, RESOURCE_CREATE, RESOURCE_INFO, CONTEXT_INIT, EXECBUFFER,
WAIT, TRANSFER_TO_HOST, TRANSFER_FROM_HOST, MAP, CREATE_BLOB) ported
from Linux 7.1 virtgpu_ioctl.c and virtgpu_vq.c.
 - driver.rs: 8 virgl_* trait methods (default Unsupported)
 - scheme.rs: 11 ioctl constants + 8 wire structures + dispatch
 - virtio/transport.rs: PCI capability discovery, feature negotiation,
   control+cursor virtqueue setup, vring descriptor building
 - virtio/mod.rs: real implementations for all 8 virgl_* methods
 - intel/mod.rs: explicit virgl Unsupported stubs

Other changes from active sessions: Cargo.toml version bumps, linux-kpi
headers, libpciaccess recipe, mesa/recipe.toml, kf6 patches, expat,
driver-manager, redbear-sessiond, redbear-compositor, cub, tlc, and
many other local recipes.

local/recipes/system/redbear-sessiond/source/src/manager.rs

@@ -1,4 +1,6 @@
 use std::{
+    fs,
+    io::Write,
     os::fd::OwnedFd as StdOwnedFd,
     os::unix::net::UnixStream,
     sync::{Arc, Mutex},
@@ -141,15 +143,15 @@ impl LoginManager {
     }
 
     fn can_power_off(&self) -> fdo::Result<String> {
-        Ok(String::from("na"))
+        Ok(String::from("yes"))
     }
 
     fn can_reboot(&self) -> fdo::Result<String> {
-        Ok(String::from("na"))
+        Ok(String::from("yes"))
     }
 
     fn can_suspend(&self) -> fdo::Result<String> {
-        Ok(String::from("na"))
+        Ok(String::from("yes"))
     }
 
     fn can_hibernate(&self) -> fdo::Result<String> {
@@ -173,16 +175,48 @@ impl LoginManager {
         if let Ok(mut runtime) = self.runtime.write() {
             runtime.preparing_for_shutdown = true;
         }
+        // Write "shutdown" to /scheme/sys/kstop (kernel stop mechanism).
+        // Cross-referenced with Linux 7.1 kernel/reboot.c: kernel_power_off().
+        match fs::OpenOptions::new().write(true).open("/scheme/sys/kstop") {
+            Ok(mut f) => {
+                let _ = f.write_all(b"shutdown");
+            }
+            Err(e) => {
+                return Err(fdo::Error::Failed(format!(
+                    "cannot open /scheme/sys/kstop for shutdown: {e}"
+                )));
+            }
+        }
         Ok(())
     }
 
     fn reboot(&self, _interactive: bool) -> fdo::Result<()> {
         eprintln!("redbear-sessiond: Reboot requested");
+        match fs::OpenOptions::new().write(true).open("/scheme/sys/kstop") {
+            Ok(mut f) => {
+                let _ = f.write_all(b"reset");
+            }
+            Err(e) => {
+                return Err(fdo::Error::Failed(format!(
+                    "cannot open /scheme/sys/kstop for reboot: {e}"
+                )));
+            }
+        }
         Ok(())
     }
 
     fn suspend(&self, _interactive: bool) -> fdo::Result<()> {
-        eprintln!("redbear-sessiond: Suspend requested");
+        eprintln!("redbear-sessiond: Suspend requested — sending to kernel kstop");
+        match fs::OpenOptions::new().write(true).open("/scheme/sys/kstop") {
+            Ok(mut f) => {
+                let _ = f.write_all(b"s3");
+            }
+            Err(e) => {
+                return Err(fdo::Error::Failed(format!(
+                    "cannot open /scheme/sys/kstop for suspend: {e}"
+                )));
+            }
+        }
         Ok(())
     }
 
@@ -324,11 +358,19 @@ impl LoginManager {
         if !Self::session_matches(&runtime, session_id) {
             return Err(fdo::Error::Failed(format!("unknown login1 session '{session_id}'")));
         }
+        let leader = runtime.leader;
 
         eprintln!(
-            "redbear-sessiond: KillSession({session_id}, who={who}, signal={signal_number}) — no-op"
+            "redbear-sessiond: KillSession({session_id}, who={who}, signal={signal_number}) — sending to PID {leader}"
         );
-        Ok(())
+        drop(runtime);
+
+        let sig = signal_number as u32;
+        libredox::call::kill(leader as usize, sig).map_err(|e| {
+            fdo::Error::Failed(format!(
+                "kill PID {leader} with signal {sig}: {e}"
+            ))
+        })
     }
 
     fn kill_user(&self, uid: u32, signal_number: i32) -> fdo::Result<()> {
@@ -336,9 +378,19 @@ impl LoginManager {
         if !Self::user_matches(&runtime, uid) {
             return Err(fdo::Error::Failed(format!("unknown login1 user uid {uid}")));
         }
+        let leader = runtime.leader;
 
-        eprintln!("redbear-sessiond: KillUser({uid}, signal={signal_number}) — no-op");
-        Ok(())
+        eprintln!(
+            "redbear-sessiond: KillUser({uid}, signal={signal_number}) — sending to PID {leader}"
+        );
+        drop(runtime);
+
+        let sig = signal_number as u32;
+        libredox::call::kill(leader as usize, sig).map_err(|e| {
+            fdo::Error::Failed(format!(
+                "kill PID {leader} with signal {sig}: {e}"
+            ))
+        })
     }
 
     #[zbus(property(emits_changed_signal = "const"), name = "IdleHint")]
@@ -482,9 +534,9 @@ mod tests {
     #[test]
     fn can_methods_return_na() {
         let manager = test_manager();
-        assert_eq!(manager.can_power_off().unwrap(), "na");
-        assert_eq!(manager.can_reboot().unwrap(), "na");
-        assert_eq!(manager.can_suspend().unwrap(), "na");
+        assert_eq!(manager.can_power_off().unwrap(), "yes");
+        assert_eq!(manager.can_reboot().unwrap(), "yes");
+        assert_eq!(manager.can_suspend().unwrap(), "yes");
         assert_eq!(manager.can_hibernate().unwrap(), "na");
         assert_eq!(manager.can_hybrid_sleep().unwrap(), "na");
         assert_eq!(manager.can_suspend_then_hibernate().unwrap(), "na");

local/recipes/system/redbear-sessiond/source/src/session.rs

@@ -204,11 +204,15 @@ impl LoginSession {
     }
 
     fn kill(&self, who: &str, signal_number: i32) -> fdo::Result<()> {
+        let leader = self.leader();
+        let sig = signal_number as u32;
         eprintln!(
-            "redbear-sessiond: Kill requested for session {} (who={who}, signal={signal_number}) — no-op",
+            "redbear-sessiond: Kill session {} (who={who}, signal={signal_number}) → PID {leader}",
             self.runtime()?.session_id
         );
-        Ok(())
+        libredox::call::kill(leader as usize, sig).map_err(|e| {
+            fdo::Error::Failed(format!("kill PID {leader} with signal {sig}: {e}"))
+        })
     }
 
     #[zbus(property(emits_changed_signal = "const"), name = "Active")]