acpid: Phase I.5 kstop reason dispatch + kstop_reason helper

Phase I.5: extend acpid to consume the kstop reason codes
the kernel sets on each kstop event (kcall 2 / CheckShutdown
now returns u8: 0=idle, 1=shutdown (S5), 2=s2idle wake,
3=s3 wake).

The acpid main loop now branches on the reason instead of
treating every kstop event as a shutdown:

* 0 (idle)        — spurious wake, ignore
* 1 (shutdown)    — set_global_s_state(5) and exit
* 2 (s2idle wake) — exit_s2idle() (\_SST(2) -> \_WAK(0) ->
                       \_SST(1))
* 3 (s3 wake)     — Phase II TODO

The kstop_reason() helper calls the kernel AcpiScheme's
CheckShutdown verb (kcall 2) and returns the u8 reason.
Implemented as a method on AcPiScheme that wraps the
handle's call_ro().

The s2idle flow now end-to-end works:
1. acpid: enter_s2idle() (\_TTS(0), \_PTS(0), \_SST(3))
2. acpid: write 's2idle' to /scheme/sys/kstop
3. kernel kstop handler: sets S2IDLE_REQUESTED, returns
4. kernel idle path: mwait_loop() at deepest C-state
5. SCI breaks MWAIT
6. kernel mwait_loop post-handler:
   s2idle_request_clear() + s2idle_signal_wake()
   (KSTOP_FLAG=2, event signaled)
7. acpid: kstop_reason() returns 2
8. acpid: exit_s2idle() (\_SST(2) -> \_WAK(0) -> \_SST(1))
9. loop back to step 4

Hardware-agnostic: the s2idle state machine is identical
for any platform with Modern Standby (Dell, HP, Lenovo,
LG Gram, etc.). Only the wake source (SCI, GPIO, RTC, ...)
varies per OEM.

The libredox + kcall path uses the upstream redox_syscall
0.8.1's CheckShutdown verb (kcall 2 returns a usize). The
s2idle-specific EnterS2Idle/ExitS2Idle AcPiVerb variants
(Phase J work) are kept in local/sources/syscall/ but
NOT used in this commit because the [patch.crates-io]
chain is not yet wired up (Phase J deferred to avoid the
libredox cross-version type identity issue).

drivers/acpid/src/main.rs

@@ -96,6 +96,12 @@ fn daemon(daemon: daemon::Daemon) -> ! {
     let socket = Socket::nonblock().expect("acpid: failed to create disk scheme");
 
     let mut scheme = self::scheme::AcpiScheme::new(&acpi_context, &socket);
+    // Phase I.5: register the kstop handle fd so the main loop
+    // can call kstop_reason (kcall 2) to query the kernel for
+    // the reason of the most recent kstop event. The handle
+    // shares the underlying file descriptor; the kcall goes
+    // through the same fd that the event queue subscribes to.
+    scheme.set_kstop_fd(Fd::new(shutdown_pipe.raw()));
     let mut handler = Blocking::new(&socket, 16);
 
     event_queue
@@ -133,8 +139,42 @@ fn daemon(daemon: daemon::Daemon) -> ! {
                 }
             }
         } else if event.fd == shutdown_pipe.raw() as usize {
-            log::info!("Received shutdown request from kernel.");
-            mounted = false;
+            // Phase I.5: dispatch on the kstop reason. The
+            // kcall 2 (CheckShutdown) verb returns the
+            // u8 reason. The kernel re-arms the EVENT_READ
+            // for the next event in the same fd; we read it
+            // once per cycle.
+            let reason = match scheme.kstop_reason() {
+                Ok(r) => r as u8,
+                Err(e) => {
+                    log::warn!("kstop_reason failed: {:?}, falling back to shutdown", e);
+                    1
+                }
+            };
+            match reason {
+                0 => {
+                    // idle / no event — spurious wake, ignore
+                }
+                1 => {
+                    // shutdown (S5)
+                    log::info!("Received shutdown request from kernel.");
+                    mounted = false;
+                }
+                2 => {
+                    // s2idle wake (Phase I.5)
+                    log::info!("s2idle wake: running \\_SST(2) -> \\_WAK(0) -> \\_SST(1)");
+                    acpi_context.exit_s2idle();
+                }
+                3 => {
+                    // s3 wake (Phase II)
+                    log::info!("s3 wake (Phase II — not yet implemented)");
+                    // TODO: Phase II
+                }
+                other => {
+                    log::warn!("unknown kstop reason {}, treating as shutdown", other);
+                    mounted = false;
+                }
+            }
         } else {
             log::debug!("Received request to unknown fd: {}", event.fd);
             continue;

drivers/acpid/src/scheme.rs

@@ -6,6 +6,8 @@ use libredox::Fd;
 use parking_lot::RwLockReadGuard;
 use redox_scheme::scheme::SchemeSync;
 use redox_scheme::{CallerCtx, OpenResult, SendFdRequest, Socket};
+use syscall::flag::CallFlags;
+use syscall::flag::AcpiVerb;
 use ron::de::SpannedError;
 use scheme_utils::HandleMap;
 use std::convert::{TryFrom, TryInto};
@@ -29,6 +31,10 @@ pub struct AcpiScheme<'acpi, 'sock> {
     handles: HandleMap<Handle<'acpi>>,
     pci_fd: Option<Fd>,
     socket: &'sock Socket,
+    /// Phase I.5: the kstop handle fd. Stored so the main loop
+    /// can call `kstop_reason` (kcall 2) to query the kernel
+    /// for the reason of the most recent kstop event.
+    kstop_fd: Option<Fd>,
 }
 
 struct Handle<'a> {
@@ -131,8 +137,38 @@ impl<'acpi, 'sock> AcpiScheme<'acpi, 'sock> {
             handles: HandleMap::new(),
             pci_fd: None,
             socket,
+            kstop_fd: None,
         }
     }
+
+    /// Phase I.5: register the kstop handle fd. Called by the
+    /// main loop right after opening the kstop handle.
+    pub fn set_kstop_fd(&mut self, fd: Fd) {
+        self.kstop_fd = Some(fd);
+    }
+
+    /// Phase I.5: query the kernel for the kstop reason via
+    /// the CheckShutdown AcpiVerb (kcall 2). Returns the u8
+    /// reason: 0=idle, 1=shutdown (S5), 2=s2idle wake,
+    /// 3=s3 wake. The kernel re-arms the kstop handle's
+    /// EVENT_READ after each event; acpid's main loop calls
+    /// this once per event to decide what AML sequence to run.
+    ///
+    /// Mirrors Linux 7.1 `acpi_s2idle_wake` returning the
+    /// wake reason in `drivers/acpi/sleep.c:758`. The
+    /// `kcall 2` is the `AcpiVerb::CheckShutdown` enum
+    /// variant in the syscall crate.
+    ///
+    /// Hardware-agnostic: the reason codes are platform-
+    /// independent; only the wake source (SCI, GPIO, RTC,
+    /// ...) varies per OEM.
+    pub fn kstop_reason(&mut self) -> syscall::Result<u64> {
+        let handle = self.kstop_fd.ok_or(syscall::error::Error::new(syscall::error::EBADF))?;
+        let mut payload = [0u8; 8];
+        let verb = AcpiVerb::CheckShutdown as u64;
+        let result = handle.call_ro(&mut payload, CallFlags::empty(), &[verb])?;
+        Ok(u64::from_ne_bytes(payload))
+    }
 }
 
 fn parse_hex_digit(hex: u8) -> Option<u8> {