Merge pull request #207 from lumen/link

:erlang.link/1

Author: KronicDeth

liblumen_alloc/src/erts/process.rs

@@ -19,7 +19,7 @@ use core::sync::atomic::{AtomicU16, AtomicU64, AtomicUsize, Ordering};
 
 use ::alloc::sync::Arc;
 
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use intrusive_collections::{LinkedList, UnsafeRef};
 
 use liblumen_core::locks::{Mutex, MutexGuard, RwLock, SpinLock};
@@ -100,6 +100,9 @@ pub struct ProcessControlBlock {
     code_stack: Mutex<code::stack::Stack>,
     pub status: RwLock<Status>,
     pub registered_name: RwLock<Option<Atom>>,
+    /// Pids of processes that are linked to this process and need to be exited when this process
+    /// exits
+    pub linked_pid_set: Mutex<HashSet<Pid>>,
     pub mailbox: Mutex<RefCell<Mailbox>>,
     // process heap, cache line aligned to avoid false sharing with rest of struct
     heap: Mutex<ProcessHeap>,
@@ -140,6 +143,7 @@ impl ProcessControlBlock {
             run_reductions: Default::default(),
             total_reductions: Default::default(),
             registered_name: Default::default(),
+            linked_pid_set: Default::default(),
         }
     }
 
@@ -242,6 +246,8 @@ impl ProcessControlBlock {
         heap.virtual_alloc(bin)
     }
 
+    // Stack
+
     /// Frees stack space occupied by the last term on the stack,
     /// adjusting the stack pointer accordingly.
     ///
@@ -290,6 +296,23 @@ impl ProcessControlBlock {
         self.heap.lock().stack_used()
     }
 
+    // Links
+
+    pub fn link(&self, other: &ProcessControlBlock) {
+        // link in order so that locks are always taken in the same order to prevent deadlocks
+        if self.pid < other.pid {
+            let mut self_pid_set = self.linked_pid_set.lock();
+            let mut other_pid_set = other.linked_pid_set.lock();
+
+            self_pid_set.insert(other.pid);
+            other_pid_set.insert(self.pid);
+        } else {
+            other.link(self)
+        }
+    }
+
+    // Pid
+
     pub fn pid(&self) -> Pid {
         self.pid
     }

lumen_runtime/src/otp/erlang.rs

@@ -3,6 +3,8 @@
 pub mod add_2;
 pub mod apply_3;
 pub mod convert_time_unit_3;
+pub mod exit_1;
+pub mod link_1;
 pub mod monotonic_time_0;
 pub mod number_or_badarith_1;
 pub mod self_0;
@@ -38,7 +40,7 @@ use liblumen_alloc::erts::term::{
     Term, Tuple, TypedTerm,
 };
 use liblumen_alloc::erts::ProcessControlBlock;
-use liblumen_alloc::{badarg, badarith, badkey, badmap, error, exit, raise, throw};
+use liblumen_alloc::{badarg, badarith, badkey, badmap, error, raise, throw};
 
 use crate::binary::{start_length_to_part_range, PartRange, ToTermOptions};
 use crate::node;
@@ -822,10 +824,6 @@ pub fn error_2(reason: Term, arguments: Term) -> Result {
     Err(error!(reason, Some(arguments)).into())
 }
 
