use crate::{

AsObject, Py, PyObjectRef, PyResult, VirtualMachine,

builtins::{PyDictRef, PyInt, PyListRef, PyTupleRef, PyUtf8Str},

convert::{IntoPyException, ToPyException, ToPyObject, TryFromObject},

exceptions::OSErrorBuilder,

function::{ArgMapping, Either, KwArgs, OptionalArg},

ospath::{OsPath, OsPathOrFd},

stdlib::os::{

_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, fs_metadata,

warn_if_bool_fd,

},

};

#[cfg(any(

use crate::{builtins::PyUtf8StrRef, utils::ToCString};

use alloc::ffi::CString;

use core::ffi::CStr;

use rustpython_host_env::os::ffi::OsStringExt;

use std::{

fs, io,

os::fd::{BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},

};

use strum::IntoEnumIterator;

use strum_macros::{EnumIter, EnumString};

#[cfg(target_os = "linux")]

#[pyattr]

use libc::PIDFD_NONBLOCK;

#[cfg(target_os = "macos")]

#[pyattr]

use libc::{

COPYFILE_DATA as _COPYFILE_DATA, O_EVTONLY, O_NOFOLLOW_ANY, PRIO_DARWIN_BG,

PRIO_DARWIN_NONUI, PRIO_DARWIN_PROCESS, PRIO_DARWIN_THREAD,

};

#[cfg(target_os = "freebsd")]

#[pyattr]

use libc::{SF_MNOWAIT, SF_NOCACHE, SF_NODISKIO, SF_SYNC};

#[cfg(any(target_os = "android", target_os = "linux"))]

#[pyattr]

use libc::{

CLONE_FILES, CLONE_FS, CLONE_NEWCGROUP, CLONE_NEWIPC, CLONE_NEWNET, CLONE_NEWNS,

CLONE_NEWPID, CLONE_NEWUSER, CLONE_NEWUTS, CLONE_SIGHAND, CLONE_SYSVSEM, CLONE_THREAD,

CLONE_VM, MFD_HUGE_SHIFT, O_NOATIME, O_TMPFILE, P_PIDFD, SCHED_BATCH, SCHED_DEADLINE,

SCHED_IDLE, SCHED_NORMAL, SCHED_RESET_ON_FORK, SPLICE_F_MORE, SPLICE_F_MOVE,

SPLICE_F_NONBLOCK,

};

#[cfg(any(target_os = "macos", target_os = "redox"))]

#[pyattr]

use libc::O_SYMLINK;

#[cfg(any(target_os = "android", target_os = "redox", unix))]

#[pyattr]

use libc::{O_NOFOLLOW, PRIO_PGRP, PRIO_PROCESS, PRIO_USER};

#[cfg(any(target_os = "linux", target_os = "macos", target_os = "netbsd"))]

#[pyattr]

use libc::{XATTR_CREATE, XATTR_REPLACE};

#[cfg(any(target_os = "android", target_os = "linux", target_os = "netbsd"))]

#[pyattr]

use libc::O_RSYNC;

#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]

#[pyattr]

use libc::{

MFD_ALLOW_SEALING, MFD_CLOEXEC, MFD_HUGE_MASK, MFD_HUGETLB, POSIX_FADV_DONTNEED,

POSIX_FADV_NOREUSE, POSIX_FADV_NORMAL, POSIX_FADV_RANDOM, POSIX_FADV_SEQUENTIAL,

POSIX_FADV_WILLNEED,

};

#[cfg(any(target_os = "android", target_os = "linux", target_os = "redox", unix))]

#[pyattr]

use libc::{RTLD_LAZY, RTLD_NOW, WNOHANG};

#[cfg(any(target_os = "android", target_os = "macos", target_os = "redox", unix))]

#[pyattr]

use libc::RTLD_GLOBAL;

#[cfg(any(

#[pyattr]

use libc::O_PATH;

#[cfg(any(

#[pyattr]

use libc::{

EFD_CLOEXEC, EFD_NONBLOCK, EFD_SEMAPHORE, TFD_CLOEXEC, TFD_NONBLOCK, TFD_TIMER_ABSTIME,

TFD_TIMER_CANCEL_ON_SET,

};

#[cfg(any(

