basic theading

Author: beepster4096

src/lib.rs

@@ -5,6 +5,8 @@
 #![feature(try_blocks)]
 #![feature(let_else)]
 #![feature(io_error_more)]
+#![feature(int_log)]
+#![feature(variant_count)]
 #![warn(rust_2018_idioms)]
 #![allow(
     clippy::collapsible_else_if,

src/shims/tls.rs

@@ -235,7 +235,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn schedule_windows_tls_dtors(&mut self) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let active_thread = this.get_active_thread();
-        assert_eq!(this.get_total_thread_count(), 1, "concurrency on Windows is not supported");
+
         // Windows has a special magic linker section that is run on certain events.
         // Instead of searching for that section and supporting arbitrary hooks in there
         // (that would be basically https://github.com/rust-lang/miri/issues/450),
@@ -252,7 +252,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             this.get_ptr_fn(this.scalar_to_ptr(thread_callback)?)?.as_instance()?;
 
         // The signature of this function is `unsafe extern "system" fn(h: c::LPVOID, dwReason: c::DWORD, pv: c::LPVOID)`.
-        let reason = this.eval_path_scalar(&["std", "sys", "windows", "c", "DLL_THREAD_DETACH"])?;
+        let reason = this.eval_windows("c", "DLL_THREAD_DETACH")?;
         let ret_place = MPlaceTy::dangling(this.machine.layouts.unit).into();
         this.call_function(
             thread_callback,

src/shims/unix/thread.rs

@@ -13,47 +13,14 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     ) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
 
-        // Create the new thread
-        let new_thread_id = this.create_thread();
-
-        // Write the current thread-id, switch to the next thread later
-        // to treat this write operation as occuring on the current thread.
-        let thread_info_place = this.deref_operand(thread)?;
-        this.write_scalar(
-            Scalar::from_uint(new_thread_id.to_u32(), thread_info_place.layout.size),
-            &thread_info_place.into(),
+        this.start_thread(
+            Some(thread),
+            start_routine,
+            Abi::System { unwind: false },
+            arg,
+            this.layout_of(this.tcx.types.usize)?,
         )?;
 
-        // Read the function argument that will be sent to the new thread
-        // before the thread starts executing since reading after the
-        // context switch will incorrectly report a data-race.
-        let fn_ptr = this.read_pointer(start_routine)?;
-        let func_arg = this.read_immediate(arg)?;
-
-        // Finally switch to new thread so that we can push the first stackframe.
-        // After this all accesses will be treated as occuring in the new thread.
-        let old_thread_id = this.set_active_thread(new_thread_id);
-
-        // Perform the function pointer load in the new thread frame.
-        let instance = this.get_ptr_fn(fn_ptr)?.as_instance()?;
-
-        // Note: the returned value is currently ignored (see the FIXME in
-        // pthread_join below) because the Rust standard library does not use
-        // it.
-        let ret_place =
-            this.allocate(this.layout_of(this.tcx.types.usize)?, MiriMemoryKind::Machine.into())?;
-
-        this.call_function(
-            instance,
-            Abi::C { unwind: false },
-            &[*func_arg],
-            &ret_place.into(),
-            StackPopCleanup::Root { cleanup: true },
-        )?;
-
-        // Restore the old active thread frame.
-        this.set_active_thread(old_thread_id);
-
         Ok(0)
     }
 

src/shims/windows/dlsym.rs

@@ -5,11 +5,13 @@ use rustc_target::spec::abi::Abi;
 use log::trace;
 
 use crate::helpers::check_arg_count;
+use crate::shims::windows::handle::Handle;
 use crate::*;
 
 #[derive(Debug, Copy, Clone)]
 pub enum Dlsym {
     NtWriteFile,
+    SetThreadDescription,
 }
 
 impl Dlsym {
@@ -20,6 +22,7 @@ impl Dlsym {
             "GetSystemTimePreciseAsFileTime" => None,
             "SetThreadDescription" => None,
             "NtWriteFile" => Some(Dlsym::NtWriteFile),
+            "SetThreadDescription" => Some(Dlsym::SetThreadDescription),
             _ => throw_unsup_format!("unsupported Windows dlsym: {}", name),
         })
     }
@@ -106,6 +109,22 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     dest,
                 )?;
             }
