feat: use ioctl::Ioctl for getflags and setflags

src/backend/libc/io/syscalls.rs

@@ -4,8 +4,6 @@ use crate::backend::c;
 #[cfg(not(target_os = "wasi"))]
 use crate::backend::conv::ret_discarded_fd;
 use crate::backend::conv::{borrowed_fd, ret, ret_c_int, ret_owned_fd, ret_usize};
-#[cfg(linux_kernel)]
-use crate::backend::io::types::IFlags;
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
 #[cfg(not(any(
     target_os = "aix",
@@ -219,33 +217,6 @@ pub(crate) unsafe fn ioctl_readonly(
     ioctl(fd, request, arg)
 }
 
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn ioctl_get_flags(fd: BorrowedFd<'_>) -> io::Result<IFlags> {
-    let mut result = core::mem::MaybeUninit::<IFlags>::uninit();
-
-    #[cfg(target_pointer_width = "32")]
-    let get_flags = c::FS_IOC32_GETFLAGS;
-    #[cfg(target_pointer_width = "64")]
-    let get_flags = c::FS_IOC_GETFLAGS;
-
-    unsafe {
-        ret(c::ioctl(borrowed_fd(fd), get_flags, result.as_mut_ptr()))?;
-        Ok(result.assume_init() as IFlags)
-    }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn ioctl_set_flags(fd: BorrowedFd<'_>, flags: IFlags) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    let set_flags = c::FS_IOC32_SETFLAGS;
-    #[cfg(target_pointer_width = "64")]
-    let set_flags = c::FS_IOC_SETFLAGS;
-
-    unsafe { ret(c::ioctl(borrowed_fd(fd), set_flags, flags.bits())) }
-}
-
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
 #[cfg(all(feature = "fs", feature = "net"))]
 pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {

src/backend/linux_raw/c.rs

@@ -42,6 +42,10 @@ pub(crate) use linux_raw_sys::general::{
 };
 
 pub(crate) use linux_raw_sys::ioctl::{BLKPBSZGET, BLKSSZGET, FICLONE};
+#[cfg(target_pointer_width = "32")]
+pub(crate) use linux_raw_sys::ioctl::{FS_IOC32_GETFLAGS, FS_IOC32_SETFLAGS};
+#[cfg(target_pointer_width = "64")]
+pub(crate) use linux_raw_sys::ioctl::{FS_IOC_GETFLAGS, FS_IOC_SETFLAGS};
 
 #[cfg(feature = "io_uring")]
 pub(crate) use linux_raw_sys::{general::open_how, io_uring::*};

src/backend/linux_raw/io/syscalls.rs

@@ -14,13 +14,11 @@ use crate::backend::conv::loff_t_from_u64;
 ))]
 use crate::backend::conv::zero;
 use crate::backend::conv::{
-    by_ref, c_uint, pass_usize, raw_fd, ret, ret_c_int, ret_c_uint, ret_discarded_fd, ret_owned_fd,
+    c_uint, pass_usize, raw_fd, ret, ret_c_int, ret_c_uint, ret_discarded_fd, ret_owned_fd,
     ret_usize, slice,
 };
 #[cfg(target_pointer_width = "32")]
 use crate::backend::conv::{hi, lo};
-#[cfg(linux_kernel)]
-use crate::backend::io::types::IFlags;
 use crate::backend::{c, MAX_IOV};
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
 use crate::io::{self, DupFlags, FdFlags, IoSlice, IoSliceMut, ReadWriteFlags};
@@ -29,10 +27,6 @@ use crate::ioctl::{IoctlOutput, RawOpcode};
 use crate::net::{RecvFlags, SendFlags};
 use core::cmp;
 use linux_raw_sys::general::{F_DUPFD_CLOEXEC, F_GETFD, F_SETFD};
-#[cfg(target_pointer_width = "32")]
-use linux_raw_sys::ioctl::{FS_IOC32_GETFLAGS, FS_IOC32_SETFLAGS};
-#[cfg(target_pointer_width = "64")]
-use linux_raw_sys::ioctl::{FS_IOC_GETFLAGS, FS_IOC_SETFLAGS};
 
 #[inline]
 pub(crate) unsafe fn read(fd: BorrowedFd<'_>, buf: *mut u8, len: usize) -> io::Result<usize> {
@@ -265,34 +259,6 @@ pub(crate) unsafe fn ioctl_readonly(
     ret_c_int(syscall_readonly!(__NR_ioctl, fd, c_uint(request), arg))
 }
 
-#[inline]
-pub(crate) fn ioctl_get_flags(fd: BorrowedFd<'_>) -> io::Result<IFlags> {
-    let mut result = core::mem::MaybeUninit::<IFlags>::uninit();
-
-    #[cfg(target_pointer_width = "32")]
-    let get_flags = c_uint(FS_IOC32_GETFLAGS);
-    #[cfg(target_pointer_width = "64")]
-    let get_flags = c_uint(FS_IOC_GETFLAGS);
-
-    unsafe {
-        ret(syscall!(__NR_ioctl, fd, get_flags, &mut result))?;
-        Ok(result.assume_init() as IFlags)
-    }
-}
-
-#[inline]
-pub(crate) fn ioctl_set_flags(fd: BorrowedFd<'_>, flags: IFlags) -> io::Result<()> {
-    // ioctl expect a *const c_uint, we thus need to convert it and pass it by reference
-    let attr = flags.bits();
-
-    #[cfg(target_pointer_width = "32")]
-    let set_flags = c_uint(FS_IOC32_SETFLAGS);
-    #[cfg(target_pointer_width = "64")]
-    let set_flags = c_uint(FS_IOC_SETFLAGS);
-
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, set_flags, by_ref(&attr))) }
-}
-
 #[cfg(all(feature = "fs", feature = "net"))]
 pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
     let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?;