#[pyattr]

use libc::{GRND_NONBLOCK, GRND_RANDOM};

#[cfg(any(

#[pyattr]

use libc::{F_OK, R_OK, W_OK, X_OK};

#[cfg(any(

#[pyattr]

use libc::O_NONBLOCK;

#[cfg(any(

#[pyattr]

use libc::O_DSYNC;

#[cfg(any(

#[pyattr]

use libc::SCHED_OTHER;

#[cfg(any(

#[pyattr]

use libc::{RTLD_NODELETE, SEEK_DATA, SEEK_HOLE};

#[cfg(any(

#[pyattr]

use libc::O_DIRECT;

#[cfg(any(

#[pyattr]

use libc::{O_EXLOCK, O_FSYNC, O_SHLOCK};

#[cfg(any(

#[pyattr]

use libc::RTLD_LOCAL;

#[cfg(any(

#[pyattr]

use libc::WUNTRACED;

#[cfg(any(

#[pyattr]

use libc::{

CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED, CLD_TRAPPED, O_SYNC, P_ALL,

P_PGID, P_PID, SCHED_FIFO, SCHED_RR,

};

#[cfg(any(

#[pyattr]

use libc::O_DIRECTORY;

#[cfg(any(

#[pyattr]

use libc::{

F_LOCK, F_TEST, F_TLOCK, F_ULOCK, O_ASYNC, O_NDELAY, O_NOCTTY, RTLD_NOLOAD, WEXITED,

WNOWAIT, WSTOPPED,

};

#[cfg(any(

#[pyattr]

use libc::{O_CLOEXEC, WCONTINUED};

#[pyattr]

const EX_OK: i8 = exitcode::OK as i8;

#[pyattr]

const EX_USAGE: i8 = exitcode::USAGE as i8;

#[pyattr]

const EX_DATAERR: i8 = exitcode::DATAERR as i8;

#[pyattr]

const EX_NOINPUT: i8 = exitcode::NOINPUT as i8;

#[pyattr]

const EX_NOUSER: i8 = exitcode::NOUSER as i8;

#[pyattr]

const EX_NOHOST: i8 = exitcode::NOHOST as i8;

#[pyattr]

const EX_UNAVAILABLE: i8 = exitcode::UNAVAILABLE as i8;

#[pyattr]

const EX_SOFTWARE: i8 = exitcode::SOFTWARE as i8;

#[pyattr]

const EX_OSERR: i8 = exitcode::OSERR as i8;

#[pyattr]

const EX_OSFILE: i8 = exitcode::OSFILE as i8;

#[pyattr]

const EX_CANTCREAT: i8 = exitcode::CANTCREAT as i8;

#[pyattr]

const EX_IOERR: i8 = exitcode::IOERR as i8;

#[pyattr]

const EX_TEMPFAIL: i8 = exitcode::TEMPFAIL as i8;

#[pyattr]

const EX_PROTOCOL: i8 = exitcode::PROTOCOL as i8;

#[pyattr]

const EX_NOPERM: i8 = exitcode::NOPERM as i8;

#[pyattr]

const EX_CONFIG: i8 = exitcode::CONFIG as i8;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_OPEN: i32 = PosixSpawnFileActionIdentifier::Open as i32;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_CLOSE: i32 = PosixSpawnFileActionIdentifier::Close as i32;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_DUP2: i32 = PosixSpawnFileActionIdentifier::Dup2 as i32;

impl TryFromObject for BorrowedFd<'_> {

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

crate::stdlib::os::warn_if_bool_fd(&obj, vm)?;

let fd = i32::try_from_object(vm, obj)?;

if fd == -1 {

return Err(io::Error::from_raw_os_error(libc::EBADF).into_pyexception(vm));

}

// SAFETY: none, really. but, python's os api of passing around file descriptors

// everywhere isn't really io-safe anyway, so, this is passed to the user.

Ok(unsafe { BorrowedFd::borrow_raw(fd) })

}

}

impl TryFromObject for OwnedFd {

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

let fd = i32::try_from_object(vm, obj)?;

if fd == -1 {

return Err(io::Error::from_raw_os_error(libc::EBADF).into_pyexception(vm));

}

// SAFETY: none, really. but, python's os api of passing around file descriptors

// everywhere isn't really io-safe anyway, so, this is passed to the user.

Ok(unsafe { Self::from_raw_fd(fd) })

}

}

