Use bitflags macro

native/src/Cargo.lock

@@ -54,6 +54,7 @@ name = "base"
 version = "0.0.0"
 dependencies = [
  "argh",
+ "bitflags",
  "bytemuck",
  "cfg-if",
  "const_format",

native/src/Cargo.toml

@@ -28,11 +28,12 @@ argh = { version = "0.1.13", default-features = false }
 pb-rs = { version = "0.10.0", default-features = false }
 quick-protobuf = "0.8.1"
 flate2 = { version = "1.1.2", default-features = false }
-bzip2 = { version = "0.6.0" }
+bzip2 = "0.6.0"
 zopfli = "0.8.2"
 lz4 = "1.28.1"
 lzma-rust2 = { version = "0.13.0", default-features = false, features = ["xz", "std", "encoder", "optimization"] }
 nix = "0.30.1"
+bitflags = "2.9.4"
 
 # Rust crypto crates are tied together
 sha1 = "0.11.0-rc.2"

native/src/base/Cargo.toml

@@ -8,7 +8,6 @@ path = "lib.rs"
 
 [features]
 selinux = []
-dyn_selinux = []
 
 [build-dependencies]
 cxx-gen = { workspace = true }
@@ -24,3 +23,4 @@ num-traits = { workspace = true }
 num-derive = { workspace = true }
 const_format = { workspace = true }
 nix = { workspace = true, features = ["fs", "mount"] }
+bitflags = { workspace = true }

native/src/base/logging.rs

@@ -1,21 +1,21 @@
+use crate::ffi::LogLevelCxx;
+use crate::{Utf8CStr, cstr};
+use bitflags::bitflags;
+use num_derive::{FromPrimitive, ToPrimitive};
+use num_traits::FromPrimitive;
 use std::fmt;
 use std::io::{Write, stderr, stdout};
 use std::process::exit;
 
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::FromPrimitive;
-
-use crate::ffi::LogLevelCxx;
-use crate::{Utf8CStr, cstr};
-
-// Ugly hack to avoid using enum
-#[allow(non_snake_case, non_upper_case_globals)]
-mod LogFlag {
-    pub const DisableError: u32 = 1 << 0;
-    pub const DisableWarn: u32 = 1 << 1;
-    pub const DisableInfo: u32 = 1 << 2;
-    pub const DisableDebug: u32 = 1 << 3;
-    pub const ExitOnError: u32 = 1 << 4;
+bitflags! {
+    #[derive(Copy, Clone)]
+    struct LogFlag : u32 {
+        const DISABLE_ERROR = 1 << 0;
+        const DISABLE_WARN = 1 << 1;
+        const DISABLE_INFO = 1 << 2;
+        const DISABLE_DEBUG = 1 << 3;
+        const EXIT_ON_ERROR = 1 << 4;
+    }
 }
 
 #[derive(Copy, Clone, FromPrimitive, ToPrimitive)]
@@ -31,7 +31,7 @@ pub enum LogLevel {
 // logger changes will only happen on the main thread.
 pub static mut LOGGER: Logger = Logger {
     write: |_, _| {},
-    flags: 0,
+    flags: LogFlag::empty(),
 };
 
 type LogWriter = fn(level: LogLevel, msg: &Utf8CStr);
@@ -40,48 +40,43 @@ pub(crate) type Formatter<'a> = &'a mut dyn fmt::Write;
 #[derive(Copy, Clone)]
 pub struct Logger {
     pub write: LogWriter,
-    pub flags: u32,
+    flags: LogFlag,
 }
 
-pub fn exit_on_error(b: bool) {
+pub fn update_logger(f: impl FnOnce(&mut Logger)) {
+    let mut logger = unsafe { LOGGER };
+    f(&mut logger);
     unsafe {
-        if b {
-            LOGGER.flags |= LogFlag::ExitOnError;
-        } else {
-            LOGGER.flags &= !LogFlag::ExitOnError;
-        }
+        LOGGER = logger;
     }
 }
 
+pub fn exit_on_error(b: bool) {
+    update_logger(|logger| logger.flags.set(LogFlag::EXIT_ON_ERROR, b));
+}
+
 impl LogLevel {
-    fn as_disable_flag(&self) -> u32 {
+    fn as_disable_flag(&self) -> LogFlag {
         match *self {
-            LogLevel::Error => LogFlag::DisableError,
-            LogLevel::Warn => LogFlag::DisableWarn,
-            LogLevel::Info => LogFlag::DisableInfo,
-            LogLevel::Debug => LogFlag::DisableDebug,
+            LogLevel::Error => LogFlag::DISABLE_ERROR,
+            LogLevel::Warn => LogFlag::DISABLE_WARN,
+            LogLevel::Info => LogFlag::DISABLE_INFO,
+            LogLevel::Debug => LogFlag::DISABLE_DEBUG,
         }
     }
 }
 
 pub fn set_log_level_state(level: LogLevel, enabled: bool) {
-    let flag = level.as_disable_flag();
-    unsafe {
-        if enabled {
-            LOGGER.flags &= !flag
-        } else {
-            LOGGER.flags |= flag
-        }
-    }
+    update_logger(|logger| logger.flags.set(level.as_disable_flag(), enabled));
 }
 
 fn log_with_writer<F: FnOnce(LogWriter)>(level: LogLevel, f: F) {
     let logger = unsafe { LOGGER };
-    if (logger.flags & level.as_disable_flag()) != 0 {
+    if logger.flags.contains(level.as_disable_flag()) {
         return;
     }
     f(logger.write);
-    if (logger.flags & LogFlag::ExitOnError) != 0 {
+    if logger.flags.contains(LogFlag::EXIT_ON_ERROR) {
         exit(-1);
     }
 }
@@ -108,14 +103,7 @@ pub fn cmdline_logging() {
             stderr().write_all(msg.as_bytes()).ok();
         }
     }
-
-    let logger = Logger {
-        write: cmdline_write,
-        flags: 0,
-    };
-    unsafe {
-        LOGGER = logger;
-    }
+    update_logger(|logger| logger.write = cmdline_write);
 }
 
 #[macro_export]

native/src/core/logging.rs

@@ -1,20 +1,19 @@
 use crate::consts::{LOG_PIPE, LOGFILE};
 use crate::ffi::get_magisk_tmp;
 use crate::logging::LogFile::{Actual, Buffer};
-use base::libc::{
-    O_CLOEXEC, O_RDWR, O_WRONLY, PIPE_BUF, SIG_BLOCK, SIG_SETMASK, SIGPIPE, getpid, gettid,
-    localtime_r, pthread_sigmask, sigaddset, sigset_t, sigtimedwait, time_t, timespec, tm,
-};
 use base::{
-    FsPathBuilder, LOGGER, LogLevel, Logger, ReadExt, Utf8CStr, Utf8CStrBuf, WriteExt,
-    const_format::concatcp, cstr, libc, raw_cstr,
+    FsPathBuilder, LogLevel, ReadExt, Utf8CStr, Utf8CStrBuf, WriteExt, const_format::concatcp,
+    cstr, libc, raw_cstr, update_logger,
 };
 use bytemuck::{Pod, Zeroable, bytes_of, write_zeroes};
+use libc::{
+    O_CLOEXEC, O_RDWR, O_WRONLY, PIPE_BUF, SIG_BLOCK, SIG_SETMASK, SIGPIPE, c_char, c_void, getpid,
+    gettid, localtime_r, pthread_sigmask, sigaddset, sigset_t, sigtimedwait, time_t, timespec, tm,
+};
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::FromPrimitive;
 use std::cmp::min;
-use std::ffi::{c_char, c_void};
-use std::fmt::Write as FmtWrite;
+use std::fmt::Write as _;
 use std::fs::File;
 use std::io::{IoSlice, Read, Write};
 use std::mem::ManuallyDrop;
@@ -64,13 +63,7 @@ fn android_log_write(level: LogLevel, msg: &Utf8CStr) {
 }
 
 pub fn android_logging() {
-    let logger = Logger {
-        write: android_log_write,
-        flags: 0,
-    };
-    unsafe {
-        LOGGER = logger;
-    }
+    update_logger(|logger| logger.write = android_log_write);
 }
 
 pub fn magisk_logging() {
@@ -78,14 +71,7 @@ pub fn magisk_logging() {
         android_log_write(level, msg);
         magisk_log_to_pipe(level_to_prio(level), msg);
     }
-
-    let logger = Logger {
-        write: magisk_log_write,
-        flags: 0,
-    };
-    unsafe {
-        LOGGER = logger;
-    }
+    update_logger(|logger| logger.write = magisk_log_write);
 }
 
 pub fn zygisk_logging() {
@@ -93,14 +79,7 @@ pub fn zygisk_logging() {
         android_log_write(level, msg);
         zygisk_log_to_pipe(level_to_prio(level), msg);
     }
-
-    let logger = Logger {
-        write: zygisk_log_write,
-        flags: 0,
-    };
-    unsafe {
-        LOGGER = logger;
-    }
+    update_logger(|logger| logger.write = zygisk_log_write);
 }
 
 #[derive(Copy, Clone, Pod, Zeroable)]

native/src/init/logging.rs

@@ -1,18 +1,13 @@
 use base::nix::fcntl::OFlag;
-use base::{
-    LOGGER, LogLevel, Logger, SilentLogExt, Utf8CStr, cstr,
-    libc::{
-        O_CLOEXEC, S_IFCHR, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO, SYS_dup3, makedev, mknod,
-        syscall,
-    },
-    raw_cstr,
+use base::{LogLevel, SilentLogExt, Utf8CStr, cstr, libc, raw_cstr, update_logger};
+use libc::{
+    O_CLOEXEC, S_IFCHR, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO, SYS_dup3, makedev, mknod,
+    syscall,
 };
+use std::fs::File;
+use std::io::{IoSlice, Write};
 use std::mem::ManuallyDrop;
-use std::{
-    fs::File,
-    io::{IoSlice, Write},
-    os::fd::{FromRawFd, IntoRawFd, RawFd},
-};
+use std::os::fd::{FromRawFd, IntoRawFd, RawFd};
 
 // SAFETY: magiskinit is single threaded
 static mut KMSG: RawFd = -1;
@@ -67,11 +62,5 @@ pub fn setup_klog() {
         }
     }
 
-    let logger = Logger {
-        write: kmsg_log_write,
-        flags: 0,
-    };
-    unsafe {
-        LOGGER = logger;
-    }
+    update_logger(|logger| logger.write = kmsg_log_write);
 }