[GR-17131] Detect when starting a Thread fails and report the exception to the Thread spawning the new Thread.

PullRequest: truffleruby/952

Author: eregon

CHANGELOG.md

@@ -12,6 +12,7 @@ Bug fixes:
 * Do not modify the argument passed to `IO#write` when the encoding does not match (#1714).
 * Use the class where the method was defined to check if an `UnboundMethod` can be used for `#define_method` (#1710).
 * Fixed setting `$~` for `Enumerable` and `Enumerator::Lazy`'s `#grep` and `#grep_v`.
+* Improved errors when interacting with single-threaded languages (#1709).
 
 Compatibility:
 

src/main/java/org/truffleruby/core/VMPrimitiveNodes.java

@@ -76,6 +76,7 @@
 import org.truffleruby.language.yield.YieldNode;
 import org.truffleruby.platform.Signals;
 
+import java.io.PrintStream;
 import java.util.Map.Entry;
 
 @CoreClass(value = "VM primitives")
@@ -317,7 +318,16 @@ public boolean watchSignalProc(DynamicObject signalNameString, DynamicObject pro
                 // Workaround: we need to register with Truffle (which means going multithreaded),
                 // so that NFI can get its context to call pthread_kill() (GR-7405).
                 final TruffleContext truffleContext = context.getEnv().getContext();
-                final Object prev = truffleContext.enter();
+                final Object prev;
+                try {
+                    prev = truffleContext.enter();
+                } catch (IllegalStateException e) { // Multi threaded access denied from Truffle
+                    // Not in a context, so we cannot use TruffleLogger
+                    final PrintStream printStream = new PrintStream(context.getEnv().err(), true);
+                    printStream.println("[ruby] SEVERE: signal " + signalName + " caught but can't create a thread to handle it so ignoring and restoring the default handler");
+                    Signals.restoreDefaultHandler(signalName);
+                    return;
+                }
                 try {
                     context.getSafepointManager().pauseAllThreadsAndExecuteFromNonRubyThread(true, (rubyThread, currentNode) -> {
                         if (rubyThread == rootThread &&

src/main/java/org/truffleruby/core/exception/ExceptionOperations.java

@@ -17,6 +17,7 @@
 import org.truffleruby.core.thread.ThreadNodes.ThreadGetExceptionNode;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.backtrace.Backtrace;
+import org.truffleruby.language.control.JavaException;
 import org.truffleruby.language.control.RaiseException;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -89,4 +90,14 @@ public static DynamicObject getFormatter(String name, RubyContext context) {
         return (DynamicObject) Layouts.MODULE.getFields(context.getCoreLibrary().getTruffleExceptionOperationsModule()).getConstant(name).getValue();
     }
 
+    public static void rethrow(Throwable throwable) {
+        if (throwable instanceof RuntimeException) {
+            throw (RuntimeException) throwable;
+        } else if (throwable instanceof Error) {
+            throw (Error) throwable;
+        } else {
+            throw new JavaException(throwable);
+        }
+    }
+
 }

src/main/java/org/truffleruby/core/fiber/FiberLayout.java

@@ -35,7 +35,8 @@ DynamicObject createFiber(DynamicObjectFactory factory,
                               @Volatile @Nullable DynamicObject lastResumedByFiber,
                               @Volatile boolean alive,
                               @Nullable Thread thread,
-                              @Volatile boolean transferred);
+                              @Volatile boolean transferred,
+                              @Volatile @Nullable Throwable uncaughtException);
 
     boolean isFiber(DynamicObject object);
 
@@ -64,4 +65,7 @@ DynamicObject createFiber(DynamicObjectFactory factory,
     boolean getTransferred(DynamicObject object);
     void setTransferred(DynamicObject object, boolean value);
 
+    Throwable getUncaughtException(DynamicObject object);
+    void setUncaughtException(DynamicObject object, Throwable value);
+
 }

src/main/java/org/truffleruby/core/fiber/FiberManager.java

@@ -19,6 +19,7 @@
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.core.array.ArrayHelpers;
+import org.truffleruby.core.exception.ExceptionOperations;
 import org.truffleruby.core.proc.ProcOperations;
 import org.truffleruby.core.thread.ThreadManager;
 import org.truffleruby.core.thread.ThreadManager.BlockingAction;
@@ -113,7 +114,8 @@ public DynamicObject createFiber(RubyContext context, DynamicObject thread, Dyna
                 null,
                 true,
                 null,
-                false);
+                false,
+                null);
     }
 
     @TruffleBoundary
@@ -122,9 +124,13 @@ private static LinkedBlockingQueue<FiberMessage> newMessageQueue() {
     }
 
     public void initialize(DynamicObject fiber, DynamicObject block, Node currentNode) {
-        context.getThreadManager().spawnFiber(() -> fiberMain(context, fiber, block, currentNode));
-
-        waitForInitialization(context, fiber, currentNode);
+        ThreadManager.FIBER_BEING_SPAWNED.set(fiber);
+        try {
+            context.getThreadManager().spawnFiber(() -> fiberMain(context, fiber, block, currentNode));
+            waitForInitialization(context, fiber, currentNode);
+        } finally {
+            ThreadManager.FIBER_BEING_SPAWNED.remove();
+        }
     }
 
     /** Wait for full initialization of the new fiber */
@@ -135,6 +141,11 @@ public static void waitForInitialization(RubyContext context, DynamicObject fibe
             initializedLatch.await();
             return BlockingAction.SUCCESS;
         });
+
+        final Throwable uncaughtException = Layouts.FIBER.getUncaughtException(fiber);
+        if (uncaughtException != null) {
+            ExceptionOperations.rethrow(uncaughtException);
+        }
     }
 
     private static final BranchProfile UNPROFILED = BranchProfile.create();

src/main/java/org/truffleruby/core/mutex/MutexOperations.java

@@ -15,9 +15,9 @@
 
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
+import org.truffleruby.core.exception.ExceptionOperations;
 import org.truffleruby.core.thread.ThreadManager;
 import org.truffleruby.language.RubyNode;
-import org.truffleruby.language.control.JavaException;
 import org.truffleruby.language.control.RaiseException;
 
 import java.util.concurrent.locks.ReentrantLock;
@@ -83,13 +83,7 @@ protected static void internalLockEvenWithException(ReentrantLock lock, RubyNode
         }
 
         if (throwable != null) {
-            if (throwable instanceof RuntimeException) {
-                throw (RuntimeException) throwable;
-            } else if (throwable instanceof Error) {
-                throw (Error) throwable;
-            } else {
-                throw new JavaException(throwable);
-            }
+            ExceptionOperations.rethrow(throwable);
         }
     }
 

src/main/java/org/truffleruby/core/thread/ThreadManager.java

@@ -86,7 +86,7 @@ public ThreadManager(RubyContext context) {
         this.context = context;
         this.rootThread = createBootThread("main");
         this.rootJavaThread = Thread.currentThread();
-        this.fiberPool = Executors.newCachedThreadPool(this::createJavaThread);
+        this.fiberPool = Executors.newCachedThreadPool(this::createFiberJavaThread);
     }
 
     public void initialize(TruffleNFIPlatform nfi, NativeConfiguration nativeConfiguration) {
@@ -118,7 +118,16 @@ public void restartMainThread(Thread mainJavaThread) {
         Layouts.FIBER.setFinishedLatch(rootFiber, new CountDownLatch(1));
     }
 
-    public Thread createJavaThread(Runnable runnable) {
+    // spawning Thread => Fiber object
+    public static final ThreadLocal<DynamicObject> FIBER_BEING_SPAWNED = new ThreadLocal<>();
+
+    private Thread createFiberJavaThread(Runnable runnable) {
+        DynamicObject fiber = FIBER_BEING_SPAWNED.get();
+        assert fiber != null;
+        return createJavaThread(runnable, fiber);
+    }
+
+    private Thread createJavaThread(Runnable runnable, DynamicObject fiber) {
         if (context.getOptions().SINGLE_THREADED) {
             throw new RaiseException(context, context.getCoreExceptions().securityError("threads not allowed in single-threaded mode", null));
         }
@@ -128,6 +137,18 @@ public Thread createJavaThread(Runnable runnable) {
         }
 
         final Thread thread = context.getEnv().createThread(runnable);
+
+        assert fiber != null;
+        thread.setUncaughtExceptionHandler((javaThread, throwable) -> {
+            try {
+                Layouts.FIBER.setUncaughtException(fiber, throwable);
+                Layouts.FIBER.getInitializedLatch(fiber).countDown();
+            } catch (Throwable t) {
+                t.initCause(throwable);
+                Thread.getDefaultUncaughtExceptionHandler().uncaughtException(javaThread, t);
+            }
+        });
+
         rubyManagedThreads.add(thread);
         return thread;
     }
@@ -233,12 +254,13 @@ public void initialize(DynamicObject rubyThread, Node currentNode, String info,
         startSharing(rubyThread, sharingReason);
 
         Layouts.THREAD.setSourceLocation(rubyThread, info);
+        final DynamicObject rootFiber = Layouts.THREAD.getFiberManager(rubyThread).getRootFiber();
 
-        final Thread thread = createJavaThread(() -> threadMain(rubyThread, currentNode, task));
+        final Thread thread = createJavaThread(() -> threadMain(rubyThread, currentNode, task), rootFiber);
         thread.setName(NAME_PREFIX + " id=" + thread.getId() + " from " + info);
-        thread.start();
 
-        FiberManager.waitForInitialization(context, Layouts.THREAD.getFiberManager(rubyThread).getRootFiber(), currentNode);
+        thread.start();
+        FiberManager.waitForInitialization(context, rootFiber, currentNode);
     }
 
     private void threadMain(DynamicObject thread, Node currentNode, Supplier<Object> task) {