Fix zygote restart & Show zygisksu status on module.prop

zygiskd/src/root_impl/kernelsu.rs

@@ -1,4 +1,3 @@
-use anyhow::{bail, Result};
 use nix::libc::prctl;
 use crate::constants::{MIN_KSU_VERSION, MAX_KSU_VERSION};
 
@@ -8,14 +7,20 @@ const CMD_GET_VERSION: usize = 2;
 const CMD_GET_ALLOW_LIST: usize = 5;
 const CMD_GET_DENY_LIST: usize = 6;
 
-pub fn is_kernel_su() -> Result<bool> {
+pub enum Version {
+    Supported,
+    TooOld,
+    Abnormal,
+}
+
+pub fn get_kernel_su() -> Option<Version> {
     let mut version = 0;
     unsafe { prctl(KERNEL_SU_OPTION, CMD_GET_VERSION, &mut version as *mut i32) };
-    return match version {
-        0 => Ok(false),
-        MIN_KSU_VERSION..=MAX_KSU_VERSION => Ok(true),
-        1..=MIN_KSU_VERSION => bail!("KernelSU version too old: {}", version),
-        _ => bail!("KernelSU version abnormal: {}", version)
+    match version {
+        0 => None,
+        MIN_KSU_VERSION..=MAX_KSU_VERSION => Some(Version::Supported),
+        1..=MIN_KSU_VERSION => Some(Version::TooOld),
+        _ => Some(Version::Abnormal)
     }
 }
 

zygiskd/src/root_impl/magisk.rs

@@ -1,8 +1,12 @@
-use anyhow::{bail, Result};
 use std::process::{Command, Stdio};
 use crate::constants::MIN_MAGISK_VERSION;
 
-pub fn is_magisk() -> Result<bool> {
+pub enum Version {
+    Supported,
+    TooOld,
+}
+
+pub fn get_magisk() -> Option<Version> {
     let version: Option<i32> = Command::new("magisk")
         .arg("-V")
         .stdout(Stdio::piped())
@@ -10,13 +14,13 @@ pub fn is_magisk() -> Result<bool> {
         .and_then(|child| child.wait_with_output().ok())
         .and_then(|output| String::from_utf8(output.stdout).ok())
         .and_then(|output| output.trim().parse().ok());
-    if let Some(version) = version {
-        if version < MIN_MAGISK_VERSION {
-            bail!("Magisk version too old: {}", version);
+    version.map(|version| {
+        if version >= MIN_MAGISK_VERSION {
+            Version::Supported
+        } else {
+            Version::TooOld
         }
-        return Ok(true);
-    }
-    Ok(false)
+    })
 }
 
 pub fn uid_on_allowlist(uid: i32) -> bool {

zygiskd/src/root_impl/mod.rs

@@ -2,33 +2,52 @@ mod kernelsu;
 mod magisk;
 
 use once_cell::sync::OnceCell;
-use anyhow::{bail, Result};
 
-enum RootImpl {
+pub enum RootImpl {
+    None,
+    TooOld,
+    Abnormal,
+    Multiple,
     KernelSU,
     Magisk,
 }
 
 static ROOT_IMPL: OnceCell<RootImpl> = OnceCell::new();
 
-pub fn setup() -> Result<()> {
-    if kernelsu::is_kernel_su()? {
-        if let Ok(true) = magisk::is_magisk() {
-            bail!("Multiple root implementation");
+pub fn setup() {
+    let ksu_version = kernelsu::get_kernel_su();
+    let magisk_version = magisk::get_magisk();
+
+    let _ = match (ksu_version, magisk_version) {
+        (None, None) => ROOT_IMPL.set(RootImpl::None),
+        (Some(_), Some(_)) => ROOT_IMPL.set(RootImpl::Multiple),
+        (Some(ksu_version), None) => {
+            let val = match ksu_version {
+                kernelsu::Version::Supported => RootImpl::KernelSU,
+                kernelsu::Version::TooOld => RootImpl::TooOld,
+                kernelsu::Version::Abnormal => RootImpl::Abnormal,
+            };
+            ROOT_IMPL.set(val)
         }
-        let _ = ROOT_IMPL.set(RootImpl::KernelSU);
-    } else if magisk::is_magisk()? {
-        let _ = ROOT_IMPL.set(RootImpl::Magisk);
-    } else {
-        bail!("Unknown root implementation");
-    }
-    Ok(())
+        (None, Some(magisk_version)) => {
+            let val = match magisk_version {
+                magisk::Version::Supported => RootImpl::Magisk,
+                magisk::Version::TooOld => RootImpl::TooOld,
+            };
+            ROOT_IMPL.set(val)
+        }
+    };
+}
+
+pub fn get_impl() -> &'static RootImpl {
+    ROOT_IMPL.get().unwrap()
 }
 
 pub fn uid_on_allowlist(uid: i32) -> bool {
     match ROOT_IMPL.get().unwrap() {
         RootImpl::KernelSU => kernelsu::uid_on_allowlist(uid),
         RootImpl::Magisk => magisk::uid_on_allowlist(uid),
+        _ => unreachable!(),
     }
 }
 
@@ -36,5 +55,6 @@ pub fn uid_on_denylist(uid: i32) -> bool {
     match ROOT_IMPL.get().unwrap() {
         RootImpl::KernelSU => kernelsu::uid_on_denylist(uid),
         RootImpl::Magisk => magisk::uid_on_denylist(uid),
+        _ => unreachable!(),
     }
 }