Migration to Edition 2024

native/src/Cargo.toml

@@ -5,7 +5,7 @@ resolver = "2"
 
 [workspace.package]
 version = "0.0.0"
-edition = "2021"
+edition = "2024"
 
 [workspace.dependencies]
 cxx = { path = "external/cxx-rs" }

native/src/base/build.rs

@@ -1,7 +1,7 @@
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
+#[path = "../include/codegen.rs"]
-mod gen;
+mod codegen;
 
 fn main() {
     gen_cxx_binding("base-rs");

native/src/base/cstr.rs

@@ -62,7 +62,7 @@ pub mod cstr_buf {
 
     #[inline(always)]
     pub unsafe fn wrap_ptr<'a>(buf: *mut u8, len: usize) -> Utf8CStrBufRef<'a> {
-        Utf8CStrBufRef::from_ptr(buf, len)
+        unsafe { Utf8CStrBufRef::from_ptr(buf, len) }
     }
 }
 
@@ -232,8 +232,10 @@ impl Utf8CStrBuf for Utf8CString {
     }
 
     unsafe fn set_len(&mut self, len: usize) {
+        unsafe {
             self.0.as_mut_vec().set_len(len);
         }
+    }
 
     fn push_str(&mut self, s: &str) -> usize {
         self.0.push_str(s);
@@ -277,7 +279,7 @@ pub struct Utf8CStrBufRef<'a> {
 
 impl<'a> Utf8CStrBufRef<'a> {
     pub unsafe fn from_ptr(buf: *mut u8, len: usize) -> Utf8CStrBufRef<'a> {
-        Self::from(slice_from_ptr_mut(buf, len))
+        unsafe { Self::from(slice_from_ptr_mut(buf, len)) }
     }
 }
 
@@ -366,12 +368,12 @@ impl Utf8CStr {
 
     #[inline(always)]
     pub const unsafe fn from_bytes_unchecked(buf: &[u8]) -> &Utf8CStr {
-        mem::transmute(buf)
+        unsafe { mem::transmute(buf) }
     }
 
     #[inline(always)]
     unsafe fn from_bytes_unchecked_mut(buf: &mut [u8]) -> &mut Utf8CStr {
-        mem::transmute(buf)
+        unsafe { mem::transmute(buf) }
     }
 
     pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> Result<&'a Utf8CStr, StrErr> {
@@ -382,9 +384,11 @@ impl Utf8CStr {
     }
 
     pub unsafe fn from_ptr_unchecked<'a>(ptr: *const c_char) -> &'a Utf8CStr {
+        unsafe {
             let cstr = CStr::from_ptr(ptr);
             Self::from_bytes_unchecked(cstr.to_bytes_with_nul())
         }
+    }
 
     #[inline(always)]
     pub fn as_bytes_with_nul(&self) -> &[u8] {

native/src/base/cxx_extern.rs

@@ -20,8 +20,9 @@ pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize {
         .map_or(-1_isize, |_| buf.len() as isize)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn canonical_path(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => {
                 let mut buf = cstr_buf::wrap_ptr(buf, bufsz);
@@ -31,25 +32,30 @@ unsafe extern "C" fn canonical_path(path: *const c_char, buf: *mut u8, bufsz: us
             }
             Err(_) => -1,
         }
+    }
 }
 
-#[export_name = "mkdirs"]
+#[unsafe(export_name = "mkdirs")]
 unsafe extern "C" fn mkdirs_for_cxx(path: *const c_char, mode: mode_t) -> i32 {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => FsPath::from(p).mkdirs(mode).map_or(-1, |_| 0),
             Err(_) => -1,
         }
+    }
 }
 
-#[export_name = "rm_rf"]
+#[unsafe(export_name = "rm_rf")]
 unsafe extern "C" fn rm_rf_for_cxx(path: *const c_char) -> bool {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => FsPath::from(p).remove_all().is_ok(),
             Err(_) => false,
         }
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn frm_rf(fd: OwnedFd) -> bool {
     fn inner(fd: OwnedFd) -> io::Result<()> {
         Directory::try_from(fd)?.remove_all()
@@ -83,6 +89,7 @@ pub(crate) unsafe fn readlinkat_for_cxx(
     buf: *mut u8,
     bufsz: usize,
 ) -> isize {
+    unsafe {
         // readlinkat() may fail on x86 platform, returning random value
         // instead of number of bytes placed in buf (length of link)
         cfg_if! {
@@ -100,10 +107,12 @@ pub(crate) unsafe fn readlinkat_for_cxx(
             }
         }
         r
+    }
 }
 
-#[export_name = "cp_afc"]
+#[unsafe(export_name = "cp_afc")]
 unsafe extern "C" fn cp_afc_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
+    unsafe {
         if let Ok(src) = Utf8CStr::from_ptr(src) {
             if let Ok(dest) = Utf8CStr::from_ptr(dest) {
                 let src = FsPath::from(src);
@@ -117,10 +126,12 @@ unsafe extern "C" fn cp_afc_for_cxx(src: *const c_char, dest: *const c_char) ->
             }
         }
         false
+    }
 }
 
-#[export_name = "mv_path"]
+#[unsafe(export_name = "mv_path")]
 unsafe extern "C" fn mv_path_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
+    unsafe {
         if let Ok(src) = Utf8CStr::from_ptr(src) {
             if let Ok(dest) = Utf8CStr::from_ptr(dest) {
                 let src = FsPath::from(src);
@@ -134,10 +145,12 @@ unsafe extern "C" fn mv_path_for_cxx(src: *const c_char, dest: *const c_char) ->
             }
         }
         false
+    }
 }
 
-#[export_name = "link_path"]
+#[unsafe(export_name = "link_path")]
 unsafe extern "C" fn link_path_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
+    unsafe {
         if let Ok(src) = Utf8CStr::from_ptr(src) {
             if let Ok(dest) = Utf8CStr::from_ptr(dest) {
                 let src = FsPath::from(src);
@@ -151,10 +164,12 @@ unsafe extern "C" fn link_path_for_cxx(src: *const c_char, dest: *const c_char)
             }
         }
         false
+    }
 }
 
