miri/shims/unix/linux/

foreign_items.rs

use rustc_abi::CanonAbi;
use rustc_middle::ty::Ty;
use rustc_span::Symbol;
use rustc_target::callconv::FnAbi;

use self::shims::unix::linux::mem::EvalContextExt as _;
use self::shims::unix::linux_like::eventfd::EvalContextExt as _;
use self::shims::unix::linux_like::syscall::syscall;
use crate::machine::{SIGRTMAX, SIGRTMIN};
use crate::shims::unix::foreign_items::EvalContextExt as _;
use crate::shims::unix::linux_like::epoll::EvalContextExt as _;
use crate::shims::unix::linux_like::thread::prctl;
use crate::shims::unix::*;
use crate::*;

// The documentation of glibc complains that the kernel never exposes
// TASK_COMM_LEN through the headers, so it's assumed to always be 16 bytes
// long including a null terminator.
const TASK_COMM_LEN: u64 = 16;

pub fn is_dyn_sym(name: &str) -> bool {
    matches!(name, "gettid" | "statx")
}

impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
    fn emulate_foreign_item_inner(
        &mut self,
        link_name: Symbol,
        abi: &FnAbi<'tcx, Ty<'tcx>>,
        args: &[OpTy<'tcx>],
        dest: &MPlaceTy<'tcx>,
    ) -> InterpResult<'tcx, EmulateItemResult> {
        let this = self.eval_context_mut();

        // See `fn emulate_foreign_item_inner` in `shims/foreign_items.rs` for the general pattern.

        match link_name.as_str() {
            // File related shims
            "open64" => {
                // FIXME: This does not have a direct test (#3179).
                // "open64" means that the file is opened with O_LARGEFILE, which we always do.
                let ([path_raw, flag], varargs) = this.check_shim_sig_variadic(
                    shim_sig!(extern "C" fn(*_, i32, ...) -> i32),
                    (link_name, abi, args),
                )?;
                let result = this.open(None, path_raw, flag, varargs)?;
                this.write_scalar(result, dest)?;
            }
            "openat64" => {
                // FIXME: This does not have a direct test (#3179).
                // "openat64" means that the file is opened with O_LARGEFILE, which we always do.
                let ([dirfd, path_raw, flag], varargs) = this.check_shim_sig_variadic(
                    shim_sig!(extern "C" fn(i32, *_, i32, ...) -> i32),
                    (link_name, abi, args),
                )?;
                let result = this.open(Some(dirfd), path_raw, flag, varargs)?;
                this.write_scalar(result, dest)?;
            }
            "pread64" => {
                // FIXME: This does not have a direct test (#3179).
                let [fd, buf, count, offset] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, *_, usize, libc::off64_t) -> isize),
                    (link_name, abi, args),
                )?;
                let fd = this.read_scalar(fd)?.to_i32()?;
                let buf = this.read_pointer(buf)?;
                let count = this.read_target_usize(count)?;
                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
                this.read(fd, buf, count, Some(offset), dest)?;
            }
            "pwrite64" => {
                // FIXME: This does not have a direct test (#3179).
                let [fd, buf, n, offset] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, *_, usize, libc::off64_t) -> isize),
                    (link_name, abi, args),
                )?;
                let fd = this.read_scalar(fd)?.to_i32()?;
                let buf = this.read_pointer(buf)?;
                let count = this.read_target_usize(n)?;
                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
                trace!("Called pwrite64({:?}, {:?}, {:?}, {:?})", fd, buf, count, offset);
                this.write(fd, buf, count, Some(offset), dest)?;
            }
            "lseek64" => {
                // FIXME: This does not have a direct test (#3179).
                let [fd, offset, whence] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, libc::off64_t, i32) -> libc::off64_t),
                    (link_name, abi, args),
                )?;
                let fd = this.read_scalar(fd)?.to_i32()?;
                let offset = this.read_scalar(offset)?.to_int(offset.layout.size)?;
                let whence = this.read_scalar(whence)?.to_i32()?;
                this.lseek(fd, offset, whence, dest)?;
            }
            "posix_fallocate64" => {
                let [fd, offset, len] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, libc::off64_t, libc::off64_t) -> i32),
                    (link_name, abi, args),
                )?;

                let fd = this.read_scalar(fd)?.to_i32()?;
                let offset = this.read_scalar(offset)?.to_i64()?;
                let len = this.read_scalar(len)?.to_i64()?;

                let result = this.posix_fallocate(fd, offset, len)?;
                this.write_scalar(result, dest)?;
            }
            "fallocate" => {
                let [fd, mode, offset, len] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, i32, libc::off_t, libc::off_t) -> i32),
                    (link_name, abi, args),
                )?;

                let fd = this.read_scalar(fd)?.to_i32()?;
                let mode = this.read_scalar(mode)?.to_i32()?;
                // We don't support platforms which have libc::off_t bigger than 64 bits.
                let offset =
                    i64::try_from(this.read_scalar(offset)?.to_int(offset.layout.size)?).unwrap();
                let len = i64::try_from(this.read_scalar(len)?.to_int(len.layout.size)?).unwrap();

                let result = this.linux_fallocate(fd, mode, offset, len)?;
                this.write_scalar(result, dest)?;
            }
            "fallocate64" => {
                let [fd, mode, offset, len] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, i32, libc::off64_t, libc::off64_t) -> i32),
                    (link_name, abi, args),
                )?;

                let fd = this.read_scalar(fd)?.to_i32()?;
                let mode = this.read_scalar(mode)?.to_i32()?;
                let offset = this.read_scalar(offset)?.to_i64()?;
                let len = this.read_scalar(len)?.to_i64()?;

                let result = this.linux_fallocate(fd, mode, offset, len)?;
                this.write_scalar(result, dest)?;
            }
            "ftruncate64" => {
                let [fd, length] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, libc::off64_t) -> i32),
                    (link_name, abi, args),
                )?;
                let fd = this.read_scalar(fd)?.to_i32()?;
                let length = this.read_scalar(length)?.to_int(length.layout.size)?;
                let result = this.ftruncate64(fd, length)?;
                this.write_scalar(result, dest)?;
            }
            "sync_file_range" => {
                let [fd, offset, nbytes, flags] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.sync_file_range(fd, offset, nbytes, flags)?;
                this.write_scalar(result, dest)?;
            }
            "statx" => {
                let [dirfd, pathname, flags, mask, statxbuf] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.linux_statx(dirfd, pathname, flags, mask, statxbuf)?;
                this.write_scalar(result, dest)?;
            }
            "fstat64" => {
                let [fd, buf] = this.check_shim_sig(
                    shim_sig!(extern "C" fn(i32, *_) -> i32),
                    (link_name, abi, args),
                )?;
                let result = this.fstat(fd, buf, "stat64")?;
                this.write_scalar(result, dest)?;
            }
            "readdir64" => {
                let [dirp] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                this.readdir(dirp, dest, "dirent64")?;
            }

            // epoll, eventfd
            "epoll_create1" => {
                let [flag] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.epoll_create1(flag)?;
                this.write_scalar(result, dest)?;
            }
            "epoll_ctl" => {
                let [epfd, op, fd, event] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.epoll_ctl(epfd, op, fd, event)?;
                this.write_scalar(result, dest)?;
            }
            "epoll_wait" => {
                let [epfd, events, maxevents, timeout] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                this.epoll_wait(epfd, events, maxevents, timeout, dest)?;
            }
            "eventfd" => {
                let [val, flag] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.eventfd(val, flag)?;
                this.write_scalar(result, dest)?;
            }

            // Threading
            "pthread_setname_np" => {
                let [thread, name] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let res = match this.pthread_setname_np(
                    this.read_scalar(thread)?,
                    this.read_scalar(name)?,
                    TASK_COMM_LEN,
                    /* truncate */ false,
                )? {
                    ThreadNameResult::Ok => Scalar::from_u32(0),
                    ThreadNameResult::NameTooLong => this.eval_libc("ERANGE"),
                };
                this.write_scalar(res, dest)?;
            }
            "pthread_getname_np" => {
                let [thread, name, len] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                // The function's behavior isn't portable between platforms.
                // In case of glibc, the length of the output buffer must
                // be not shorter than TASK_COMM_LEN.
                let len = this.read_scalar(len)?;
                let res = if len.to_target_usize(this)? >= TASK_COMM_LEN {
                    match this.pthread_getname_np(
                        this.read_scalar(thread)?,
                        this.read_scalar(name)?,
                        len,
                        /* truncate*/ false,
                    )? {
                        ThreadNameResult::Ok => Scalar::from_u32(0),
                        ThreadNameResult::NameTooLong => unreachable!(),
                    }
                } else {
                    this.eval_libc("ERANGE")
                };
                this.write_scalar(res, dest)?;
            }
            "gettid" => {
                let [] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.unix_gettid(link_name.as_str())?;
                this.write_scalar(result, dest)?;
            }
            "prctl" => prctl(this, link_name, abi, args, dest)?,

            // Dynamically invoked syscalls
            "syscall" => {
                syscall(this, link_name, abi, args, dest)?;
            }

            // Miscellaneous
            "mmap64" => {
                let [addr, length, prot, flags, fd, offset] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let offset = this.read_scalar(offset)?.to_i64()?;
                let ptr = this.mmap(addr, length, prot, flags, fd, offset.into())?;
                this.write_scalar(ptr, dest)?;
            }
            "mremap" => {
                let ([old_address, old_size, new_size, flags], _) = this.check_shim_sig_variadic(
                    shim_sig!(extern "C" fn(*_, usize, usize, i32, ...) -> *_),
                    (link_name, abi, args),
                )?;
                let ptr = this.mremap(old_address, old_size, new_size, flags)?;
                this.write_scalar(ptr, dest)?;
            }
            "__xpg_strerror_r" => {
                let [errnum, buf, buflen] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let result = this.strerror_r(errnum, buf, buflen)?;
                this.write_scalar(result, dest)?;
            }
            "__errno_location" => {
                let [] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                let errno_place = this.last_error_place()?;
                this.write_scalar(errno_place.to_ref(this).to_scalar(), dest)?;
            }
            "__libc_current_sigrtmin" => {
                let [] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;

                this.write_int(SIGRTMIN, dest)?;
            }
            "__libc_current_sigrtmax" => {
                let [] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;

                this.write_int(SIGRTMAX, dest)?;
            }

            // Incomplete shims that we "stub out" just to get pre-main initialization code to work.
            // These shims are enabled only when the caller is in the standard library.
            "pthread_getattr_np" if this.frame_in_std() => {
                let [_thread, _attr] =
                    this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                this.write_null(dest)?;
            }
            "gnu_get_libc_version"
                if this.frame_in_std()
                    && this.tcx.sess.target.env == rustc_target::spec::Env::Gnu =>
            {
                let [] = this.check_shim_sig_deprecated(abi, CanonAbi::C, link_name, args)?;
                // We have to be at least version 2.26 so that std does not call `res_init`.
                // This returns a C string, so we have to add a null terminator.
                let version = "2.26\0";
                let version = this.allocate_str_dedup(version)?;
                this.write_pointer(version.ptr(), dest)?;
            }

            _ => return interp_ok(EmulateItemResult::NotSupported),
        };

        interp_ok(EmulateItemResult::NeedsReturn)
    }
}