Add new mount api syscall for linux_raw

Author: yujincheng08

src/backend/linux_raw/conv.rs

@@ -450,6 +450,55 @@ pub(crate) mod fs {
             c_uint(flags.bits())
         }
     }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::FsConfigCmd> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(cmd: crate::fs::FsConfigCmd) -> Self {
+            c_uint(cmd as c::c_uint)
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::FsOpenFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::FsOpenFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::FsMountFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::FsMountFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::MountAttrFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::MountAttrFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::OpenTreeFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::OpenTreeFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::FsPickFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::FsPickFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::MoveMountFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::MoveMountFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
 }
 
 impl<'a, Num: ArgNumber> From<crate::io::FdFlags> for ArgReg<'a, Num> {

src/backend/linux_raw/fs/syscalls.rs

@@ -1436,6 +1436,205 @@ pub(crate) fn mount(
     }
 }
 
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsopen(fs_name: &CStr, flags: super::types::FsOpenFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_fsopen, fs_name, flags)) }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsmount(
+    fs_fd: BorrowedFd<'_>,
+    flags: super::types::FsMountFlags,
+    attr_flags: super::types::MountAttrFlags,
+) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_fsmount, fs_fd, flags, attr_flags)) }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn move_mount(
+    from_dfd: BorrowedFd<'_>,
+    from_pathname: &CStr,
+    to_dfd: BorrowedFd<'_>,
+    to_pathname: &CStr,
+    flags: super::types::MoveMountFlags,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_move_mount,
+            from_dfd,
+            from_pathname,
+            to_dfd,
+            to_pathname,
+            flags
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn open_tree(
+    dfd: BorrowedFd<'_>,
+    filename: &CStr,
+    flags: super::types::OpenTreeFlags,
+) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_open_tree, dfd, filename, flags)) }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fspick(
+    dfd: BorrowedFd<'_>,
+    path: &CStr,
+    flags: super::types::FsPickFlags,
+) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_fspick, dfd, path, flags)) }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_flag(fs_fd: BorrowedFd<'_>, key: &CStr) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetFlag,
+            key,
+            zero(),
+            zero()
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_string(
+    fs_fd: BorrowedFd<'_>,
+    key: &CStr,
+    value: &CStr,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetString,
+            key,
+            value,
+            zero()
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_binary(
+    fs_fd: BorrowedFd<'_>,
+    key: &CStr,
+    value: &[u8],
+) -> io::Result<()> {
+    let (value_addr, value_len) = slice(value);
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetBinary,
+            key,
+            value_addr,
+            value_len
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_fd(
+    fs_fd: BorrowedFd<'_>,
+    key: &CStr,
+    fd: BorrowedFd<'_>,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetFd,
+            key,
+            zero(),
+            fd
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_path(
+    fs_fd: BorrowedFd<'_>,
+    key: &CStr,
+    path: &CStr,
+    fd: BorrowedFd<'_>,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetPath,
+            key,
+            path,
+            fd
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_set_path_empty(
+    fs_fd: BorrowedFd<'_>,
+    key: &CStr,
+    fd: BorrowedFd<'_>,
+) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::SetPathEmpty,
+            key,
+            cstr!(""),
+            fd
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_create(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::Create,
+            zero(),
+            zero(),
+            zero()
+        ))
+    }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn fsconfig_reconfigure(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fsconfig,
+            fs_fd,
+            super::types::FsConfigCmd::Reconfigure,
+            zero(),
+            zero(),
+            zero()
+        ))
+    }
+}
+
 #[inline]
 pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_umount2, target, flags)) }