+            Dlsym::SetThreadDescription => {
+                let [handle, name] = check_arg_count(args)?;
+
+                let name = this.read_wide_str(this.read_pointer(name)?)?;
+
+                let thread =
+                    match Handle::from_scalar(this.read_scalar(handle)?.check_init()?, this)? {
+                        Some(Handle::Thread(thread)) => thread,
+                        Some(Handle::CurrentThread) => this.get_active_thread(),
+                        _ => throw_ub_format!("invalid handle"),
+                    };
+
+                this.set_thread_name_wide(thread, name);
+
+                this.write_null(dest)?;
+            }
         }
 
         trace!("{:?}", this.dump_place(**dest));

src/shims/windows/foreign_items.rs

@@ -1,13 +1,19 @@
 use std::iter;
+use std::time::{Duration, Instant};
 
 use rustc_middle::mir;
+use rustc_middle::ty::layout::LayoutOf;
 use rustc_span::Symbol;
 use rustc_target::abi::Size;
 use rustc_target::spec::abi::Abi;
 
+use crate::thread::Time;
 use crate::*;
 use shims::foreign_items::EmulateByNameResult;
+use shims::windows::handle::Handle;
 use shims::windows::sync::EvalContextExt as _;
+use shims::windows::thread::EvalContextExt as _;
+
 use smallvec::SmallVec;
 
 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
@@ -230,6 +236,29 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let result = this.QueryPerformanceFrequency(lpFrequency)?;
                 this.write_scalar(Scalar::from_i32(result), dest)?;
             }
+            "Sleep" => {
+                let [timeout] =
+                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+
+                this.check_no_isolation("`Sleep`")?;
+
+                let timeout_ms = this.read_scalar(timeout)?.to_u32()?;
+
+                let duration = Duration::from_millis(timeout_ms as u64);
+                let timeout_time = Time::Monotonic(Instant::now().checked_add(duration).unwrap());
+
+                let active_thread = this.get_active_thread();
+                this.block_thread(active_thread);
+
+                this.register_timeout_callback(
+                    active_thread,
+                    timeout_time,
+                    Box::new(move |ecx| {
+                        ecx.unblock_thread(active_thread);
+                        Ok(())
+                    }),
+                );
+            }
 
             // Synchronization primitives
             "AcquireSRWLockExclusive" => {
@@ -340,14 +369,48 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 // std-only shim.
                 this.write_scalar(Scalar::from_machine_isize(which.into(), this), dest)?;
             }
+            "CloseHandle" => {
+                let [handle] =
+                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+
+                match Handle::from_scalar(this.read_scalar(handle)?.check_init()?, this)? {
+                    Some(Handle::Thread(thread)) => this.detach_thread(thread)?,
+                    _ => throw_ub_format!("invalid handle"),
+                };
 
-            // Better error for attempts to create a thread
+                this.write_scalar(Scalar::from_u32(1), dest)?;
+            }
+
+            // Threading
             "CreateThread" => {
-                let [_, _, _, _, _, _] =
+                let [_security, _stacksize, start, arg, _flags, thread] =
+                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+
+                let thread =
+                    if this.ptr_is_null(this.read_pointer(thread)?)? { None } else { Some(thread) };
+
+                let thread_id = this.start_thread(
+                    thread,
+                    start,
+                    Abi::System { unwind: false },
+                    arg,
+                    this.layout_of(this.tcx.types.u32)?,
+                )?;
+
+                this.write_scalar(Handle::Thread(thread_id).to_scalar(this), dest)?;
+            }
+            "WaitForSingleObject" => {
+                let [handle, timeout] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
 
-                this.handle_unsupported("can't create threads on Windows")?;
-                return Ok(EmulateByNameResult::AlreadyJumped);
+                this.WaitForSingleObject(handle, timeout)?;
+
+                this.write_scalar(Scalar::from_u32(0), dest)?;
+            }
+            "GetCurrentThread" => {
+                let [] = this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+
+                this.write_scalar(Handle::CurrentThread.to_scalar(this), dest)?;
             }
 
             // Incomplete shims that we "stub out" just to get pre-main initialization code to work.

src/shims/windows/handle.rs

