Implement umask. (#585)

Author: sunfishcode

src/backend/libc/process/syscalls.rs

@@ -3,9 +3,9 @@
 use super::super::c;
 #[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
 use super::super::conv::borrowed_fd;
-#[cfg(not(target_os = "wasi"))]
-use super::super::conv::ret_pid_t;
 use super::super::conv::{c_str, ret, ret_c_int, ret_discarded_char_ptr};
+#[cfg(not(target_os = "wasi"))]
+use super::super::conv::{ret_infallible, ret_pid_t};
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use super::super::conv::{syscall_ret, syscall_ret_u32};
 #[cfg(any(
@@ -20,24 +20,25 @@ use crate::fd::BorrowedFd;
 #[cfg(target_os = "linux")]
 use crate::fd::{AsRawFd, OwnedFd};
 use crate::ffi::CStr;
+#[cfg(feature = "fs")]
+use crate::fs::Mode;
 use crate::io;
 #[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))]
 use crate::process::{WaitId, WaitidOptions, WaitidStatus};
 use core::mem::MaybeUninit;
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-use {
-    super::super::conv::ret_infallible,
-    super::super::offset::{libc_getrlimit, libc_rlimit, libc_setrlimit, LIBC_RLIM_INFINITY},
-    crate::process::{Resource, Rlimit},
-    core::convert::TryInto,
-};
 #[cfg(target_os = "linux")]
 use {super::super::conv::syscall_ret_owned_fd, crate::process::PidfdFlags};
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use {
     super::super::offset::libc_prlimit,
     crate::process::{Cpuid, MembarrierCommand, MembarrierQuery},
 };
+#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+use {
+    super::super::offset::{libc_getrlimit, libc_rlimit, libc_setrlimit, LIBC_RLIM_INFINITY},
+    crate::process::{Resource, Rlimit},
+    core::convert::TryInto,
+};
 #[cfg(not(target_os = "wasi"))]
 use {
     super::types::RawUname,
@@ -220,11 +221,19 @@ pub(crate) fn sched_yield() {
 pub(crate) fn uname() -> RawUname {
     let mut uname = MaybeUninit::<RawUname>::uninit();
     unsafe {
-        ret(c::uname(uname.as_mut_ptr())).unwrap();
+        ret_infallible(c::uname(uname.as_mut_ptr()));
         uname.assume_init()
     }
 }
 
+#[cfg(not(target_os = "wasi"))]
+#[cfg(feature = "fs")]
+#[inline]
+pub(crate) fn umask(mask: Mode) -> Mode {
+    // TODO: Use `from_bits_retain` when we switch to bitflags 2.0.
+    unsafe { Mode::from_bits_truncate(c::umask(mask.bits() as _) as _) }
+}
+
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn nice(inc: i32) -> io::Result<i32> {

src/backend/linux_raw/conv.rs

@@ -15,12 +15,12 @@
 
 use super::c;
 use super::fd::{AsRawFd, BorrowedFd, FromRawFd, RawFd};
-#[cfg(not(debug_assertions))]
-use super::io::errno::decode_usize_infallible;
 #[cfg(feature = "runtime")]
 use super::io::errno::try_decode_error;
 #[cfg(target_pointer_width = "64")]
 use super::io::errno::try_decode_u64;
+#[cfg(not(debug_assertions))]
+use super::io::errno::{decode_c_uint_infallible, decode_usize_infallible};
 use super::io::errno::{
     try_decode_c_int, try_decode_c_uint, try_decode_raw_fd, try_decode_usize, try_decode_void,
     try_decode_void_star,
@@ -802,6 +802,25 @@ pub(super) unsafe fn ret_usize_infallible(raw: RetReg<R0>) -> usize {
     }
 }
 
+/// Convert a `c_uint` returned from a syscall that effectively always
+/// returns a `c_uint`.
+///
+/// # Safety
+///
+/// This function must only be used with return values from infallible
+/// syscalls.
+#[inline]
+pub(super) unsafe fn ret_c_uint_infallible(raw: RetReg<R0>) -> c::c_uint {
+    #[cfg(debug_assertions)]
+    {
+        try_decode_c_uint(raw).unwrap()
+    }
+    #[cfg(not(debug_assertions))]
+    {
+        decode_c_uint_infallible(raw)
+    }
+}
+
 /// Convert a `usize` returned from a syscall that effectively returns an
 /// `OwnedFd` on success.
 ///

src/backend/linux_raw/io/errno.rs

@@ -236,6 +236,13 @@ pub(in crate::backend) fn decode_usize_infallible<Num: RetNumber>(raw: RetReg<Nu
     raw.decode_usize()
 }
 
+/// Return the contained `c_int` value.
+#[cfg(not(debug_assertions))]
+#[inline]
+pub(in crate::backend) fn decode_c_uint_infallible<Num: RetNumber>(raw: RetReg<Num>) -> c::c_uint {
+    raw.decode_c_uint()
+}
+
 impl Errno {
     /// `EACCES`
     #[doc(alias = "ACCES")]

src/backend/linux_raw/process/syscalls.rs

@@ -28,6 +28,9 @@ 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,
 };
+#[cfg(not(target_os = "wasi"))]
+#[cfg(feature = "fs")]
+use {super::super::conv::ret_c_uint_infallible, crate::fs::Mode};
 
 #[inline]
 pub(crate) fn chdir(filename: &CStr) -> io::Result<()> {
@@ -236,11 +239,20 @@ pub(crate) fn sched_yield() {
 pub(crate) fn uname() -> RawUname {
     let mut uname = MaybeUninit::<RawUname>::uninit();
     unsafe {
-        ret(syscall!(__NR_uname, &mut uname)).unwrap();
+        ret_infallible(syscall!(__NR_uname, &mut uname));
         uname.assume_init()
     }
 }
 
+#[cfg(feature = "fs")]
+#[inline]
+pub(crate) fn umask(mode: Mode) -> Mode {
+    unsafe {
+        // TODO: Use `from_bits_retain` when we switch to bitflags 2.0.
+        Mode::from_bits_truncate(ret_c_uint_infallible(syscall_readonly!(__NR_umask, mode)))
+    }
+}
+
 #[inline]
 pub(crate) fn nice(inc: i32) -> io::Result<i32> {
     let priority = if inc > -40 && inc < 40 {

src/process/mod.rs

@@ -27,6 +27,8 @@ mod rlimit;
 ))]
 mod sched;
 mod sched_yield;
+#[cfg(not(target_os = "wasi"))] // WASI doesn't have umask.
+mod umask;
 #[cfg(not(target_os = "wasi"))] // WASI doesn't have uname.
 mod uname;
 #[cfg(not(target_os = "wasi"))]
@@ -60,6 +62,8 @@ pub use rlimit::*;
 pub use sched::*;
 pub use sched_yield::sched_yield;
 #[cfg(not(target_os = "wasi"))]
+pub use umask::*;
+#[cfg(not(target_os = "wasi"))]
 pub use uname::{uname, Uname};
 #[cfg(not(target_os = "wasi"))]
 pub use wait::*;

src/process/umask.rs

@@ -0,0 +1,21 @@
+//! Umask support.
+
+#[cfg(feature = "fs")]
+use crate::backend;
+#[cfg(feature = "fs")]
+use crate::fs::Mode;
+
+/// `umask(mask)`—Set the process file creation mask.
+///
+/// # References
+///  - [POSIX]
+///  - [Linux]
+///
+/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/umask.html
+/// [Linux]: https://man7.org/linux/man-pages/man2/umask.2.html
+#[inline]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "fs")))]
+#[cfg(feature = "fs")]
+pub fn umask(mask: Mode) -> Mode {
+    backend::process::syscalls::umask(mask)
+}

tests/process/main.rs

@@ -26,6 +26,8 @@ mod procctl;
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
 mod rlimit;
 mod sched_yield;
+#[cfg(not(target_os = "wasi"))] // WASI doesn't have umask.
+mod umask;
 #[cfg(not(target_os = "wasi"))] // WASI doesn't have uname.
 mod uname;
 #[cfg(not(target_os = "wasi"))] // WASI doesn't have waitpid.

tests/process/umask.rs

@@ -0,0 +1,10 @@
+#[cfg(feature = "fs")]
+#[test]
+fn test_umask() {
+    use rustix::fs::Mode;
+
+    let tmp = Mode::RWXO | Mode::RWXG;
+    let old = rustix::process::umask(tmp);
+    let new = rustix::process::umask(old);
+    assert_eq!(tmp, new);
+}