src/fs/ioctl.rs

@@ -6,7 +6,7 @@
 use {
     crate::fd::AsFd,
     crate::{backend, io, ioctl},
-    backend::c,
+    backend::{c, io::types::IFlags},
 };
 
 #[cfg(all(linux_kernel, not(any(target_arch = "sparc", target_arch = "sparc64"))))]
@@ -90,3 +90,39 @@ unsafe impl ioctl::Ioctl for Ficlone<'_> {
         Ok(())
     }
 }
+
+/// `ioctl(fd, FS_IOC_GETFLAGS)`—Returns the [inode flags] attributes
+///
+/// [inode flags]: https://man7.org/linux/man-pages/man2/ioctl_iflags.2.html
+#[cfg(linux_kernel)]
+#[inline]
+#[doc(alias = "FS_IOC_GETFLAGS")]
+pub fn ioctl_getflags<Fd: AsFd>(fd: Fd) -> io::Result<IFlags> {
+    unsafe {
+        #[cfg(target_pointer_width = "32")]
+        let ctl = ioctl::Getter::<ioctl::BadOpcode<{ c::FS_IOC32_GETFLAGS }>, u32>::new();
+        #[cfg(target_pointer_width = "64")]
+        let ctl = ioctl::Getter::<ioctl::BadOpcode<{ c::FS_IOC_GETFLAGS }>, u32>::new();
+
+        ioctl::ioctl(fd, ctl).map(IFlags::from_bits_retain)
+    }
+}
+
+/// `ioctl(fd, FS_IOC_SETFLAGS)`—Modify the [inode flags] attributes
+///
+/// [inode flags]: https://man7.org/linux/man-pages/man2/ioctl_iflags.2.html
+#[cfg(linux_kernel)]
+#[inline]
+#[doc(alias = "FS_IOC_GETFLAGS")]
+pub fn ioctl_setflags<Fd: AsFd>(fd: Fd, flags: IFlags) -> io::Result<()> {
+    unsafe {
+        #[cfg(target_pointer_width = "32")]
+        let ctl =
+            ioctl::Setter::<ioctl::BadOpcode<{ c::FS_IOC32_SETFLAGS }>, u32>::new(flags.bits());
+
+        #[cfg(target_pointer_width = "64")]
+        let ctl = ioctl::Setter::<ioctl::BadOpcode<{ c::FS_IOC_SETFLAGS }>, u32>::new(flags.bits());
+
+        ioctl::ioctl(fd, ctl)
+    }
+}

src/io/ioctl.rs

@@ -12,9 +12,6 @@ use crate::{backend, io, ioctl};
 use backend::c;
 use backend::fd::AsFd;
 
-#[cfg(linux_kernel)]
-pub use backend::io::types::IFlags;
-
 /// `ioctl(fd, FIOCLEX, NULL)`—Set the close-on-exec flag.
 ///
 /// This is similar to `fcntl(fd, F_SETFD, FD_CLOEXEC)`, except that it avoids
@@ -78,23 +75,3 @@ pub fn ioctl_fionread<Fd: AsFd>(fd: Fd) -> io::Result<u64> {
         ioctl::ioctl(fd, ctl).map(|n| n as u64)
     }
 }
-
-/// `ioctl(fd, FS_IOC_GETFLAGS)`—Returns the [inode flags] attributes
-///
-/// [inode flags]: https://man7.org/linux/man-pages/man2/ioctl_iflags.2.html
-#[cfg(linux_kernel)]
-#[inline]
-#[doc(alias = "FS_IOC_GETFLAGS")]
-pub fn ioctl_getflags<Fd: AsFd>(fd: Fd) -> io::Result<IFlags> {
-    backend::io::syscalls::ioctl_get_flags(fd.as_fd())
-}
-
-/// `ioctl(fd, FS_IOC_SETFLAGS)`—Modify the [inode flags] attributes
-///
-/// [inode flags]: https://man7.org/linux/man-pages/man2/ioctl_iflags.2.html
-#[cfg(linux_kernel)]
-#[inline]
-#[doc(alias = "FS_IOC_GETFLAGS")]
-pub fn ioctl_setflags<Fd: AsFd>(fd: Fd, flags: IFlags) -> io::Result<()> {
-    backend::io::syscalls::ioctl_set_flags(fd.as_fd(), flags)
-}