bitflags升级，适配修改

Signed-off-by: ljy9810 <longjianyin@h-partners.com>

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<SealFlags> {
     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,
     }
 }

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(),
         }
     }

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<SealFlags> {
     #[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))
     }
 }
 

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;

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(),
         }

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 _) } )
     }
 }
 

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),