-#[export_name = "clone_attr"]
+#[unsafe(export_name = "clone_attr")]
 unsafe extern "C" fn clone_attr_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
+    unsafe {
         if let Ok(src) = Utf8CStr::from_ptr(src) {
             if let Ok(dest) = Utf8CStr::from_ptr(dest) {
                 let src = FsPath::from(src);
@@ -167,26 +182,29 @@ unsafe extern "C" fn clone_attr_for_cxx(src: *const c_char, dest: *const c_char)
             }
         }
         false
+    }
 }
 
-#[export_name = "fclone_attr"]
+#[unsafe(export_name = "fclone_attr")]
 unsafe extern "C" fn fclone_attr_for_cxx(a: RawFd, b: RawFd) -> bool {
     fclone_attr(a, b)
         .log_cxx_with_msg(|w| w.write_str("fclone_attr failed"))
         .is_ok()
 }
 
-#[export_name = "cxx$utf8str$new"]
+#[unsafe(export_name = "cxx$utf8str$new")]
 unsafe extern "C" fn str_new(this: &mut &Utf8CStr, s: *const u8, len: usize) {
+    unsafe {
         *this = Utf8CStr::from_bytes(slice_from_ptr(s, len)).unwrap_or(cstr!(""));
+    }
 }
 
-#[export_name = "cxx$utf8str$ptr"]
+#[unsafe(export_name = "cxx$utf8str$ptr")]
 unsafe extern "C" fn str_ptr(this: &&Utf8CStr) -> *const u8 {
     this.as_ptr().cast()
 }
 
-#[export_name = "cxx$utf8str$len"]
+#[unsafe(export_name = "cxx$utf8str$len")]
 unsafe extern "C" fn str_len(this: &&Utf8CStr) -> usize {
     this.len()
 }

native/src/base/files.rs

