[GR-7405] Use JNI to interrupt threads natively instead of Truffle NFI

eregon · eregon · commit dd4bb578dbbf · 2021-02-23T19:23:22.000+01:00
* Truffle NFI needs to be inside a TruffleContext to work, but that is
  quite limiting.
diff --git a/mx.truffleruby/mx_truffleruby.py b/mx.truffleruby/mx_truffleruby.py
@@ -105,6 +105,7 @@ def contents(self, result):
         ruby_options = [
             '--experimental-options',
             '--building-core-cexts',
+            '--platform-native-interrupt=false', # no librubysignal in the ruby home yet
             '--launcher=' + result,
             '--disable-gems',
             '--disable-rubyopt',
@@ -267,6 +268,6 @@ def verify_ci(args):
     'ruby_testdownstream_hello': [ruby_testdownstream_hello, ''],
     'ruby_testdownstream_sulong': [ruby_testdownstream_sulong, ''],
     'ruby_spotbugs': [ruby_spotbugs, ''],
-    'verify-ci' : [verify_ci, '[options]'],
+    'verify-ci': [verify_ci, '[options]'],
     'ruby_jacoco_args': [ruby_jacoco_args, ''],
 })
diff --git a/mx.truffleruby/suite.py b/mx.truffleruby/suite.py
@@ -2,15 +2,15 @@
     "mxversion": "5.281.0",
     "name": "truffleruby",
 
