1 files changed, 34 insertions, 44 deletions

diff --git a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs b/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
index 1895c8c6d..f23b7c2df 100644
--- a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
@@ -6,20 +6,19 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-use super::super::conv::{
-    by_ref, c_int, c_uint, ret, ret_c_int, ret_usize, ret_usize_infallible, zero,
+use crate::backend::c;
+use crate::backend::conv::{
+    by_mut, by_ref, c_int, c_uint, ret, ret_c_int, ret_c_int_infallible, ret_usize,
+    slice_just_addr, slice_just_addr_mut, zero,
 };
 use crate::fd::BorrowedFd;
 use crate::io;
-use crate::process::{Pid, RawNonZeroPid};
+use crate::pid::Pid;
 use crate::thread::{ClockId, FutexFlags, FutexOperation, NanosleepRelativeResult, Timespec};
 use core::mem::MaybeUninit;
-use linux_raw_sys::general::{__kernel_pid_t, __kernel_timespec, TIMER_ABSTIME};
 #[cfg(target_pointer_width = "32")]
-use {
-    core::convert::TryInto, core::ptr, linux_raw_sys::general::timespec as __kernel_old_timespec,
-};
+use linux_raw_sys::general::timespec as __kernel_old_timespec;
+use linux_raw_sys::general::{__kernel_timespec, TIMER_ABSTIME};
 
 #[inline]
 pub(crate) fn clock_nanosleep_relative(
@@ -86,14 +85,10 @@ unsafe fn clock_nanosleep_relative_old(
         &mut old_rem
     ))?;
     let old_rem = old_rem.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        rem.as_mut_ptr(),
-        __kernel_timespec {
-            tv_sec: old_rem.tv_sec.into(),
-            tv_nsec: old_rem.tv_nsec.into(),
-        },
-    );
+    rem.write(__kernel_timespec {
+        tv_sec: old_rem.tv_sec.into(),
+        tv_nsec: old_rem.tv_nsec.into(),
+    });
     Ok(())
 }
 
@@ -194,23 +189,18 @@ unsafe fn nanosleep_old(
     let mut old_rem = MaybeUninit::<__kernel_old_timespec>::uninit();
     ret(syscall!(__NR_nanosleep, by_ref(&old_req), &mut old_rem))?;
     let old_rem = old_rem.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        rem.as_mut_ptr(),
-        __kernel_timespec {
-            tv_sec: old_rem.tv_sec.into(),
-            tv_nsec: old_rem.tv_nsec.into(),
-        },
-    );
+    rem.write(__kernel_timespec {
+        tv_sec: old_rem.tv_sec.into(),
+        tv_nsec: old_rem.tv_nsec.into(),
+    });
     Ok(())
 }
 
 #[inline]
 pub(crate) fn gettid() -> Pid {
     unsafe {
-        let tid: i32 = ret_usize_infallible(syscall_readonly!(__NR_gettid)) as __kernel_pid_t;
-        debug_assert_ne!(tid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid as u32))
+        let tid = ret_c_int_infallible(syscall_readonly!(__NR_gettid));
+        Pid::from_raw_unchecked(tid)
     }
 }
 
@@ -283,48 +273,48 @@ unsafe fn futex_old(
     ))
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> {
     unsafe { ret_c_int(syscall_readonly!(__NR_setns, fd, c_int(nstype))) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_unshare, c_uint(flags.bits()))) }
+    unsafe { ret(syscall_readonly!(__NR_unshare, flags)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn capget(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &mut [MaybeUninit<linux_raw_sys::general::__user_cap_data_struct>],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { ret(syscall!(__NR_capget, header, data)) }
+    unsafe {
+        ret(syscall!(
+            __NR_capget,
+            by_mut(header),
+            slice_just_addr_mut(data)
+        ))
+    }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn capset(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &[linux_raw_sys::general::__user_cap_data_struct],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { ret(syscall!(__NR_capset, header, data.as_ptr())) }
+    unsafe { ret(syscall!(__NR_capset, by_mut(header), slice_just_addr(data))) }
 }
 
 #[inline]
-pub(crate) fn setuid_thread(uid: crate::process::Uid) -> io::Result<()> {
+pub(crate) fn setuid_thread(uid: crate::ugid::Uid) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_setuid, uid)) }
 }
 
 #[inline]
 pub(crate) fn setresuid_thread(
-    ruid: crate::process::Uid,
-    euid: crate::process::Uid,
-    suid: crate::process::Uid,
+    ruid: crate::ugid::Uid,
+    euid: crate::ugid::Uid,
+    suid: crate::ugid::Uid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     unsafe {
@@ -337,15 +327,15 @@ pub(crate) fn setresuid_thread(
 }
 
 #[inline]
-pub(crate) fn setgid_thread(gid: crate::process::Gid) -> io::Result<()> {
+pub(crate) fn setgid_thread(gid: crate::ugid::Gid) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_setgid, gid)) }
 }
 
 #[inline]
 pub(crate) fn setresgid_thread(
-    rgid: crate::process::Gid,
-    egid: crate::process::Gid,
-    sgid: crate::process::Gid,
+    rgid: crate::ugid::Gid,
+    egid: crate::ugid::Gid,
+    sgid: crate::ugid::Gid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     unsafe {