Use fewer linux_raw_sys::general:: qualifiers in implementation code.

This is a minor code cleanup to add `use linux_raw_sys::general::`
declarations to eliminate some explicit qualifiers in the code.

Author: sunfishcode

src/imp/linux_raw/fs/dir.rs

@@ -8,7 +8,7 @@ use alloc::borrow::ToOwned;
 use alloc::vec::Vec;
 use core::fmt;
 use core::mem::size_of;
-use linux_raw_sys::general::linux_dirent64;
+use linux_raw_sys::general::{linux_dirent64, SEEK_SET};
 
 /// `DIR*`
 pub struct Dir {
@@ -51,11 +51,7 @@ impl Dir {
     /// `readdir(self)`, where `None` means the end of the directory.
     pub fn read(&mut self) -> Option<io::Result<DirEntry>> {
         if let Some(next) = self.next.take() {
-            match crate::imp::fs::syscalls::_seek(
-                self.fd.as_fd(),
-                next as i64,
-                linux_raw_sys::general::SEEK_SET,
-            ) {
+            match crate::imp::fs::syscalls::_seek(self.fd.as_fd(), next as i64, SEEK_SET) {
                 Ok(_) => (),
                 Err(err) => return Some(Err(err)),
             }

src/imp/linux_raw/fs/syscalls.rs

@@ -41,9 +41,9 @@ use core::sync::atomic::{AtomicBool, Ordering::Relaxed};
 #[cfg(target_arch = "mips64")]
 use linux_raw_sys::general::stat as linux_stat64;
 use linux_raw_sys::general::{
-    __kernel_timespec, open_how, statx, AT_FDCWD, AT_REMOVEDIR, AT_SYMLINK_NOFOLLOW, F_ADD_SEALS,
-    F_DUPFD, F_DUPFD_CLOEXEC, F_GETFD, F_GETFL, F_GETLEASE, F_GETOWN, F_GETPIPE_SZ, F_GETSIG,
-    F_GET_SEALS, F_SETFD, F_SETFL, F_SETPIPE_SZ,
+    __kernel_timespec, open_how, statx, AT_EACCESS, AT_FDCWD, AT_REMOVEDIR, AT_SYMLINK_NOFOLLOW,
+    F_ADD_SEALS, F_DUPFD, F_DUPFD_CLOEXEC, F_GETFD, F_GETFL, F_GETLEASE, F_GETOWN, F_GETPIPE_SZ,
+    F_GETSIG, F_GET_SEALS, F_SETFD, F_SETFL, F_SETPIPE_SZ, SEEK_CUR, SEEK_END, SEEK_SET,
 };
 #[cfg(target_pointer_width = "32")]
 use {
@@ -219,10 +219,10 @@ pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
         SeekFrom::Start(pos) => {
             let pos: u64 = pos;
             // Silently cast; we'll get `EINVAL` if the value is negative.
-            (linux_raw_sys::general::SEEK_SET, pos as i64)
+            (SEEK_SET, pos as i64)
         }
-        SeekFrom::End(offset) => (linux_raw_sys::general::SEEK_END, offset),
-        SeekFrom::Current(offset) => (linux_raw_sys::general::SEEK_CUR, offset),
+        SeekFrom::End(offset) => (SEEK_END, offset),
+        SeekFrom::Current(offset) => (SEEK_CUR, offset),
     };
     _seek(fd, offset, whence)
 }
@@ -257,7 +257,7 @@ pub(crate) fn _seek(fd: BorrowedFd<'_>, offset: i64, whence: c::c_uint) -> io::R
 
 #[inline]
 pub(crate) fn tell(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    _seek(fd, 0, linux_raw_sys::general::SEEK_CUR).map(|x| x as u64)
+    _seek(fd, 0, SEEK_CUR).map(|x| x as u64)
 }
 
 #[inline]
@@ -1314,14 +1314,14 @@ pub(crate) fn accessat(
     // Linux's `faccessat` doesn't have a flags parameter. If we have
     // `AT_EACCESS` and we're not setuid or setgid, we can emulate it.
     if flags.is_empty()
-        || (flags.bits() == linux_raw_sys::general::AT_EACCESS
+        || (flags.bits() == AT_EACCESS
             && crate::process::getuid() == crate::process::geteuid()
             && crate::process::getgid() == crate::process::getegid())
     {
         return unsafe { ret(syscall_readonly!(__NR_faccessat, dirfd, path, access)) };
     }
 
-    if flags.bits() != linux_raw_sys::general::AT_EACCESS {
+    if flags.bits() != AT_EACCESS {
         return Err(io::Errno::INVAL);
     }
 

src/imp/linux_raw/io/syscalls.rs

@@ -24,7 +24,9 @@ use crate::io::{
 use crate::net::{RecvFlags, SendFlags};
 use core::cmp;
 use core::mem::MaybeUninit;
-use linux_raw_sys::general::{epoll_event, EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD};
+use linux_raw_sys::general::{
+    epoll_event, EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD, UIO_MAXIOV,
+};
 use linux_raw_sys::ioctl::{BLKPBSZGET, BLKSSZGET, FIONBIO, FIONREAD, TIOCEXCL, TIOCNXCL};
 #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use {
@@ -281,7 +283,7 @@ pub(crate) fn pwritev2(
 /// The maximum number of buffers that can be passed into a vectored I/O system
 /// call on the current platform.
 const fn max_iov() -> usize {
-    linux_raw_sys::general::UIO_MAXIOV as usize
+    UIO_MAXIOV as usize
 }
 
 #[inline]

src/imp/linux_raw/mm/syscalls.rs

@@ -18,6 +18,7 @@ use crate::fd::BorrowedFd;
 use crate::io::{self, OwnedFd};
 #[cfg(target_pointer_width = "32")]
 use core::convert::TryInto;
+use linux_raw_sys::general::MAP_ANONYMOUS;
 
 #[inline]
 pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::Result<()> {
@@ -96,7 +97,7 @@ pub(crate) unsafe fn mmap_anonymous(
             addr,
             pass_usize(length),
             prot,
-            c_uint(flags.bits() | linux_raw_sys::general::MAP_ANONYMOUS),
+            c_uint(flags.bits() | MAP_ANONYMOUS),
             no_fd(),
             pass_usize(0)
         ))
@@ -108,7 +109,7 @@ pub(crate) unsafe fn mmap_anonymous(
             addr,
             pass_usize(length),
             prot,
-            c_uint(flags.bits() | linux_raw_sys::general::MAP_ANONYMOUS),
+            c_uint(flags.bits() | MAP_ANONYMOUS),
             no_fd(),
             loff_t_from_u64(0)
         ))

src/imp/linux_raw/process/syscalls.rs

@@ -22,7 +22,10 @@ use crate::process::{
 use core::convert::TryInto;
 use core::mem::MaybeUninit;
 use core::ptr::{null, null_mut};
-use linux_raw_sys::general::{__kernel_gid_t, __kernel_pid_t, __kernel_uid_t};
+use linux_raw_sys::general::{
+    __kernel_gid_t, __kernel_pid_t, __kernel_uid_t, membarrier_cmd, membarrier_cmd_flag, rlimit,
+    rlimit64, PRIO_PGRP, PRIO_PROCESS, PRIO_USER, RLIM64_INFINITY, RLIM_INFINITY,
+};
 
 #[inline]
 pub(crate) fn chdir(filename: &CStr) -> io::Result<()> {
@@ -45,7 +48,7 @@ pub(crate) fn membarrier_query() -> MembarrierQuery {
     unsafe {
         match ret_c_uint(syscall!(
             __NR_membarrier,
-            c_int(linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_QUERY as _),
+            c_int(membarrier_cmd::MEMBARRIER_CMD_QUERY as _),
             c_uint(0)
         )) {
             Ok(query) => {
@@ -73,7 +76,7 @@ pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<(
         ret(syscall!(
             __NR_membarrier,
             cmd,
-            c_uint(linux_raw_sys::general::membarrier_cmd_flag::MEMBARRIER_CMD_FLAG_CPU as _),
+            c_uint(membarrier_cmd_flag::MEMBARRIER_CMD_FLAG_CPU as _),
             cpu
         ))
     }
@@ -226,7 +229,7 @@ pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> {
         Ok(20
             - ret_c_int(syscall_readonly!(
                 __NR_getpriority,
-                c_uint(linux_raw_sys::general::PRIO_USER),
+                c_uint(PRIO_USER),
                 c_uint(uid.as_raw())
             ))?)
     }
@@ -238,7 +241,7 @@ pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
         Ok(20
             - ret_c_int(syscall_readonly!(
                 __NR_getpriority,
-                c_uint(linux_raw_sys::general::PRIO_PGRP),
+                c_uint(PRIO_PGRP),
                 c_uint(Pid::as_raw(pgid))
             ))?)
     }
@@ -250,7 +253,7 @@ pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
         Ok(20
             - ret_c_int(syscall_readonly!(
                 __NR_getpriority,
-                c_uint(linux_raw_sys::general::PRIO_PROCESS),
+                c_uint(PRIO_PROCESS),
                 c_uint(Pid::as_raw(pid))
             ))?)
     }
@@ -261,7 +264,7 @@ pub(crate) fn setpriority_user(uid: Uid, priority: i32) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_setpriority,
-            c_uint(linux_raw_sys::general::PRIO_USER),
+            c_uint(PRIO_USER),
             c_uint(uid.as_raw()),
             c_int(priority)
         ))
@@ -273,7 +276,7 @@ pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<(
     unsafe {
         ret(syscall_readonly!(
             __NR_setpriority,
-            c_uint(linux_raw_sys::general::PRIO_PGRP),
+            c_uint(PRIO_PGRP),
             c_uint(Pid::as_raw(pgid)),
             c_int(priority)
         ))
@@ -285,7 +288,7 @@ pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result
     unsafe {
         ret(syscall_readonly!(
             __NR_setpriority,
-            c_uint(linux_raw_sys::general::PRIO_PROCESS),
+            c_uint(PRIO_PROCESS),
             c_uint(Pid::as_raw(pid)),
             c_int(priority)
         ))
@@ -294,7 +297,7 @@ pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result
 
 #[inline]
 pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<linux_raw_sys::general::rlimit64>::uninit();
+    let mut result = MaybeUninit::<rlimit64>::uninit();
     unsafe {
         match ret(syscall!(
             __NR_prlimit64,
@@ -315,7 +318,7 @@ pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
 /// The old 32-bit-only `getrlimit` syscall, for when we lack the new
 /// `prlimit64`.
 unsafe fn getrlimit_old(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<linux_raw_sys::general::rlimit>::uninit();
+    let mut result = MaybeUninit::<rlimit>::uninit();
 
     // On these platforms, `__NR_getrlimit` is called `__NR_ugetrlimit`.
     #[cfg(any(
@@ -370,7 +373,7 @@ unsafe fn setrlimit_old(limit: Resource, new: Rlimit) -> io::Result<()> {
 #[inline]
 pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Result<Rlimit> {
     let lim = rlimit_to_linux(new)?;
-    let mut result = MaybeUninit::<linux_raw_sys::general::rlimit64>::uninit();
+    let mut result = MaybeUninit::<rlimit64>::uninit();
     unsafe {
         match ret(syscall!(
             __NR_prlimit64,
@@ -387,13 +390,13 @@ pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Res
 
 /// Convert a Rust [`Rlimit`] to a C `rlimit64`.
 #[inline]
-fn rlimit_from_linux(lim: linux_raw_sys::general::rlimit64) -> Rlimit {
-    let current = if lim.rlim_cur == linux_raw_sys::general::RLIM64_INFINITY as _ {
+fn rlimit_from_linux(lim: rlimit64) -> Rlimit {
+    let current = if lim.rlim_cur == RLIM64_INFINITY as _ {
         None
     } else {
         Some(lim.rlim_cur)
     };
-    let maximum = if lim.rlim_max == linux_raw_sys::general::RLIM64_INFINITY as _ {
+    let maximum = if lim.rlim_max == RLIM64_INFINITY as _ {
         None
     } else {
         Some(lim.rlim_max)
@@ -403,27 +406,27 @@ fn rlimit_from_linux(lim: linux_raw_sys::general::rlimit64) -> Rlimit {
 
 /// Convert a C `rlimit64` to a Rust `Rlimit`.
 #[inline]
-fn rlimit_to_linux(lim: Rlimit) -> io::Result<linux_raw_sys::general::rlimit64> {
+fn rlimit_to_linux(lim: Rlimit) -> io::Result<rlimit64> {
     let rlim_cur = match lim.current {
         Some(r) => r,
-        None => linux_raw_sys::general::RLIM64_INFINITY as _,
+        None => RLIM64_INFINITY as _,
     };
     let rlim_max = match lim.maximum {
         Some(r) => r,
-        None => linux_raw_sys::general::RLIM64_INFINITY as _,
+        None => RLIM64_INFINITY as _,
     };
-    Ok(linux_raw_sys::general::rlimit64 { rlim_cur, rlim_max })
+    Ok(rlimit64 { rlim_cur, rlim_max })
 }
 
 /// Like `rlimit_from_linux` but uses Linux's old 32-bit `rlimit`.
 #[allow(clippy::useless_conversion)]
-fn rlimit_from_linux_old(lim: linux_raw_sys::general::rlimit) -> Rlimit {
-    let current = if lim.rlim_cur == linux_raw_sys::general::RLIM_INFINITY as _ {
+fn rlimit_from_linux_old(lim: rlimit) -> Rlimit {
+    let current = if lim.rlim_cur == RLIM_INFINITY as _ {
         None
     } else {
         Some(lim.rlim_cur.into())
     };
-    let maximum = if lim.rlim_max == linux_raw_sys::general::RLIM_INFINITY as _ {
+    let maximum = if lim.rlim_max == RLIM_INFINITY as _ {
         None
     } else {
         Some(lim.rlim_max.into())
@@ -433,16 +436,16 @@ fn rlimit_from_linux_old(lim: linux_raw_sys::general::rlimit) -> Rlimit {
 
 /// Like `rlimit_to_linux` but uses Linux's old 32-bit `rlimit`.
 #[allow(clippy::useless_conversion)]
-fn rlimit_to_linux_old(lim: Rlimit) -> io::Result<linux_raw_sys::general::rlimit> {
+fn rlimit_to_linux_old(lim: Rlimit) -> io::Result<rlimit> {
     let rlim_cur = match lim.current {
         Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => linux_raw_sys::general::RLIM_INFINITY as _,
+        None => RLIM_INFINITY as _,
     };
     let rlim_max = match lim.maximum {
         Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => linux_raw_sys::general::RLIM_INFINITY as _,
+        None => RLIM_INFINITY as _,
     };
-    Ok(linux_raw_sys::general::rlimit { rlim_cur, rlim_max })
+    Ok(rlimit { rlim_cur, rlim_max })
 }
 
 #[inline]

src/imp/linux_raw/process/types.rs

@@ -1,4 +1,5 @@
 use super::super::c;
+use linux_raw_sys::general::membarrier_cmd;
 
 /// A command for use with [`membarrier`] and [`membarrier_cpu`].
 ///
@@ -13,31 +14,25 @@ pub enum MembarrierCommand {
     /// `MEMBARRIER_CMD_GLOBAL`
     #[doc(alias = "Shared")]
     #[doc(alias = "MEMBARRIER_CMD_SHARED")]
-    Global = linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_GLOBAL as _,
+    Global = membarrier_cmd::MEMBARRIER_CMD_GLOBAL as _,
     /// `MEMBARRIER_CMD_GLOBAL_EXPEDITED`
-    GlobalExpedited = linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_GLOBAL_EXPEDITED as _,
+    GlobalExpedited = membarrier_cmd::MEMBARRIER_CMD_GLOBAL_EXPEDITED as _,
     /// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`
-    RegisterGlobalExpedited =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED as _,
+    RegisterGlobalExpedited = membarrier_cmd::MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED as _,
     /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED`
-    PrivateExpedited =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED as _,
+    PrivateExpedited = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED as _,
     /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`
-    RegisterPrivateExpedited =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED as _,
+    RegisterPrivateExpedited = membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED as _,
     /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`
-    PrivateExpeditedSyncCore =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE as _,
+    PrivateExpeditedSyncCore = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE as _,
     /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`
     RegisterPrivateExpeditedSyncCore =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE
-            as _,
+        membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE as _,
     /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    PrivateExpeditedRseq =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ as _,
+    PrivateExpeditedRseq = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ as _,
     /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
     RegisterPrivateExpeditedRseq =
-        linux_raw_sys::general::membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ as _,
+        membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ as _,
 }
 
 /// A resource value for use with [`getrlimit`], [`setrlimit`], and