Implement basic support for concurrency (Linux/macos only)

src/eval.rs

@@ -211,7 +211,7 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
                     assert!(ecx.step()?, "a terminated thread was scheduled for execution");
                 }
                 SchedulingAction::ExecuteDtors => {
-                    ecx.schedule_tls_dtors_for_active_thread()?;
+                    ecx.schedule_next_tls_dtor_for_active_thread()?;
                 }
                 SchedulingAction::Stop => {
                     break;

src/shims/foreign_items/posix/macos.rs

@@ -83,7 +83,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let dtor = this.memory.get_fn(dtor)?.as_instance()?;
                 let data = this.read_scalar(args[1])?.not_undef()?;
                 let active_thread = this.get_active_thread()?;
-                this.machine.tls.set_thread_global_dtor(active_thread, dtor, data)?;
+                this.machine.tls.set_thread_dtor(active_thread, dtor, data)?;
             }
 
             // Querying system information

src/shims/sync.rs

@@ -80,7 +80,8 @@ fn mutexattr_set_kind<'mir, 'tcx: 'mir>(
 // bytes 8-11: when count > 0, id of the owner thread as a u32
 // bytes 12-15 or 16-19 (depending on platform): mutex kind, as an i32
 // (the kind has to be at its offset for compatibility with static initializer macros)
-// bytes 20-23: when count > 0, id of the blockset in which the blocked threads are waiting.
+// bytes 20-23: when count > 0, id of the blockset in which the blocked threads
+// are waiting or 0 if blockset is not yet assigned.
 
 const PTHREAD_MUTEX_T_MIN_SIZE: u64 = 24;
 
@@ -158,7 +159,7 @@ fn mutex_get_or_create_blockset<'mir, 'tcx: 'mir>(
         mutex_set_blockset(ecx, mutex_op, blockset.to_u32_scalar())?;
         Ok(blockset)
     } else {
-        Ok(blockset.into())
+        Ok(BlockSetId::new(blockset))
     }
 }
 
@@ -170,9 +171,9 @@ fn mutex_get_or_create_blockset<'mir, 'tcx: 'mir>(
 // bytes 4-7: reader count, as a u32
 // bytes 8-11: writer count, as a u32
 // bytes 12-15: when writer or reader count > 0, id of the blockset in which the
-// blocked writers are waiting.
+// blocked writers are waiting or 0 if blockset is not yet assigned.
 // bytes 16-20: when writer count > 0, id of the blockset in which the blocked
-// readers are waiting.
+// readers are waiting or 0 if blockset is not yet assigned.
 
 const PTHREAD_RWLOCK_T_MIN_SIZE: u64 = 20;
 
@@ -233,7 +234,7 @@ fn rwlock_get_or_create_writer_blockset<'mir, 'tcx: 'mir>(
         rwlock_set_writer_blockset(ecx, rwlock_op, blockset.to_u32_scalar())?;
         Ok(blockset)
     } else {
-        Ok(blockset.into())
+        Ok(BlockSetId::new(blockset))
     }
 }
 
@@ -264,7 +265,7 @@ fn rwlock_get_or_create_reader_blockset<'mir, 'tcx: 'mir>(
         rwlock_set_reader_blockset(ecx, rwlock_op, blockset.to_u32_scalar())?;
         Ok(blockset)
     } else {
-        Ok(blockset.into())
+        Ok(BlockSetId::new(blockset))
     }
 }
 