-    "imports" : {
-        "suites" : [
+    "imports": {
+        "suites": [
             {
                 "name": "regex",
                 "subdir": True,
                 "version": "8c1abd10ad2992580462d7629db316177a256f82",
                 "urls": [
-                    {"url": "https://github.com/oracle/graal.git", "kind" : "git"},
-                    {"url": "https://curio.ssw.jku.at/nexus/content/repositories/snapshots", "kind" : "binary"},
+                    {"url": "https://github.com/oracle/graal.git", "kind": "git"},
+                    {"url": "https://curio.ssw.jku.at/nexus/content/repositories/snapshots", "kind": "binary"},
                 ]
             },
             {
@@ -172,9 +172,20 @@
             "license": ["EPL-2.0"],
         },
 
+        "org.truffleruby.rubysignal": {
+            "dir": "src/main/c/rubysignal",
+            "native": "shared_lib",
+            "deliverable": "rubysignal",
+            "buildDependencies": [
+                "org.truffleruby", # for the generated JNI header file
+            ],
+            "cflags": ["-g", "-Wall", "-Werror"],
+        },
+
         "org.truffleruby": {
             "dir": "src/main",
             "sourceDirs": ["java"],
+            "jniHeaders": True,
             "dependencies": [
                 "truffleruby:TRUFFLERUBY-ANNOTATIONS",
                 "truffleruby:TRUFFLERUBY-SHARED",
@@ -446,6 +457,7 @@
                     "file:lib/cext/*.rb",
                     "dependency:org.truffleruby.cext/src/main/c/truffleposix/<lib:truffleposix>",
                     "dependency:org.truffleruby.cext/src/main/c/cext/<lib:truffleruby>",
+                    "dependency:org.truffleruby.rubysignal",
                 ],
                 "lib/cext/include/": [
                     "file:lib/cext/include/ccan",
diff --git a/src/main/c/rubysignal/src/rubysignal.c b/src/main/c/rubysignal/src/rubysignal.c
@@ -0,0 +1,24 @@
+#include "org_truffleruby_signal_LibRubySignal.h"
+#include <pthread.h>
+#include <signal.h>
+
+static void empty_handler(int sig) {
+}
+
+JNIEXPORT jint JNICALL Java_org_truffleruby_signal_LibRubySignal_setupSIGVTALRMEmptySignalHandler(JNIEnv *env, jclass clazz) {
+  struct sigaction action = {
+    .sa_flags = 0, /* flags = 0 is intended as we want no SA_RESTART so we can interrupt blocking syscalls */
+    .sa_handler = empty_handler,
+  };
+  return sigaction(SIGVTALRM, &action, NULL);
+}
+
+JNIEXPORT jlong JNICALL Java_org_truffleruby_signal_LibRubySignal_threadID(JNIEnv *env, jclass clazz) {
+  pthread_t pthread_id = pthread_self();
+  return (jlong) pthread_id;
+}
+
+JNIEXPORT jint JNICALL Java_org_truffleruby_signal_LibRubySignal_sendSIGVTALRMToThread(JNIEnv *env, jclass clazz, jlong threadID) {
+  pthread_t pthread_id = (pthread_t) threadID;
+  return pthread_kill(pthread_id, SIGVTALRM);
+}
diff --git a/src/main/java/org/truffleruby/RubyContext.java b/src/main/java/org/truffleruby/RubyContext.java
@@ -214,7 +214,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
 
         Metrics.printTime("before-thread-manager");
         threadManager = new ThreadManager(this, language);
-        threadManager.initialize(truffleNFIPlatform, nativeConfiguration);
+        threadManager.initialize();
         threadManager.initializeMainThread(Thread.currentThread());
         Metrics.printTime("after-thread-manager");
 
@@ -300,7 +300,7 @@ protected boolean patch(Env newEnv) {
         this.truffleNFIPlatform = createNativePlatform();
         encodingManager.initializeDefaultEncodings(truffleNFIPlatform, nativeConfiguration);
 
-        threadManager.initialize(truffleNFIPlatform, nativeConfiguration);
+        threadManager.initialize();
         threadManager.restartMainThread(Thread.currentThread());
 
         Metrics.printTime("before-rehash");
diff --git a/src/main/java/org/truffleruby/core/thread/ThreadManager.java b/src/main/java/org/truffleruby/core/thread/ThreadManager.java
@@ -32,23 +32,20 @@
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.core.support.PRNGRandomizerNodes;
-import org.truffleruby.extra.ffi.Pointer;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.control.DynamicReturnException;
 import org.truffleruby.language.control.ExitException;
 import org.truffleruby.language.control.KillException;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.objects.shared.SharedObjects;
-import org.truffleruby.platform.NativeConfiguration;
-import org.truffleruby.platform.TruffleNFIPlatform;
-import org.truffleruby.platform.TruffleNFIPlatform.NativeFunction;
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.TruffleStackTrace;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.Shape;
+import org.truffleruby.signal.LibRubySignal;
 
 public class ThreadManager {
 
@@ -104,13 +101,10 @@ void restore(UnblockingAction action) {
     public static final UnblockingAction EMPTY_UNBLOCKING_ACTION = () -> {
     };
 
+    private boolean nativeInterrupt;
     private final ThreadLocal<UnblockingAction> blockingNativeCallUnblockingAction = ThreadLocal
             .withInitial(() -> EMPTY_UNBLOCKING_ACTION);
 
-    private int SIGVTALRM;
-    private NativeFunction pthread_self;
-    private NativeFunction pthread_kill;
-
     private final ExecutorService fiberPool;
 
     public ThreadManager(RubyContext context, RubyLanguage language) {
@@ -120,10 +114,11 @@ public ThreadManager(RubyContext context, RubyLanguage language) {
         this.fiberPool = Executors.newCachedThreadPool(this::createFiberJavaThread);
     }
 
-    public void initialize(TruffleNFIPlatform nfi, NativeConfiguration nativeConfiguration) {
-        if (context.getOptions().NATIVE_INTERRUPT && nfi != null) {
-            setupSignalHandler(nfi, nativeConfiguration);
-            setupNativeThreadSupport(nfi, nativeConfiguration);
+    public void initialize() {
+        nativeInterrupt = context.getOptions().NATIVE_INTERRUPT && context.getRubyHome() != null;
+        if (nativeInterrupt) {
+            LibRubySignal.loadLibrary(context.getRubyHome());
+            LibRubySignal.setupSIGVTALRMEmptySignalHandler();
         }
     }
 
@@ -251,37 +246,6 @@ private boolean getGlobalAbortOnException() {
         return (boolean) DynamicObjectLibrary.getUncached().getOrDefault(threadClass, "@abort_on_exception", null);
     }
 
-    private void setupSignalHandler(TruffleNFIPlatform nfi, NativeConfiguration config) {
-        SIGVTALRM = (int) config.get("platform.signal.SIGVTALRM");
-
-        final Object libC = nfi.getDefaultLibrary();
-
-        // We use abs() as a function taking a int and having no side effects
-        final Object abs = nfi.lookup(libC, "abs");
-        final NativeFunction sigaction = nfi.getFunction("sigaction", "(sint32,pointer,pointer):sint32");
-
-        final int sizeOfSigAction = (int) config.get("platform.sigaction.sizeof");
-        final int handlerOffset = (int) config.get("platform.sigaction.sa_handler.offset");
-
-        try (Pointer structSigAction = Pointer.calloc(sizeOfSigAction)) {
-            structSigAction.writeLong(handlerOffset, nfi.asPointer(abs));
-
-            // flags = 0 is OK as we want no SA_RESTART so we can interrupt blocking syscalls.
-            final int result = (int) sigaction.call(SIGVTALRM, structSigAction.getAddress(), 0L);
-            if (result != 0) {
-                // TODO (eregon, 24 Nov. 2017): we should show the NFI errno here.
-                throw new UnsupportedOperationException("sigaction() failed");
-            }
-        }
-    }
-
-    private void setupNativeThreadSupport(TruffleNFIPlatform nfi, NativeConfiguration nativeConfiguration) {
-        final String pthread_t = nfi.resolveType(nativeConfiguration, "pthread_t");
-
-        pthread_self = nfi.getFunction("pthread_self", "():" + pthread_t);
-        pthread_kill = nfi.getFunction("pthread_kill", "(" + pthread_t + ",sint32):sint32");
-    }
-
     public void initialize(RubyThread rubyThread, Node currentNode, String info, String sharingReason,
             Supplier<Object> task) {
         startSharing(rubyThread, sharingReason);
@@ -541,10 +505,9 @@ public void initializeValuesForJavaThread(RubyThread rubyThread, Thread thread)
             foreignThreadMap.put(thread, rubyThread);
         }
 
-        if (pthread_self != null && isRubyManagedThread(thread)) {
-            final Object pThreadID = pthread_self.call();
-
-            blockingNativeCallUnblockingAction.set(() -> pthread_kill.call(pThreadID, SIGVTALRM));
+        if (nativeInterrupt && isRubyManagedThread(thread)) {
+            final long threadID = LibRubySignal.threadID();
+            blockingNativeCallUnblockingAction.set(() -> LibRubySignal.sendSIGVTALRMToThread(threadID));
         }
 
         unblockingActions.put(thread, new UnblockingActionHolder(thread, () -> thread.interrupt()));
@@ -556,7 +519,7 @@ public void cleanupValuesForJavaThread(Thread thread) {
         }
         foreignThreadMap.remove(thread);
 
-        if (pthread_self != null) {
+        if (nativeInterrupt) {
             blockingNativeCallUnblockingAction.remove();
         }
 
diff --git a/src/main/java/org/truffleruby/signal/LibRubySignal.java b/src/main/java/org/truffleruby/signal/LibRubySignal.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.signal;
+
+import org.truffleruby.platform.Platform;
+
+public abstract class LibRubySignal {
+
+    public static void loadLibrary(String rubyHome) {
+        final String path = rubyHome + "/lib/cext/librubysignal" + Platform.LIB_SUFFIX;
+        System.load(path);
+    }
+
+    public static native int setupSIGVTALRMEmptySignalHandler();
+
+    public static native long threadID();
+
+    public static native int sendSIGVTALRMToThread(long thread);
+
+}
