1 /* 2 * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 package requires; 25 26 import java.io.BufferedInputStream; 27 import java.io.FileInputStream; 28 import java.io.IOException; 29 import java.io.InputStream; 30 import java.io.File; 31 import java.nio.charset.Charset; 32 import java.nio.file.Files; 33 import java.nio.file.Path; 34 import java.nio.file.Paths; 35 import java.nio.file.StandardOpenOption; 36 import java.time.Instant; 37 import java.util.ArrayList; 38 import java.util.Collections; 39 import java.util.HashMap; 40 import java.util.List; 41 import java.util.Map; 42 import java.util.Properties; 43 import java.util.Set; 44 import java.util.concurrent.Callable; 45 import java.util.concurrent.TimeUnit; 46 import java.util.function.Predicate; 47 import java.util.function.Supplier; 48 import java.util.regex.Matcher; 49 import java.util.regex.Pattern; 50 import java.util.stream.Stream; 51 52 import jdk.internal.foreign.CABI; 53 import jdk.internal.misc.PreviewFeatures; 54 import jdk.test.whitebox.code.Compiler; 55 import jdk.test.whitebox.cpuinfo.CPUInfo; 56 import jdk.test.whitebox.gc.GC; 57 import jdk.test.whitebox.WhiteBox; 58 import jdk.test.lib.Platform; 59 import jdk.test.lib.Container; 60 61 /** 62 * The Class to be invoked by jtreg prior Test Suite execution to 63 * collect information about VM. 64 * Do not use any APIs that may not be available in all target VMs. 65 * Properties set by this Class will be available in the @requires expressions. 66 */ 67 public class VMProps implements Callable<Map<String, String>> { 68 // value known to jtreg as an indicator of error state 69 private static final String ERROR_STATE = "__ERROR__"; 70 71 private static final String GC_PREFIX = "-XX:+Use"; 72 private static final String GC_SUFFIX = "GC"; 73 74 private static final WhiteBox WB = WhiteBox.getWhiteBox(); 75 76 private static class SafeMap { 77 private final Map<String, String> map = new HashMap<>(); 78 79 public void put(String key, Supplier<String> s) { 80 String value; 81 try { 82 value = s.get(); 83 } catch (Throwable t) { 84 System.err.println("failed to get value for " + key); 85 t.printStackTrace(System.err); 86 value = ERROR_STATE + t; 87 } 88 map.put(key, value); 89 } 90 } 91 92 /** 93 * Collects information about VM properties. 94 * This method will be invoked by jtreg. 95 * 96 * @return Map of property-value pairs. 97 */ 98 @Override 99 public Map<String, String> call() { 100 log("Entering call()"); 101 SafeMap map = new SafeMap(); 102 map.put("vm.flavor", this::vmFlavor); 103 map.put("vm.compMode", this::vmCompMode); 104 map.put("vm.bits", this::vmBits); 105 map.put("vm.flightRecorder", this::vmFlightRecorder); 106 map.put("vm.simpleArch", this::vmArch); 107 map.put("vm.debug", this::vmDebug); 108 map.put("vm.jvmci", this::vmJvmci); 109 map.put("vm.jvmci.enabled", this::vmJvmciEnabled); 110 map.put("vm.emulatedClient", this::vmEmulatedClient); 111 // vm.hasSA is "true" if the VM contains the serviceability agent 112 // and jhsdb. 113 map.put("vm.hasSA", this::vmHasSA); 114 // vm.hasJFR is "true" if JFR is included in the build of the VM and 115 // so tests can be executed. 116 map.put("vm.hasJFR", this::vmHasJFR); 117 map.put("vm.hasDTrace", this::vmHasDTrace); 118 map.put("vm.jvmti", this::vmHasJVMTI); 119 map.put("vm.cpu.features", this::cpuFeatures); 120 map.put("vm.pageSize", this::vmPageSize); 121 // vm.cds is true if the VM is compiled with cds support. 122 map.put("vm.cds", this::vmCDS); 123 map.put("vm.cds.default.archive.available", this::vmCDSDefaultArchiveAvailable); 124 map.put("vm.cds.custom.loaders", this::vmCDSForCustomLoaders); 125 map.put("vm.cds.supports.aot.class.linking", this::vmCDSSupportsAOTClassLinking); 126 map.put("vm.cds.supports.aot.code.caching", this::vmCDSSupportsAOTCodeCaching); 127 map.put("vm.cds.write.archived.java.heap", this::vmCDSCanWriteArchivedJavaHeap); 128 map.put("vm.continuations", this::vmContinuations); 129 // vm.graal.enabled is true if Graal is used as JIT 130 map.put("vm.graal.enabled", this::isGraalEnabled); 131 // jdk.hasLibgraal is true if the libgraal shared library file is present 132 map.put("jdk.hasLibgraal", this::hasLibgraal); 133 map.put("java.enablePreview", this::isPreviewEnabled); 134 map.put("vm.libgraal.jit", this::isLibgraalJIT); 135 map.put("vm.compiler1.enabled", this::isCompiler1Enabled); 136 map.put("vm.compiler2.enabled", this::isCompiler2Enabled); 137 map.put("container.support", this::containerSupport); 138 map.put("systemd.support", this::systemdSupport); 139 map.put("vm.musl", this::isMusl); 140 map.put("vm.asan", this::isAsanEnabled); 141 map.put("vm.ubsan", this::isUbsanEnabled); 142 map.put("release.implementor", this::implementor); 143 map.put("jdk.containerized", this::jdkContainerized); 144 map.put("vm.flagless", this::isFlagless); 145 map.put("jdk.foreign.linker", this::jdkForeignLinker); 146 map.put("jlink.packagedModules", this::packagedModules); 147 map.put("jdk.static", this::isStatic); 148 vmGC(map); // vm.gc.X = true/false 149 vmGCforCDS(map); // may set vm.gc 150 vmOptFinalFlags(map); 151 152 dump(map.map); 153 log("Leaving call()"); 154 return map.map; 155 } 156 157 /** 158 * Print a stack trace before returning error state; 159 * Used by the various helper functions which parse information from 160 * VM properties in the case where they don't find an expected property 161 * or a property doesn't conform to an expected format. 162 * 163 * @return {@link #ERROR_STATE} 164 */ 165 private String errorWithMessage(String message) { 166 new Exception(message).printStackTrace(); 167 return ERROR_STATE + message; 168 } 169 170 /** 171 * @return vm.simpleArch value of "os.simpleArch" property of tested JDK. 172 */ 173 protected String vmArch() { 174 String arch = System.getProperty("os.arch"); 175 if (arch.equals("x86_64") || arch.equals("amd64")) { 176 return "x64"; 177 } else if (arch.contains("86")) { 178 return "x86"; 179 } else { 180 return arch; 181 } 182 } 183 184 /** 185 * @return VM type value extracted from the "java.vm.name" property. 186 */ 187 protected String vmFlavor() { 188 // E.g. "Java HotSpot(TM) 64-Bit Server VM" 189 String vmName = System.getProperty("java.vm.name"); 190 if (vmName == null) { 191 return errorWithMessage("Can't get 'java.vm.name' property"); 192 } 193 194 Pattern startP = Pattern.compile(".* (\\S+) VM"); 195 Matcher m = startP.matcher(vmName); 196 if (m.matches()) { 197 return m.group(1).toLowerCase(); 198 } 199 return errorWithMessage("Can't get VM flavor from 'java.vm.name'"); 200 } 201 202 /** 203 * @return VM compilation mode extracted from the "java.vm.info" property. 204 */ 205 protected String vmCompMode() { 206 // E.g. "mixed mode" 207 String vmInfo = System.getProperty("java.vm.info"); 208 if (vmInfo == null) { 209 return errorWithMessage("Can't get 'java.vm.info' property"); 210 } 211 vmInfo = vmInfo.toLowerCase(); 212 if (vmInfo.contains("mixed mode")) { 213 return "Xmixed"; 214 } else if (vmInfo.contains("compiled mode")) { 215 return "Xcomp"; 216 } else if (vmInfo.contains("interpreted mode")) { 217 return "Xint"; 218 } else { 219 return errorWithMessage("Can't get compilation mode from 'java.vm.info'"); 220 } 221 } 222 223 /** 224 * @return VM bitness, the value of the "sun.arch.data.model" property. 225 */ 226 protected String vmBits() { 227 String dataModel = System.getProperty("sun.arch.data.model"); 228 if (dataModel != null) { 229 return dataModel; 230 } else { 231 return errorWithMessage("Can't get 'sun.arch.data.model' property"); 232 } 233 } 234 235 /** 236 * @return "true" if Flight Recorder is enabled, "false" if is disabled. 237 */ 238 protected String vmFlightRecorder() { 239 Boolean isFlightRecorder = WB.getBooleanVMFlag("FlightRecorder"); 240 String startFROptions = WB.getStringVMFlag("StartFlightRecording"); 241 if (isFlightRecorder != null && isFlightRecorder) { 242 return "true"; 243 } 244 if (startFROptions != null && !startFROptions.isEmpty()) { 245 return "true"; 246 } 247 return "false"; 248 } 249 250 /** 251 * @return debug level value extracted from the "jdk.debug" property. 252 */ 253 protected String vmDebug() { 254 String debug = System.getProperty("jdk.debug"); 255 if (debug != null) { 256 return "" + debug.contains("debug"); 257 } else { 258 return errorWithMessage("Can't get 'jdk.debug' property"); 259 } 260 } 261 262 /** 263 * @return true if VM supports JVMCI and false otherwise 264 */ 265 protected String vmJvmci() { 266 // builds with jvmci have this flag 267 if (WB.getBooleanVMFlag("EnableJVMCI") == null) { 268 return "false"; 269 } 270 271 // Not all GCs have full JVMCI support 272 if (!WB.isJVMCISupportedByGC()) { 273 return "false"; 274 } 275 276 // Interpreted mode cannot enable JVMCI 277 if (vmCompMode().equals("Xint")) { 278 return "false"; 279 } 280 281 return "true"; 282 } 283 284 285 /** 286 * @return true if JVMCI is enabled 287 */ 288 protected String vmJvmciEnabled() { 289 // builds with jvmci have this flag 290 if ("false".equals(vmJvmci())) { 291 return "false"; 292 } 293 294 return "" + Compiler.isJVMCIEnabled(); 295 } 296 297 298 /** 299 * @return true if VM runs in emulated-client mode and false otherwise. 300 */ 301 protected String vmEmulatedClient() { 302 String vmInfo = System.getProperty("java.vm.info"); 303 if (vmInfo == null) { 304 return errorWithMessage("Can't get 'java.vm.info' property"); 305 } 306 return "" + vmInfo.contains(" emulated-client"); 307 } 308 309 /** 310 * @return supported CPU features 311 */ 312 protected String cpuFeatures() { 313 return CPUInfo.getFeatures().toString(); 314 } 315 316 /** 317 * For all existing GC sets vm.gc.X property. 318 * Example vm.gc.G1=true means: 319 * VM supports G1 320 * User either set G1 explicitely (-XX:+UseG1GC) or did not set any GC 321 * G1 can be selected, i.e. it doesn't conflict with other VM flags 322 * 323 * @param map - property-value pairs 324 */ 325 protected void vmGC(SafeMap map) { 326 var isJVMCIEnabled = Compiler.isJVMCIEnabled(); 327 Predicate<GC> vmGCProperty = (GC gc) -> (gc.isSupported() 328 && (!isJVMCIEnabled || gc.isSupportedByJVMCICompiler()) 329 && (gc.isSelected() || GC.isSelectedErgonomically())); 330 for (GC gc: GC.values()) { 331 map.put("vm.gc." + gc.name(), () -> "" + vmGCProperty.test(gc)); 332 } 333 } 334 335 /** 336 * "jtreg -vmoptions:-Dtest.cds.runtime.options=..." can be used to specify 337 * the GC type to be used when running with a CDS archive. Set "vm.gc" accordingly, 338 * so that tests that need to explicitly choose the GC type can be excluded 339 * with "@requires vm.gc == null". 340 * 341 * @param map - property-value pairs 342 */ 343 protected void vmGCforCDS(SafeMap map) { 344 if (!GC.isSelectedErgonomically()) { 345 // The GC has been explicitly specified on the command line, so 346 // jtreg will set the "vm.gc" property. Let's not interfere with it. 347 return; 348 } 349 350 String jtropts = System.getProperty("test.cds.runtime.options"); 351 if (jtropts != null) { 352 for (String opt : jtropts.split(",")) { 353 if (opt.startsWith(GC_PREFIX) && opt.endsWith(GC_SUFFIX)) { 354 String gc = opt.substring(GC_PREFIX.length(), opt.length() - GC_SUFFIX.length()); 355 map.put("vm.gc", () -> gc); 356 } 357 } 358 } 359 } 360 361 /** 362 * Selected final flag. 363 * 364 * @param map - property-value pairs 365 * @param flagName - flag name 366 */ 367 private void vmOptFinalFlag(SafeMap map, String flagName) { 368 map.put("vm.opt.final." + flagName, 369 () -> String.valueOf(WB.getBooleanVMFlag(flagName))); 370 } 371 372 /** 373 * Selected sets of final flags. 374 * 375 * @param map - property-value pairs 376 */ 377 protected void vmOptFinalFlags(SafeMap map) { 378 vmOptFinalFlag(map, "ClassUnloading"); 379 vmOptFinalFlag(map, "ClassUnloadingWithConcurrentMark"); 380 vmOptFinalFlag(map, "CriticalJNINatives"); 381 vmOptFinalFlag(map, "EnableJVMCI"); 382 vmOptFinalFlag(map, "EliminateAllocations"); 383 vmOptFinalFlag(map, "UnlockExperimentalVMOptions"); 384 vmOptFinalFlag(map, "UseCompressedOops"); 385 vmOptFinalFlag(map, "UseLargePages"); 386 vmOptFinalFlag(map, "UseTransparentHugePages"); 387 vmOptFinalFlag(map, "UseVectorizedMismatchIntrinsic"); 388 } 389 390 /** 391 * @return "true" if VM has a serviceability agent. 392 */ 393 protected String vmHasSA() { 394 return "" + Platform.hasSA(); 395 } 396 397 /** 398 * @return "true" if the VM is compiled with Java Flight Recorder (JFR) 399 * support. 400 */ 401 protected String vmHasJFR() { 402 return "" + WB.isJFRIncluded(); 403 } 404 405 /** 406 * @return "true" if the VM is compiled with JVMTI 407 */ 408 protected String vmHasJVMTI() { 409 return "" + WB.isJVMTIIncluded(); 410 } 411 412 /** 413 * @return "true" if the VM is compiled with DTrace 414 */ 415 protected String vmHasDTrace() { 416 return "" + WB.isDTraceIncluded(); 417 } 418 419 /** 420 * Check for CDS support. 421 * 422 * @return true if CDS is supported by the VM to be tested. 423 */ 424 protected String vmCDS() { 425 boolean noJvmtiAdded = allFlags() 426 .filter(s -> s.startsWith("-agentpath")) 427 .findAny() 428 .isEmpty(); 429 430 return "" + (noJvmtiAdded && WB.isCDSIncluded()); 431 } 432 433 /** 434 * Check for CDS default archive existence. 435 * 436 * @return true if CDS default archive classes.jsa exists in the JDK to be tested. 437 */ 438 protected String vmCDSDefaultArchiveAvailable() { 439 Path archive = Paths.get(System.getProperty("java.home"), "lib", "server", "classes.jsa"); 440 return "" + ("true".equals(vmCDS()) && Files.exists(archive)); 441 } 442 443 /** 444 * Check for CDS support for custom loaders. 445 * 446 * @return true if CDS provides support for customer loader in the VM to be tested. 447 */ 448 protected String vmCDSForCustomLoaders() { 449 return "" + ("true".equals(vmCDS()) && Platform.areCustomLoadersSupportedForCDS()); 450 } 451 452 /** 453 * @return true if it's possible for "java -Xshare:dump" to write Java heap objects 454 * with the current set of jtreg VM options. For example, false will be returned 455 * if -XX:-UseCompressedClassPointers is specified, 456 */ 457 protected String vmCDSCanWriteArchivedJavaHeap() { 458 return "" + ("true".equals(vmCDS()) && WB.canWriteJavaHeapArchive() 459 && isCDSRuntimeOptionsCompatible()); 460 } 461 462 /** 463 * @return true if this VM can support the -XX:AOTClassLinking option 464 */ 465 protected String vmCDSSupportsAOTClassLinking() { 466 // Currently, the VM supports AOTClassLinking as long as it's able to write archived java heap. 467 return vmCDSCanWriteArchivedJavaHeap(); 468 } 469 470 /** 471 * @return true if this VM can support the AOT Code Caching 472 */ 473 protected String vmCDSSupportsAOTCodeCaching() { 474 if ("true".equals(vmCDSSupportsAOTClassLinking()) && 475 !"zero".equals(vmFlavor()) && 476 "false".equals(vmJvmciEnabled()) && 477 (Platform.isX64() || Platform.isAArch64())) { 478 return "true"; 479 } else { 480 return "false"; 481 } 482 } 483 484 /** 485 * @return true if the VM options specified via the "test.cds.runtime.options" 486 * property is compatible with writing Java heap objects into the CDS archive 487 */ 488 protected boolean isCDSRuntimeOptionsCompatible() { 489 String jtropts = System.getProperty("test.cds.runtime.options"); 490 if (jtropts == null) { 491 return true; 492 } 493 String CCP_DISABLED = "-XX:-UseCompressedClassPointers"; 494 String G1GC_ENABLED = "-XX:+UseG1GC"; 495 String PARALLELGC_ENABLED = "-XX:+UseParallelGC"; 496 String SERIALGC_ENABLED = "-XX:+UseSerialGC"; 497 for (String opt : jtropts.split(",")) { 498 if (opt.equals(CCP_DISABLED)) { 499 return false; 500 } 501 if (opt.startsWith(GC_PREFIX) && opt.endsWith(GC_SUFFIX) && 502 !opt.equals(G1GC_ENABLED) && !opt.equals(PARALLELGC_ENABLED) && !opt.equals(SERIALGC_ENABLED)) { 503 return false; 504 } 505 } 506 return true; 507 } 508 509 /** 510 * @return "true" if this VM supports continuations. 511 */ 512 protected String vmContinuations() { 513 if (WB.getBooleanVMFlag("VMContinuations")) { 514 return "true"; 515 } else { 516 return "false"; 517 } 518 } 519 520 /** 521 * @return System page size in bytes. 522 */ 523 protected String vmPageSize() { 524 return "" + WB.getVMPageSize(); 525 } 526 527 /** 528 * Check if Graal is used as JIT compiler. 529 * 530 * @return true if Graal is used as JIT compiler. 531 */ 532 protected String isGraalEnabled() { 533 return "" + Compiler.isGraalEnabled(); 534 } 535 536 /** 537 * Check if the libgraal shared library file is present. 538 * 539 * @return true if the libgraal shared library file is present. 540 */ 541 protected String hasLibgraal() { 542 return "" + WB.hasLibgraal(); 543 } 544 545 /** 546 * Check if libgraal is used as JIT compiler. 547 * 548 * @return true if libgraal is used as JIT compiler. 549 */ 550 protected String isLibgraalJIT() { 551 return "" + Compiler.isLibgraalJIT(); 552 } 553 554 /** 555 * Check if Compiler1 is present. 556 * 557 * @return true if Compiler1 is used as JIT compiler, either alone or as part of the tiered system. 558 */ 559 protected String isCompiler1Enabled() { 560 return "" + Compiler.isC1Enabled(); 561 } 562 563 /** 564 * Check if Compiler2 is present. 565 * 566 * @return true if Compiler2 is used as JIT compiler, either alone or as part of the tiered system. 567 */ 568 protected String isCompiler2Enabled() { 569 return "" + Compiler.isC2Enabled(); 570 } 571 572 protected String isPreviewEnabled() { 573 return "" + PreviewFeatures.isEnabled(); 574 } 575 /** 576 * A simple check for container support 577 * 578 * @return true if container is supported in a given environment 579 */ 580 protected String containerSupport() { 581 log("Entering containerSupport()"); 582 583 boolean isSupported = false; 584 if (Platform.isLinux()) { 585 // currently container testing is only supported for Linux, 586 // on certain platforms 587 588 String arch = System.getProperty("os.arch"); 589 590 if (Platform.isX64()) { 591 isSupported = true; 592 } else if (Platform.isAArch64()) { 593 isSupported = true; 594 } else if (Platform.isS390x()) { 595 isSupported = true; 596 } else if (arch.equals("ppc64le")) { 597 isSupported = true; 598 } 599 } 600 601 log("containerSupport(): platform check: isSupported = " + isSupported); 602 603 if (isSupported) { 604 try { 605 isSupported = checkProgramSupport("checkContainerSupport()", Container.ENGINE_COMMAND); 606 } catch (Exception e) { 607 isSupported = false; 608 } 609 } 610 611 log("containerSupport(): returning isSupported = " + isSupported); 612 return "" + isSupported; 613 } 614 615 /** 616 * A simple check for systemd support 617 * 618 * @return true if systemd is supported in a given environment 619 */ 620 protected String systemdSupport() { 621 log("Entering systemdSupport()"); 622 623 boolean isSupported = Platform.isLinux(); 624 if (isSupported) { 625 try { 626 isSupported = checkProgramSupport("checkSystemdSupport()", "systemd-run"); 627 } catch (Exception e) { 628 isSupported = false; 629 } 630 } 631 632 log("systemdSupport(): returning isSupported = " + isSupported); 633 return "" + isSupported; 634 } 635 636 // Configures process builder to redirect process stdout and stderr to a file. 637 // Returns file names for stdout and stderr. 638 private Map<String, String> redirectOutputToLogFile(String msg, ProcessBuilder pb, String fileNameBase) { 639 Map<String, String> result = new HashMap<>(); 640 String timeStamp = Instant.now().toString().replace(":", "-").replace(".", "-"); 641 642 String stdoutFileName = String.format("./%s-stdout--%s.log", fileNameBase, timeStamp); 643 pb.redirectOutput(new File(stdoutFileName)); 644 log(msg + ": child process stdout redirected to " + stdoutFileName); 645 result.put("stdout", stdoutFileName); 646 647 String stderrFileName = String.format("./%s-stderr--%s.log", fileNameBase, timeStamp); 648 pb.redirectError(new File(stderrFileName)); 649 log(msg + ": child process stderr redirected to " + stderrFileName); 650 result.put("stderr", stderrFileName); 651 652 return result; 653 } 654 655 private void printLogfileContent(Map<String, String> logFileNames) { 656 logFileNames.entrySet().stream() 657 .forEach(entry -> 658 { 659 log("------------- " + entry.getKey()); 660 try { 661 Files.lines(Path.of(entry.getValue())) 662 .forEach(line -> log(line)); 663 } catch (IOException ie) { 664 log("Exception while reading file: " + ie); 665 } 666 log("-------------"); 667 }); 668 } 669 670 private boolean checkProgramSupport(String logString, String cmd) throws IOException, InterruptedException { 671 log(logString + ": entering"); 672 ProcessBuilder pb = new ProcessBuilder("which", cmd); 673 Map<String, String> logFileNames = 674 redirectOutputToLogFile(logString + ": which " + cmd, 675 pb, "which-cmd"); 676 Process p = pb.start(); 677 p.waitFor(10, TimeUnit.SECONDS); 678 int exitValue = p.exitValue(); 679 680 log(String.format("%s: exitValue = %s, pid = %s", logString, exitValue, p.pid())); 681 if (exitValue != 0) { 682 printLogfileContent(logFileNames); 683 } 684 685 return (exitValue == 0); 686 } 687 688 /** 689 * Checks musl libc. 690 * 691 * @return true if musl libc is used. 692 */ 693 protected String isMusl() { 694 return Boolean.toString(WB.getLibcName().contains("musl")); 695 } 696 697 // Sanitizer support 698 protected String isAsanEnabled() { 699 return "" + WB.isAsanEnabled(); 700 } 701 702 protected String isUbsanEnabled() { 703 return "" + WB.isUbsanEnabled(); 704 } 705 706 private String implementor() { 707 try (InputStream in = new BufferedInputStream(new FileInputStream( 708 System.getProperty("java.home") + "/release"))) { 709 Properties properties = new Properties(); 710 properties.load(in); 711 String implementorProperty = properties.getProperty("IMPLEMENTOR"); 712 if (implementorProperty != null) { 713 return implementorProperty.replace("\"", ""); 714 } 715 return errorWithMessage("Can't get 'IMPLEMENTOR' property from 'release' file"); 716 } catch (IOException e) { 717 e.printStackTrace(); 718 return errorWithMessage("Failed to read 'release' file " + e); 719 } 720 } 721 722 private String jdkContainerized() { 723 String isEnabled = System.getenv("TEST_JDK_CONTAINERIZED"); 724 return "" + "true".equalsIgnoreCase(isEnabled); 725 } 726 727 private String packagedModules() { 728 // Some jlink tests require packaged modules being present (jmods). 729 // For a runtime linkable image build packaged modules aren't present 730 try { 731 Path jmodsDir = Path.of(System.getProperty("java.home"), "jmods"); 732 if (jmodsDir.toFile().exists()) { 733 return Boolean.TRUE.toString(); 734 } else { 735 return Boolean.FALSE.toString(); 736 } 737 } catch (Throwable t) { 738 return Boolean.FALSE.toString(); 739 } 740 } 741 742 /** 743 * Checks if we are in <i>almost</i> out-of-box configuration, i.e. the flags 744 * which JVM is started with don't affect its behavior "significantly". 745 * {@code TEST_VM_FLAGLESS} enviroment variable can be used to force this 746 * method to return true or false and allow or reject any flags. 747 * 748 * @return true if there are no JVM flags 749 */ 750 private String isFlagless() { 751 boolean result = true; 752 String flagless = System.getenv("TEST_VM_FLAGLESS"); 753 if (flagless != null) { 754 return "" + "true".equalsIgnoreCase(flagless); 755 } 756 757 List<String> allFlags = allFlags().toList(); 758 759 // check -XX flags 760 var ignoredXXFlags = Set.of( 761 // added by run-test framework 762 "MaxRAMPercentage", 763 // added by test environment 764 "CreateCoredumpOnCrash" 765 ); 766 result &= allFlags.stream() 767 .filter(s -> s.startsWith("-XX:")) 768 // map to names: 769 // remove -XX: 770 .map(s -> s.substring(4)) 771 // remove +/- from bool flags 772 .map(s -> s.charAt(0) == '+' || s.charAt(0) == '-' ? s.substring(1) : s) 773 // remove =.* from others 774 .map(s -> s.contains("=") ? s.substring(0, s.indexOf('=')) : s) 775 // skip known-to-be-there flags 776 .filter(s -> !ignoredXXFlags.contains(s)) 777 .findAny() 778 .isEmpty(); 779 780 // check -X flags 781 var ignoredXFlags = Set.of( 782 // default, yet still seen to be explicitly set 783 "mixed", 784 // -XmxmNNNm added by run-test framework for non-hotspot tests 785 "mx" 786 ); 787 result &= allFlags.stream() 788 .filter(s -> s.startsWith("-X") && !s.startsWith("-XX:")) 789 // map to names: 790 // remove -X 791 .map(s -> s.substring(2)) 792 // remove :.* from flags with values 793 .map(s -> s.contains(":") ? s.substring(0, s.indexOf(':')) : s) 794 // remove size like 4G, 768m which might be set for non-hotspot tests 795 .map(s -> s.replaceAll("(\\d+)[mMgGkK]", "")) 796 // skip known-to-be-there flags 797 .filter(s -> !ignoredXFlags.contains(s)) 798 .findAny() 799 .isEmpty(); 800 801 return "" + result; 802 } 803 804 private Stream<String> allFlags() { 805 return Stream.of((System.getProperty("test.vm.opts", "") + " " + System.getProperty("test.java.opts", "")).trim().split("\\s+")); 806 } 807 808 /* 809 * A string indicating the foreign linker that is currently being used. See jdk.internal.foreign.CABI 810 * for valid values. 811 * 812 * "FALLBACK" and "UNSUPPORTED" are special values. The former indicates the fallback linker is 813 * being used. The latter indicates an unsupported platform. 814 */ 815 private String jdkForeignLinker() { 816 return String.valueOf(CABI.current()); 817 } 818 819 private String isStatic() { 820 return Boolean.toString(WB.isStatic()); 821 } 822 823 /** 824 * Dumps the map to the file if the file name is given as the property. 825 * This functionality could be helpful to know context in the real 826 * execution. 827 * 828 * @param map 829 */ 830 protected static void dump(Map<String, String> map) { 831 String dumpFileName = System.getProperty("vmprops.dump"); 832 if (dumpFileName == null) { 833 return; 834 } 835 List<String> lines = new ArrayList<>(); 836 map.forEach((k, v) -> lines.add(k + ":" + v)); 837 Collections.sort(lines); 838 try { 839 Files.write(Paths.get(dumpFileName), lines, 840 StandardOpenOption.APPEND, StandardOpenOption.CREATE); 841 } catch (IOException e) { 842 throw new RuntimeException("Failed to dump properties into '" 843 + dumpFileName + "'", e); 844 } 845 } 846 847 /** 848 * Log diagnostic message. 849 * 850 * @param msg 851 */ 852 protected static void log(String msg) { 853 // Always log to a file. 854 logToFile(msg); 855 856 // Also log to stderr; guarded by property to avoid excessive verbosity. 857 // By jtreg design stderr produced here will be visible 858 // in the output of a parent process. Note: stdout should not be used 859 // for logging as jtreg parses that output directly and only echoes it 860 // in the event of a failure. 861 if (Boolean.getBoolean("jtreg.log.vmprops")) { 862 System.err.println("VMProps: " + msg); 863 } 864 } 865 866 /** 867 * Log diagnostic message to a file. 868 * 869 * @param msg 870 */ 871 protected static void logToFile(String msg) { 872 String fileName = "./vmprops.log"; 873 try { 874 Files.writeString(Paths.get(fileName), msg + "\n", Charset.forName("ISO-8859-1"), 875 StandardOpenOption.APPEND, StandardOpenOption.CREATE); 876 } catch (IOException e) { 877 throw new RuntimeException("Failed to log into '" + fileName + "'", e); 878 } 879 } 880 881 /** 882 * This method is for the testing purpose only. 883 * 884 * @param args 885 */ 886 public static void main(String args[]) { 887 Map<String, String> map = new VMProps().call(); 888 map.forEach((k, v) -> System.out.println(k + ": '" + v + "'")); 889 } 890 }