impl ToPyObject for OwnedFd {

fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {

self.into_raw_fd().to_pyobject(vm)

}

}

#[pyfunction]

fn getgroups(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {

let group_ids =

rustpython_host_env::posix::getgroups().map_err(|e| e.into_pyexception(vm))?;

Ok(group_ids

.into_iter()

.map(|gid| vm.ctx.new_int(gid).into())

.collect())

}

#[pyfunction]

pub(super) fn access(path: OsPath, mode: u8, vm: &VirtualMachine) -> PyResult<bool> {

rustpython_host_env::posix::check_access(path.as_ref(), mode)

.map_err(|err| err.to_pyexception(vm))

}

#[pyattr]

fn environ(vm: &VirtualMachine) -> PyDictRef {

let environ = vm.ctx.new_dict();

for (key, value) in crate::host_env::os::vars_os() {

let key: PyObjectRef = vm.ctx.new_bytes(key.into_vec()).into();

let value: PyObjectRef = vm.ctx.new_bytes(value.into_vec()).into();

environ.set_item(&*key, value, vm).unwrap();

}

environ

}

#[pyfunction]

fn _create_environ(vm: &VirtualMachine) -> PyDictRef {

let environ = vm.ctx.new_dict();

for (key, value) in crate::host_env::os::vars_os() {

let key: PyObjectRef = vm.ctx.new_bytes(key.into_vec()).into();

let value: PyObjectRef = vm.ctx.new_bytes(value.into_vec()).into();

environ.set_item(&*key, value, vm).unwrap();

}

environ

}

#[derive(FromArgs)]

pub(super) struct SymlinkArgs<'fd> {

src: OsPath,

dst: OsPath,

#[pyarg(flatten)]

_target_is_directory: TargetIsDirectory,

#[pyarg(flatten)]

dir_fd: DirFd<'fd, { _os::SYMLINK_DIR_FD as usize }>,

}

#[pyfunction]

pub(super) fn symlink(args: SymlinkArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {

let src = args.src.into_cstring(vm)?;

let dst = args.dst.into_cstring(vm)?;

#[cfg(not(target_os = "redox"))]

{

rustpython_host_env::posix::symlinkat(&src, args.dir_fd.get().into(), &dst)

.map_err(|err| err.into_pyexception(vm))

}

#[cfg(target_os = "redox")]

{

let [] = args.dir_fd.0;

rustpython_host_env::posix::symlink(&src, &dst).map_err(|err| err.into_pyexception(vm))

}

}

#[pyfunction]

#[pyfunction(name = "unlink")]

fn remove(

path: OsPath,

dir_fd: DirFd<'_, { _os::UNLINK_DIR_FD as usize }>,

vm: &VirtualMachine,

) -> PyResult<()> {

#[cfg(not(target_os = "redox"))]

if let Some(fd) = dir_fd.raw_opt() {

let c_path = path.clone().into_cstring(vm)?;

return rustpython_host_env::posix::unlinkat(fd, &c_path)

.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm));

}

#[cfg(target_os = "redox")]

let [] = dir_fd.0;

crate::host_env::fs::remove_file(&path)

.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))

}

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn fchdir(fd: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

warn_if_bool_fd(&fd, vm)?;

let fd = i32::try_from_object(vm, fd)?;

rustpython_host_env::posix::fchdir(fd).map_err(|err| err.into_pyexception(vm))

}

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn chroot(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {

use crate::exceptions::OSErrorBuilder;

rustpython_host_env::posix::chroot(std::path::Path::new(&path.path))

.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))

}

