X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fshims%2Ftls.rs;h=3339e3bee19990d2378759a9803fca3d842abdbf;hb=4f899ce9acb3827cc45fd4a8672372b1ff64b8b2;hp=ec8c31fe2c1277e55179a7d7766ec00834c6f0a1;hpb=52184193c363e030818a18a60123eed25b12c7c9;p=rust.git diff --git a/src/shims/tls.rs b/src/shims/tls.rs index ec8c31fe2c1..3339e3bee19 100644 --- a/src/shims/tls.rs +++ b/src/shims/tls.rs @@ -1,15 +1,17 @@ //! Implement thread-local storage. use std::collections::BTreeMap; -use std::collections::btree_map::Entry; +use std::collections::btree_map::Entry as BTreeEntry; +use std::collections::hash_map::Entry as HashMapEntry; use log::trace; +use rustc_data_structures::fx::FxHashMap; use rustc_middle::ty; use rustc_target::abi::{Size, HasDataLayout}; +use rustc_target::spec::abi::Abi; -use crate::{HelpersEvalContextExt, ThreadsEvalContextExt, InterpResult, MPlaceTy, Scalar, StackPopCleanup, Tag}; -use crate::machine::{ThreadId, ThreadState}; +use crate::*; pub type TlsKey = u128; @@ -17,11 +19,18 @@ pub struct TlsEntry<'tcx> { /// The data for this key. None is used to represent NULL. /// (We normalize this early to avoid having to do a NULL-ptr-test each time we access the data.) - /// Will eventually become a map from thread IDs to `Scalar`s, if we ever support more than one thread. data: BTreeMap>, dtor: Option>, } +#[derive(Clone, Debug)] +struct RunningDtorsState { + /// The last TlsKey used to retrieve a TLS destructor. `None` means that we + /// have not tried to retrieve a TLS destructor yet or that we already tried + /// all keys. + last_dtor_key: Option, +} + #[derive(Debug)] pub struct TlsData<'tcx> { /// The Key to use for the next thread-local allocation. @@ -30,11 +39,14 @@ pub struct TlsData<'tcx> { /// pthreads-style thread-local storage. keys: BTreeMap>, - /// A single global dtor (that's how things work on macOS) with a data argument. - global_dtor: Option<(ty::Instance<'tcx>, Scalar)>, + /// A single per thread destructor of the thread local storage (that's how + /// things work on macOS) with a data argument. + macos_thread_dtors: BTreeMap, Scalar)>, - /// Whether we are in the "destruct" phase, during which some operations are UB. - dtors_running: bool, + /// State for currently running TLS dtors. If this map contains a key for a + /// specific thread, it means that we are in the "destruct" phase, during + /// which some operations are UB. + dtors_running: FxHashMap, } impl<'tcx> Default for TlsData<'tcx> { @@ -42,8 +54,8 @@ fn default() -> Self { TlsData { next_key: 1, // start with 1 as we must not use 0 on Windows keys: Default::default(), - global_dtor: None, - dtors_running: false, + macos_thread_dtors: Default::default(), + dtors_running: Default::default(), } } } @@ -54,7 +66,7 @@ impl<'tcx> TlsData<'tcx> { pub fn create_tls_key(&mut self, dtor: Option>, max_size: Size) -> InterpResult<'tcx, TlsKey> { let new_key = self.next_key; self.next_key += 1; - self.keys.insert(new_key, TlsEntry { data: Default::default(), dtor }).unwrap_none(); + self.keys.try_insert(new_key, TlsEntry { data: Default::default(), dtor }).unwrap(); trace!("New TLS key allocated: {} with dtor {:?}", new_key, dtor); if max_size.bits() < 128 && new_key >= (1u128 << max_size.bits() as u128) { @@ -81,7 +93,7 @@ pub fn load_tls( ) -> InterpResult<'tcx, Scalar> { match self.keys.get(&key) { Some(TlsEntry { data, .. }) => { - let value = data.get(&thread_id).cloned(); + let value = data.get(&thread_id).copied(); trace!("TLS key {} for thread {:?} loaded: {:?}", key, thread_id, value); Ok(value.unwrap_or_else(|| Scalar::null_ptr(cx).into())) } @@ -91,13 +103,16 @@ pub fn load_tls( pub fn store_tls( &mut self, - key: TlsKey, thread_id: ThreadId, new_data: Option>) -> InterpResult<'tcx> { + key: TlsKey, + thread_id: ThreadId, + new_data: Option> + ) -> InterpResult<'tcx> { match self.keys.get_mut(&key) { Some(TlsEntry { data, .. }) => { match new_data { - Some(ptr) => { - trace!("TLS key {} for thread {:?} stored: {:?}", key, thread_id, ptr); - data.insert(thread_id, ptr); + Some(scalar) => { + trace!("TLS key {} for thread {:?} stored: {:?}", key, thread_id, scalar); + data.insert(thread_id, scalar); } None => { trace!("TLS key {} for thread {:?} removed", key, thread_id); @@ -110,16 +125,28 @@ pub fn store_tls( } } - pub fn set_global_dtor(&mut self, dtor: ty::Instance<'tcx>, data: Scalar) -> InterpResult<'tcx> { - if self.dtors_running { + /// Set the thread wide destructor of the thread local storage for the given + /// thread. This function is used to implement `_tlv_atexit` shim on MacOS. + /// + /// Thread wide dtors are available only on MacOS. There is one destructor + /// per thread as can be guessed from the following comment in the + /// [`_tlv_atexit` + /// implementation](https://github.com/opensource-apple/dyld/blob/195030646877261f0c8c7ad8b001f52d6a26f514/src/threadLocalVariables.c#L389): + /// + /// // NOTE: this does not need locks because it only operates on current thread data + pub fn set_macos_thread_dtor( + &mut self, + thread: ThreadId, + dtor: ty::Instance<'tcx>, + data: Scalar + ) -> InterpResult<'tcx> { + if self.dtors_running.contains_key(&thread) { // UB, according to libstd docs. - throw_ub_format!("setting global destructor while destructors are already running"); + throw_ub_format!("setting thread's local storage destructor while destructors are already running"); } - if self.global_dtor.is_some() { - throw_unsup_format!("setting more than one global destructor is not supported"); + if self.macos_thread_dtors.insert(thread, (dtor, data)).is_some() { + throw_unsup_format!("setting more than one thread local storage destructor for the same thread is not supported"); } - - self.global_dtor = Some((dtor, data)); Ok(()) } @@ -146,8 +173,8 @@ fn fetch_tls_dtor( &mut self, key: Option, thread_id: ThreadId, - ) -> Option<(ty::Instance<'tcx>, ThreadId, Scalar, TlsKey)> { - use std::collections::Bound::*; + ) -> Option<(ty::Instance<'tcx>, Scalar, TlsKey)> { + use std::ops::Bound::*; let thread_local = &mut self.keys; let start = match key { @@ -158,99 +185,194 @@ fn fetch_tls_dtor( thread_local.range_mut((start, Unbounded)) { match data.entry(thread_id) { - Entry::Occupied(entry) => { - let (thread_id, data_scalar) = entry.remove_entry(); + BTreeEntry::Occupied(entry) => { if let Some(dtor) = dtor { - let ret = Some((dtor, thread_id, data_scalar, key)); + // Set TLS data to NULL, and call dtor with old value. + let data_scalar = entry.remove(); + let ret = Some((*dtor, data_scalar, key)); return ret; } } - Entry::Vacant(_) => {} + BTreeEntry::Vacant(_) => {} } } None } + + /// Set that dtors are running for `thread`. It is guaranteed not to change + /// the existing values stored in `dtors_running` for this thread. Returns + /// `true` if dtors for `thread` are already running. + fn set_dtors_running_for_thread(&mut self, thread: ThreadId) -> bool { + match self.dtors_running.entry(thread) { + HashMapEntry::Occupied(_) => true, + HashMapEntry::Vacant(entry) => { + // We cannot just do `self.dtors_running.insert` because that + // would overwrite `last_dtor_key` with `None`. + entry.insert(RunningDtorsState { last_dtor_key: None }); + false + } + } + } + + /// Delete all TLS entries for the given thread. This function should be + /// called after all TLS destructors have already finished. + fn delete_all_thread_tls(&mut self, thread_id: ThreadId) { + for TlsEntry { data, .. } in self.keys.values_mut() { + data.remove(&thread_id); + } + } } -impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {} -pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> { - /// Run TLS destructors for all threads. - fn run_tls_dtors(&mut self) -> InterpResult<'tcx> { +impl<'mir, 'tcx: 'mir> EvalContextPrivExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {} +trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> { + /// Schedule TLS destructors for the main thread on Windows. The + /// implementation assumes that we do not support concurrency on Windows + /// yet. + 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), + // we specifically look up the static in libstd that we know is placed + // in that section. + let thread_callback = this.eval_path_scalar(&["std", "sys", "windows", "thread_local_key", "p_thread_callback"])?; + let thread_callback = this.memory.get_fn(thread_callback.check_init()?)?.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 ret_place = MPlaceTy::dangling(this.machine.layouts.unit, this).into(); + this.call_function( + thread_callback, + Abi::System { unwind: false }, + &[Scalar::null_ptr(this).into(), reason.into(), Scalar::null_ptr(this).into()], + Some(&ret_place), + StackPopCleanup::None { cleanup: true }, + )?; + + this.enable_thread(active_thread); + Ok(()) + } + + /// Schedule the MacOS thread destructor of the thread local storage to be + /// executed. Returns `true` if scheduled. + /// + /// Note: It is safe to call this function also on other Unixes. + fn schedule_macos_tls_dtor(&mut self) -> InterpResult<'tcx, bool> { let this = self.eval_context_mut(); - assert!(!this.machine.tls.dtors_running, "running TLS dtors twice"); - this.machine.tls.dtors_running = true; - - if this.tcx.sess.target.target.target_os == "windows" { - // 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), - // we specifically look up the static in libstd that we know is placed - // in that section. - let thread_callback = this.eval_path_scalar(&["std", "sys", "windows", "thread_local", "p_thread_callback"])?; - let thread_callback = this.memory.get_fn(thread_callback.not_undef()?)?.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_PROCESS_DETACH"])?; + let thread_id = this.get_active_thread(); + if let Some((instance, data)) = this.machine.tls.macos_thread_dtors.remove(&thread_id) { + trace!("Running macos dtor {:?} on {:?} at {:?}", instance, data, thread_id); + let ret_place = MPlaceTy::dangling(this.machine.layouts.unit, this).into(); this.call_function( - thread_callback, - &[Scalar::null_ptr(this).into(), reason.into(), Scalar::null_ptr(this).into()], - Some(ret_place), + instance, + Abi::C { unwind: false }, + &[data.into()], + Some(&ret_place), StackPopCleanup::None { cleanup: true }, )?; - // step until out of stackframes - this.run()?; - - // Windows doesn't have other destructors. - return Ok(()); + // Enable the thread so that it steps through the destructor which + // we just scheduled. Since we deleted the destructor, it is + // guaranteed that we will schedule it again. The `dtors_running` + // flag will prevent the code from adding the destructor again. + this.enable_thread(thread_id); + Ok(true) + } else { + Ok(false) } + } - // The macOS global dtor runs "before any TLS slots get freed", so do that first. - if let Some((instance, data)) = this.machine.tls.global_dtor { - trace!("Running global dtor {:?} on {:?}", instance, data); + /// Schedule a pthread TLS destructor. Returns `true` if found + /// a destructor to schedule, and `false` otherwise. + fn schedule_next_pthread_tls_dtor(&mut self) -> InterpResult<'tcx, bool> { + let this = self.eval_context_mut(); + let active_thread = this.get_active_thread(); + + assert!(this.has_terminated(active_thread), "running TLS dtors for non-terminated thread"); + // Fetch next dtor after `key`. + let last_key = this.machine.tls.dtors_running[&active_thread].last_dtor_key.clone(); + let dtor = match this.machine.tls.fetch_tls_dtor(last_key, active_thread) { + dtor @ Some(_) => dtor, + // We ran each dtor once, start over from the beginning. + None => { + this.machine.tls.fetch_tls_dtor(None, active_thread) + } + }; + if let Some((instance, ptr, key)) = dtor { + this.machine.tls.dtors_running.get_mut(&active_thread).unwrap().last_dtor_key = Some(key); + trace!("Running TLS dtor {:?} on {:?} at {:?}", instance, ptr, active_thread); + assert!(!this.is_null(ptr).unwrap(), "data can't be NULL when dtor is called!"); let ret_place = MPlaceTy::dangling(this.machine.layouts.unit, this).into(); this.call_function( instance, - &[data.into()], - Some(ret_place), + Abi::C { unwind: false }, + &[ptr.into()], + Some(&ret_place), StackPopCleanup::None { cleanup: true }, )?; - // step until out of stackframes - this.run()?; + this.enable_thread(active_thread); + return Ok(true); } + this.machine.tls.dtors_running.get_mut(&active_thread).unwrap().last_dtor_key = None; + + Ok(false) + } +} + +impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {} +pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> { - // Now run the "keyed" destructors. - for (thread_id, thread_state) in this.get_all_thread_ids_with_states() { - assert!(thread_state == ThreadState::Terminated, - "TLS destructors should be executed after all threads terminated."); - this.set_active_thread(thread_id)?; - let mut dtor = this.machine.tls.fetch_tls_dtor(None, thread_id); - while let Some((instance, thread_id, ptr, key)) = dtor { - trace!("Running TLS dtor {:?} on {:?} at {:?}", instance, ptr, thread_id); - assert!(!this.is_null(ptr).unwrap(), "Data can't be NULL when dtor is called!"); - - let ret_place = MPlaceTy::dangling(this.layout_of(this.tcx.mk_unit())?, this).into(); - this.call_function( - instance, - &[ptr.into()], - Some(ret_place), - StackPopCleanup::None { cleanup: true }, - )?; - - // step until out of stackframes - this.run()?; - - // Fetch next dtor after `key`. - dtor = match this.machine.tls.fetch_tls_dtor(Some(key), thread_id) { - dtor @ Some(_) => dtor, - // We ran each dtor once, start over from the beginning. - None => this.machine.tls.fetch_tls_dtor(None, thread_id), - }; + /// Schedule an active thread's TLS destructor to run on the active thread. + /// Note that this function does not run the destructors itself, it just + /// schedules them one by one each time it is called and reenables the + /// thread so that it can be executed normally by the main execution loop. + /// + /// Note: we consistently run TLS destructors for all threads, including the + /// main thread. However, it is not clear that we should run the TLS + /// destructors for the main thread. See issue: + /// https://github.com/rust-lang/rust/issues/28129. + fn schedule_next_tls_dtor_for_active_thread(&mut self) -> InterpResult<'tcx> { + let this = self.eval_context_mut(); + let active_thread = this.get_active_thread(); + + if !this.machine.tls.set_dtors_running_for_thread(active_thread) { + // This is the first time we got asked to schedule a destructor. The + // Windows schedule destructor function must be called exactly once, + // this is why it is in this block. + if this.tcx.sess.target.os == "windows" { + // On Windows, we signal that the thread quit by starting the + // relevant function, reenabling the thread, and going back to + // the scheduler. + this.schedule_windows_tls_dtors()?; + return Ok(()) } } + // The remaining dtors make some progress each time around the scheduler loop, + // until they return `false` to indicate that they are done. + + // The macOS thread wide destructor runs "before any TLS slots get + // freed", so do that first. + if this.schedule_macos_tls_dtor()? { + // We have scheduled a MacOS dtor to run on the thread. Execute it + // to completion and come back here. Scheduling a destructor + // destroys it, so we will not enter this branch again. + return Ok(()) + } + if this.schedule_next_pthread_tls_dtor()? { + // We have scheduled a pthread destructor and removed it from the + // destructors list. Run it to completion and come back here. + return Ok(()) + } + + // All dtors done! + this.machine.tls.delete_all_thread_tls(active_thread); + this.thread_terminated()?; + Ok(()) } }