8352689: Allow for hash sum overrides when linking from the run-time image

Author: jerboaa

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JRTArchive.java

@@ -41,10 +41,12 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.HexFormat;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -74,6 +76,7 @@ public class JRTArchive implements Archive {
     // Maps a module resource path to the corresponding diff to packaged
     // modules for that resource (if any)
     private final Map<String, ResourceDiff> resDiff;
+    private final Map<String, Set<String>> altHashSums;
     private final boolean errorOnModifiedFile;
     private final TaskHelper taskHelper;
 
@@ -86,11 +89,15 @@ public class JRTArchive implements Archive {
      *        install aborts the link.
      * @param perModDiff The lib/modules (a.k.a jimage) diff for this module,
      *                   possibly an empty list if there are no differences.
+     * @param altHashSums A map of alternative hash sums for files in
+     *                    a module, possibly empty.
+     * @param taskHelper The task helper reference.
      */
     JRTArchive(String module,
                Path path,
                boolean errorOnModifiedFile,
                List<ResourceDiff> perModDiff,
+               Map<String, Set<String>> altHashSums,
                TaskHelper taskHelper) {
         this.module = module;
         this.path = path;
@@ -105,6 +112,7 @@ public class JRTArchive implements Archive {
         this.resDiff = Objects.requireNonNull(perModDiff).stream()
                             .collect(Collectors.toMap(ResourceDiff::getName, Function.identity()));
         this.taskHelper = taskHelper;
+        this.altHashSums = altHashSums;
     }
 
     @Override
@@ -217,7 +225,21 @@ private void addNonClassResources() {
 
                         // Read from the base JDK image.
                         Path path = BASE.resolve(m.resPath);
-                        if (shaSumMismatch(path, m.hashOrTarget, m.symlink)) {
+                        // Allow for additional hash sums so as to support
+                        // file modifications done after jlink has run at build
+                        // time. For example for Windows builds done with
+                        // --with-external-symbols-in-bundles=public or
+                        // distribution builds, where some post-processing happens
+                        // on produced binaries and libraries invalidating the
+                        // hash sum included in the jdk.jlink module for those
+                        // files at jlink-time
+                        Set<String> shaSums = new HashSet<>();
+                        shaSums.add(m.hashOrTarget);
+                        Set<String> extra = altHashSums.get(m.resPath);
+                        if (extra != null) {
+                            shaSums.addAll(extra);
+                        }
+                        if (shaSumMismatch(path, shaSums, m.symlink)) {
                             if (errorOnModifiedFile) {
                                 String msg = taskHelper.getMessage("err.runtime.link.modified.file", path.toString());
                                 IOException cause = new IOException(msg);
@@ -239,14 +261,12 @@ private void addNonClassResources() {
         }
     }
 
-    static boolean shaSumMismatch(Path res, String expectedSha, boolean isSymlink) {
+    static boolean shaSumMismatch(Path res, Set<String> expectedShas, boolean isSymlink) {
         if (isSymlink) {
             return false;
         }
         // handle non-symlink resources
         try {
-            HexFormat format = HexFormat.of();
-            byte[] expected = format.parseHex(expectedSha);
             MessageDigest digest = MessageDigest.getInstance("SHA-512");
             try (InputStream is = Files.newInputStream(res)) {
                 byte[] buf = new byte[1024];
@@ -256,7 +276,9 @@ static boolean shaSumMismatch(Path res, String expectedSha, boolean isSymlink) {
                 }
             }
             byte[] actual = digest.digest();
-            return !MessageDigest.isEqual(expected, actual);
+            // Convert actual to string
+            String strActual = HexFormat.of().formatHex(actual);
+            return !expectedShas.contains(strActual);
         } catch (Exception e) {
             throw new AssertionError("SHA-512 sum check failed!", e);
         }

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/Jlink.java

@@ -148,7 +148,7 @@ public static final class JlinkConfiguration {
         private final Set<String> modules;
         private final ModuleFinder finder;
         private final boolean linkFromRuntimeImage;
-        private final boolean ignoreModifiedRuntime;
+        private final LinkableRuntimeImage.Config runtimeImageConfig;
         private final boolean generateRuntimeImage;
 
         /**
@@ -162,13 +162,13 @@ public JlinkConfiguration(Path output,
                                   Set<String> modules,
                                   ModuleFinder finder,
                                   boolean linkFromRuntimeImage,
-                                  boolean ignoreModifiedRuntime,
+                                  LinkableRuntimeImage.Config runtimeImageConfig,
                                   boolean generateRuntimeImage) {
             this.output = output;
             this.modules = Objects.requireNonNull(modules);
             this.finder = finder;
             this.linkFromRuntimeImage = linkFromRuntimeImage;
-            this.ignoreModifiedRuntime = ignoreModifiedRuntime;
+            this.runtimeImageConfig = runtimeImageConfig;
             this.generateRuntimeImage = generateRuntimeImage;
         }
 
@@ -198,8 +198,8 @@ public boolean linkFromRuntimeImage() {
             return linkFromRuntimeImage;
         }
 
-        public boolean ignoreModifiedRuntime() {
-            return ignoreModifiedRuntime;
+        public LinkableRuntimeImage.Config runtimeImageConfig() {
+            return runtimeImageConfig;
         }
 
         public boolean isGenerateRuntimeImage() {

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/JlinkTask.java

@@ -191,7 +191,35 @@ public class JlinkTask {
         // be used for linking from the run-time image.
         new Option<JlinkTask>(false, (task, opt, arg) -> {
             task.options.generateLinkableRuntime = true;
-        }, true, "--generate-linkable-runtime")
+        }, true, "--generate-linkable-runtime"),
+        new Option<JlinkTask>(true, (task, opt, arg) -> {
+            if (arg.startsWith("@")) {
+                // Read overrides from file
+                if (!task.options.shaOverrides.isEmpty()) {
+                    // Only allow a single @file value
+                    throw taskHelper.newBadArgs("err.sha.overrides.multiple");
+                }
+                Path file = Paths.get(arg.substring(1));
+                // Ignore non-existing sha overrides file.
+                //
+                // This is to allow for custom builds needing to optionally
+                // support run-time image links on (possibly) modified
+                // binaries/debuginfo files done after the JDK build
+                if (Files.exists(file)) {
+                    try {
+                        Files.readAllLines(file).stream()
+                            .forEach(task.options.shaOverrides::add);
+                    } catch (IOException e) {
+                        throw taskHelper.newBadArgs("err.sha.overrides.freaderr", file.toString());
+                    }
+                }
+            } else {
+                // Allow multiple values, separated by comma in addition to
+                // multiple times the same option.
+                Arrays.asList(arg.split(",")).stream()
+                    .forEach(task.options.shaOverrides::add);
+            }
+        }, true, "--sha-overrides"),
     };
 
 
@@ -235,6 +263,7 @@ static class OptionsValues {
         boolean suggestProviders = false;
         boolean ignoreModifiedRuntime = false;
         boolean generateLinkableRuntime = false;
+        final Set<String> shaOverrides = new HashSet<>();
     }
 
     public static final String OPTIONS_RESOURCE = "jdk/tools/jlink/internal/options";
@@ -459,14 +488,41 @@ private JlinkConfiguration initJlinkConfig() throws BadArgs {
             throw taskHelper.newBadArgs("err.runtime.link.packaged.mods");
         }
 
+        LinkableRuntimeImage.Config linkableRuntimeConfig = new LinkableRuntimeImage.Config(
+                options.ignoreModifiedRuntime,
+                isLinkFromRuntime ? buildShaSumMap(taskHelper, options.shaOverrides) : null);
         return new JlinkConfiguration(options.output,
                                       roots,
                                       finder,
                                       isLinkFromRuntime,
-                                      options.ignoreModifiedRuntime,
+                                      linkableRuntimeConfig,
                                       options.generateLinkableRuntime);
     }
 
+    private Map<String, Map<String, Set<String>>> buildShaSumMap(TaskHelper taskHelper,
+                                                                 Set<String> shaOverrides) throws BadArgs {
+        Map<String, Map<String, Set<String>>> moduleToFiles = new HashMap<>();
+        for (String t: shaOverrides) {
+            String trimmed = t.trim();
+            if (trimmed.startsWith("#")) {
+                // skip comment lines
+                continue;
+            }
+            String[] tokens = trimmed.split("\\|");
+            if (tokens.length != 3) {
+                throw taskHelper.newBadArgs("err.sha.overrides.bad.format", t);
+            }
+            // t is a '|'-separated item of (in that order):
+            //    <module-name>
+            //    <file-path>
+            //    <SHA-512-sum>
+            Map<String, Set<String>> perModuleMap = moduleToFiles.computeIfAbsent(tokens[0], k -> new HashMap<>());
+            Set<String> shaSumsPerFile = perModuleMap.computeIfAbsent(tokens[1], k -> new HashSet<>());
+            shaSumsPerFile.add(tokens[2]);
+        }
+        return moduleToFiles;
+    }
+
     /*
      * Creates a ModuleFinder for the given module paths.
      */
@@ -788,7 +844,7 @@ private static Archive newArchive(String module,
                         taskHelper.getMessage("err.not.a.module.directory", path));
             }
         } else if (config.linkFromRuntimeImage()) {
-            return LinkableRuntimeImage.newArchive(module, path, config.ignoreModifiedRuntime(), taskHelper);
+            return LinkableRuntimeImage.newArchive(module, path, config.runtimeImageConfig(), taskHelper);
         } else {
             throw new IllegalArgumentException(
                     taskHelper.getMessage("err.not.modular.format", module, path));

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/LinkableRuntimeImage.java

@@ -29,6 +29,8 @@
 import java.io.InputStream;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import jdk.tools.jlink.internal.runtimelink.ResourceDiff;
 
@@ -67,7 +69,7 @@ private static InputStream getDiffInputStream(String module) throws IOException
 
     public static Archive newArchive(String module,
                                      Path path,
-                                     boolean ignoreModifiedRuntime,
+                                     Config config,
                                      TaskHelper taskHelper) {
         assert isLinkableRuntime();
         // Here we retrieve the per module difference file, which is
@@ -81,8 +83,15 @@ public static Archive newArchive(String module,
             throw new AssertionError("Failure to retrieve resource diff for " +
                                      "module " + module, e);
         }
-        return new JRTArchive(module, path, !ignoreModifiedRuntime, perModuleDiff, taskHelper);
+        return new JRTArchive(module,
+                              path,
+                              !config.ignoreModifiedRuntime,
+                              perModuleDiff,
+                              // Empty map if no alternative sha sums
+                              config.altHashSums.computeIfAbsent(module, k -> Map.of()),
+                              taskHelper);
     }
 
-
+    static record Config(boolean ignoreModifiedRuntime,
+                         Map<String, Map<String, Set<String>>> altHashSums) {}
 }

src/jdk.jlink/share/classes/jdk/tools/jlink/resources/jlink.properties

@@ -127,6 +127,12 @@ err.runtime.link.packaged.mods=This JDK has no packaged modules.\
 err.runtime.link.modified.file={0} has been modified
 err.runtime.link.patched.module=jlink does not support linking from the run-time image\
 \ when running on a patched runtime with --patch-module
+
+# Linking from the run-time image, SHA sum handling
+err.sha.overrides.multiple=option --sha-overrides does not allow @file and non-file combinations
+err.sha.overrides.freaderr=Error reading file ''{0}'' passed with option --sha-overrides
+err.sha.overrides.bad.format=Bad format in --sha-overrides. Token was {0}. Expected <module-name>|<file-path>|<sha-sum>
+
 err.no.module.path=--module-path option must be specified with --add-modules ALL-MODULE-PATH
 err.empty.module.path=No module found in module path ''{0}'' with --add-modules ALL-MODULE-PATH
 err.limit.modules=--limit-modules not allowed with --add-modules ALL-MODULE-PATH

test/jdk/tools/jlink/IntegrationTest.java

@@ -159,7 +159,7 @@ private static void test() throws Exception {
                 mods,
                 JlinkTask.limitFinder(JlinkTask.newModuleFinder(modulePaths), limits, mods),
                 linkFromRuntime,
-                false /* ignore modified runtime */,
+                null /* run-time image link config */,
                 false /* generate run-time image */);
 
         List<Plugin> lst = new ArrayList<>();