// As of now, redox does not seems to support chown command (cf. https://gitlab.redox-os.org/redox-os/coreutils , last checked on 05/07/2020)

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn chown(

path: OsPathOrFd<'_>,

uid: isize,

gid: isize,

dir_fd: DirFd<'_, 1>,

follow_symlinks: FollowSymlinks,

vm: &VirtualMachine,

) -> PyResult<()> {

let uid = if uid >= 0 {

Some(uid as u32)

} else if uid == -1 {

None

} else {

return Err(vm.new_os_error("Specified uid is not valid."));

};

let gid = if gid >= 0 {

Some(gid as u32)

} else if gid == -1 {

None

} else {

return Err(vm.new_os_error("Specified gid is not valid."));

};

match path {

OsPathOrFd::Path(ref p) => rustpython_host_env::posix::fchownat(

dir_fd.get().into(),

p.path.as_os_str(),

uid,

gid,

follow_symlinks.0,

),

OsPathOrFd::Fd(fd) => rustpython_host_env::posix::fchown(fd.into(), uid, gid),

}

.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))

}

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn lchown(path: OsPath, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {

chown(

OsPathOrFd::Path(path),

uid,

gid,

DirFd::default(),

FollowSymlinks(false),

vm,

)

}

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn fchown(fd: BorrowedFd<'_>, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {

chown(

OsPathOrFd::Fd(fd.into()),

uid,

gid,

DirFd::default(),

FollowSymlinks(true),

vm,

)

}

#[derive(FromArgs)]

struct RegisterAtForkArgs {

#[pyarg(named, optional)]

before: OptionalArg<PyObjectRef>,

#[pyarg(named, optional)]

after_in_parent: OptionalArg<PyObjectRef>,

#[pyarg(named, optional)]

after_in_child: OptionalArg<PyObjectRef>,

}

impl RegisterAtForkArgs {

fn into_validated(

self,

vm: &VirtualMachine,

) -> PyResult<(

Option<PyObjectRef>,

Option<PyObjectRef>,

Option<PyObjectRef>,

)> {

fn into_option(

arg: OptionalArg<PyObjectRef>,

vm: &VirtualMachine,

) -> PyResult<Option<PyObjectRef>> {

match arg {

OptionalArg::Present(obj) => {

if !obj.is_callable() {

return Err(vm.new_type_error("Args must be callable"));

}

Ok(Some(obj))

}

OptionalArg::Missing => Ok(None),

}

}

let before = into_option(self.before, vm)?;

let after_in_parent = into_option(self.after_in_parent, vm)?;

let after_in_child = into_option(self.after_in_child, vm)?;

if before.is_none() && after_in_parent.is_none() && after_in_child.is_none() {

return Err(vm.new_type_error("At least one arg must be present"));

}

Ok((before, after_in_parent, after_in_child))

}

}

#[pyfunction]

fn register_at_fork(

args: RegisterAtForkArgs,

_ignored: KwArgs,

vm: &VirtualMachine,

) -> PyResult<()> {

let (before, after_in_parent, after_in_child) = args.into_validated(vm)?;

if let Some(before) = before {

vm.state.before_forkers.lock().push(before);

}

if let Some(after_in_parent) = after_in_parent {

vm.state.after_forkers_parent.lock().push(after_in_parent);

}

if let Some(after_in_child) = after_in_child {

vm.state.after_forkers_child.lock().push(after_in_child);

}

Ok(())

}

fn run_at_forkers(mut funcs: Vec<PyObjectRef>, reversed: bool, vm: &VirtualMachine) {

if !funcs.is_empty() {

if reversed {

funcs.reverse();

}

for func in funcs {

if let Err(e) = func.call((), vm) {

let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);

vm.run_unraisable(e, Some("Exception ignored in".to_owned()), func);

if exit {

// Do nothing!

}

}

}

}

}

fn py_os_before_fork(vm: &VirtualMachine) {

let before_forkers: Vec<PyObjectRef> = vm.state.before_forkers.lock().clone();

// functions must be executed in reversed order as they are registered

// only for before_forkers, refer: test_register_at_fork in test_posix

run_at_forkers(before_forkers, true, vm);

#[cfg(feature = "threading")]

crate::stdlib::_imp::acquire_imp_lock_for_fork();

#[cfg(feature = "threading")]

vm.state.stop_the_world.stop_the_world(vm);

}

