Improve error when internal resource cache folder read-only during native-image build.

Author: tzezula

substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleFeature.java

@@ -100,6 +100,7 @@
 import java.util.function.ToLongFunction;
 import java.util.function.UnaryOperator;
 
+import com.oracle.truffle.api.impl.DefaultTruffleRuntime;
 import org.graalvm.collections.Pair;
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
@@ -276,7 +277,16 @@ public static boolean isInConfiguration() {
 
     @Override
     public void afterRegistration(AfterRegistrationAccess access) {
-        UserError.guarantee(Truffle.getRuntime() instanceof SubstrateTruffleRuntime, "TruffleFeature requires SubstrateTruffleRuntime");
+        TruffleRuntime runtime = Truffle.getRuntime();
+        if (runtime instanceof DefaultTruffleRuntime defaultTruffleRuntime) {
+            String errorMessage = defaultTruffleRuntime.getFallbackReason();
+            throw UserError.abort("""
+                            Failed to create the optimized Truffle runtime: %s
+                            Either fix the problem above or enable the fallback Truffle runtime by setting the system property `-Dtruffle.UseFallbackRuntime=true`.
+                            Execution without runtime compilation will negatively impact the guest application performance.
+                            """, errorMessage);
+        }
+        UserError.guarantee(runtime instanceof SubstrateTruffleRuntime, "TruffleFeature requires SubstrateTruffleRuntime");
         SubstrateTruffleRuntime truffleRuntime = (SubstrateTruffleRuntime) Truffle.getRuntime();
         truffleRuntime.resetHosted();
         RuntimeCompilationFeature.singleton().setUniverseFactory(new SubstrateTruffleUniverseFactory(truffleRuntime));

truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/Truffle.java

@@ -129,8 +129,12 @@ private static TruffleRuntime createRuntime() throws InternalError {
                  * This path is taken if a truffle runtime class is directly specified. In such case
                  * we try to export JVMCI to the module of that class.
                  */
-                maybeExportJVMCITo(runtimeClass);
-                return (TruffleRuntime) runtimeClass.getDeclaredConstructor().newInstance();
+                String errorMessage = maybeExportJVMCITo(runtimeClass);
+                if (errorMessage == null) {
+                    return (TruffleRuntime) runtimeClass.getDeclaredConstructor().newInstance();
+                } else {
+                    return new DefaultTruffleRuntime(errorMessage);
+                }
             } catch (Throwable e) {
                 // Fail fast for other errors
                 throw new InternalError(e);
@@ -166,16 +170,16 @@ private static TruffleRuntime createRuntime() throws InternalError {
         return new DefaultTruffleRuntime(reason);
     }
 
-    private static void maybeExportJVMCITo(Class<?> runtimeClass) throws ReflectiveOperationException {
+    private static String maybeExportJVMCITo(Class<?> runtimeClass) throws ReflectiveOperationException {
         Class<?> modulesSupport;
         try {
             modulesSupport = Class.forName("com.oracle.truffle.runtime.ModulesSupport");
         } catch (ClassNotFoundException e) {
             // we ignore if modules support is not available.
             // this typically means that the runtime not on the module-path
-            return;
+            return null;
         }
-        modulesSupport.getMethod("exportJVMCI", Class.class).invoke(null, runtimeClass);
+        return (String) modulesSupport.getMethod("exportJVMCI", Class.class).invoke(null, runtimeClass);
     }
 
     @SuppressWarnings("deprecation")

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/InternalResourceCache.java

@@ -128,6 +128,10 @@ String getResourceId() {
         return resourceId;
     }
 
+    Path getOwningRoot() {
+        return owningRoot == null ? null : owningRoot.path();
+    }
+
     Path getPathOrNull() {
         return path;
     }
@@ -202,10 +206,10 @@ boolean requiresEagerUnpack() {
     }
 
     /**
-     * Installs truffleattach library. Used reflectively by
-     * {@code com.oracle.truffle.runtime.JDKSupport}. The {@code JDKSupport} is initialized before
-     * the Truffle runtime is created and accessor classes are initialized. For this reason, it
-     * cannot use {@code EngineSupport} to call this method, nor can this method use any accessor.
+     * Installs {@code truffleattach} library. Used by{@link JDKSupport}. The {@code JDKSupport} is
+     * initialized before the Truffle runtime is created and accessor classes are initialized. For
+     * this reason, it cannot use {@code EngineSupport} to call this method, nor can this method use
+     * any accessor.
      */
     static Path installRuntimeResource(InternalResource resource, String id) throws IOException {
         InternalResourceCache cache = createRuntimeResourceCache(resource, id);
@@ -219,7 +223,12 @@ static Path installRuntimeResource(InternalResource resource, String id) throws
         }
     }
 
-    private static InternalResourceCache createRuntimeResourceCache(InternalResource resource, String id) {
+    /**
+     * Creates an {@link InternalResourceCache} for the {@code truffleattach} library. This method
+     * is used by {@link JDKSupport} to diagnose the cause of {@code truffleattach} library
+     * installation failure.
+     */
+    static InternalResourceCache createRuntimeResourceCache(InternalResource resource, String id) {
         assert verifyAnnotationConsistency(resource, id) : resource.getClass() + " must be annotated by @InternalResource.Id(\"" + id + "\"";
         InternalResourceCache cache = new InternalResourceCache(PolyglotEngineImpl.ENGINE_ID, id, () -> resource);
         InternalResourceRoots.initializeRuntimeResource(cache);

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/JDKSupport.java

@@ -54,6 +54,7 @@
 import java.lang.reflect.Method;
 import java.net.URI;
 import java.nio.ByteBuffer;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayDeque;
 import java.util.Collections;
@@ -83,6 +84,7 @@
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.access.SharedSecrets;
 import jdk.internal.module.Modules;
+import org.graalvm.collections.Pair;
 
 final class JDKSupport {
 
@@ -108,36 +110,57 @@ final class JDKSupport {
         }
     }
 
-    private static final ModulesAccessor MODULES_ACCESSOR = initializeModuleAccessor();
+    /**
+     * Represents either a {@code ModuleAccessor} or an error message.
+     * <p>
+     * The following combinations are valid:
+     * <ul>
+     * <li>{@code {moduleAccessor, null}} - a successful result with a module accessor.</li>
+     * <li>{@code {null, errorMessage}} - a failure with an error message.</li>
+     * </ul>
+     */
+    private static final Pair<ModulesAccessor, String> MODULES_ACCESSOR = initializeModuleAccessor();
 
     @SuppressWarnings("restricted")
-    private static ModulesAccessor initializeModuleAccessor() {
+    private static Pair<ModulesAccessor, String> initializeModuleAccessor() {
         String attachLibPath = System.getProperty("truffle.attach.library");
         if (attachLibPath == null) {
             if (isUnsupportedPlatform()) {
-                performTruffleAttachLoadFailureAction("Truffle is running on an unsupported platform where the TruffleAttach library is unavailable.", null);
-                return null;
+                String errorMessage = "Truffle is running on an unsupported platform where the TruffleAttach library is unavailable.";
+                performTruffleAttachLoadFailureAction(errorMessage, null);
+                return Pair.create(null, errorMessage);
             }
+            InternalResource libTruffleAttachResource = new LibTruffleAttachResource();
             try {
-                Path truffleAttachRoot = InternalResourceCache.installRuntimeResource(new LibTruffleAttachResource(), LibTruffleAttachResource.ID);
+                Path truffleAttachRoot = InternalResourceCache.installRuntimeResource(libTruffleAttachResource, LibTruffleAttachResource.ID);
                 Path libAttach = truffleAttachRoot.resolve("bin").resolve(System.mapLibraryName("truffleattach"));
                 attachLibPath = libAttach.toString();
             } catch (IOException ioe) {
-                performTruffleAttachLoadFailureAction("The Truffle API JAR is missing the 'truffleattach' resource, likely due to issues when Truffle was repackaged into a fat JAR.", ioe);
-                return null;
+                String errorMessage;
+                InternalResourceCache cache = InternalResourceCache.createRuntimeResourceCache(libTruffleAttachResource, LibTruffleAttachResource.ID);
+                Path root = cache.getOwningRoot();
+                if (root == null || !Files.isDirectory(root) || !Files.isReadable(root) || !Files.isWritable(root)) {
+                    errorMessage = String.format("Failed to install the 'truffleattach' resource: the resource cache folder %s is not a readable and writable directory.", root);
+                } else {
+                    errorMessage = "The Truffle API JAR is missing the 'truffleattach' resource, likely due to issues when Truffle was repackaged into a fat JAR.";
+                }
+                performTruffleAttachLoadFailureAction(errorMessage, ioe);
+                return Pair.create(null, errorMessage);
             }
         }
         try {
             try {
                 System.load(attachLibPath);
             } catch (UnsatisfiedLinkError failedToLoad) {
-                performTruffleAttachLoadFailureAction("Unable to load the TruffleAttach library.", failedToLoad);
-                return null;
+                String errorMessage = String.format("Unable to load the TruffleAttach library %s", attachLibPath);
+                performTruffleAttachLoadFailureAction(errorMessage, failedToLoad);
+                return Pair.create(null, errorMessage);
             } catch (IllegalCallerException illegalCaller) {
                 String vmOption = "--enable-native-access=" + (JDKSupport.class.getModule().isNamed() ? "org.graalvm.truffle" : "ALL-UNNAMED");
-                performTruffleAttachLoadFailureAction(String.format("Failed to load the TruffleAttach library. The Truffle module does not have native access enabled. " +
-                                "To resolve this, pass the following VM option: %s.", vmOption), illegalCaller);
-                return null;
+                String errorMessage = String.format("Failed to load the TruffleAttach library. The Truffle module does not have native access enabled. " +
+                                "To resolve this, pass the following VM option: %s.", vmOption);
+                performTruffleAttachLoadFailureAction(errorMessage, illegalCaller);
+                return Pair.create(null, errorMessage);
             }
             ModulesAccessor accessor;
             if (ModulesAccessor.class.getModule().isNamed()) {
@@ -148,7 +171,7 @@ private static ModulesAccessor initializeModuleAccessor() {
             Module javaBase = ModuleLayer.boot().findModule("java.base").orElseThrow();
             addExports0(javaBase, "jdk.internal.module", accessor.getTargetModule());
             addExports0(javaBase, "jdk.internal.access", accessor.getTargetModule());
-            return accessor;
+            return Pair.create(accessor, null);
         } catch (ReflectiveOperationException re) {
             throw new InternalError(re);
         }
@@ -235,7 +258,11 @@ static void enableNativeAccess(Module clientModule) {
 
     @SuppressWarnings("restricted")
     static ModulesAccessor getModulesAccessor() {
-        return MODULES_ACCESSOR;
+        return MODULES_ACCESSOR.getLeft();
+    }
+
+    static String getInitializationErrorMessage() {
+        return MODULES_ACCESSOR.getRight();
     }
 
     private static void forEach(Module rootModule, Set<Edge> edges, Predicate<? super Module> filter, Consumer<? super Module> action) {
@@ -699,10 +726,10 @@ private static final class JavaLangSupportImpl extends JavaLangSupport {
             static {
                 if (JDKSupport.MODULES_ACCESSOR == null) {
                     throw new IllegalStateException("JavaLangAccessorImpl initialized before JDKSupport.");
-                } else if (!(JDKSupport.MODULES_ACCESSOR instanceof IsolatedImpl)) {
+                } else if (!(JDKSupport.MODULES_ACCESSOR.getLeft() instanceof IsolatedImpl)) {
                     throw new IllegalStateException("JDKSupport.MODULES_ACCESSOR initialized with wrong type " + JDKSupport.MODULES_ACCESSOR.getClass());
                 } else {
-                    CURRENT_CARRIER_THREAD = ((IsolatedImpl) JDKSupport.MODULES_ACCESSOR).currentCarrierThread;
+                    CURRENT_CARRIER_THREAD = ((IsolatedImpl) JDKSupport.MODULES_ACCESSOR.getLeft()).currentCarrierThread;
                 }
             }
 

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/ModulesSupport.java

@@ -95,8 +95,8 @@ private static String exportJVMCI(Module module, Set<Module> seenModules) {
             return "JVMCI is not enabled for this JVM. Enable JVMCI using -XX:+EnableJVMCI.";
         }
         if (ACCESSOR == null) {
-            return "The Truffle attach library is not available or cannot be loaded. " +
-                            "This can happen if the Truffle jar files are invalid or if Truffle is loaded multiple times in separate class loaders.";
+            String initializationError = getAccessorInitializationErrorMessage();
+            return "The Truffle attach library is not available or cannot be loaded. " + initializationError;
         }
         addExportsRecursive(layer, jvmciModule, module, seenModules);
         return null;
@@ -178,4 +178,18 @@ private static ModulesAccessor initializeModulesAccessor() {
             throw new InternalError(throwable);
         }
     }
+
+    /**
+     * Gets reflectively an error message when {@code ModulesAccessor} failed to initialize.
+     */
+    private static String getAccessorInitializationErrorMessage() {
+        try {
+            Class<?> resourceCacheClass = Class.forName("com.oracle.truffle.polyglot.JDKSupport", false, ModulesSupport.class.getClassLoader());
+            Method getModulesAccessor = resourceCacheClass.getDeclaredMethod("getInitializationErrorMessage");
+            getModulesAccessor.setAccessible(true);
+            return (String) getModulesAccessor.invoke(null);
+        } catch (Throwable throwable) {
+            return null;
+        }
+    }
 }