@@ -263,7 +263,7 @@ impl DirEntry<'_> {
     }
 
     unsafe fn open_fd(&self, flags: i32) -> io::Result<RawFd> {
-        self.dir.open_raw_fd(self.name(), flags, 0)
+        unsafe { self.dir.open_raw_fd(self.name(), flags, 0) }
     }
 
     pub fn open_as_dir(&self) -> io::Result<Directory> {
@@ -361,8 +361,10 @@ impl Directory {
     }
 
     unsafe fn open_raw_fd(&self, name: &CStr, flags: i32, mode: i32) -> io::Result<RawFd> {
+        unsafe {
             libc::openat(self.as_raw_fd(), name.as_ptr(), flags | O_CLOEXEC, mode).check_os_err()
         }
+    }
 
     pub fn open_fd(&self, name: &Utf8CStr, flags: i32, mode: i32) -> io::Result<OwnedFd> {
         unsafe {
@@ -929,7 +931,7 @@ impl Drop for MappedFile {
     }
 }
 
-extern "C" {
+unsafe extern "C" {
     // Don't use the declaration from the libc crate as request should be u32 not i32
     fn ioctl(fd: RawFd, request: u32, ...) -> i32;
 }

native/src/base/misc.rs

@@ -16,21 +16,25 @@ pub fn errno() -> &'static mut i32 {
 // When len is 0, don't care whether buf is null or not
 #[inline]
 pub unsafe fn slice_from_ptr<'a, T>(buf: *const T, len: usize) -> &'a [T] {
+    unsafe {
         if len == 0 {
             &[]
         } else {
             slice::from_raw_parts(buf, len)
         }
+    }
 }
 
 // When len is 0, don't care whether buf is null or not
 #[inline]
 pub unsafe fn slice_from_ptr_mut<'a, T>(buf: *mut T, len: usize) -> &'a mut [T] {
+    unsafe {
         if len == 0 {
             &mut []
         } else {
             slice::from_raw_parts_mut(buf, len)
         }
+    }
 }
 
 // Check libc return value and map to Result

native/src/base/xwrap.rs

@@ -50,19 +50,20 @@ mod c_export {
 
     use crate::{slice_from_ptr, slice_from_ptr_mut};
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     unsafe extern "C" fn xwrite(fd: RawFd, buf: *const u8, bufsz: usize) -> isize {
-        super::xwrite(fd, slice_from_ptr(buf, bufsz))
+        unsafe { super::xwrite(fd, slice_from_ptr(buf, bufsz)) }
     }
 
-    #[no_mangle]
+    #[unsafe(no_mangle)]
     unsafe extern "C" fn xxread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize {
-        super::xxread(fd, slice_from_ptr_mut(buf, bufsz))
+        unsafe { super::xxread(fd, slice_from_ptr_mut(buf, bufsz)) }
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => {
                 let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz);
@@ -73,10 +74,12 @@ unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize)
             }
             Err(_) => -1,
         }
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => {
                 let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz);
@@ -87,56 +90,67 @@ unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize)
             }
             Err(_) => -1,
         }
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xreadlinkat(
     dirfd: RawFd,
     path: *const c_char,
     buf: *mut u8,
     bufsz: usize,
 ) -> isize {
+    unsafe {
         let r = readlinkat_for_cxx(dirfd, path, buf, bufsz);
         if r < 0 {
             perror!("readlinkat {}", ptr_to_str(path))
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mut libc::FILE {
+    unsafe {
         let fp = libc::fopen(path, mode);
         if fp.is_null() {
             perror!("fopen {}", ptr_to_str(path));
         }
         fp
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::FILE {
+    unsafe {
         let fp = libc::fdopen(fd, mode);
         if fp.is_null() {
             perror!("fdopen");
         }
         fp
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
+    unsafe {
         let r = libc::open(path, flags, mode as c_uint);
         if r < 0 {
             perror!("open {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xopenat(dirfd: RawFd, path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
+    unsafe {
         let r = libc::openat(dirfd, path, flags, mode as c_uint);
         if r < 0 {
             perror!("openat {}", ptr_to_str(path));
         }
         r
+    }
 }
 
 // Fully write data slice
@@ -168,7 +182,7 @@ fn xwrite(fd: RawFd, data: &[u8]) -> isize {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xread(fd: RawFd, buf: *mut c_void, bufsz: usize) -> isize {
     unsafe {
         let r = libc::read(fd, buf, bufsz);
@@ -208,7 +222,7 @@ fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
     unsafe {
         let r = libc::lseek64(fd, offset, whence);
@@ -229,7 +243,7 @@ pub(crate) fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
     unsafe {
         let r = libc::setns(fd, nstype);
@@ -240,7 +254,7 @@ extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xunshare(flags: i32) -> i32 {
     unsafe {
         let r = libc::unshare(flags);
@@ -251,16 +265,18 @@ extern "C" fn xunshare(flags: i32) -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
+    unsafe {
         let dp = libc::opendir(path);
         if dp.is_null() {
             perror!("opendir {}", ptr_to_str(path));
         }
         dp
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
     unsafe {
         let dp = libc::fdopendir(fd);
@@ -271,8 +287,9 @@ extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
+    unsafe {
         *errno() = 0;
         loop {
             let e = libc::readdir(dirp);
@@ -289,9 +306,10 @@ unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
             };
             return e;
         }
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xsetsid() -> i32 {
     unsafe {
         let r = libc::setsid();
@@ -302,7 +320,7 @@ extern "C" fn xsetsid() -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
     unsafe {
         let fd = libc::socket(domain, ty, protocol);
@@ -313,16 +331,18 @@ extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: socklen_t) -> i32 {
+    unsafe {
         let r = libc::bind(socket, address, len);
         if r < 0 {
             perror!("bind");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
     unsafe {
         let r = libc::listen(socket, backlog);
@@ -333,49 +353,58 @@ extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xaccept4(
     sockfd: RawFd,
     addr: *mut sockaddr,
     len: *mut socklen_t,
     flg: i32,
 ) -> RawFd {
+    unsafe {
         let fd = libc::accept4(sockfd, addr, len, flg);
         if fd < 0 {
             perror!("accept4");
         }
         fd
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i32) -> ssize_t {
+    unsafe {
         let r = libc::sendmsg(fd, msg, flags);
         if r < 0 {
             perror!("sendmsg");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32) -> ssize_t {
+    unsafe {
         let r = libc::recvmsg(fd, msg, flags);
         if r < 0 {
             perror!("recvmsg");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
+    unsafe {
         let r = libc::access(path, mode);
         if r < 0 {
             perror!("access {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xfaccessat(dirfd: RawFd, path: *const c_char, mode: i32, flags: i32) -> i32 {
+    unsafe {
         #[allow(unused_mut)]
         let mut r = libc::faccessat(dirfd, path, mode, flags);
         if r < 0 {
@@ -386,50 +415,59 @@ unsafe extern "C" fn xfaccessat(dirfd: RawFd, path: *const c_char, mode: i32, fl
             r = 0
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
+    unsafe {
         let r = libc::stat(path, buf);
         if r < 0 {
             perror!("stat {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
+    unsafe {
         let r = libc::lstat(path, buf);
         if r < 0 {
             perror!("lstat {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
+    unsafe {
         let r = libc::fstat(fd, buf);
         if r < 0 {
             perror!("fstat");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xfstatat(
     dirfd: RawFd,
     path: *const c_char,
     buf: *mut libc::stat,
     flags: i32,
 ) -> i32 {
+    unsafe {
         let r = libc::fstatat(dirfd, path, buf, flags);
         if r < 0 {
             perror!("fstatat {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xdup(oldfd: RawFd) -> RawFd {
     unsafe {
         let fd = libc::dup(oldfd);
@@ -440,7 +478,7 @@ extern "C" fn xdup(oldfd: RawFd) -> RawFd {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
     unsafe {
         let fd = libc::dup2(oldfd, newfd);
@@ -451,7 +489,7 @@ extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
     unsafe {
         let fd = libc::syscall(SYS_dup3, oldfd, newfd, flags) as RawFd;
@@ -462,21 +500,24 @@ extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char) -> i32 {
+    unsafe {
         let r = libc::symlink(target, linkpath);
         if r < 0 {
             perror!("symlink {} -> {}", ptr_to_str(target), ptr_to_str(linkpath));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xsymlinkat(
     target: *const c_char,
     dirfd: RawFd,
     linkpath: *const c_char,
 ) -> i32 {
+    unsafe {
         let r = libc::symlinkat(target, dirfd, linkpath);
         if r < 0 {
             perror!(
@@ -486,9 +527,10 @@ unsafe extern "C" fn xsymlinkat(
             );
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xlinkat(
     olddirfd: RawFd,
     target: *const c_char,
@@ -496,14 +538,16 @@ unsafe extern "C" fn xlinkat(
     linkpath: *const c_char,
     flags: i32,
 ) -> i32 {
+    unsafe {
         let r = libc::linkat(olddirfd, target, newdirfd, linkpath, flags);
         if r < 0 {
             perror!("linkat {} -> {}", ptr_to_str(target), ptr_to_str(linkpath));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmount(
     src: *const c_char,
     target: *const c_char,
@@ -511,51 +555,62 @@ unsafe extern "C" fn xmount(
     flags: c_ulong,
     data: *const c_void,
 ) -> i32 {
+    unsafe {
         let r = libc::mount(src, target, fstype, flags, data);
         if r < 0 {
             perror!("mount {} -> {}", ptr_to_str(src), ptr_to_str(target));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
+    unsafe {
         let r = libc::umount(target);
         if r < 0 {
             perror!("umount {}", ptr_to_str(target));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
+    unsafe {
         let r = libc::umount2(target, flags);
         if r < 0 {
             perror!("umount2 {}", ptr_to_str(target));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char) -> i32 {
+    unsafe {
         let r = libc::rename(oldname, newname);
         if r < 0 {
             perror!("rename {} -> {}", ptr_to_str(oldname), ptr_to_str(newname));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
+    unsafe {
         let r = libc::mkdir(path, mode);
         if r < 0 && *errno() != libc::EEXIST {
             perror!("mkdir {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
+    unsafe {
         match Utf8CStr::from_ptr(path) {
             Ok(p) => FsPath::from(p)
                 .mkdirs(mode)
@@ -563,32 +618,37 @@ unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
                 .map_or(-1, |_| 0),
             Err(_) => -1,
         }
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_t) -> i32 {
+    unsafe {
         let r = libc::mkdirat(dirfd, path, mode);
         if r < 0 && *errno() != libc::EEXIST {
             perror!("mkdirat {}", ptr_to_str(path));
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xsendfile(
     out_fd: RawFd,
     in_fd: RawFd,
     offset: *mut off_t,
     count: usize,
 ) -> isize {
+    unsafe {
         let r = libc::sendfile(out_fd, in_fd, offset, count);
         if r < 0 {
             perror!("sendfile");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmmap(
     addr: *mut c_void,
     len: usize,
@@ -597,15 +657,17 @@ unsafe extern "C" fn xmmap(
     fd: RawFd,
     offset: off_t,
 ) -> *mut c_void {
+    unsafe {
         let r = libc::mmap(addr, len, prot, flags, fd, offset);
         if r == libc::MAP_FAILED {
             perror!("mmap");
             return ptr::null_mut();
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 extern "C" fn xfork() -> i32 {
     unsafe {
         let r = libc::fork();
@@ -616,20 +678,24 @@ extern "C" fn xfork() -> i32 {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xpoll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32 {
+    unsafe {
         let r = libc::poll(fds, nfds, timeout);
         if r < 0 {
             perror!("poll");
         }
         r
+    }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 {
+    unsafe {
         let r = libc::mknod(pathname, mode, dev);
         if r < 0 {
             perror!("mknod {}", ptr_to_str(pathname));
         }
         r
+    }
 }

native/src/boot/build.rs

@@ -1,9 +1,9 @@
 use pb_rs::{types::FileDescriptor, ConfigBuilder};
 
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
+#[path = "../include/codegen.rs"]
-mod gen;
+mod codegen;
 
 fn main() {
     println!("cargo:rerun-if-changed=proto/update_metadata.proto");

native/src/boot/dtb.rs

@@ -1,7 +1,10 @@
 use std::{cell::UnsafeCell, process::exit};
 
 use argh::FromArgs;
-use fdt::{node::{FdtNode, NodeProperty}, Fdt, FdtError};
+use fdt::{
+    node::{FdtNode, NodeProperty},
+    Fdt, FdtError,
+};
 
 use base::{
     libc::c_char, log_err, map_args, EarlyExitExt, LoggedResult, MappedFile, ResultExt, Utf8CStr,
@@ -172,7 +175,7 @@ fn for_each_fdt<F: FnMut(usize, Fdt) -> LoggedResult<()>>(
             Err(FdtError::BufferTooSmall) => {
                 eprintln!("dtb.{:04} is truncated", dtb_num);
                 break;
-            },
+            }
             Ok(fdt) => fdt,
             e => e?,
         };

native/src/boot/patch.rs

@@ -63,6 +63,7 @@ fn remove_pattern(buf: &mut [u8], pattern_matcher: unsafe fn(&[u8]) -> Option<us
 
 pub fn patch_verity(buf: &mut [u8]) -> usize {
     unsafe fn match_verity_pattern(buf: &[u8]) -> Option<usize> {
+        unsafe {
             match_patterns!(
                 buf,
                 b"verifyatboot",
@@ -73,13 +74,14 @@ pub fn patch_verity(buf: &mut [u8]) -> usize {
                 b"fsverity"
             )
         }
+    }
 
     remove_pattern(buf, match_verity_pattern)
 }
 
 pub fn patch_encryption(buf: &mut [u8]) -> usize {
     unsafe fn match_encryption_pattern(buf: &[u8]) -> Option<usize> {
-        match_patterns!(buf, b"forceencrypt", b"forcefdeorfbe", b"fileencryption")
+        unsafe { match_patterns!(buf, b"forceencrypt", b"forcefdeorfbe", b"fileencryption") }
     }
 
     remove_pattern(buf, match_encryption_pattern)

native/src/boot/sign.rs

@@ -157,20 +157,32 @@ struct Signer {
 impl Signer {
     fn from_private_key(key: &[u8]) -> LoggedResult<Signer> {
         let digest: Box<dyn DynDigest>;
-        let key = if let Ok(rsa) = RsaPrivateKey::from_pkcs8_der(key) {
+        let key = match RsaPrivateKey::from_pkcs8_der(key) {
+            Ok(rsa) => {
                 digest = Box::<Sha256>::default();
                 SigningKey::SHA256withRSA(RsaSigningKey::<Sha256>::new(rsa))
-        } else if let Ok(ec) = P256SigningKey::from_pkcs8_der(key) {
+            }
+            _ => match P256SigningKey::from_pkcs8_der(key) {
+                Ok(ec) => {
                     digest = Box::<Sha256>::default();
                     SigningKey::SHA256withECDSA(ec)
-        } else if let Ok(ec) = P384SigningKey::from_pkcs8_der(key) {
+                }
+                _ => match P384SigningKey::from_pkcs8_der(key) {
+                    Ok(ec) => {
                         digest = Box::<Sha384>::default();
                         SigningKey::SHA384withECDSA(ec)
-        } else if let Ok(ec) = P521SigningKey::from_pkcs8_der(key) {
+                    }
+                    _ => match P521SigningKey::from_pkcs8_der(key) {
+                        Ok(ec) => {
                             digest = Box::<Sha512>::default();
                             SigningKey::SHA521withECDSA(ec)
-        } else {
+                        }
+                        _ => {
                             return Err(log_err!("Unsupported private key"));
+                        }
+                    },
+                },
+            },
         };
         Ok(Signer { digest, key })
     }

native/src/core/build.rs

@@ -1,9 +1,9 @@
 use pb_rs::{types::FileDescriptor, ConfigBuilder};
 
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
+#[path = "../include/codegen.rs"]
-mod gen;
+mod codegen;
 
 fn main() {
     println!("cargo:rerun-if-changed=resetprop/proto/persistent_properties.proto");

native/src/core/db.rs

@@ -138,7 +138,7 @@ unsafe impl Send for Sqlite3 {}
 type SqlBindCallback = Option<unsafe extern "C" fn(*mut c_void, i32, Pin<&mut DbStatement>) -> i32>;
 type SqlExecCallback = Option<unsafe extern "C" fn(*mut c_void, &[String], &DbValues)>;
 
-extern "C" {
+unsafe extern "C" {
     fn sql_exec_impl(
         db: *mut sqlite3,
         sql: &str,
@@ -160,6 +160,7 @@ struct DbArgs<'a> {
 }
 
 unsafe extern "C" fn bind_arguments(v: *mut c_void, idx: i32, stmt: Pin<&mut DbStatement>) -> i32 {
+    unsafe {
         let args = &mut *(v as *mut DbArgs<'_>);
         if args.curr < args.args.len() {
             let arg = &args.args[args.curr];
@@ -171,6 +172,7 @@ unsafe extern "C" fn bind_arguments(v: *mut c_void, idx: i32, stmt: Pin<&mut DbS
         } else {
             0
         }
+    }
 }
 
 unsafe extern "C" fn read_db_row<T: SqlTable>(
@@ -178,8 +180,10 @@ unsafe extern "C" fn read_db_row<T: SqlTable>(
     columns: &[String],
     values: &DbValues,
 ) {
+    unsafe {
         let table = &mut *(v as *mut T);
         table.on_row(columns, values);
+    }
 }
 
 impl MagiskD {
@@ -189,10 +193,9 @@ impl MagiskD {
             let raw_db = open_and_init_db();
             *db = NonNull::new(raw_db).map(Sqlite3);
         }
-        if let Some(ref mut db) = *db {
+        match *db {
-            f(db.0.as_ptr())
+            Some(ref mut db) => f(db.0.as_ptr()),
-        } else {
+            _ => -1,
-            -1
         }
     }
 
@@ -333,7 +336,7 @@ impl MagiskD {
     }
 }
 
-#[export_name = "sql_exec_rs"]
+#[unsafe(export_name = "sql_exec_rs")]
 unsafe extern "C" fn sql_exec_for_cxx(
     sql: &str,
     bind_callback: SqlBindCallback,
@@ -341,6 +344,7 @@ unsafe extern "C" fn sql_exec_for_cxx(
     exec_callback: SqlExecCallback,
     exec_cookie: *mut c_void,
 ) -> i32 {
+    unsafe {
         MAGISKD.get().unwrap_unchecked().with_db(|db| {
             sql_exec_impl(
                 db,
@@ -351,4 +355,5 @@ unsafe extern "C" fn sql_exec_for_cxx(
                 exec_cookie,
             )
         })
+    }
 }

native/src/core/lib.rs

@@ -257,9 +257,11 @@ unsafe impl ExternType for UCred {
 
 impl SuRequest {
     unsafe fn write_to_fd(&self, fd: i32) {
+        unsafe {
             let mut w = ManuallyDrop::new(File::from_raw_fd(fd));
             self.encode(w.deref_mut()).ok();
         }
+    }
 }
 
 pub fn get_prop(name: &Utf8CStr, persist: bool) -> String {

native/src/core/logging.rs

@@ -42,7 +42,7 @@ enum ALogPriority {
 
 type ThreadEntry = extern "C" fn(*mut c_void) -> *mut c_void;
 
-extern "C" {
+unsafe extern "C" {
     fn __android_log_write(prio: i32, tag: *const c_char, msg: *const c_char);
     fn strftime(buf: *mut c_char, len: usize, fmt: *const c_char, tm: *const tm) -> usize;
     fn new_daemon_thread(entry: ThreadEntry, arg: *mut c_void);

native/src/core/package.rs

@@ -485,6 +485,7 @@ impl MagiskD {
     }
 
     pub unsafe fn get_manager_for_cxx(&self, user: i32, ptr: *mut CxxString, install: bool) -> i32 {
+        unsafe {
             let mut info = self.manager_info.lock().unwrap();
             let (uid, pkg) = info.get_manager(self, user, install);
             if let Some(str) = ptr.as_mut() {
@@ -494,6 +495,7 @@ impl MagiskD {
             }
             uid
         }
+    }
 
     // app_id = app_no + AID_APP_START
     // app_no range: [0, 9999]

native/src/core/resetprop/persist.rs

@@ -130,8 +130,8 @@ pub fn persist_get_prop(name: &Utf8CStr, mut prop_cb: Pin<&mut PropCb>) {
             let mut props = proto_read_props()?;
             let prop = props.find(name)?;
             if let PersistentPropertyRecord {
-                name: Some(ref mut n),
+                name: Some(n),
-                value: Some(ref mut v),
+                value: Some(v),
             } = prop
             {
                 prop_cb.exec(Utf8CStr::from_string(n), Utf8CStr::from_string(v));
@@ -151,8 +151,8 @@ pub fn persist_get_props(mut prop_cb: Pin<&mut PropCb>) {
             let mut props = proto_read_props()?;
             props.iter_mut().for_each(|prop| {
                 if let PersistentPropertyRecord {
-                    name: Some(ref mut n),
+                    name: Some(n),
-                    value: Some(ref mut v),
+                    value: Some(v),
                 } = prop
                 {
                     prop_cb.exec(Utf8CStr::from_string(n), Utf8CStr::from_string(v));

native/src/include/codegen.rs

@@ -39,7 +39,7 @@ fn write_if_diff<P: AsRef<Path>>(path: P, bytes: &[u8]) -> io::Result<()> {
 pub fn gen_cxx_binding(name: &str) {
     println!("cargo:rerun-if-changed=lib.rs");
     let opt = Opt::default();
-    let gen = cxx_gen::generate_header_and_cc_with_path("lib.rs", &opt);
+    let code = cxx_gen::generate_header_and_cc_with_path("lib.rs", &opt);
-    write_if_diff(format!("{}.cpp", name), gen.implementation.as_slice()).ok_or_exit();
+    write_if_diff(format!("{}.cpp", name), code.implementation.as_slice()).ok_or_exit();
-    write_if_diff(format!("{}.hpp", name), gen.header.as_slice()).ok_or_exit();
+    write_if_diff(format!("{}.hpp", name), code.header.as_slice()).ok_or_exit();
 }

native/src/init/build.rs

@@ -1,7 +1,7 @@
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
+#[path = "../include/codegen.rs"]
-mod gen;
+mod codegen;
 
 fn main() {
     gen_cxx_binding("init-rs");

native/src/init/init.rs

@@ -132,12 +132,13 @@ impl MagiskInit {
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn main(
     argc: i32,
     argv: *mut *mut c_char,
     _envp: *const *const c_char,
 ) -> i32 {
+    unsafe {
         umask(0);
 
         let name = basename(*argv);
@@ -151,4 +152,5 @@ pub unsafe extern "C" fn main(
         }
 
         1
+    }
 }

native/src/init/mount.rs

@@ -13,7 +13,7 @@ use std::{
     ptr::null as nullptr,
 };
 
-extern "C" {
+unsafe extern "C" {
     static environ: *const *mut libc::c_char;
 }
 

native/src/init/twostage.rs

@@ -75,7 +75,8 @@ impl MagiskInit {
             self.restore_ramdisk_init();
 
             // fallback to hexpatch if /sdcard exists
-            if let Ok(mut map) = MappedFile::open_rw(cstr!("/init")) {
+            match MappedFile::open_rw(cstr!("/init")) {
+                Ok(mut map) => {
                     let from = "/system/bin/init";
                     let to = "/data/magiskinit";
 
@@ -85,17 +86,20 @@ impl MagiskInit {
                     for off in &v {
                         debug!("Patch @ {:#010X} [{}] -> [{}]", off, from, to);
                     }
-            } else {
+                }
+                _ => {
                     error!("Failed to open /init for hexpatch");
                 }
             }
         }
+    }
 
     pub(crate) fn redirect_second_stage(&self) {
         let src = path!("/init");
         let dest = path!("/data/init");
         // Patch init binary
-        if let Ok(mut map) = MappedFile::open(src) {
+        match MappedFile::open(src) {
+            Ok(mut map) => {
                 let from = "/system/bin/init";
                 let to = "/data/magiskinit";
 
@@ -105,14 +109,19 @@ impl MagiskInit {
                 for off in &v {
                     debug!("Patch @ {:#010X} [{}] -> [{}]", off, from, to);
                 }
-            if let Ok(mut dest) = dest.create(O_CREAT | O_WRONLY, 0) {
+                match dest.create(O_CREAT | O_WRONLY, 0) {
+                    Ok(mut dest) => {
                         dest.write_all(map.as_ref()).log_ok();
-            } else {
+                    }
+                    _ => {
                         error!("Failed to create {}", dest);
                     }
-        } else {
+                }
+            }
+            _ => {
                 error!("Failed to open {} for hexpatch", src);
             }
+        }
         clone_attr(src, dest).log_ok();
         unsafe {
             mount(dest.as_ptr(), src.as_ptr(), null(), MS_BIND, null())

native/src/sepolicy/build.rs

@@ -1,7 +1,7 @@
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
+#[path = "../include/codegen.rs"]
-mod gen;
+mod codegen;
 
 fn main() {
     gen_cxx_binding("policy-rs");