fn py_os_after_fork_child(vm: &VirtualMachine) {

#[cfg(feature = "threading")]

vm.state.stop_the_world.reset_after_fork();

// Phase 1: Reset all internal locks FIRST.

// After fork(), locks held by dead parent threads would deadlock

// if we try to acquire them. This must happen before anything else.

#[cfg(feature = "threading")]

reinit_locks_after_fork(vm);

// Reinit per-object IO buffer locks on std streams.

// BufferedReader/Writer/TextIOWrapper use PyThreadMutex which can be

// held by dead parent threads, causing deadlocks on any IO in the child.

#[cfg(feature = "threading")]

unsafe {

crate::stdlib::_io::reinit_std_streams_after_fork(vm)

};

// Phase 2: Reset low-level atomic state (no locks needed).

crate::signal::clear_after_fork();

crate::stdlib::_signal::_signal::clear_wakeup_fd_after_fork();

// Reset weakref stripe locks that may have been held during fork.

#[cfg(feature = "threading")]

crate::object::reset_weakref_locks_after_fork();

// Phase 3: Clean up thread state. Locks are now reinit'd so we can

// acquire them normally instead of using try_lock().

#[cfg(feature = "threading")]

crate::stdlib::_thread::after_fork_child(vm);

// CPython parity: reinit import lock ownership metadata in child

// and release the lock acquired by PyOS_BeforeFork().

#[cfg(feature = "threading")]

unsafe {

crate::stdlib::_imp::after_fork_child_imp_lock_release()

};

// Initialize signal handlers for the child's main thread.

// When forked from a worker thread, the OnceCell is empty.

vm.signal_handlers

.get_or_init(crate::signal::new_signal_handlers);

// Phase 4: Run Python-level at-fork callbacks.

let after_forkers_child: Vec<PyObjectRef> = vm.state.after_forkers_child.lock().clone();

run_at_forkers(after_forkers_child, false, vm);

}

/// Reset all parking_lot-based locks in the interpreter state after fork().

///

/// After fork(), only the calling thread survives. Any locks held by other

/// (now-dead) threads would cause deadlocks. We unconditionally reset them

/// to unlocked by zeroing the raw lock bytes.

#[cfg(all(unix, feature = "threading"))]

fn reinit_locks_after_fork(vm: &VirtualMachine) {

use rustpython_common::lock::reinit_mutex_after_fork;

unsafe {

// PyGlobalState PyMutex locks

reinit_mutex_after_fork(&vm.state.before_forkers);

reinit_mutex_after_fork(&vm.state.after_forkers_child);

reinit_mutex_after_fork(&vm.state.after_forkers_parent);

reinit_mutex_after_fork(&vm.state.atexit_funcs);

reinit_mutex_after_fork(&vm.state.global_trace_func);

reinit_mutex_after_fork(&vm.state.global_profile_func);

reinit_mutex_after_fork(&vm.state.monitoring);

// PyGlobalState parking_lot::Mutex locks

reinit_mutex_after_fork(&vm.state.thread_frames);

reinit_mutex_after_fork(&vm.state.thread_handles);

reinit_mutex_after_fork(&vm.state.shutdown_handles);

// Context-level RwLock

vm.ctx.string_pool.reinit_after_fork();

// Codec registry RwLock

vm.state.codec_registry.reinit_after_fork();

// GC state (multiple Mutex + RwLock)

crate::gc_state::gc_state().reinit_after_fork();

// Import lock (RawReentrantMutex<RawMutex, RawThreadId>)

crate::stdlib::_imp::reinit_imp_lock_after_fork();

}

}

fn py_os_after_fork_parent(vm: &VirtualMachine) {

#[cfg(feature = "threading")]

vm.state.stop_the_world.start_the_world(vm);

#[cfg(feature = "threading")]

crate::stdlib::_imp::release_imp_lock_after_fork_parent();

let after_forkers_parent: Vec<PyObjectRef> = vm.state.after_forkers_parent.lock().clone();

run_at_forkers(after_forkers_parent, false, vm);

}

/// Best-effort number of OS threads in this process.

/// Returns <= 0 when unavailable.

fn get_number_of_os_threads() -> isize {

rustpython_host_env::posix::get_number_of_os_threads()

}

/// Warn if forking from a multi-threaded process.

/// `num_os_threads` should be captured before parent after-fork hooks run.