@@ -342,8 +343,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             Ok(0)
         } else {
             // The mutex is locked. Let's check by whom.
-            let owner_thread: ThreadId =
-                mutex_get_owner(this, mutex_op)?.not_undef()?.to_u32()?.into();
+            let owner_thread: ThreadId = mutex_get_owner(this, mutex_op)?.to_u32()?.into();
             if owner_thread != active_thread {
                 // Block the active thread.
                 let blockset = mutex_get_or_create_blockset(this, mutex_op)?;
@@ -425,6 +425,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 mutex_set_owner(this, mutex_op, new_owner.to_u32_scalar())?;
             } else {
                 // No thread is waiting on this mutex.
+                mutex_set_owner(this, mutex_op, Scalar::from_u32(0))?;
                 mutex_set_locked_count(this, mutex_op, Scalar::from_u32(0))?;
             }
             Ok(0)
@@ -550,10 +551,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             Ok(0)
         } else if writers != 0 {
             let reader_blockset = rwlock_get_or_create_reader_blockset(this, rwlock_op)?;
-            rwlock_set_writers(this, rwlock_op, Scalar::from_u32(0))?;
+            // We are prioritizing writers here against the readers. As a
+            // result, not only readers can starve writers, but also writers can
+            // starve readers.
             if let Some(_writer) = this.unblock_some_thread(writer_blockset)? {
                 rwlock_set_writers(this, rwlock_op, Scalar::from_u32(1))?;
             } else {
+                rwlock_set_writers(this, rwlock_op, Scalar::from_u32(0))?;
                 let mut readers = 0;
                 while let Some(_reader) = this.unblock_some_thread(reader_blockset)? {
                     readers += 1;

src/shims/thread.rs

@@ -1,5 +1,6 @@
+use std::convert::TryInto;
+
 use crate::*;
-use rustc_index::vec::Idx;
 use rustc_target::abi::LayoutOf;
 
 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
@@ -19,33 +20,29 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         );
 
         let new_thread_id = this.create_thread()?;
+        // Also switch to new thread so that we can push the first stackframe.
         let old_thread_id = this.set_active_thread(new_thread_id)?;
 
         let thread_info_place = this.deref_operand(thread)?;
-        let thread_info_type = thread.layout.ty
-            .builtin_deref(true)
-            .ok_or_else(|| err_ub_format!(
-                "wrong signature used for `pthread_create`: first argument must be a raw pointer."
-            ))?
-            .ty;
-        let thread_info_layout = this.layout_of(thread_info_type)?;
         this.write_scalar(
-            Scalar::from_uint(new_thread_id.index() as u128, thread_info_layout.size),
+            Scalar::from_uint(new_thread_id.to_u128(), thread_info_place.layout.size),
             thread_info_place.into(),
         )?;
 
         let fn_ptr = this.read_scalar(start_routine)?.not_undef()?;
         let instance = this.memory.get_fn(fn_ptr)?.as_instance()?;
 
         let func_arg = this.read_immediate(arg)?;
-        let func_args = [*func_arg];
 
+        // 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,
-            &func_args[..],
+            &[*func_arg],
             Some(ret_place.into()),
             StackPopCleanup::None { cleanup: true },
         )?;
@@ -63,20 +60,21 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_mut();
 
         if !this.is_null(this.read_scalar(retval)?.not_undef()?)? {
+            // FIXME: implement reading the thread function's return place.
             throw_unsup_format!("Miri supports pthread_join only with retval==NULL");
         }
 
-        let thread_id = this.read_scalar(thread)?.not_undef()?.to_machine_usize(this)?;
-        this.join_thread(thread_id.into())?;
+        let thread_id = this.read_scalar(thread)?.to_machine_usize(this)?;
+        this.join_thread(thread_id.try_into().expect("thread ID should fit in u32"))?;
 
         Ok(0)
     }
 
     fn pthread_detach(&mut self, thread: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
 
-        let thread_id = this.read_scalar(thread)?.not_undef()?.to_machine_usize(this)?;
-        this.detach_thread(thread_id.into())?;
+        let thread_id = this.read_scalar(thread)?.to_machine_usize(this)?;
+        this.detach_thread(thread_id.try_into().expect("thread ID should fit in u32"))?;
 
         Ok(0)
     }
@@ -85,44 +83,30 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_mut();
 
         let thread_id = this.get_active_thread()?;
-        this.write_scalar(Scalar::from_uint(thread_id.index() as u128, dest.layout.size), dest)
+        this.write_scalar(Scalar::from_uint(thread_id.to_u128(), dest.layout.size), dest)
     }
 
     fn prctl(
         &mut self,
         option: OpTy<'tcx, Tag>,
         arg2: OpTy<'tcx, Tag>,
-        arg3: OpTy<'tcx, Tag>,
-        arg4: OpTy<'tcx, Tag>,
-        arg5: OpTy<'tcx, Tag>,
+        _arg3: OpTy<'tcx, Tag>,
+        _arg4: OpTy<'tcx, Tag>,
+        _arg5: OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
 
-        // prctl last 5 arguments are declared as variadic. Therefore, we need
-        // to check their types manually.
-        let c_long_size = this.libc_ty_layout("c_long")?.size.bytes();
-        let check_arg = |arg: OpTy<'tcx, Tag>| -> InterpResult<'tcx> {
-            match this.read_scalar(arg)?.not_undef()? {
-                Scalar::Raw { size, .. } if u64::from(size) == c_long_size => Ok(()),
-                _ => throw_ub_format!("an argument of unsupported type was passed to prctl"),
-            }
-        };
-        check_arg(arg2)?;
-        check_arg(arg3)?;
-        check_arg(arg4)?;
-        check_arg(arg5)?;
-
-        let option = this.read_scalar(option)?.not_undef()?.to_i32()?;
+        let option = this.read_scalar(option)?.to_i32()?;
         if option == this.eval_libc_i32("PR_SET_NAME")? {
             let address = this.read_scalar(arg2)?.not_undef()?;
             let name = this.memory.read_c_str(address)?.to_owned();
             this.set_active_thread_name(name)?;
         } else if option == this.eval_libc_i32("PR_GET_NAME")? {
             let address = this.read_scalar(arg2)?.not_undef()?;
-            let name = this.get_active_thread_name()?;
+            let name = this.get_active_thread_name()?.to_vec();
             this.memory.write_bytes(address, name)?;
         } else {
-            throw_unsup_format!("Unsupported prctl option.");
+            throw_unsup_format!("unsupported prctl option {}", option);
         }
 
         Ok(0)