@@ -0,0 +1,115 @@
+use rustc_target::abi::HasDataLayout;
+use std::mem::variant_count;
+
+use crate::*;
+
+#[derive(Clone, Copy)]
+enum RealHandle {
+    Thread(ThreadId),
+}
+
+impl RealHandle {
+    fn discriminant(self) -> u64 {
+        match self {
+            // can't use zero here because all zero handle is invalid
+            Self::Thread(_) => 1,
+        }
+    }
+
+    fn data(self) -> u64 {
+        match self {
+            Self::Thread(thread) => thread.to_u32() as u64,
+        }
+    }
+
+    fn packed_disc_size() -> u64 {
+        (variant_count::<Self>().log2() + 1) as u64
+    }
+
+    fn to_packed(self, bits: u64) -> u64 {
+        // top bit and lower 2 bits need to be clear
+        let usable_bits = (bits - 3).min(32);
+
+        let disc_size = Self::packed_disc_size();
+        let data_size = usable_bits - disc_size;
+
+        let discriminant = self.discriminant();
+        let data = self.data();
+
+        assert!(discriminant < 2u64.pow(disc_size as u32));
+        assert!(data < 2u64.pow(data_size as u32));
+
+        (discriminant << data_size | data) << 2
+    }
+
+    fn new(discriminant: u32, data: u32) -> Option<Self> {
+        match discriminant {
+            1 => Some(Self::Thread(data.into())),
+            _ => None,
+        }
+    }
+
+    fn from_packed(handle: u64, bits: u64) -> Option<Self> {
+        let usable_bits = (bits - 3).min(32);
+
+        let disc_size = Self::packed_disc_size();
+        let data_size = usable_bits - disc_size;
+        let data_mask = 2u64.pow(data_size as u32) - 1;
+
+        let discriminant = handle >> data_size >> 2;
+        let data = handle >> 2 & data_mask;
+
+        Self::new(discriminant.try_into().unwrap(), data.try_into().unwrap())
+    }
+}
+
+/// Miri representation of a Windows `HANDLE`
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Handle {
+    Null, // = 0
+    // pseudo-handles
+    CurrentThread, // = -2
+    // real handles
+    Thread(ThreadId),
+}
+
+impl Handle {
+    fn to_packed(self, bits: u64) -> i64 {
+        match self {
+            Self::Null => 0,
+            Self::CurrentThread => -2,
+            Self::Thread(thread) => RealHandle::Thread(thread).to_packed(bits) as i64,
+        }
+    }
+
+    pub fn to_scalar(self, cx: &impl HasDataLayout) -> Scalar<Tag> {
+        let bits = cx.data_layout().pointer_size.bits();
+
+        let handle = self.to_packed(bits);
+
+        Scalar::from_machine_isize(handle, cx)
+    }
+
+    fn from_packed(handle: i64, bits: u64) -> Option<Self> {
+        if handle == 0 {
+            Some(Self::Null)
+        } else if handle == -2 {
+            Some(Self::CurrentThread)
+        } else {
+            match RealHandle::from_packed(handle as u64, bits)? {
+                RealHandle::Thread(id) => Some(Self::Thread(id)),
+            }
+        }
+    }
+
+    pub fn from_scalar<'tcx>(
+        handle: Scalar<Tag>,
+        cx: &impl HasDataLayout,
+    ) -> InterpResult<'tcx, Option<Self>> {
+        let bits = cx.data_layout().pointer_size.bits();
+
+        let handle = handle.to_machine_isize(cx)?;
+
+        Ok(Self::from_packed(handle, bits))
+    }
+}

src/shims/windows/mod.rs

@@ -1,4 +1,6 @@
 pub mod dlsym;
 pub mod foreign_items;
 
+mod handle;
 mod sync;
+mod thread;

src/shims/windows/thread.rs

@@ -0,0 +1,42 @@
+use std::time::{Duration, Instant};
+
+use crate::thread::Time;
+use crate::*;
+use shims::windows::handle::Handle;
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+
+#[allow(non_snake_case)]
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn WaitForSingleObject(
+        &mut self,
+        handle: &OpTy<'tcx, Tag>,
+        timeout: &OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        let thread = match Handle::from_scalar(this.read_scalar(handle)?.check_init()?, this)? {
+            Some(Handle::Thread(thread)) => thread,
+            Some(Handle::CurrentThread) => throw_ub_format!("trying to wait on itself"),
+            _ => throw_ub_format!("invalid handle"),
+        };
+
+        if this.read_scalar(timeout)?.to_u32()? != this.eval_windows("c", "INFINITE")?.to_u32()? {
+            throw_unsup_format!("Miri does not support joining with timeout")
+        }
+
+        let timeout_ms = this.read_scalar(timeout)?.to_u32()?;
+
+        let timeout_time = if timeout_ms == this.eval_windows("c", "INFINITE")?.to_u32()? {
+            None
+        } else {
+            let duration = Duration::from_millis(timeout_ms as u64);
+
+            Some(Time::Monotonic(Instant::now().checked_add(duration).unwrap()))
+        };
+
+        this.wait_on_thread(timeout_time, thread)?;
+
+        Ok(())
+    }
+}