Initial signal support

RustPython · windelbouwman · Aug 4, 2019 · Jul 28, 2019 · Jul 29, 2019 · Jul 29, 2019
commit 1b17926e913140f946c3b102edad10532f33a933
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -163,6 +163,7 @@ impl Frame {
     /// Execute a single instruction.
     #[allow(clippy::cognitive_complexity)]
     fn execute_instruction(&self, vm: &VirtualMachine) -> FrameResult {
+        vm.check_signals();
         let instruction = self.fetch_instruction();
 
         flame_guard!(format!("Frame::execute_instruction({:?})", instruction));

diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs
@@ -38,6 +38,8 @@ pub mod io;
 mod os;
 #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
 mod pwd;
+#[cfg(not(target_arch = "wasm32"))]
+mod signal;
 
 use crate::pyobject::PyObjectRef;
 
@@ -92,6 +94,7 @@ pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
         modules.insert("_io".to_string(), Box::new(io::make_module));
         modules.insert("_os".to_string(), Box::new(os::make_module));
         modules.insert("socket".to_string(), Box::new(socket::make_module));
+        modules.insert("_signal".to_string(), Box::new(signal::make_module));
     }
 
     // Unix-only

diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs
@@ -0,0 +1,37 @@
+use crate::obj::objfunction::PyFunctionRef;
+use crate::obj::objint::PyIntRef;
+use crate::pyobject::PyObjectRef;
+use crate::pyobject::PyResult;
+use crate::vm::{VirtualMachine, TRIGGERS};
+
+use std::sync::atomic::Ordering;
+
+use num_traits::cast::ToPrimitive;
+
+use nix::sys::signal;
+
+extern "C" fn run_signal(signum: i32) {
+    unsafe {
+        TRIGGERS[signum as usize].store(true, Ordering::Relaxed);
+    }
+}
+
+fn signal(signalnum: PyIntRef, handler: PyFunctionRef, vm: &VirtualMachine) -> PyResult<()> {
+    vm.signal_handlers.borrow_mut().insert(
+        signalnum.as_bigint().to_i32().unwrap(),
+        handler.into_object(),
+    );
+    let handler = nix::sys::signal::SigHandler::Handler(run_signal);
+    let sig_action =
+        signal::SigAction::new(handler, signal::SaFlags::empty(), signal::SigSet::empty());
+    unsafe { signal::sigaction(signal::SIGINT, &sig_action) }.unwrap();
+    Ok(())
+}
+
+pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+    let ctx = &vm.ctx;
+
+    py_module!(vm, "_signal", {
+        "signal" => ctx.new_rustfunc(signal),
+    })
+}
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -9,6 +9,7 @@ use std::collections::hash_map::HashMap;
 use std::collections::hash_set::HashSet;
 use std::fmt;
 use std::rc::Rc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Mutex, MutexGuard};
 
 use crate::builtins;
@@ -42,6 +43,23 @@ use num_bigint::BigInt;
 #[cfg(feature = "rustpython-compiler")]
 use rustpython_compiler::{compile, error::CompileError};
 
+// Signal triggers
+// TODO: 64
+pub const NSIG: usize = 10;
+
+pub static mut TRIGGERS: [AtomicBool; NSIG] = [
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+    AtomicBool::new(false),
+];
+
 // use objects::objects;
 
 // Objects are live when they are on stack, or referenced by a name (for now)
@@ -62,6 +80,7 @@ pub struct VirtualMachine {
     pub trace_func: RefCell<PyObjectRef>,
     pub use_tracing: RefCell<bool>,
     pub settings: PySettings,
+    pub signal_handlers: RefCell<HashMap<i32, PyObjectRef>>,
 }
 
 /// Struct containing all kind of settings for the python vm.
@@ -160,6 +179,7 @@ impl VirtualMachine {
             trace_func,
             use_tracing: RefCell::new(false),
             settings,
+            signal_handlers: RefCell::new(HashMap::new()),
         };
 
         builtins::make_module(&vm, builtins.clone());
@@ -1143,6 +1163,21 @@ impl VirtualMachine {
     pub fn current_exception(&self) -> Option<PyObjectRef> {
         self.exceptions.borrow().last().cloned()
     }
+
+    pub fn check_signals(&self) {
+        for (signum, handler) in self.signal_handlers.borrow().iter() {
+            if *signum as usize >= NSIG {
+                panic!("Signum bigger then NSIG");
+            }
+            let triggerd;
+            unsafe {
+                triggerd = TRIGGERS[*signum as usize].swap(false, Ordering::Relaxed);
+            }
+            if triggerd {
+                self.invoke(handler.clone(), vec![]).expect("Test");
+            }
+        }
+    }
 }
 
 impl Default for VirtualMachine {