-pub fn exit_1(reason: Term) -> Result {
-    Err(exit!(reason).into())
-}
-
 pub fn hd_1(list: Term) -> Result {
     let cons: Boxed<Cons> = list.try_into()?;
 

lumen_runtime/src/otp/erlang/exit_1.rs

@@ -0,0 +1,60 @@
+// wasm32 proptest cannot be compiled at the same time as non-wasm32 proptest, so disable tests that
+// use proptest completely for wasm32
+//
+// See https://github.com/rust-lang/cargo/issues/4866
+#[cfg(all(not(target_arch = "wasm32"), test))]
+mod test;
+
+use std::sync::Arc;
+
+use liblumen_alloc::erts::exception;
+use liblumen_alloc::erts::exception::system::Alloc;
+use liblumen_alloc::erts::process::code::stack::frame::{Frame, Placement};
+use liblumen_alloc::erts::process::code::{self, result_from_exception};
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{Atom, Term};
+use liblumen_alloc::{exit, ModuleFunctionArity};
+
+pub fn place_frame_with_arguments(
+    process: &ProcessControlBlock,
+    placement: Placement,
+    reason: Term,
+) -> Result<(), Alloc> {
+    process.stack_push(reason)?;
+    process.place_frame(frame(), placement);
+
+    Ok(())
+}
+
+// Private
+
+fn code(arc_process: &Arc<ProcessControlBlock>) -> code::Result {
+    arc_process.reduce();
+
+    let reason = arc_process.stack_pop().unwrap();
+
+    match native(reason) {
+        Ok(_) => unreachable!(),
+        Err(exception) => result_from_exception(arc_process, exception),
+    }
+}
+
+fn frame() -> Frame {
+    Frame::new(module_function_arity(), code)
+}
+
+fn function() -> Atom {
+    Atom::try_from_str("exit").unwrap()
+}
+
+fn module_function_arity() -> Arc<ModuleFunctionArity> {
+    Arc::new(ModuleFunctionArity {
+        module: super::module(),
+        function: function(),
+        arity: 1,
+    })
+}
+
+fn native(reason: Term) -> exception::Result {
+    Err(exit!(reason).into())
+}

lumen_runtime/src/otp/erlang/tests/exit_1.rs renamed to lumen_runtime/src/otp/erlang/exit_1/test.rs

@@ -1,11 +1,18 @@
-use super::*;
+use proptest::prop_assert_eq;
+use proptest::test_runner::{Config, TestRunner};
+
+use liblumen_alloc::exit;
+
+use crate::otp::erlang::exit_1;
+use crate::scheduler::with_process_arc;
+use crate::test::strategy;
 
 #[test]
 fn exits_with_reason() {
     with_process_arc(|arc_process| {
         TestRunner::new(Config::with_source_file(file!()))
             .run(&strategy::term(arc_process.clone()), |reason| {
-                prop_assert_eq!(erlang::exit_1(reason), Err(exit!(reason).into()));
+                prop_assert_eq!(exit_1::native(reason), Err(exit!(reason).into()));
 
                 Ok(())
             })

lumen_runtime/src/otp/erlang/link_1.rs

@@ -0,0 +1,88 @@
+// wasm32 proptest cannot be compiled at the same time as non-wasm32 proptest, so disable tests that
+// use proptest completely for wasm32
+//
+// See https://github.com/rust-lang/cargo/issues/4866
+#[cfg(all(not(target_arch = "wasm32"), test))]
+mod test;
+
+use std::sync::Arc;
+
+use liblumen_alloc::erts::exception;
+use liblumen_alloc::erts::exception::system::Alloc;
+use liblumen_alloc::erts::process::code::stack::frame::{Frame, Placement};
+use liblumen_alloc::erts::process::code::{self, result_from_exception};
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term, TypedTerm};
+use liblumen_alloc::{badarg, error, ModuleFunctionArity};
+
+use crate::registry::pid_to_process;
+
+pub fn place_frame_with_arguments(
+    process: &ProcessControlBlock,
+    placement: Placement,
+    pid_or_port: Term,
+) -> Result<(), Alloc> {
+    process.stack_push(pid_or_port)?;
+    process.place_frame(frame(), placement);
+
+    Ok(())
+}
+
+// Private
+
+fn code(arc_process: &Arc<ProcessControlBlock>) -> code::Result {
+    arc_process.reduce();
+
+    let pid_or_port = arc_process.stack_pop().unwrap();
+
+    match native(arc_process, pid_or_port) {
+        Ok(true_term) => {
+            arc_process.return_from_call(true_term)?;
+
+            ProcessControlBlock::call_code(arc_process)
+        }
+        Err(exception) => result_from_exception(arc_process, exception),
+    }
+}
+
+fn frame() -> Frame {
+    Frame::new(module_function_arity(), code)
+}
+
+fn function() -> Atom {
+    Atom::try_from_str("link").unwrap()
+}
+
+fn module_function_arity() -> Arc<ModuleFunctionArity> {
+    Arc::new(ModuleFunctionArity {
+        module: super::module(),
+        function: function(),
+        arity: 1,
+    })
+}
+
+fn native(process: &ProcessControlBlock, pid_or_port: Term) -> exception::Result {
+    match pid_or_port.to_typed_term().unwrap() {
+        TypedTerm::Pid(pid) => {
+            if pid == process.pid() {
+                Ok(true.into())
+            } else {
+                match pid_to_process(&pid) {
+                    Some(pid_arc_process) => {
+                        process.link(&pid_arc_process);
+
+                        Ok(true.into())
+                    }
+                    None => Err(error!(atom_unchecked("noproc")).into()),
+                }
+            }
+        }
+        TypedTerm::Port(_) => unimplemented!(),
+        TypedTerm::Boxed(boxed) => match boxed.to_typed_term().unwrap() {
+            TypedTerm::ExternalPid(_) => unimplemented!(),
+            TypedTerm::ExternalPort(_) => unimplemented!(),
+            _ => Err(badarg!().into()),
+        },
+        _ => Err(badarg!().into()),
+    }
+}

lumen_runtime/src/otp/erlang/link_1/test.rs

@@ -0,0 +1,35 @@
+mod with_local_pid;
+
+use proptest::prop_assert_eq;
+use proptest::strategy::Strategy;
+use proptest::test_runner::{Config, TestRunner};
+
+use liblumen_alloc::badarg;
+use liblumen_alloc::erts::process::ProcessControlBlock;
+
+use crate::otp::erlang::link_1::native;
+use crate::scheduler::{with_process, with_process_arc};
+use crate::test::strategy;
+
+#[test]
+fn without_pid_or_port_errors_badarg() {
+    with_process_arc(|arc_process| {
+        TestRunner::new(Config::with_source_file(file!()))
+            .run(
+                &strategy::term(arc_process.clone())
+                    .prop_filter("Cannot be pid or port", |pid_or_port| {
+                        !(pid_or_port.is_pid() || pid_or_port.is_port())
+                    }),
+                |pid_or_port| {
+                    prop_assert_eq!(native(&arc_process, pid_or_port), Err(badarg!().into()));
+
+                    Ok(())
+                },
+            )
+            .unwrap();
+    });
+}
+
+fn link_count(process: &ProcessControlBlock) -> usize {
+    process.linked_pid_set.lock().len()
+}