fn warn_if_multi_threaded(name: &str, num_os_threads: isize, vm: &VirtualMachine) {

let num_threads = if num_os_threads > 0 {

num_os_threads as usize

} else {

// CPython fallback: if OS-level count isn't available, use the

// threading module's active+limbo view.

// Only check threading if it was already imported. Avoid vm.import()

// which can execute arbitrary Python code in the fork path.

let threading = match vm

.sys_module

.get_attr("modules", vm)

.and_then(|m| m.get_item("threading", vm))

{

Ok(m) => m,

Err(_) => return,

};

let active = threading.get_attr("_active", vm).ok();

let limbo = threading.get_attr("_limbo", vm).ok();

// Match threading module internals and avoid sequence overcounting:

// count only dict-backed _active/_limbo containers.

let count_dict = |obj: Option<crate::PyObjectRef>| -> usize {

obj.and_then(|o| {

o.downcast_ref::<crate::builtins::PyDict>()

.map(|d| d.__len__())

})

.unwrap_or(0)

};

count_dict(active) + count_dict(limbo)

};

if num_threads > 1 {

let pid = rustpython_host_env::posix::getpid();

let msg = format!(

"This process (pid={pid}) is multi-threaded, use of {name}() may lead to deadlocks in the child."

);

// Match PyErr_WarnFormat(..., stacklevel=1) in CPython.

// Best effort: ignore failures like CPython does in this path.

let _ =

crate::stdlib::_warnings::warn(vm.ctx.exceptions.deprecation_warning, msg, 1, vm);

}

}

#[pyfunction]

fn fork(vm: &VirtualMachine) -> PyResult<i32> {

if vm

.state

.finalizing

.load(core::sync::atomic::Ordering::Acquire)

{

return Err(vm.new_exception_msg(

vm.ctx.exceptions.python_finalization_error.to_owned(),

"can't fork at interpreter shutdown".into(),

));

}

// RustPython does not yet have C-level audit hooks; call sys.audit()

// to preserve Python-visible behavior and failure semantics.

vm.sys_module

.get_attr("audit", vm)?

.call(("os.fork",), vm)?;

py_os_before_fork(vm);

let pid = rustpython_host_env::posix::fork();

match pid {

Ok(0) => {

py_os_after_fork_child(vm);

Ok(0)

}

Ok(pid) => {

// Match CPython timing: capture this before parent after-fork hooks

// in case those hooks start threads.

let num_os_threads = get_number_of_os_threads();

py_os_after_fork_parent(vm);

// Match CPython timing: warn only after parent callback path resumes world.

warn_if_multi_threaded("fork", num_os_threads, vm);

Ok(pid)

}

Err(err) => Err(err.into_pyexception(vm)),

}

}

#[cfg(not(target_os = "redox"))]

const MKNOD_DIR_FD: bool = cfg!(not(target_vendor = "apple"));

#[cfg(not(target_os = "redox"))]

#[derive(FromArgs)]

struct MknodArgs<'fd> {

#[pyarg(any)]

path: OsPath,

#[pyarg(any)]

mode: libc::mode_t,

#[pyarg(any)]

device: libc::dev_t,

#[pyarg(flatten)]

dir_fd: DirFd<'fd, { MKNOD_DIR_FD as usize }>,

}

#[cfg(not(target_os = "redox"))]

impl MknodArgs<'_> {

#[cfg(not(target_vendor = "apple"))]

fn mknod(self, vm: &VirtualMachine) -> PyResult<()> {

let c_path = self.path.clone().into_cstring(vm)?;

match self.dir_fd.raw_opt() {

None => rustpython_host_env::posix::mknod(&c_path, self.mode, self.device),

Some(non_default_fd) => rustpython_host_env::posix::mknodat(

non_default_fd,

&c_path,

self.mode,

self.device,

),

}

.map_err(|err| err.into_pyexception(vm))

}

#[cfg(target_vendor = "apple")]

fn mknod(self, vm: &VirtualMachine) -> PyResult<()> {

let [] = self.dir_fd.0;

let c_path = self.path.clone().into_cstring(vm)?;

rustpython_host_env::posix::mknod(&c_path, self.mode, self.device)

.map_err(|err| err.into_pyexception(vm))

}

}

#[cfg(not(target_os = "redox"))]

#[pyfunction]

fn mknod(args: MknodArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {