Support init_module etc. in the libc backend. (#1018)

And, fix the return types of `init_module` and friends to be
`io::Result<()>`, as they can succeed and return.

Author: sunfishcode

.github/workflows/main.yml

@@ -437,7 +437,7 @@ jobs:
         rustup target add ${{ matrix.target }}
       if: matrix.target != ''
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: ${{ runner.tool_cache }}/qemu
         key: qemu-${{ matrix.target }}-${{ env.QEMU_BUILD_VERSION }}-patched
@@ -573,7 +573,7 @@ jobs:
         rustup target add ${{ matrix.target }}
       if: matrix.target != ''
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: ${{ runner.tool_cache }}/qemu
         key: qemu-${{ matrix.target }}-${{ env.QEMU_BUILD_VERSION }}-patched
@@ -665,7 +665,7 @@ jobs:
         rustup target add ${{ matrix.target }}
       if: matrix.target != ''
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: ${{ runner.tool_cache }}/qemu
         key: qemu-${{ matrix.target }}-${{ env.QEMU_BUILD_VERSION }}-patched

src/backend/libc/system/syscalls.rs

@@ -6,9 +6,11 @@ use crate::backend::c;
 use crate::backend::conv::ret_infallible;
 #[cfg(target_os = "linux")]
 use crate::system::RebootCommand;
-#[cfg(linux_kernel)]
-use crate::system::Sysinfo;
 use core::mem::MaybeUninit;
+#[cfg(linux_kernel)]
+use {
+    crate::backend::conv::c_str, crate::fd::BorrowedFd, crate::ffi::CStr, crate::system::Sysinfo,
+};
 #[cfg(not(any(
     target_os = "emscripten",
     target_os = "espidf",
@@ -65,3 +67,55 @@ pub(crate) fn sethostname(name: &[u8]) -> io::Result<()> {
 pub(crate) fn reboot(cmd: RebootCommand) -> io::Result<()> {
     unsafe { ret(c::reboot(cmd as i32)) }
 }
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn init_module(image: &[u8], param_values: &CStr) -> io::Result<()> {
+    syscall! {
+        fn init_module(
+            module_image: *const c::c_void,
+            len: c::c_ulong,
+            param_values: *const c::c_char
+        ) via SYS_init_module -> c::c_int
+    }
+
+    unsafe {
+        ret(init_module(
+            image.as_ptr().cast(),
+            image.len() as _,
+            c_str(param_values),
+        ))
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn finit_module(
+    fd: BorrowedFd<'_>,
+    param_values: &CStr,
+    flags: c::c_int,
+) -> io::Result<()> {
+    use crate::fd::AsRawFd;
+
+    syscall! {
+        fn finit_module(
+            fd: c::c_int,
+            param_values: *const c::c_char,
+            flags: c::c_int
+        ) via SYS_finit_module -> c::c_int
+    }
+
+    unsafe { ret(finit_module(fd.as_raw_fd(), c_str(param_values), flags)) }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn delete_module(name: &CStr, flags: c::c_int) -> io::Result<()> {
+    syscall! {
+        fn delete_module(
+            name: *const c::c_char,
+            flags: c::c_int
+        ) via SYS_delete_module -> c::c_int
+    }
+    unsafe { ret(delete_module(c_str(name), flags)) }
+}

src/backend/linux_raw/conv.rs

@@ -15,7 +15,7 @@
 
 use super::c;
 use super::fd::{AsRawFd, BorrowedFd, FromRawFd, RawFd};
-#[cfg(any(feature = "event", feature = "runtime"))]
+#[cfg(any(feature = "event", feature = "runtime", feature = "system"))]
 use super::io::errno::try_decode_error;
 #[cfg(target_pointer_width = "64")]
 use super::io::errno::try_decode_u64;
@@ -874,7 +874,7 @@ pub(super) unsafe fn ret(raw: RetReg<R0>) -> io::Result<()> {
 ///
 /// The caller must ensure that this is the return value of a syscall which
 /// doesn't return on success.
-#[cfg(any(feature = "event", feature = "runtime"))]
+#[cfg(any(feature = "event", feature = "runtime", feature = "system"))]
 #[inline]
 pub(super) unsafe fn ret_error(raw: RetReg<R0>) -> io::Errno {
     try_decode_error(raw)

src/backend/linux_raw/io/errno.rs

@@ -236,7 +236,7 @@ pub(in crate::backend) unsafe fn try_decode_void<Num: RetNumber>(
 /// # Safety
 ///
 /// This must only be used with syscalls which do not return on success.
-#[cfg(any(feature = "event", feature = "runtime"))]
+#[cfg(any(feature = "event", feature = "runtime", feature = "system"))]
 #[inline]
 pub(in crate::backend) unsafe fn try_decode_error<Num: RetNumber>(raw: RetReg<Num>) -> io::Errno {
     debug_assert!(raw.is_in_range(-4095..0));

src/backend/linux_raw/net/mod.rs

@@ -1,6 +1,5 @@
 pub(crate) mod addr;
 pub(crate) mod msghdr;
-#[cfg(linux_kernel)]
 pub(crate) mod netdevice;
 pub(crate) mod read_sockaddr;
 pub(crate) mod send_recv;

src/backend/linux_raw/system/syscalls.rs

@@ -7,8 +7,8 @@
 
 use super::types::RawUname;
 use crate::backend::c;
-use crate::backend::conv::{c_int, ret, ret_error, ret_infallible, slice};
-#[cfg(feature = "fs")]
+use crate::backend::conv::{c_int, ret, ret_infallible, slice};
+#[cfg(any(target_os = "linux", target_os = "android"))]
 use crate::fd::BorrowedFd;
 use crate::ffi::CStr;
 use crate::io;
@@ -51,12 +51,11 @@ pub(crate) fn reboot(cmd: RebootCommand) -> io::Result<()> {
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
 #[inline]
-pub(crate) fn init_module(image: &[u8], param_values: &CStr) -> io::Errno {
+pub(crate) fn init_module(image: &[u8], param_values: &CStr) -> io::Result<()> {
     let (image, len) = slice(image);
     unsafe {
-        ret_error(syscall_readonly!(
+        ret(syscall_readonly!(
             __NR_init_module,
             image,
             len,
@@ -65,12 +64,14 @@ pub(crate) fn init_module(image: &[u8], param_values: &CStr) -> io::Errno {
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-#[cfg(feature = "fs")]
 #[inline]
-pub(crate) fn finit_module(fd: BorrowedFd<'_>, param_values: &CStr, flags: c::c_int) -> io::Errno {
+pub(crate) fn finit_module(
+    fd: BorrowedFd<'_>,
+    param_values: &CStr,
+    flags: c::c_int,
+) -> io::Result<()> {
     unsafe {
-        ret_error(syscall_readonly!(
+        ret(syscall_readonly!(
             __NR_finit_module,
             fd,
             param_values,
@@ -79,9 +80,7 @@ pub(crate) fn finit_module(fd: BorrowedFd<'_>, param_values: &CStr, flags: c::c_
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-#[cfg(feature = "fs")]
 #[inline]
-pub(crate) fn delete_module(name: &CStr, flags: c::c_int) -> io::Errno {
-    unsafe { ret_error(syscall_readonly!(__NR_delete_module, name, c_int(flags))) }
+pub(crate) fn delete_module(name: &CStr, flags: c::c_int) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_delete_module, name, c_int(flags))) }
 }

src/system.rs

@@ -7,7 +7,7 @@
 #![allow(unsafe_code)]
 
 use crate::backend;
-#[cfg(any(linux_raw, target_os = "linux"))]
+#[cfg(linux_kernel)]
 use crate::backend::c;
 use crate::ffi::CStr;
 #[cfg(not(any(target_os = "espidf", target_os = "emscripten", target_os = "vita")))]
@@ -17,9 +17,9 @@ use core::fmt;
 #[cfg(linux_kernel)]
 pub use backend::system::types::Sysinfo;
 
-#[cfg(linux_raw)]
+#[cfg(linux_kernel)]
 use crate::fd::AsFd;
-#[cfg(linux_raw)]
+#[cfg(linux_kernel)]
 use c::c_int;
 
 /// `uname()`—Returns high-level information about the runtime OS and
@@ -231,8 +231,8 @@ pub fn reboot(cmd: RebootCommand) -> io::Result<()> {
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man2/init_module.2.html
 #[inline]
-#[cfg(linux_raw)]
-pub fn init_module(image: &[u8], param_values: &CStr) -> io::Errno {
+#[cfg(linux_kernel)]
+pub fn init_module(image: &[u8], param_values: &CStr) -> io::Result<()> {
     backend::system::syscalls::init_module(image, param_values)
 }
 
@@ -243,9 +243,8 @@ pub fn init_module(image: &[u8], param_values: &CStr) -> io::Errno {
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man2/finit_module.2.html
 #[inline]
-#[cfg(linux_raw)]
-#[cfg(feature = "fs")]
-pub fn finit_module<Fd: AsFd>(fd: Fd, param_values: &CStr, flags: c_int) -> io::Errno {
+#[cfg(linux_kernel)]
+pub fn finit_module<Fd: AsFd>(fd: Fd, param_values: &CStr, flags: c_int) -> io::Result<()> {
     backend::system::syscalls::finit_module(fd.as_fd(), param_values, flags)
 }
 
@@ -256,7 +255,7 @@ pub fn finit_module<Fd: AsFd>(fd: Fd, param_values: &CStr, flags: c_int) -> io::
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man2/delete_module.2.html
 #[inline]
-#[cfg(linux_raw)]
-pub fn delete_module(name: &CStr, flags: c_int) -> io::Errno {
+#[cfg(linux_kernel)]
+pub fn delete_module(name: &CStr, flags: c_int) -> io::Result<()> {
     backend::system::syscalls::delete_module(name, flags)
 }