From 615af9ef3ca5f5f4ddcf0fd189fde93be8944586 Mon Sep 17 00:00:00 2001 From: ljy9810 Date: Sat, 25 Oct 2025 17:22:26 +0800 Subject: [PATCH] =?UTF-8?q?bitflags=E5=8D=87=E7=BA=A7=EF=BC=8C=E9=80=82?= =?UTF-8?q?=E9=85=8D=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: ljy9810 --- src/backend/libc/fs/syscalls.rs | 4 ++-- src/backend/libc/process/syscalls.rs | 2 +- src/backend/linux_raw/fs/syscalls.rs | 6 +++--- src/backend/linux_raw/io/epoll.rs | 2 +- src/backend/linux_raw/process/syscalls.rs | 2 +- src/process/membarrier.rs | 2 +- tests/fs/statx.rs | 4 ++-- 7 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/backend/libc/fs/syscalls.rs b/src/backend/libc/fs/syscalls.rs index 817b896d..cc21ab53 100644 --- a/src/backend/libc/fs/syscalls.rs +++ b/src/backend/libc/fs/syscalls.rs @@ -877,7 +877,7 @@ pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> { pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result { unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS)) - .map(|flags| SealFlags::from_bits_unchecked(flags)) + .map(|flags| SealFlags::from_bits_retain(flags)) } } @@ -1044,7 +1044,7 @@ fn libc_statvfs_to_statvfs(from: libc_statvfs) -> StatVfs { f_ffree: from.f_ffree as u64, f_favail: from.f_ffree as u64, f_fsid: from.f_fsid as u64, - f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(from.f_flag as u64) }, + f_flag: unsafe { StatVfsMountFlags::from_bits_retain(from.f_flag as u64) }, f_namemax: from.f_namemax as u64, } } diff --git a/src/backend/libc/process/syscalls.rs b/src/backend/libc/process/syscalls.rs index 6f4e8591..da98b1e2 100644 --- a/src/backend/libc/process/syscalls.rs +++ b/src/backend/libc/process/syscalls.rs @@ -62,7 +62,7 @@ pub(crate) fn membarrier_query() -> MembarrierQuery { const MEMBARRIER_CMD_QUERY: u32 = 0; unsafe { match syscall_ret_u32(c::syscall(c::SYS_membarrier, MEMBARRIER_CMD_QUERY, 0)) { - Ok(query) => MembarrierQuery::from_bits_unchecked(query), + Ok(query) => MembarrierQuery::from_bits_retain(query), Err(_) => MembarrierQuery::empty(), } } diff --git a/src/backend/linux_raw/fs/syscalls.rs b/src/backend/linux_raw/fs/syscalls.rs index 1bf00261..d45347a4 100644 --- a/src/backend/linux_raw/fs/syscalls.rs +++ b/src/backend/linux_raw/fs/syscalls.rs @@ -851,7 +851,7 @@ fn statfs_to_statvfs(statfs: StatFs) -> StatVfs { f_ffree: statfs.f_ffree as u64, f_favail: statfs.f_ffree as u64, f_fsid: f_fsid_val0 as u32 as u64 | ((f_fsid_val1 as u32 as u64) << 32), - f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(statfs.f_flags as u64) }, + f_flag: unsafe { StatVfsMountFlags::from_bits_retain(statfs.f_flags as u64) }, f_namemax: statfs.f_namelen as u64, } } @@ -985,12 +985,12 @@ pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result { #[cfg(target_pointer_width = "32")] unsafe { ret_c_int(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GET_SEALS))) - .map(|seals| SealFlags::from_bits_unchecked(seals as u32)) + .map(|seals| SealFlags::from_bits_retain(seals as u32)) } #[cfg(target_pointer_width = "64")] unsafe { ret_c_int(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GET_SEALS))) - .map(|seals| SealFlags::from_bits_unchecked(seals as u32)) + .map(|seals| SealFlags::from_bits_retain(seals as u32)) } } diff --git a/src/backend/linux_raw/io/epoll.rs b/src/backend/linux_raw/io/epoll.rs index 1f59ddb0..af8c8901 100644 --- a/src/backend/linux_raw/io/epoll.rs +++ b/src/backend/linux_raw/io/epoll.rs @@ -83,7 +83,7 @@ bitflags! { bitflags! { /// `EPOLL*` for use with [`Epoll::add`]. - #[derive(Default)] + #[derive(Default, Copy, Clone)] pub struct EventFlags: u32 { /// `EPOLLIN` const IN = linux_raw_sys::general::EPOLLIN as u32; diff --git a/src/backend/linux_raw/process/syscalls.rs b/src/backend/linux_raw/process/syscalls.rs index ac62e694..266db65f 100644 --- a/src/backend/linux_raw/process/syscalls.rs +++ b/src/backend/linux_raw/process/syscalls.rs @@ -59,7 +59,7 @@ pub(crate) fn membarrier_query() -> MembarrierQuery { // contains "source of truth" valid bits. // // [here]: https://github.com/bitflags/bitflags/pull/207#issuecomment-671668662 - MembarrierQuery::from_bits_unchecked(query) + MembarrierQuery::from_bits_retain(query) } Err(_) => MembarrierQuery::empty(), } diff --git a/src/process/membarrier.rs b/src/process/membarrier.rs index b64deb82..05c56753 100644 --- a/src/process/membarrier.rs +++ b/src/process/membarrier.rs @@ -48,7 +48,7 @@ impl MembarrierQuery { pub fn contains_command(self, cmd: MembarrierCommand) -> bool { // Safety: `MembarrierCommand` is an enum that only contains values // also valid in `MembarrierQuery`. - self.contains(unsafe { Self::from_bits_unchecked(cmd as _) }) + self.contains( unsafe { Self::from_bits_retain(cmd as _) } ) } } diff --git a/tests/fs/statx.rs b/tests/fs/statx.rs index d02e9cf7..a12ce062 100644 --- a/tests/fs/statx.rs +++ b/tests/fs/statx.rs @@ -8,7 +8,7 @@ fn test_statx_unknown_flags() { // unknown bits. Exclude `STATX__RESERVED` here as that evokes an explicit // failure; that's tested separately below. let too_many_flags = - unsafe { StatxFlags::from_bits_unchecked(!0 & !linux_raw_sys::general::STATX__RESERVED) }; + unsafe { StatxFlags::from_bits_retain(!0 & !linux_raw_sys::general::STATX__RESERVED) }; // It's also ok to pass such flags to `statx`. let result = rustix::fs::statx(&f, "Cargo.toml", AtFlags::empty(), too_many_flags).unwrap(); @@ -29,7 +29,7 @@ fn test_statx_reserved() { // It's ok (though still unwise) to construct a `STATX__RESERVED` flag // value but `statx` should reliably fail with `INVAL`. let reserved = - unsafe { StatxFlags::from_bits_unchecked(linux_raw_sys::general::STATX__RESERVED) }; + unsafe { StatxFlags::from_bits_retain(linux_raw_sys::general::STATX__RESERVED) }; match rustix::fs::statx(&f, "Cargo.toml", AtFlags::empty(), reserved) { Ok(_) => panic!("statx succeeded with `STATX__RESERVED`"), Err(err) => assert_eq!(err, rustix::io::Errno::INVAL),