diff --git a/Cargo.lock b/Cargo.lock
index e2b7b58c372ba..8ccad78614ba3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3118,9 +3118,9 @@ dependencies = [
[[package]]
name = "rustc-build-sysroot"
-version = "0.5.5"
+version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb332121f7845c6bd016f9655cf22f03c2999df936694b624a88669a78667d98"
+checksum = "10edc2e4393515193bd766e2f6c050b0536a68e56f2b6d56c07ababfdc114ff0"
dependencies = [
"anyhow",
"rustc_version",
diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 122438a2509b3..de521393cd0ab 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -218,7 +218,7 @@ degree documented below):
make no promises and we don't run tests for such targets.
- We have unofficial support (not maintained by the Miri team itself) for some further operating systems.
- `solaris` / `illumos`: maintained by @devnexen. Supports the entire test suite.
- - `freebsd`: maintained by @YohDeadfall. Supports `std::env` and parts of `std::{thread, fs}`, but not `std::sync`.
+ - `freebsd`: maintained by @YohDeadfall and @LorrensP-2158466. Supports the entire test suite.
- `android`: **maintainer wanted**. Support very incomplete, but a basic "hello world" works.
- `wasi`: **maintainer wanted**. Support very incomplete, not even standard output works, but an empty `main` function works.
- For targets on other operating systems, Miri might fail before even reaching the `main` function.
diff --git a/src/tools/miri/cargo-miri/Cargo.lock b/src/tools/miri/cargo-miri/Cargo.lock
index bd4ca2860f35a..c1915ae617e87 100644
--- a/src/tools/miri/cargo-miri/Cargo.lock
+++ b/src/tools/miri/cargo-miri/Cargo.lock
@@ -208,9 +208,9 @@ dependencies = [
[[package]]
name = "rustc-build-sysroot"
-version = "0.5.4"
+version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6d984a9db43148467059309bd1e5ad577085162f695d9fe2cf3543aeb25cd38"
+checksum = "10edc2e4393515193bd766e2f6c050b0536a68e56f2b6d56c07ababfdc114ff0"
dependencies = [
"anyhow",
"rustc_version",
diff --git a/src/tools/miri/cargo-miri/Cargo.toml b/src/tools/miri/cargo-miri/Cargo.toml
index 23048914af18e..5c579b2a77d62 100644
--- a/src/tools/miri/cargo-miri/Cargo.toml
+++ b/src/tools/miri/cargo-miri/Cargo.toml
@@ -18,7 +18,7 @@ directories = "6"
rustc_version = "0.4"
serde_json = "1.0.40"
cargo_metadata = "0.19"
-rustc-build-sysroot = "0.5.4"
+rustc-build-sysroot = "0.5.7"
# Enable some feature flags that dev-dependencies need but dependencies
# do not. This makes `./miri install` after `./miri build` faster.
diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 755e02d02eca1..9ae15739dcbe1 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -156,16 +156,17 @@ case $HOST_TARGET in
MANY_SEEDS=64 TEST_TARGET=i686-pc-windows-gnu run_tests
MANY_SEEDS=64 TEST_TARGET=x86_64-pc-windows-msvc CARGO_MIRI_ENV=1 run_tests
# Extra tier 2
- TEST_TARGET=arm-unknown-linux-gnueabi run_tests
- TEST_TARGET=s390x-unknown-linux-gnu run_tests # big-endian architecture of choice
+ MANY_SEEDS=16 TEST_TARGET=arm-unknown-linux-gnueabi run_tests
+ MANY_SEEDS=16 TEST_TARGET=s390x-unknown-linux-gnu run_tests # big-endian architecture of choice
# Not officially supported tier 2
- TEST_TARGET=x86_64-unknown-illumos run_tests
- TEST_TARGET=x86_64-pc-solaris run_tests
+ MANY_SEEDS=16 TEST_TARGET=mips-unknown-linux-gnu run_tests # a 32bit big-endian target, and also a target without 64bit atomics
+ MANY_SEEDS=16 TEST_TARGET=x86_64-unknown-illumos run_tests
+ MANY_SEEDS=16 TEST_TARGET=x86_64-pc-solaris run_tests
+ MANY_SEEDS=16 TEST_TARGET=x86_64-unknown-freebsd run_tests
+ MANY_SEEDS=16 TEST_TARGET=i686-unknown-freebsd run_tests
# Partially supported targets (tier 2)
BASIC="empty_main integer heap_alloc libc-mem vec string btreemap" # ensures we have the basics: pre-main code, system allocator
UNIX="hello panic/panic panic/unwind concurrency/simple atomic libc-mem libc-misc libc-random env num_cpus" # the things that are very similar across all Unixes, and hence easily supported there
- TEST_TARGET=x86_64-unknown-freebsd run_tests_minimal $BASIC $UNIX time hashmap random thread sync concurrency fs libc-pipe
- TEST_TARGET=i686-unknown-freebsd run_tests_minimal $BASIC $UNIX time hashmap random thread sync concurrency fs libc-pipe
TEST_TARGET=aarch64-linux-android run_tests_minimal $BASIC $UNIX time hashmap random thread sync concurrency epoll eventfd
TEST_TARGET=wasm32-wasip2 run_tests_minimal $BASIC wasm
TEST_TARGET=wasm32-unknown-unknown run_tests_minimal no_std empty_main wasm # this target doesn't really have std
diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 8b98fe3c4fc3e..4698969530292 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-ac17c3486c6fdfbb0c3c18b99f3d8dfbff625d29
+2b96ddca1272960623e41829439df8dae82d20af
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index dd389d97cdce0..21bd7fb54c6cd 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -168,7 +168,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
AllocKind::Dead => unreachable!(),
};
// We don't have to expose this pointer yet, we do that in `prepare_for_native_call`.
- return interp_ok(base_ptr.addr().try_into().unwrap());
+ return interp_ok(base_ptr.addr().to_u64());
}
// We are not in native lib mode, so we control the addresses ourselves.
if let Some((reuse_addr, clock)) = global_state.reuse.take_addr(
diff --git a/src/tools/miri/src/alloc_addresses/reuse_pool.rs b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
index 29d4f2bb7b0f3..ab6aaed5e3e1c 100644
--- a/src/tools/miri/src/alloc_addresses/reuse_pool.rs
+++ b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
@@ -4,6 +4,7 @@ use rand::Rng;
use rustc_abi::{Align, Size};
use crate::concurrency::VClock;
+use crate::helpers::ToUsize as _;
use crate::{MemoryKind, MiriConfig, ThreadId};
const MAX_POOL_SIZE: usize = 64;
@@ -46,7 +47,7 @@ impl ReusePool {
}
fn subpool(&mut self, align: Align) -> &mut Vec<(u64, Size, ThreadId, VClock)> {
- let pool_idx: usize = align.bytes().trailing_zeros().try_into().unwrap();
+ let pool_idx: usize = align.bytes().trailing_zeros().to_usize();
if self.pool.len() <= pool_idx {
self.pool.resize(pool_idx + 1, Vec::new());
}
diff --git a/src/tools/miri/src/alloc_bytes.rs b/src/tools/miri/src/alloc_bytes.rs
index 69ede279aa9b1..6788494c01cce 100644
--- a/src/tools/miri/src/alloc_bytes.rs
+++ b/src/tools/miri/src/alloc_bytes.rs
@@ -5,6 +5,8 @@ use std::{alloc, slice};
use rustc_abi::{Align, Size};
use rustc_middle::mir::interpret::AllocBytes;
+use crate::helpers::ToU64 as _;
+
/// Allocation bytes that explicitly handle the layout of the data they're storing.
/// This is necessary to interface with native code that accesses the program store in Miri.
#[derive(Debug)]
@@ -21,7 +23,7 @@ pub struct MiriAllocBytes {
impl Clone for MiriAllocBytes {
fn clone(&self) -> Self {
let bytes: Cow<'_, [u8]> = Cow::Borrowed(self);
- let align = Align::from_bytes(self.layout.align().try_into().unwrap()).unwrap();
+ let align = Align::from_bytes(self.layout.align().to_u64()).unwrap();
MiriAllocBytes::from_bytes(bytes, align)
}
}
@@ -90,7 +92,7 @@ impl AllocBytes for MiriAllocBytes {
let align = align.bytes();
// SAFETY: `alloc_fn` will only be used with `size != 0`.
let alloc_fn = |layout| unsafe { alloc::alloc(layout) };
- let alloc_bytes = MiriAllocBytes::alloc_with(size.try_into().unwrap(), align, alloc_fn)
+ let alloc_bytes = MiriAllocBytes::alloc_with(size.to_u64(), align, alloc_fn)
.unwrap_or_else(|()| {
panic!("Miri ran out of memory: cannot create allocation of {size} bytes")
});
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
index 7874721c0ac37..dcd5a6cb02305 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
@@ -17,6 +17,8 @@ use std::mem;
use rustc_data_structures::fx::FxHashMap;
+use crate::helpers::ToUsize;
+
/// Intermediate key between a UniKeyMap and a UniValMap.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct UniIndex {
@@ -158,7 +160,7 @@ where
impl<V> UniValMap<V> {
/// Whether this index has an associated value.
pub fn contains_idx(&self, idx: UniIndex) -> bool {
- self.data.get(idx.idx as usize).and_then(Option::as_ref).is_some()
+ self.data.get(idx.idx.to_usize()).and_then(Option::as_ref).is_some()
}
/// Reserve enough space to insert the value at the right index.
@@ -174,29 +176,29 @@ impl<V> UniValMap<V> {
/// Assign a value to the index. Permanently overwrites any previous value.
pub fn insert(&mut self, idx: UniIndex, val: V) {
- self.extend_to_length(idx.idx as usize + 1);
- self.data[idx.idx as usize] = Some(val)
+ self.extend_to_length(idx.idx.to_usize() + 1);
+ self.data[idx.idx.to_usize()] = Some(val)
}
/// Get the value at this index, if it exists.
pub fn get(&self, idx: UniIndex) -> Option<&V> {
- self.data.get(idx.idx as usize).and_then(Option::as_ref)
+ self.data.get(idx.idx.to_usize()).and_then(Option::as_ref)
}
/// Get the value at this index mutably, if it exists.
pub fn get_mut(&mut self, idx: UniIndex) -> Option<&mut V> {
- self.data.get_mut(idx.idx as usize).and_then(Option::as_mut)
+ self.data.get_mut(idx.idx.to_usize()).and_then(Option::as_mut)
}
/// Delete any value associated with this index.
/// Returns None if the value was not present, otherwise
/// returns the previously stored value.
pub fn remove(&mut self, idx: UniIndex) -> Option<V> {
- if idx.idx as usize >= self.data.len() {
+ if idx.idx.to_usize() >= self.data.len() {
return None;
}
let mut res = None;
- mem::swap(&mut res, &mut self.data[idx.idx as usize]);
+ mem::swap(&mut res, &mut self.data[idx.idx.to_usize()]);
res
}
}
@@ -209,8 +211,8 @@ pub struct UniEntry<'a, V> {
impl<'a, V> UniValMap<V> {
/// Get a wrapper around a mutable access to the value corresponding to `idx`.
pub fn entry(&'a mut self, idx: UniIndex) -> UniEntry<'a, V> {
- self.extend_to_length(idx.idx as usize + 1);
- UniEntry { inner: &mut self.data[idx.idx as usize] }
+ self.extend_to_length(idx.idx.to_usize() + 1);
+ UniEntry { inner: &mut self.data[idx.idx.to_usize()] }
}
}
diff --git a/src/tools/miri/src/concurrency/cpu_affinity.rs b/src/tools/miri/src/concurrency/cpu_affinity.rs
index b47b614cf5f0e..9583de5a4838c 100644
--- a/src/tools/miri/src/concurrency/cpu_affinity.rs
+++ b/src/tools/miri/src/concurrency/cpu_affinity.rs
@@ -25,7 +25,7 @@ impl CpuAffinityMask {
let mut this = Self([0; Self::CPU_MASK_BYTES]);
// the default affinity mask includes only the available CPUs
- for i in 0..cpu_count as usize {
+ for i in 0..cpu_count.to_usize() {
this.set(cx, i);
}
diff --git a/src/tools/miri/src/concurrency/vector_clock.rs b/src/tools/miri/src/concurrency/vector_clock.rs
index 78858fcedaec7..494e7922d2b2b 100644
--- a/src/tools/miri/src/concurrency/vector_clock.rs
+++ b/src/tools/miri/src/concurrency/vector_clock.rs
@@ -7,6 +7,7 @@ use rustc_span::{DUMMY_SP, Span, SpanData};
use smallvec::SmallVec;
use super::data_race::NaReadType;
+use crate::helpers::ToUsize;
/// A vector clock index, this is associated with a thread id
/// but in some cases one vector index may be shared with
@@ -157,7 +158,7 @@ impl VClock {
#[inline]
pub(super) fn index_mut(&mut self, index: VectorIdx) -> &mut VTimestamp {
- self.0.as_mut_slice().get_mut(index.to_u32() as usize).unwrap()
+ self.0.as_mut_slice().get_mut(index.to_u32().to_usize()).unwrap()
}
/// Get a mutable slice to the internal vector with minimum `min_len`
@@ -420,7 +421,7 @@ impl Index<VectorIdx> for VClock {
#[inline]
fn index(&self, index: VectorIdx) -> &VTimestamp {
- self.as_slice().get(index.to_u32() as usize).unwrap_or(&VTimestamp::ZERO)
+ self.as_slice().get(index.to_u32().to_usize()).unwrap_or(&VTimestamp::ZERO)
}
}
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index 8e7c9edfcc078..ff2ec1b3e60a8 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -1412,3 +1412,26 @@ pub(crate) fn windows_check_buffer_size((success, len): (bool, u64)) -> u32 {
u32::try_from(len).unwrap()
}
}
+
+/// We don't support 16-bit systems, so let's have ergonomic conversion from `u32` to `usize`.
+pub trait ToUsize {
+ fn to_usize(self) -> usize;
+}
+
+impl ToUsize for u32 {
+ fn to_usize(self) -> usize {
+ self.try_into().unwrap()
+ }
+}
+
+/// Similarly, a maximum address size of `u64` is assumed widely here, so let's have ergonomic
+/// converion from `usize` to `u64`.
+pub trait ToU64 {
+ fn to_u64(self) -> u64;
+}
+
+impl ToU64 for usize {
+ fn to_u64(self) -> u64 {
+ self.try_into().unwrap()
+ }
+}
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index c9250ba1b818d..b17fd4fb7f932 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -634,7 +634,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let index_len = index.len();
assert_eq!(left_len, right_len);
- assert_eq!(index_len as u64, dest_len);
+ assert_eq!(u64::try_from(index_len).unwrap(), dest_len);
for i in 0..dest_len {
let src_index: u64 =
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 329a7e56bc09f..9a3325f8286af 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -41,14 +41,7 @@
rustc::potential_query_instability,
rustc::untranslatable_diagnostic,
)]
-#![warn(
- rust_2018_idioms,
- unqualified_local_imports,
- clippy::cast_possible_wrap, // unsigned -> signed
- clippy::cast_sign_loss, // signed -> unsigned
- clippy::cast_lossless,
- clippy::cast_possible_truncation,
-)]
+#![warn(rust_2018_idioms, unqualified_local_imports, clippy::as_conversions)]
// Needed for rustdoc from bootstrap (with `-Znormalize-docs`).
#![recursion_limit = "256"]
@@ -140,7 +133,7 @@ pub use crate::eval::{
AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, MiriEntryFnType, RejectOpWith,
ValidationMode, create_ecx, eval_entry,
};
-pub use crate::helpers::{AccessKind, EvalContextExt as _};
+pub use crate::helpers::{AccessKind, EvalContextExt as _, ToU64 as _, ToUsize as _};
pub use crate::intrinsics::EvalContextExt as _;
pub use crate::machine::{
AllocExtra, DynMachineCallback, FrameExtra, MachineCallback, MemoryKind, MiriInterpCx,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 1c6c7894cb456..f75adffd9508e 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -544,9 +544,6 @@ pub struct MiriMachine<'tcx> {
/// Failure rate of compare_exchange_weak, between 0.0 and 1.0
pub(crate) cmpxchg_weak_failure_rate: f64,
- /// Corresponds to -Zmiri-mute-stdout-stderr and doesn't write the output but acts as if it succeeded.
- pub(crate) mute_stdout_stderr: bool,
-
/// The probability of the active thread being preempted at the end of each basic block.
pub(crate) preemption_rate: f64,
@@ -722,7 +719,6 @@ impl<'tcx> MiriMachine<'tcx> {
track_alloc_accesses: config.track_alloc_accesses,
check_alignment: config.check_alignment,
cmpxchg_weak_failure_rate: config.cmpxchg_weak_failure_rate,
- mute_stdout_stderr: config.mute_stdout_stderr,
preemption_rate: config.preemption_rate,
report_progress: config.report_progress,
basic_block_count: 0,
@@ -925,7 +921,6 @@ impl VisitProvenance for MiriMachine<'_> {
track_alloc_accesses: _,
check_alignment: _,
cmpxchg_weak_failure_rate: _,
- mute_stdout_stderr: _,
preemption_rate: _,
report_progress: _,
basic_block_count: _,
diff --git a/src/tools/miri/src/shims/backtrace.rs b/src/tools/miri/src/shims/backtrace.rs
index 7e667e70a1721..9f3bc06771f55 100644
--- a/src/tools/miri/src/shims/backtrace.rs
+++ b/src/tools/miri/src/shims/backtrace.rs
@@ -25,7 +25,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let frame_count = this.active_thread_stack().len();
- this.write_scalar(Scalar::from_target_usize(frame_count.try_into().unwrap(), this), dest)
+ this.write_scalar(Scalar::from_target_usize(frame_count.to_u64(), this), dest)
}
fn handle_miri_get_backtrace(
@@ -70,7 +70,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
1 =>
for (i, ptr) in ptrs.into_iter().enumerate() {
- let offset = ptr_layout.size.checked_mul(i.try_into().unwrap(), this).unwrap();
+ let offset = ptr_layout.size.checked_mul(i.to_u64(), this).unwrap();
let op_place = buf_place.offset(offset, ptr_layout, this)?;
@@ -158,11 +158,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
1 => {
this.write_scalar(
- Scalar::from_target_usize(name.len().try_into().unwrap(), this),
+ Scalar::from_target_usize(name.len().to_u64(), this),
&this.project_field(dest, 0)?,
)?;
this.write_scalar(
- Scalar::from_target_usize(filename.len().try_into().unwrap(), this),
+ Scalar::from_target_usize(filename.len().to_u64(), this),
&this.project_field(dest, 1)?,
)?;
}
diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs
index 42603e784bbd7..31142431247c4 100644
--- a/src/tools/miri/src/shims/files.rs
+++ b/src/tools/miri/src/shims/files.rs
@@ -135,7 +135,10 @@ pub trait FileDescription: std::fmt::Debug + FileDescriptionExt {
/// Reads as much as possible into the given buffer `ptr`.
/// `len` indicates how many bytes we should try to read.
- /// `dest` is where the return value should be stored: number of bytes read, or `-1` in case of error.
+ ///
+ /// When the read is done, `finish` will be called. Note that `read` itself may return before
+ /// that happens! Everything that should happen "after" the `read` needs to happen inside
+ /// `finish`.
fn read<'tcx>(
self: FileDescriptionRef<Self>,
_communicate_allowed: bool,
@@ -149,7 +152,10 @@ pub trait FileDescription: std::fmt::Debug + FileDescriptionExt {
/// Writes as much as possible from the given buffer `ptr`.
/// `len` indicates how many bytes we should try to write.
- /// `dest` is where the return value should be stored: number of bytes written, or `-1` in case of error.
+ ///
+ /// When the write is done, `finish` will be called. Note that `write` itself may return before
+ /// that happens! Everything that should happen "after" the `write` needs to happen inside
+ /// `finish`.
fn write<'tcx>(
self: FileDescriptionRef<Self>,
_communicate_allowed: bool,
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 52c16a0c2e2dc..a81f459e5e1ae 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -639,7 +639,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
let val = this.read_scalar(val)?.to_i32()?;
let num = this.read_target_usize(num)?;
// The docs say val is "interpreted as unsigned char".
- #[expect(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+ #[expect(clippy::as_conversions)]
let val = val as u8;
// C requires that this must always be a valid pointer (C18 §7.1.4).
@@ -665,7 +665,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
let val = this.read_scalar(val)?.to_i32()?;
let num = this.read_target_usize(num)?;
// The docs say val is "interpreted as unsigned char".
- #[expect(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+ #[expect(clippy::as_conversions)]
let val = val as u8;
// C requires that this must always be a valid pointer (C18 §7.1.4).
@@ -676,7 +676,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
.iter()
.position(|&c| c == val);
if let Some(idx) = idx {
- let new_ptr = ptr.wrapping_offset(Size::from_bytes(idx as u64), this);
+ let new_ptr = ptr.wrapping_offset(Size::from_bytes(idx), this);
this.write_pointer(new_ptr, dest)?;
} else {
this.write_null(dest)?;
diff --git a/src/tools/miri/src/shims/io_error.rs b/src/tools/miri/src/shims/io_error.rs
index acf3f74a93d8b..e597b527cb7a8 100644
--- a/src/tools/miri/src/shims/io_error.rs
+++ b/src/tools/miri/src/shims/io_error.rs
@@ -1,4 +1,5 @@
use std::io;
+use std::io::ErrorKind;
use crate::*;
@@ -13,6 +14,29 @@ pub enum IoError {
}
pub use self::IoError::*;
+impl IoError {
+ pub(crate) fn into_ntstatus(self) -> i32 {
+ let raw = match self {
+ HostError(e) =>
+ match e.kind() {
+ // STATUS_MEDIA_WRITE_PROTECTED
+ ErrorKind::ReadOnlyFilesystem => 0xC00000A2u32,
+ // STATUS_FILE_INVALID
+ ErrorKind::InvalidInput => 0xC0000098,
+ // STATUS_DISK_FULL
+ ErrorKind::QuotaExceeded => 0xC000007F,
+ // STATUS_ACCESS_DENIED
+ ErrorKind::PermissionDenied => 0xC0000022,
+ // For the default error code we arbitrarily pick 0xC0000185, STATUS_IO_DEVICE_ERROR.
+ _ => 0xC0000185,
+ },
+ // For the default error code we arbitrarily pick 0xC0000185, STATUS_IO_DEVICE_ERROR.
+ _ => 0xC0000185,
+ };
+ raw.cast_signed()
+ }
+}
+
impl From<io::Error> for IoError {
fn from(value: io::Error) -> Self {
IoError::HostError(value)
diff --git a/src/tools/miri/src/shims/native_lib.rs b/src/tools/miri/src/shims/native_lib.rs
index 1a43e2297255e..1e6c93333c157 100644
--- a/src/tools/miri/src/shims/native_lib.rs
+++ b/src/tools/miri/src/shims/native_lib.rs
@@ -93,14 +93,10 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
let this = self.eval_context_mut();
// Try getting the function from the shared library.
let (lib, lib_path) = this.machine.native_lib.as_ref().unwrap();
- let func: libloading::Symbol<'_, unsafe extern "C" fn()> = unsafe {
- match lib.get(link_name.as_str().as_bytes()) {
- Ok(x) => x,
- Err(_) => {
- return None;
- }
- }
- };
+ let func: libloading::Symbol<'_, unsafe extern "C" fn()> =
+ unsafe { lib.get(link_name.as_str().as_bytes()).ok()? };
+ #[expect(clippy::as_conversions)] // fn-ptr to raw-ptr cast needs `as`.
+ let fn_ptr = *func.deref() as *mut std::ffi::c_void;
// FIXME: this is a hack!
// The `libloading` crate will automatically load system libraries like `libc`.
@@ -115,7 +111,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
// using the `libc` crate where this interface is public.
let mut info = std::mem::MaybeUninit::<libc::Dl_info>::zeroed();
unsafe {
- if libc::dladdr(*func.deref() as *const _, info.as_mut_ptr()) != 0 {
+ if libc::dladdr(fn_ptr, info.as_mut_ptr()) != 0 {
let info = info.assume_init();
#[cfg(target_os = "cygwin")]
let fname_ptr = info.dli_fname.as_ptr();
@@ -129,8 +125,9 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
}
}
+
// Return a pointer to the function.
- Some(CodePtr(*func.deref() as *mut _))
+ Some(CodePtr(fn_ptr))
}
}
diff --git a/src/tools/miri/src/shims/unix/android/thread.rs b/src/tools/miri/src/shims/unix/android/thread.rs
index 30ec0aefcbf1a..aa3a05ead85b4 100644
--- a/src/tools/miri/src/shims/unix/android/thread.rs
+++ b/src/tools/miri/src/shims/unix/android/thread.rs
@@ -7,7 +7,7 @@ use crate::helpers::check_min_vararg_count;
use crate::shims::unix::thread::{EvalContextExt as _, ThreadNameResult};
use crate::*;
-const TASK_COMM_LEN: usize = 16;
+const TASK_COMM_LEN: u64 = 16;
pub fn prctl<'tcx>(
ecx: &mut MiriInterpCx<'tcx>,
@@ -38,7 +38,7 @@ pub fn prctl<'tcx>(
let [name] = check_min_vararg_count("prctl(PR_GET_NAME, ...)", varargs)?;
let name = ecx.read_scalar(name)?;
let thread = ecx.pthread_self()?;
- let len = Scalar::from_target_usize(TASK_COMM_LEN as u64, ecx);
+ let len = Scalar::from_target_usize(TASK_COMM_LEN, ecx);
ecx.check_ptr_access(
name.to_pointer(ecx)?,
Size::from_bytes(TASK_COMM_LEN),
diff --git a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
index 21a386b29272a..533a741fea3f2 100644
--- a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
@@ -24,7 +24,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// Threading
"pthread_setname_np" => {
let [thread, name] = this.check_shim(abi, Conv::C, link_name, args)?;
- let max_len = usize::MAX; // FreeBSD does not seem to have a limit.
+ let max_len = u64::MAX; // FreeBSD does not seem to have a limit.
let res = match this.pthread_setname_np(
this.read_scalar(thread)?,
this.read_scalar(name)?,
@@ -56,6 +56,70 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
this.write_scalar(res, dest)?;
}
+ "cpuset_getaffinity" => {
+ // The "same" kind of api as `sched_getaffinity` but more fine grained control for FreeBSD specifically.
+ let [level, which, id, set_size, mask] =
+ this.check_shim(abi, Conv::C, link_name, args)?;
+
+ let level = this.read_scalar(level)?.to_i32()?;
+ let which = this.read_scalar(which)?.to_i32()?;
+ let id = this.read_scalar(id)?.to_i64()?;
+ let set_size = this.read_target_usize(set_size)?; // measured in bytes
+ let mask = this.read_pointer(mask)?;
+
+ let _level_root = this.eval_libc_i32("CPU_LEVEL_ROOT");
+ let _level_cpuset = this.eval_libc_i32("CPU_LEVEL_CPUSET");
+ let level_which = this.eval_libc_i32("CPU_LEVEL_WHICH");
+
+ let _which_tid = this.eval_libc_i32("CPU_WHICH_TID");
+ let which_pid = this.eval_libc_i32("CPU_WHICH_PID");
+ let _which_jail = this.eval_libc_i32("CPU_WHICH_JAIL");
+ let _which_cpuset = this.eval_libc_i32("CPU_WHICH_CPUSET");
+ let _which_irq = this.eval_libc_i32("CPU_WHICH_IRQ");
+
+ // For sched_getaffinity, the current process is identified by -1.
+ // TODO: Use gettid? I'm (LorrensP-2158466) not that familiar with this api .
+ let id = match id {
+ -1 => this.active_thread(),
+ _ =>
+ throw_unsup_format!(
+ "`cpuset_getaffinity` is only supported with a pid of -1 (indicating the current thread)"
+ ),
+ };
+
+ if this.ptr_is_null(mask)? {
+ this.set_last_error_and_return(LibcError("EFAULT"), dest)?;
+ }
+ // We only support CPU_LEVEL_WHICH and CPU_WHICH_PID for now.
+ // This is the bare minimum to make the tests pass.
+ else if level != level_which || which != which_pid {
+ throw_unsup_format!(
+ "`cpuset_getaffinity` is only supported with `level` set to CPU_LEVEL_WHICH and `which` set to CPU_WHICH_PID."
+ );
+ } else if let Some(cpuset) = this.machine.thread_cpu_affinity.get(&id) {
+ // `cpusetsize` must be large enough to contain the entire CPU mask.
+ // FreeBSD only uses `cpusetsize` to verify that it's sufficient for the kernel's CPU mask.
+ // If it's too small, the syscall returns ERANGE.
+ // If it's large enough, copying the kernel mask to user space is safe, regardless of the actual size.
+ // See https://github.com/freebsd/freebsd-src/blob/909aa6781340f8c0b4ae01c6366bf1556ee2d1be/sys/kern/kern_cpuset.c#L1985
+ if set_size < u64::from(this.machine.num_cpus).div_ceil(8) {
+ this.set_last_error_and_return(LibcError("ERANGE"), dest)?;
+ } else {
+ let cpuset = cpuset.clone();
+ let byte_count =
+ Ord::min(cpuset.as_slice().len(), set_size.try_into().unwrap());
+ this.write_bytes_ptr(
+ mask,
+ cpuset.as_slice()[..byte_count].iter().copied(),
+ )?;
+ this.write_null(dest)?;
+ }
+ } else {
+ // `id` is always that of the active thread, so this is currently unreachable.
+ unreachable!();
+ }
+ }
+
// Synchronization primitives
"_umtx_op" => {
let [obj, op, val, uaddr, uaddr2] =
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 1f6acff0787a6..fa8f84e3867b1 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -121,13 +121,13 @@ impl UnixFileDescription for FileHandle {
use std::os::windows::io::AsRawHandle;
use windows_sys::Win32::Foundation::{
- ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, FALSE, HANDLE, TRUE,
+ ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, FALSE, TRUE,
};
use windows_sys::Win32::Storage::FileSystem::{
LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY, LockFileEx, UnlockFile,
};
- let fh = self.file.as_raw_handle() as HANDLE;
+ let fh = self.file.as_raw_handle();
use FlockOp::*;
let (ret, lock_nb) = match op {
diff --git a/src/tools/miri/src/shims/unix/linux/foreign_items.rs b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
index f5da7b0170b6a..51c2434d68ac8 100644
--- a/src/tools/miri/src/shims/unix/linux/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
@@ -14,7 +14,7 @@ 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: usize = 16;
+const TASK_COMM_LEN: u64 = 16;
pub fn is_dyn_sym(name: &str) -> bool {
matches!(name, "statx")
@@ -96,7 +96,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// 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 as u64 {
+ let res = if len.to_target_usize(this)? >= TASK_COMM_LEN {
match this.pthread_getname_np(
this.read_scalar(thread)?,
this.read_scalar(name)?,
diff --git a/src/tools/miri/src/shims/unix/macos/foreign_items.rs b/src/tools/miri/src/shims/unix/macos/foreign_items.rs
index 5046e96508227..0281bb9f71dfc 100644
--- a/src/tools/miri/src/shims/unix/macos/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/macos/foreign_items.rs
@@ -186,7 +186,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let res = match this.pthread_setname_np(
thread,
this.read_scalar(name)?,
- this.eval_libc("MAXTHREADNAMESIZE").to_target_usize(this)?.try_into().unwrap(),
+ this.eval_libc("MAXTHREADNAMESIZE").to_target_usize(this)?,
/* truncate */ false,
)? {
ThreadNameResult::Ok => Scalar::from_u32(0),
diff --git a/src/tools/miri/src/shims/unix/thread.rs b/src/tools/miri/src/shims/unix/thread.rs
index 3d990a1a04201..4b6615b3ea82c 100644
--- a/src/tools/miri/src/shims/unix/thread.rs
+++ b/src/tools/miri/src/shims/unix/thread.rs
@@ -86,7 +86,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
&mut self,
thread: Scalar,
name: Scalar,
- name_max_len: usize,
+ name_max_len: u64,
truncate: bool,
) -> InterpResult<'tcx, ThreadNameResult> {
let this = self.eval_context_mut();
@@ -99,9 +99,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let mut name = this.read_c_str(name)?.to_owned();
// Comparing with `>=` to account for null terminator.
- if name.len() >= name_max_len {
+ if name.len().to_u64() >= name_max_len {
if truncate {
- name.truncate(name_max_len.saturating_sub(1));
+ name.truncate(name_max_len.saturating_sub(1).try_into().unwrap());
} else {
return interp_ok(ThreadNameResult::NameTooLong);
}
diff --git a/src/tools/miri/src/shims/windows/env.rs b/src/tools/miri/src/shims/windows/env.rs
index 1b2ccd99ef9f4..0cbabc52d2a5d 100644
--- a/src/tools/miri/src/shims/windows/env.rs
+++ b/src/tools/miri/src/shims/windows/env.rs
@@ -238,8 +238,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// Of course we cannot use `windows_check_buffer_size` here since this uses
// a different method for dealing with a too-small buffer than the other functions...
let (success, len) = this.write_path_to_wide_str(home, buf, size_avail.into())?;
- // The Windows docs just say that this is written on failure. But std
- // seems to rely on it always being written.
+ // The Windows docs just say that this is written on failure, but std relies on it
+ // always being written. Also see <https://github.com/rust-lang/rust/issues/141254>.
this.write_scalar(Scalar::from_u32(len.try_into().unwrap()), &size)?;
if success {
Scalar::from_i32(1) // return TRUE
diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
index c80858c63639a..d822dd07fcd7b 100644
--- a/src/tools/miri/src/shims/windows/foreign_items.rs
+++ b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -195,69 +195,52 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// File related shims
"NtWriteFile" => {
- if !this.frame_in_std() {
- throw_unsup_format!(
- "`NtWriteFile` support is crude and just enough for stdout to work"
- );
- }
-
let [
handle,
- _event,
- _apc_routine,
- _apc_context,
+ event,
+ apc_routine,
+ apc_context,
io_status_block,
buf,
n,
byte_offset,
- _key,
+ key,
] = this.check_shim(abi, sys_conv, link_name, args)?;
- let handle = this.read_target_isize(handle)?;
- let buf = this.read_pointer(buf)?;
- let n = this.read_scalar(n)?.to_u32()?;
- let byte_offset = this.read_target_usize(byte_offset)?; // is actually a pointer
- let io_status_block = this
- .deref_pointer_as(io_status_block, this.windows_ty_layout("IO_STATUS_BLOCK"))?;
-
- if byte_offset != 0 {
- throw_unsup_format!(
- "`NtWriteFile` `ByteOffset` parameter is non-null, which is unsupported"
- );
- }
-
- let written = if handle == -11 || handle == -12 {
- // stdout/stderr
- use io::Write;
-
- let buf_cont =
- this.read_bytes_ptr_strip_provenance(buf, Size::from_bytes(u64::from(n)))?;
- let res = if this.machine.mute_stdout_stderr {
- Ok(buf_cont.len())
- } else if handle == -11 {
- io::stdout().write(buf_cont)
- } else {
- io::stderr().write(buf_cont)
- };
- // We write at most `n` bytes, which is a `u32`, so we cannot have written more than that.
- res.ok().map(|n| u32::try_from(n).unwrap())
- } else {
- throw_unsup_format!(
- "on Windows, writing to anything except stdout/stderr is not supported"
- )
- };
- // We have to put the result into io_status_block.
- if let Some(n) = written {
- let io_status_information =
- this.project_field_named(&io_status_block, "Information")?;
- this.write_scalar(
- Scalar::from_target_usize(n.into(), this),
- &io_status_information,
- )?;
- }
- // Return whether this was a success. >= 0 is success.
- // For the error code we arbitrarily pick 0xC0000185, STATUS_IO_DEVICE_ERROR.
- this.write_scalar(
- Scalar::from_u32(if written.is_some() { 0 } else { 0xC0000185u32 }),
+ this.NtWriteFile(
+ handle,
+ event,
+ apc_routine,
+ apc_context,
+ io_status_block,
+ buf,
+ n,
+ byte_offset,
+ key,
+ dest,
+ )?;
+ }
+ "NtReadFile" => {
+ let [
+ handle,
+ event,
+ apc_routine,
+ apc_context,
+ io_status_block,
+ buf,
+ n,
+ byte_offset,
+ key,
+ ] = this.check_shim(abi, sys_conv, link_name, args)?;
+ this.NtReadFile(
+ handle,
+ event,
+ apc_routine,
+ apc_context,
+ io_status_block,
+ buf,
+ n,
+ byte_offset,
+ key,
dest,
)?;
}
@@ -322,6 +305,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let res = this.DeleteFileW(file_name)?;
this.write_scalar(res, dest)?;
}
+ "SetFilePointerEx" => {
+ let [file, distance_to_move, new_file_pointer, move_method] =
+ this.check_shim(abi, sys_conv, link_name, args)?;
+ let res =
+ this.SetFilePointerEx(file, distance_to_move, new_file_pointer, move_method)?;
+ this.write_scalar(res, dest)?;
+ }
// Allocation
"HeapAlloc" => {
@@ -700,12 +690,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
"GetStdHandle" => {
let [which] = this.check_shim(abi, sys_conv, link_name, args)?;
- let which = this.read_scalar(which)?.to_i32()?;
- // We just make this the identity function, so we know later in `NtWriteFile` which
- // one it is. This is very fake, but libtest needs it so we cannot make it a
- // std-only shim.
- // FIXME: this should return real HANDLEs when io support is added
- this.write_scalar(Scalar::from_target_isize(which.into(), this), dest)?;
+ let res = this.GetStdHandle(which)?;
+ this.write_scalar(res, dest)?;
}
"CloseHandle" => {
let [handle] = this.check_shim(abi, sys_conv, link_name, args)?;
diff --git a/src/tools/miri/src/shims/windows/fs.rs b/src/tools/miri/src/shims/windows/fs.rs
index 7561bf45219ba..72e016c12e944 100644
--- a/src/tools/miri/src/shims/windows/fs.rs
+++ b/src/tools/miri/src/shims/windows/fs.rs
@@ -1,5 +1,6 @@
use std::fs::{Metadata, OpenOptions};
use std::io;
+use std::io::SeekFrom;
use std::path::PathBuf;
use std::time::SystemTime;
@@ -390,6 +391,267 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
}
}
+
+ fn NtWriteFile(
+ &mut self,
+ handle: &OpTy<'tcx>, // HANDLE
+ event: &OpTy<'tcx>, // HANDLE
+ apc_routine: &OpTy<'tcx>, // PIO_APC_ROUTINE
+ apc_ctx: &OpTy<'tcx>, // PVOID
+ io_status_block: &OpTy<'tcx>, // PIO_STATUS_BLOCK
+ buf: &OpTy<'tcx>, // PVOID
+ n: &OpTy<'tcx>, // ULONG
+ byte_offset: &OpTy<'tcx>, // PLARGE_INTEGER
+ key: &OpTy<'tcx>, // PULONG
+ dest: &MPlaceTy<'tcx>, // return type: NTSTATUS
+ ) -> InterpResult<'tcx, ()> {
+ let this = self.eval_context_mut();
+ let handle = this.read_handle(handle, "NtWriteFile")?;
+ let event = this.read_handle(event, "NtWriteFile")?;
+ let apc_routine = this.read_pointer(apc_routine)?;
+ let apc_ctx = this.read_pointer(apc_ctx)?;
+ let buf = this.read_pointer(buf)?;
+ let count = this.read_scalar(n)?.to_u32()?;
+ let byte_offset = this.read_target_usize(byte_offset)?; // is actually a pointer, but we only support null
+ let key = this.read_pointer(key)?;
+ let io_status_block =
+ this.deref_pointer_as(io_status_block, this.windows_ty_layout("IO_STATUS_BLOCK"))?;
+
+ if event != Handle::Null {
+ throw_unsup_format!(
+ "`NtWriteFile` `Event` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if !this.ptr_is_null(apc_routine)? {
+ throw_unsup_format!(
+ "`NtWriteFile` `ApcRoutine` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if !this.ptr_is_null(apc_ctx)? {
+ throw_unsup_format!(
+ "`NtWriteFile` `ApcContext` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if byte_offset != 0 {
+ throw_unsup_format!(
+ "`NtWriteFile` `ByteOffset` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if !this.ptr_is_null(key)? {
+ throw_unsup_format!("`NtWriteFile` `Key` parameter is non-null, which is unsupported");
+ }
+
+ let fd = match handle {
+ Handle::File(fd) => fd,
+ _ => this.invalid_handle("NtWriteFile")?,
+ };
+
+ let Some(desc) = this.machine.fds.get(fd) else { this.invalid_handle("NtWriteFile")? };
+
+ // Windows writes the output code to IO_STATUS_BLOCK.Status, and number of bytes written
+ // to IO_STATUS_BLOCK.Information.
+ // The status block value and the returned value don't need to match - but
+ // for the cases implemented by miri so far, we can choose to decide that they do.
+ let io_status = {
+ let anon = this.project_field_named(&io_status_block, "Anonymous")?;
+ this.project_field_named(&anon, "Status")?
+ };
+ let io_status_info = this.project_field_named(&io_status_block, "Information")?;
+
+ let finish = {
+ let io_status = io_status.clone();
+ let io_status_info = io_status_info.clone();
+ let dest = dest.clone();
+ callback!(
+ @capture<'tcx> {
+ count: u32,
+ io_status: MPlaceTy<'tcx>,
+ io_status_info: MPlaceTy<'tcx>,
+ dest: MPlaceTy<'tcx>,
+ }
+ |this, result: Result<usize, IoError>| {
+ match result {
+ Ok(read_size) => {
+ assert!(read_size <= count.try_into().unwrap());
+ // This must fit since `count` fits.
+ this.write_int(u64::try_from(read_size).unwrap(), &io_status_info)?;
+ this.write_int(0, &io_status)?;
+ this.write_int(0, &dest)
+ }
+ Err(e) => {
+ this.write_int(0, &io_status_info)?;
+ let status = e.into_ntstatus();
+ this.write_int(status, &io_status)?;
+ this.write_int(status, &dest)
+ }
+ }}
+ )
+ };
+
+ desc.write(this.machine.communicate(), buf, count.try_into().unwrap(), this, finish)?;
+
+ // Return status is written to `dest` and `io_status_block` on callback completion.
+ interp_ok(())
+ }
+
+ fn NtReadFile(
+ &mut self,
+ handle: &OpTy<'tcx>, // HANDLE
+ event: &OpTy<'tcx>, // HANDLE
+ apc_routine: &OpTy<'tcx>, // PIO_APC_ROUTINE
+ apc_ctx: &OpTy<'tcx>, // PVOID
+ io_status_block: &OpTy<'tcx>, // PIO_STATUS_BLOCK
+ buf: &OpTy<'tcx>, // PVOID
+ n: &OpTy<'tcx>, // ULONG
+ byte_offset: &OpTy<'tcx>, // PLARGE_INTEGER
+ key: &OpTy<'tcx>, // PULONG
+ dest: &MPlaceTy<'tcx>, // return type: NTSTATUS
+ ) -> InterpResult<'tcx, ()> {
+ let this = self.eval_context_mut();
+ let handle = this.read_handle(handle, "NtReadFile")?;
+ let event = this.read_handle(event, "NtReadFile")?;
+ let apc_routine = this.read_pointer(apc_routine)?;
+ let apc_ctx = this.read_pointer(apc_ctx)?;
+ let buf = this.read_pointer(buf)?;
+ let count = this.read_scalar(n)?.to_u32()?;
+ let byte_offset = this.read_target_usize(byte_offset)?; // is actually a pointer, but we only support null
+ let key = this.read_pointer(key)?;
+ let io_status_block =
+ this.deref_pointer_as(io_status_block, this.windows_ty_layout("IO_STATUS_BLOCK"))?;
+
+ if event != Handle::Null {
+ throw_unsup_format!("`NtReadFile` `Event` parameter is non-null, which is unsupported");
+ }
+
+ if !this.ptr_is_null(apc_routine)? {
+ throw_unsup_format!(
+ "`NtReadFile` `ApcRoutine` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if !this.ptr_is_null(apc_ctx)? {
+ throw_unsup_format!(
+ "`NtReadFile` `ApcContext` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if byte_offset != 0 {
+ throw_unsup_format!(
+ "`NtReadFile` `ByteOffset` parameter is non-null, which is unsupported"
+ );
+ }
+
+ if !this.ptr_is_null(key)? {
+ throw_unsup_format!("`NtReadFile` `Key` parameter is non-null, which is unsupported");
+ }
+
+ // See NtWriteFile above for commentary on this
+ let io_status = {
+ let anon = this.project_field_named(&io_status_block, "Anonymous")?;
+ this.project_field_named(&anon, "Status")?
+ };
+ let io_status_info = this.project_field_named(&io_status_block, "Information")?;
+
+ let finish = {
+ let io_status = io_status.clone();
+ let io_status_info = io_status_info.clone();
+ let dest = dest.clone();
+ callback!(
+ @capture<'tcx> {
+ count: u32,
+ io_status: MPlaceTy<'tcx>,
+ io_status_info: MPlaceTy<'tcx>,
+ dest: MPlaceTy<'tcx>,
+ }
+ |this, result: Result<usize, IoError>| {
+ match result {
+ Ok(read_size) => {
+ assert!(read_size <= count.try_into().unwrap());
+ // This must fit since `count` fits.
+ this.write_int(u64::try_from(read_size).unwrap(), &io_status_info)?;
+ this.write_int(0, &io_status)?;
+ this.write_int(0, &dest)
+ }
+ Err(e) => {
+ this.write_int(0, &io_status_info)?;
+ let status = e.into_ntstatus();
+ this.write_int(status, &io_status)?;
+ this.write_int(status, &dest)
+ }
+ }}
+ )
+ };
+
+ let fd = match handle {
+ Handle::File(fd) => fd,
+ _ => this.invalid_handle("NtWriteFile")?,
+ };
+
+ let Some(desc) = this.machine.fds.get(fd) else { this.invalid_handle("NtReadFile")? };
+
+ desc.read(this.machine.communicate(), buf, count.try_into().unwrap(), this, finish)?;
+
+ // See NtWriteFile for commentary on this
+ interp_ok(())
+ }
+
+ fn SetFilePointerEx(
+ &mut self,
+ file: &OpTy<'tcx>, // HANDLE
+ dist_to_move: &OpTy<'tcx>, // LARGE_INTEGER
+ new_fp: &OpTy<'tcx>, // PLARGE_INTEGER
+ move_method: &OpTy<'tcx>, // DWORD
+ ) -> InterpResult<'tcx, Scalar> {
+ // ^ Returns BOOL (i32 on Windows)
+ let this = self.eval_context_mut();
+ let file = this.read_handle(file, "SetFilePointerEx")?;
+ let dist_to_move = this.read_scalar(dist_to_move)?.to_i64()?;
+ let new_fp_ptr = this.read_pointer(new_fp)?;
+ let move_method = this.read_scalar(move_method)?.to_u32()?;
+
+ let fd = match file {
+ Handle::File(fd) => fd,
+ _ => this.invalid_handle("SetFilePointerEx")?,
+ };
+
+ let Some(desc) = this.machine.fds.get(fd) else {
+ throw_unsup_format!("`SetFilePointerEx` is only supported on file backed handles");
+ };
+
+ let file_begin = this.eval_windows_u32("c", "FILE_BEGIN");
+ let file_current = this.eval_windows_u32("c", "FILE_CURRENT");
+ let file_end = this.eval_windows_u32("c", "FILE_END");
+
+ let seek = if move_method == file_begin {
+ SeekFrom::Start(dist_to_move.try_into().unwrap())
+ } else if move_method == file_current {
+ SeekFrom::Current(dist_to_move)
+ } else if move_method == file_end {
+ SeekFrom::End(dist_to_move)
+ } else {
+ throw_unsup_format!("Invalid move method: {move_method}")
+ };
+
+ match desc.seek(this.machine.communicate(), seek)? {
+ Ok(n) => {
+ if !this.ptr_is_null(new_fp_ptr)? {
+ this.write_scalar(
+ Scalar::from_i64(n.try_into().unwrap()),
+ &this.deref_pointer_as(new_fp, this.machine.layouts.i64)?,
+ )?;
+ }
+ interp_ok(this.eval_windows("c", "TRUE"))
+ }
+ Err(e) => {
+ this.set_last_error(e)?;
+ interp_ok(this.eval_windows("c", "FALSE"))
+ }
+ }
+ }
}
/// Windows FILETIME is measured in 100-nanosecs since 1601
@@ -401,7 +663,7 @@ fn extract_windows_epoch<'tcx>(
Some(time) => {
let duration = ecx.system_time_since_windows_epoch(&time)?;
let duration_ticks = ecx.windows_ticks_for(duration)?;
- #[allow(clippy::cast_possible_truncation)]
+ #[expect(clippy::as_conversions)]
interp_ok(Some((duration_ticks as u32, (duration_ticks >> 32) as u32)))
}
None => interp_ok(None),
diff --git a/src/tools/miri/src/shims/windows/handle.rs b/src/tools/miri/src/shims/windows/handle.rs
index eec6c62bebc73..5c04271fac590 100644
--- a/src/tools/miri/src/shims/windows/handle.rs
+++ b/src/tools/miri/src/shims/windows/handle.rs
@@ -70,8 +70,7 @@ impl Handle {
Self::Null => 0,
Self::Pseudo(pseudo_handle) => pseudo_handle.value(),
Self::Thread(thread) => thread.to_u32(),
- #[expect(clippy::cast_sign_loss)]
- Self::File(fd) => fd as u32,
+ Self::File(fd) => fd.cast_unsigned(),
// INVALID_HANDLE_VALUE is -1. This fact is explicitly declared or implied in several
// pages of Windows documentation.
// 1: https://learn.microsoft.com/en-us/dotnet/api/microsoft.win32.safehandles.safefilehandle?view=net-9.0
@@ -124,11 +123,10 @@ impl Handle {
Self::NULL_DISCRIMINANT if data == 0 => Some(Self::Null),
Self::PSEUDO_DISCRIMINANT => Some(Self::Pseudo(PseudoHandle::from_value(data)?)),
Self::THREAD_DISCRIMINANT => Some(Self::Thread(ThreadId::new_unchecked(data))),
- #[expect(clippy::cast_possible_wrap)]
Self::FILE_DISCRIMINANT => {
// This cast preserves all bits.
assert_eq!(size_of_val(&data), size_of::<FdNum>());
- Some(Self::File(data as FdNum))
+ Some(Self::File(data.cast_signed()))
}
Self::INVALID_DISCRIMINANT => Some(Self::Invalid),
_ => None,
@@ -156,8 +154,7 @@ impl Handle {
pub fn to_scalar(self, cx: &impl HasDataLayout) -> Scalar {
// 64-bit handles are sign extended 32-bit handles
// see https://docs.microsoft.com/en-us/windows/win32/winprog64/interprocess-communication
- #[expect(clippy::cast_possible_wrap)] // we want it to wrap
- let signed_handle = self.to_packed() as i32;
+ let signed_handle = self.to_packed().cast_signed();
Scalar::from_target_isize(signed_handle.into(), cx)
}
@@ -171,9 +168,8 @@ impl Handle {
) -> InterpResult<'tcx, Result<Self, HandleError>> {
let sign_extended_handle = handle.to_target_isize(cx)?;
- #[expect(clippy::cast_sign_loss)] // we want to lose the sign
let handle = if let Ok(signed_handle) = i32::try_from(sign_extended_handle) {
- signed_handle as u32
+ signed_handle.cast_unsigned()
} else {
// if a handle doesn't fit in an i32, it isn't valid.
return interp_ok(Err(HandleError::InvalidHandle));
@@ -224,6 +220,30 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
)))
}
+ fn GetStdHandle(&mut self, which: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
+ let this = self.eval_context_mut();
+ let which = this.read_scalar(which)?.to_i32()?;
+
+ let stdin = this.eval_windows("c", "STD_INPUT_HANDLE").to_i32()?;
+ let stdout = this.eval_windows("c", "STD_OUTPUT_HANDLE").to_i32()?;
+ let stderr = this.eval_windows("c", "STD_ERROR_HANDLE").to_i32()?;
+
+ // These values don't mean anything on Windows, but Miri unconditionally sets them up to the
+ // unix in/out/err descriptors. So we take advantage of that.
+ // Due to the `Handle` encoding, these values will not be directly exposed to the user.
+ let fd_num = if which == stdin {
+ 0
+ } else if which == stdout {
+ 1
+ } else if which == stderr {
+ 2
+ } else {
+ throw_unsup_format!("Invalid argument to `GetStdHandle`: {which}")
+ };
+ let handle = Handle::File(fd_num);
+ interp_ok(handle.to_scalar(this))
+ }
+
fn CloseHandle(&mut self, handle_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
let this = self.eval_context_mut();
diff --git a/src/tools/miri/src/shims/x86/gfni.rs b/src/tools/miri/src/shims/x86/gfni.rs
index 4774ec9f9d8f5..a91c74283fd85 100644
--- a/src/tools/miri/src/shims/x86/gfni.rs
+++ b/src/tools/miri/src/shims/x86/gfni.rs
@@ -133,12 +133,12 @@ fn affine_transform<'tcx>(
// This is a evaluated at compile time. Trait based conversion is not available.
/// See <https://www.corsix.org/content/galois-field-instructions-2021-cpus> for the
/// definition of `gf_inv` which was used for the creation of this table.
-#[expect(clippy::cast_possible_truncation)]
static TABLE: [u8; 256] = {
let mut array = [0; 256];
let mut i = 1;
while i < 256 {
+ #[expect(clippy::as_conversions)] // no `try_from` in const...
let mut x = i as u8;
let mut y = gf2p8_mul(x, x);
x = y;
@@ -160,7 +160,7 @@ static TABLE: [u8; 256] = {
/// polynomial representation with the reduction polynomial x^8 + x^4 + x^3 + x + 1.
/// See <https://www.corsix.org/content/galois-field-instructions-2021-cpus> for details.
// This is a const function. Trait based conversion is not available.
-#[expect(clippy::cast_possible_truncation)]
+#[expect(clippy::as_conversions)]
const fn gf2p8_mul(left: u8, right: u8) -> u8 {
// This implementation is based on the `gf2p8mul_byte` definition found inside the Intel intrinsics guide.
// See https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=gf2p8mul
diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index e57217dc6f299..ac59cc2dfeb39 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -1110,7 +1110,7 @@ fn pmulhrsw<'tcx>(
// The result of this operation can overflow a signed 16-bit integer.
// When `left` and `right` are -0x8000, the result is 0x8000.
- #[expect(clippy::cast_possible_truncation)]
+ #[expect(clippy::as_conversions)]
let res = res as i16;
ecx.write_scalar(Scalar::from_i16(res), &dest)?;
diff --git a/src/tools/miri/src/shims/x86/sha.rs b/src/tools/miri/src/shims/x86/sha.rs
index 6d2c151243ca1..23c83553f3b32 100644
--- a/src/tools/miri/src/shims/x86/sha.rs
+++ b/src/tools/miri/src/shims/x86/sha.rs
@@ -43,7 +43,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// We reverse the order because x86 is little endian but the copied implementation uses
// big endian.
for (i, part) in val.into_iter().rev().enumerate() {
- let projected = &ecx.project_index(dest, i.try_into().unwrap())?;
+ let projected = &ecx.project_index(dest, i.to_u64())?;
ecx.write_scalar(Scalar::from_u32(part), projected)?;
}
interp_ok(())
diff --git a/src/tools/miri/src/shims/x86/sse42.rs b/src/tools/miri/src/shims/x86/sse42.rs
index 02336a722f7ed..66bff328626a1 100644
--- a/src/tools/miri/src/shims/x86/sse42.rs
+++ b/src/tools/miri/src/shims/x86/sse42.rs
@@ -440,7 +440,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let crc = if bit_size == 64 {
// The 64-bit version will only consider the lower 32 bits,
// while the upper 32 bits get discarded.
- #[expect(clippy::cast_possible_truncation)]
+ #[expect(clippy::as_conversions)]
u128::from((left.to_u64()? as u32).reverse_bits())
} else {
u128::from(left.to_u32()?.reverse_bits())
diff --git a/src/tools/miri/test_dependencies/Cargo.toml b/src/tools/miri/test_dependencies/Cargo.toml
index 653228a5e3db6..fa833b51fa31b 100644
--- a/src/tools/miri/test_dependencies/Cargo.toml
+++ b/src/tools/miri/test_dependencies/Cargo.toml
@@ -25,6 +25,13 @@ page_size = "0.6"
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "net", "fs", "sync", "signal", "io-util"] }
[target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.59", features = ["Win32_Foundation", "Win32_System_Threading", "Win32_Storage_FileSystem", "Win32_Security"] }
+windows-sys = { version = "0.59", features = [
+ "Win32_Foundation",
+ "Win32_System_Threading",
+ "Win32_Storage_FileSystem",
+ "Win32_Security",
+ "Win32_System_IO",
+ "Wdk_Storage_FileSystem",
+] }
[workspace]
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.rs b/src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.rs
deleted file mode 100644
index 3ef194c5c7172..0000000000000
--- a/src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ignore-target: windows # No libc IO on Windows
-
-fn main() -> std::io::Result<()> {
- let mut bytes = [0u8; 512];
- unsafe {
- libc::read(0, bytes.as_mut_ptr() as *mut libc::c_void, 512); //~ ERROR: `read` from stdin not available when isolation is enabled
- }
- Ok(())
-}
diff --git a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.rs b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.rs
index 42c3a9619d464..2c01b0132b824 100644
--- a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.rs
+++ b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.rs
@@ -2,6 +2,7 @@
//@compile-flags: -Zmiri-disable-stacked-borrows
// Needs atomic accesses larger than the pointer size
//@ignore-bitwidth: 64
+//@ignore-target: mips-
use std::sync::atomic::{AtomicI64, Ordering};
diff --git a/src/tools/miri/tests/fail/shims/isolated_stdin.rs b/src/tools/miri/tests/fail/shims/isolated_stdin.rs
new file mode 100644
index 0000000000000..9f809039adad7
--- /dev/null
+++ b/src/tools/miri/tests/fail/shims/isolated_stdin.rs
@@ -0,0 +1,12 @@
+//@error-in-other-file: `read` from stdin not available when isolation is enabled
+//@normalize-stderr-test: "src/sys/.*\.rs" -> "$$FILE"
+//@normalize-stderr-test: "\nLL \| .*" -> ""
+//@normalize-stderr-test: "\n... .*" -> ""
+//@normalize-stderr-test: "\| +[|_^]+" -> "| ^"
+//@normalize-stderr-test: "\n *= note:.*" -> ""
+use std::io::{self, Read};
+
+fn main() {
+ let mut bytes = [0u8; 512];
+ io::stdin().read(&mut bytes).unwrap();
+}
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.stderr b/src/tools/miri/tests/fail/shims/isolated_stdin.stderr
similarity index 58%
rename from src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.stderr
rename to src/tools/miri/tests/fail/shims/isolated_stdin.stderr
index bb7e8cef5dcd2..1a4d7e963298e 100644
--- a/src/tools/miri/tests/fail-dep/libc/fs/isolated_stdin.stderr
+++ b/src/tools/miri/tests/fail/shims/isolated_stdin.stderr
@@ -1,13 +1,14 @@
error: unsupported operation: `read` from stdin not available when isolation is enabled
- --> tests/fail-dep/libc/fs/isolated_stdin.rs:LL:CC
+ --> RUSTLIB/std/$FILE:LL:CC
|
-LL | libc::read(0, bytes.as_mut_ptr() as *mut libc::c_void, 512);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `read` from stdin not available when isolation is enabled
+ | ^ `read` from stdin not available when isolation is enabled
|
= help: set `MIRIFLAGS=-Zmiri-disable-isolation` to disable isolation;
= help: or set `MIRIFLAGS=-Zmiri-isolation-error=warn` to make Miri return an error code from isolated operations (if supported for that operation) and continue with a warning
- = note: BACKTRACE:
- = note: inside `main` at tests/fail-dep/libc/fs/isolated_stdin.rs:LL:CC
+note: inside `main`
+ --> tests/fail/shims/isolated_stdin.rs:LL:CC
+ |
+ | ^
note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
diff --git a/src/tools/miri/tests/panic/transmute_fat2.rs b/src/tools/miri/tests/panic/transmute_fat2.rs
index 0205433ad9fb9..e695ff2d57ba5 100644
--- a/src/tools/miri/tests/panic/transmute_fat2.rs
+++ b/src/tools/miri/tests/panic/transmute_fat2.rs
@@ -5,6 +5,8 @@ fn main() {
let bad = unsafe { std::mem::transmute::<u128, &[u8]>(42 << 64) };
#[cfg(all(target_endian = "little", target_pointer_width = "32"))]
let bad = unsafe { std::mem::transmute::<u64, &[u8]>(42) };
+ #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
+ let bad = unsafe { std::mem::transmute::<u64, &[u8]>(42 << 32) };
// This created a slice with length 0, so the following will fail the bounds check.
bad[0];
}
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-fs-with-isolation.rs b/src/tools/miri/tests/pass-dep/libc/libc-fs-with-isolation.rs
index cffcf4a867fee..06a8cc7f4879a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs-with-isolation.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs-with-isolation.rs
@@ -11,6 +11,10 @@ fn main() {
assert!(libc::fcntl(1, libc::F_DUPFD, 0) >= 0);
}
+ // Although `readlink` and `stat` require disable-isolation mode
+ // to properly run, they are tested with isolation mode on to check the error emitted
+ // with `-Zmiri-isolation-error=warn-nobacktrace`.
+
// test `readlink`
let mut buf = vec![0; "foo_link.txt".len() + 1];
unsafe {
diff --git a/src/tools/miri/tests/pass-dep/shims/freebsd-cpuset-affinity.rs b/src/tools/miri/tests/pass-dep/shims/freebsd-cpuset-affinity.rs
new file mode 100644
index 0000000000000..9a868128d2716
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/shims/freebsd-cpuset-affinity.rs
@@ -0,0 +1,51 @@
+//@only-target: freebsd
+//@compile-flags: -Zmiri-num-cpus=256
+
+use std::mem;
+
+fn getaffinity() {
+ let mut set: libc::cpuset_t = unsafe { mem::zeroed() };
+ unsafe {
+ if libc::cpuset_getaffinity(
+ libc::CPU_LEVEL_WHICH,
+ libc::CPU_WHICH_PID,
+ -1,
+ size_of::<libc::cpuset_t>(),
+ &mut set,
+ ) == 0
+ {
+ assert!(libc::CPU_COUNT(&set) == 256);
+ }
+ }
+}
+
+fn get_small_cpu_mask() {
+ let mut set: libc::cpuset_t = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
+
+ // 256 CPUs so we need 32 bytes to represent this mask.
+ // According to Freebsd only when `cpusetsize` is smaller than this value, does it return with ERANGE
+
+ let err = unsafe {
+ libc::cpuset_getaffinity(libc::CPU_LEVEL_WHICH, libc::CPU_WHICH_PID, -1, 32, &mut set)
+ };
+ assert_eq!(err, 0, "Success Expected");
+
+ // 31 is not enough, so it should fail.
+ let err = unsafe {
+ libc::cpuset_getaffinity(libc::CPU_LEVEL_WHICH, libc::CPU_WHICH_PID, -1, 31, &mut set)
+ };
+ assert_eq!(err, -1, "Expected Failure");
+ assert_eq!(std::io::Error::last_os_error().raw_os_error().unwrap(), libc::ERANGE);
+
+ // Zero should fail as well.
+ let err = unsafe {
+ libc::cpuset_getaffinity(libc::CPU_LEVEL_WHICH, libc::CPU_WHICH_PID, -1, 0, &mut set)
+ };
+ assert_eq!(err, -1, "Expected Failure");
+ assert_eq!(std::io::Error::last_os_error().raw_os_error().unwrap(), libc::ERANGE);
+}
+
+fn main() {
+ getaffinity();
+ get_small_cpu_mask();
+}
diff --git a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
index 698ca4e0b4ba6..4ca19046b676b 100644
--- a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
+++ b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
@@ -2,25 +2,28 @@
//@compile-flags: -Zmiri-disable-isolation
#![allow(nonstandard_style)]
-use std::io::ErrorKind;
+use std::io::{ErrorKind, Read, Write};
use std::os::windows::ffi::OsStrExt;
+use std::os::windows::io::AsRawHandle;
use std::path::Path;
-use std::ptr;
+use std::{fs, ptr};
#[path = "../../utils/mod.rs"]
mod utils;
+use windows_sys::Wdk::Storage::FileSystem::{NtReadFile, NtWriteFile};
use windows_sys::Win32::Foundation::{
CloseHandle, ERROR_ACCESS_DENIED, ERROR_ALREADY_EXISTS, ERROR_IO_DEVICE, GENERIC_READ,
GENERIC_WRITE, GetLastError, RtlNtStatusToDosError, STATUS_ACCESS_DENIED,
- STATUS_IO_DEVICE_ERROR,
+ STATUS_IO_DEVICE_ERROR, STATUS_SUCCESS, SetLastError,
};
use windows_sys::Win32::Storage::FileSystem::{
BY_HANDLE_FILE_INFORMATION, CREATE_ALWAYS, CREATE_NEW, CreateFileW, DeleteFileW,
- FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_NORMAL, FILE_FLAG_BACKUP_SEMANTICS,
- FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
- GetFileInformationByHandle, OPEN_ALWAYS, OPEN_EXISTING,
+ FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_NORMAL, FILE_BEGIN, FILE_CURRENT,
+ FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_DELETE, FILE_SHARE_READ,
+ FILE_SHARE_WRITE, GetFileInformationByHandle, OPEN_ALWAYS, OPEN_EXISTING, SetFilePointerEx,
};
+use windows_sys::Win32::System::IO::IO_STATUS_BLOCK;
fn main() {
unsafe {
@@ -31,6 +34,8 @@ fn main() {
test_open_dir_reparse();
test_delete_file();
test_ntstatus_to_dos();
+ test_file_read_write();
+ test_file_seek();
}
}
@@ -199,13 +204,13 @@ unsafe fn test_open_dir_reparse() {
unsafe fn test_delete_file() {
let temp = utils::tmp().join("test_delete_file.txt");
let raw_path = to_wide_cstr(&temp);
- let _ = std::fs::File::create(&temp).unwrap();
+ let _ = fs::File::create(&temp).unwrap();
if DeleteFileW(raw_path.as_ptr()) == 0 {
panic!("Failed to delete file");
}
- match std::fs::File::open(temp) {
+ match fs::File::open(temp) {
Ok(_) => panic!("File not deleted"),
Err(e) => assert!(e.kind() == ErrorKind::NotFound, "File not deleted"),
}
@@ -217,6 +222,82 @@ unsafe fn test_ntstatus_to_dos() {
assert_eq!(RtlNtStatusToDosError(STATUS_ACCESS_DENIED), ERROR_ACCESS_DENIED);
}
+unsafe fn test_file_read_write() {
+ let temp = utils::tmp().join("test_file_read_write.txt");
+ let file = fs::File::create(&temp).unwrap();
+ let handle = file.as_raw_handle();
+
+ // Testing NtWriteFile doesn't clobber the error
+ SetLastError(1234);
+
+ let text = b"Example text!";
+ let mut status = std::mem::zeroed::<IO_STATUS_BLOCK>();
+ let out = NtWriteFile(
+ handle,
+ ptr::null_mut(),
+ None,
+ ptr::null_mut(),
+ &mut status,
+ text.as_ptr().cast(),
+ text.len() as u32,
+ ptr::null_mut(),
+ ptr::null_mut(),
+ );
+
+ assert_eq!(out, status.Anonymous.Status);
+ assert_eq!(out, STATUS_SUCCESS);
+ assert_eq!(GetLastError(), 1234);
+
+ let file = fs::File::open(&temp).unwrap();
+ let handle = file.as_raw_handle();
+
+ // Testing NtReadFile doesn't clobber the error
+ SetLastError(1234);
+
+ let mut buffer = vec![0; 13];
+ let out = NtReadFile(
+ handle,
+ ptr::null_mut(),
+ None,
+ ptr::null_mut(),
+ &mut status,
+ buffer.as_mut_ptr().cast(),
+ buffer.len() as u32,
+ ptr::null_mut(),
+ ptr::null_mut(),
+ );
+
+ assert_eq!(out, status.Anonymous.Status);
+ assert_eq!(out, STATUS_SUCCESS);
+ assert_eq!(buffer, text);
+ assert_eq!(GetLastError(), 1234);
+}
+
+unsafe fn test_file_seek() {
+ let temp = utils::tmp().join("test_file_seek.txt");
+ let mut file = fs::File::options().create(true).write(true).read(true).open(&temp).unwrap();
+ file.write_all(b"Hello, World!\n").unwrap();
+
+ let handle = file.as_raw_handle();
+
+ if SetFilePointerEx(handle, 7, ptr::null_mut(), FILE_BEGIN) == 0 {
+ panic!("Failed to seek");
+ }
+
+ let mut buf = vec![0; 5];
+ file.read(&mut buf).unwrap();
+ assert_eq!(buf, b"World");
+
+ let mut pos = 0;
+ if SetFilePointerEx(handle, -7, &mut pos, FILE_CURRENT) == 0 {
+ panic!("Failed to seek");
+ }
+ buf.truncate(2);
+ file.read_exact(&mut buf).unwrap();
+ assert_eq!(buf, b", ");
+ assert_eq!(pos, 5);
+}
+
fn to_wide_cstr(path: &Path) -> Vec<u16> {
let mut raw_path = path.as_os_str().encode_wide().collect::<Vec<_>>();
raw_path.extend([0, 0]);
diff --git a/src/tools/miri/tests/pass/atomic.rs b/src/tools/miri/tests/pass/atomic.rs
index 2b2e89e6d70fc..3de34e570c7ee 100644
--- a/src/tools/miri/tests/pass/atomic.rs
+++ b/src/tools/miri/tests/pass/atomic.rs
@@ -7,15 +7,17 @@
#![allow(static_mut_refs)]
use std::sync::atomic::Ordering::*;
-use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicPtr, AtomicU64, compiler_fence, fence};
+use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicPtr, AtomicUsize, compiler_fence, fence};
fn main() {
atomic_bool();
atomic_all_ops();
- atomic_u64();
atomic_fences();
atomic_ptr();
weak_sometimes_fails();
+
+ #[cfg(target_has_atomic = "64")]
+ atomic_u64();
}
fn atomic_bool() {
@@ -36,25 +38,10 @@ fn atomic_bool() {
}
}
-// There isn't a trait to use to make this generic, so just use a macro
-macro_rules! compare_exchange_weak_loop {
- ($atom:expr, $from:expr, $to:expr, $succ_order:expr, $fail_order:expr) => {
- loop {
- match $atom.compare_exchange_weak($from, $to, $succ_order, $fail_order) {
- Ok(n) => {
- assert_eq!(n, $from);
- break;
- }
- Err(n) => assert_eq!(n, $from),
- }
- }
- };
-}
-
/// Make sure we can handle all the intrinsics
fn atomic_all_ops() {
static ATOMIC: AtomicIsize = AtomicIsize::new(0);
- static ATOMIC_UNSIGNED: AtomicU64 = AtomicU64::new(0);
+ static ATOMIC_UNSIGNED: AtomicUsize = AtomicUsize::new(0);
let load_orders = [Relaxed, Acquire, SeqCst];
let stored_orders = [Relaxed, Release, SeqCst];
@@ -94,9 +81,26 @@ fn atomic_all_ops() {
}
}
+#[cfg(target_has_atomic = "64")]
fn atomic_u64() {
+ use std::sync::atomic::AtomicU64;
static ATOMIC: AtomicU64 = AtomicU64::new(0);
+ // There isn't a trait to use to make this generic, so just use a macro
+ macro_rules! compare_exchange_weak_loop {
+ ($atom:expr, $from:expr, $to:expr, $succ_order:expr, $fail_order:expr) => {
+ loop {
+ match $atom.compare_exchange_weak($from, $to, $succ_order, $fail_order) {
+ Ok(n) => {
+ assert_eq!(n, $from);
+ break;
+ }
+ Err(n) => assert_eq!(n, $from),
+ }
+ }
+ };
+ }
+
ATOMIC.store(1, SeqCst);
assert_eq!(ATOMIC.compare_exchange(0, 0x100, AcqRel, Acquire), Err(1));
assert_eq!(ATOMIC.compare_exchange(0, 1, Release, Relaxed), Err(1));
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index d0a7f245ee0ff..315637ff7ec73 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -17,20 +17,20 @@ mod utils;
fn main() {
test_path_conversion();
+ test_file();
test_file_create_new();
+ test_metadata();
+ test_seek();
+ test_errors();
+ test_from_raw_os_error();
// Windows file handling is very incomplete.
if cfg!(not(windows)) {
- test_file();
- test_seek();
test_file_clone();
- test_metadata();
test_file_set_len();
test_file_sync();
- test_errors();
test_rename();
test_directory();
test_canonicalize();
- test_from_raw_os_error();
#[cfg(unix)]
test_pread_pwrite();
}
diff --git a/src/tools/miri/tests/pass/shims/io.rs b/src/tools/miri/tests/pass/shims/io.rs
index 420ef95a0cbf4..a96b98c022746 100644
--- a/src/tools/miri/tests/pass/shims/io.rs
+++ b/src/tools/miri/tests/pass/shims/io.rs
@@ -1,8 +1,10 @@
-use std::io::{self, IsTerminal};
+use std::io::{self, IsTerminal, Write};
fn main() {
- // We can't really assume that this is truly a terminal, and anyway on Windows Miri will always
- // return `false` here, but we can check that the call succeeds.
+ io::stdout().write_all(b"stdout\n").unwrap();
+ io::stderr().write_all(b"stderr\n").unwrap();
+
+ // We can't assume that this is truly a terminal, but we can check that the call succeeds.
io::stdout().is_terminal();
// Ensure we can format `io::Error` created from OS errors
diff --git a/src/tools/miri/tests/pass/shims/io.stderr b/src/tools/miri/tests/pass/shims/io.stderr
new file mode 100644
index 0000000000000..af6415db3c724
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/io.stderr
@@ -0,0 +1 @@
+stderr
diff --git a/src/tools/miri/tests/pass/shims/io.stdout b/src/tools/miri/tests/pass/shims/io.stdout
new file mode 100644
index 0000000000000..faa3a15c184b5
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/io.stdout
@@ -0,0 +1 @@
+stdout