linux_raw: mount: Add support for mount_attr()

Author: livingsilver94

src/backend/linux_raw/conv.rs

@@ -483,6 +483,14 @@ impl<'a, Num: ArgNumber> From<crate::backend::mount::types::MountAttrFlags> for
     }
 }
 
+#[cfg(feature = "mount")]
+impl<'a, Num: ArgNumber> From<crate::backend::mount::types::MountSetAttrFlags> for ArgReg<'a, Num> {
+    #[inline]
+    fn from(flags: crate::backend::mount::types::MountSetAttrFlags) -> Self {
+        c_uint(flags.bits())
+    }
+}
+
 #[cfg(feature = "mount")]
 impl<'a, Num: ArgNumber> From<crate::backend::mount::types::OpenTreeFlags> for ArgReg<'a, Num> {
     #[inline]

src/backend/linux_raw/mount/syscalls.rs

@@ -6,7 +6,7 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use crate::backend::conv::{ret, ret_owned_fd, slice, zero};
+use crate::backend::conv::{pass_usize, ret, ret_owned_fd, slice, zero};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::ffi::CStr;
 use crate::io;
@@ -235,3 +235,22 @@ pub(crate) fn fsconfig_create_excl(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
         ))
     }
 }
+
+#[inline]
+pub(crate) fn mount_setattr(
+    fs_fd: BorrowedFd<'_>,
+    path: &CStr,
+    flags: super::types::MountSetAttrFlags,
+    attr: &super::types::MountAttr<'_>,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_mount_setattr,
+            fs_fd,
+            path,
+            flags,
+            &attr.raw as *const linux_raw_sys::general::mount_attr,
+            pass_usize(core::mem::size_of_val(&attr.raw))
+        ))
+    }
+}

src/backend/linux_raw/mount/types.rs

@@ -1,6 +1,12 @@
-use crate::ffi;
+use core::marker::PhantomData;
+
 use bitflags::bitflags;
 
+use crate::{
+    fd::{AsRawFd, BorrowedFd},
+    ffi,
+};
+
 bitflags! {
     /// `MS_*` constants for use with [`mount`].
     ///
@@ -280,6 +286,105 @@ bitflags! {
     }
 }
 
+bitflags! {
+    /// `AT_*` flags accepted by [`mount_setattr`].
+    ///
+    /// [`mount_setattr`]: crate::mount::mount_setattr
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MountSetAttrFlags: ffi::c_uint {
+        /// `AT_EMPTY_PATH`
+        const AT_EMPTY_PATH = linux_raw_sys::general::AT_EMPTY_PATH;
+
+        /// `AT_RECURSIVE`
+        const AT_RECURSIVE = linux_raw_sys::general::AT_RECURSIVE;
+
+        /// `AT_SYMLINK_NOFOLLOW`
+        const AT_SYMLINK_NOFOLLOW = linux_raw_sys::general::AT_SYMLINK_NOFOLLOW;
+
+        /// `AT_NO_AUTOMOUNT`
+        const AT_NO_AUTOMOUNT = linux_raw_sys::general::AT_NO_AUTOMOUNT;
+    }
+}
+
+/// `MOUNT_ATTR_*` flags that also carry a parameter.
+#[cfg(linux_kernel)]
+pub enum MountAttrParamFlags<'a> {
+    /// `MOUNT_ATTR_IDMAP`, which carries the descriptor of a user namespace.
+    IdMap(BorrowedFd<'a>),
+}
+
+#[cfg(linux_kernel)]
+impl<'a> MountAttrParamFlags<'a> {
+    fn apply(self, attr: MountAttr<'a>, operation: MountAttrOperation) -> MountAttr<'a> {
+        let mut raw = attr.raw;
+        let flags = match operation {
+            MountAttrOperation::Set => &mut raw.attr_set,
+            MountAttrOperation::Clear => &mut raw.attr_clr,
+        };
+
+        match self {
+            Self::IdMap(userns_fd) => {
+                *flags |= MountAttrFlags::from_bits_retain(
+                    linux_raw_sys::general::MOUNT_ATTR_IDMAP as u32,
+                )
+                .bits() as u64;
+                raw.userns_fd = userns_fd.as_raw_fd() as u64;
+            }
+        }
+
+        MountAttr {
+            raw,
+            userns_fd: PhantomData::<BorrowedFd<'a>>,
+        }
+    }
+}
+
+/// `struct mount_attr`
+#[cfg(linux_kernel)]
+#[derive(Clone)]
+#[doc(alias = "mount_attr")]
+pub struct MountAttr<'a> {
+    pub(crate) raw: linux_raw_sys::general::mount_attr,
+    userns_fd: PhantomData<BorrowedFd<'a>>,
+}
+
+#[cfg(linux_kernel)]
+impl<'a> MountAttr<'a> {
+    /// Create a `MountAttr` with the given simple fields.
+    pub fn new(
+        attr_set: MountAttrFlags,
+        attr_clr: MountAttrFlags,
+        propagation: MountPropagationFlags,
+    ) -> Self {
+        Self {
+            raw: linux_raw_sys::general::mount_attr {
+                attr_set: attr_set.bits() as u64,
+                attr_clr: attr_clr.bits() as u64,
+                propagation: propagation.bits() as u64,
+                userns_fd: 0,
+            },
+            userns_fd: PhantomData,
+        }
+    }
+
+    /// Set a parameterized flag.
+    pub fn set_param_flag(self, param: MountAttrParamFlags<'a>) -> Self {
+        param.apply(self, MountAttrOperation::Set)
+    }
+
+    /// Clear a parameterized flag.
+    pub fn clear_param_flag(self, param: MountAttrParamFlags<'a>) -> Self {
+        param.apply(self, MountAttrOperation::Clear)
+    }
+}
+
+#[cfg(linux_kernel)]
+enum MountAttrOperation {
+    Set,
+    Clear,
+}
+
 bitflags! {
     /// `MS_*` constants for use with [`mount_change`].
     ///