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, "TieredCompilation"); 384 vmOptFinalFlag(map, "UnlockExperimentalVMOptions"); 385 vmOptFinalFlag(map, "UseCompressedOops"); 386 vmOptFinalFlag(map, "UseLargePages"); 387 vmOptFinalFlag(map, "UseTransparentHugePages"); 388 vmOptFinalFlag(map, "UseVectorizedMismatchIntrinsic"); 389 } 390 391 /** 392 * @return "true" if VM has a serviceability agent. 393 */ 394 protected String vmHasSA() { 395 return "" + Platform.hasSA(); 396 } 397 398 /** 399 * @return "true" if the VM is compiled with Java Flight Recorder (JFR) 400 * support. 401 */ 402 protected String vmHasJFR() { 403 return "" + WB.isJFRIncluded(); 404 } 405 406 /** 407 * @return "true" if the VM is compiled with JVMTI 408 */ 409 protected String vmHasJVMTI() { 410 return "" + WB.isJVMTIIncluded(); 411 } 412 413 /** 414 * @return "true" if the VM is compiled with DTrace 415 */ 416 protected String vmHasDTrace() { 417 return "" + WB.isDTraceIncluded(); 418 } 419 420 /** 421 * Check for CDS support. 422 * 423 * @return true if CDS is supported by the VM to be tested. 424 */ 425 protected String vmCDS() { 426 boolean noJvmtiAdded = allFlags() 427 .filter(s -> s.startsWith("-agentpath")) 428 .findAny() 429 .isEmpty(); 430 431 return "" + (noJvmtiAdded && WB.isCDSIncluded()); 432 } 433 434 /** 435 * Check for CDS default archive existence. 436 * 437 * @return true if CDS default archive classes.jsa exists in the JDK to be tested. 438 */ 439 protected String vmCDSDefaultArchiveAvailable() { 440 Path archive = Paths.get(System.getProperty("java.home"), "lib", "server", "classes.jsa"); 441 return "" + ("true".equals(vmCDS()) && Files.exists(archive)); 442 } 443 444 /** 445 * Check for CDS support for custom loaders. 446 * 447 * @return true if CDS provides support for customer loader in the VM to be tested. 448 */ 449 protected String vmCDSForCustomLoaders() { 450 return "" + ("true".equals(vmCDS()) && Platform.areCustomLoadersSupportedForCDS()); 451 } 452 453 /** 454 * @return true if it's possible for "java -Xshare:dump" to write Java heap objects 455 * with the current set of jtreg VM options. For example, false will be returned 456 * if -XX:-UseCompressedClassPointers is specified, 457 */ 458 protected String vmCDSCanWriteArchivedJavaHeap() { 459 return "" + ("true".equals(vmCDS()) && WB.canWriteJavaHeapArchive() 460 && isCDSRuntimeOptionsCompatible()); 461 } 462 463 /** 464 * @return true if this VM can support the -XX:AOTClassLinking option 465 */ 466 protected String vmCDSSupportsAOTClassLinking() { 467 // Currently, the VM supports AOTClassLinking as long as it's able to write archived java heap. 468 return vmCDSCanWriteArchivedJavaHeap(); 469 } 470 471 /** 472 * @return true if this VM can support the AOT Code Caching 473 */ 474 protected String vmCDSSupportsAOTCodeCaching() { 475 if ("true".equals(vmCDSSupportsAOTClassLinking()) && 476 !"zero".equals(vmFlavor()) && 477 "false".equals(vmJvmciEnabled()) && 478 (Platform.isX64() || Platform.isAArch64())) { 479 return "true"; 480 } else { 481 return "false"; 482 } 483 } 484 485 /** 486 * @return true if the VM options specified via the "test.cds.runtime.options" 487 * property is compatible with writing Java heap objects into the CDS archive 488 */ 489 protected boolean isCDSRuntimeOptionsCompatible() { 490 String jtropts = System.getProperty("test.cds.runtime.options"); 491 if (jtropts == null) { 492 return true; 493 } 494 String CCP_DISABLED = "-XX:-UseCompressedClassPointers"; 495 String G1GC_ENABLED = "-XX:+UseG1GC"; 496 String PARALLELGC_ENABLED = "-XX:+UseParallelGC"; 497 String SERIALGC_ENABLED = "-XX:+UseSerialGC"; 498 for (String opt : jtropts.split(",")) { 499 if (opt.equals(CCP_DISABLED)) { 500 return false; 501 } 502 if (opt.startsWith(GC_PREFIX) && opt.endsWith(GC_SUFFIX) && 503 !opt.equals(G1GC_ENABLED) && !opt.equals(PARALLELGC_ENABLED) && !opt.equals(SERIALGC_ENABLED)) { 504 return false; 505 } 506 } 507 return true; 508 } 509 510 /** 511 * @return "true" if this VM supports continuations. 512 */ 513 protected String vmContinuations() { 514 if (WB.getBooleanVMFlag("VMContinuations")) { 515 return "true"; 516 } else { 517 return "false"; 518 } 519 } 520 521 /** 522 * @return System page size in bytes. 523 */ 524 protected String vmPageSize() { 525 return "" + WB.getVMPageSize(); 526 } 527 528 /** 529 * Check if Graal is used as JIT compiler. 530 * 531 * @return true if Graal is used as JIT compiler. 532 */ 533 protected String isGraalEnabled() { 534 return "" + Compiler.isGraalEnabled(); 535 } 536 537 /** 538 * Check if the libgraal shared library file is present. 539 * 540 * @return true if the libgraal shared library file is present. 541 */ 542 protected String hasLibgraal() { 543 return "" + WB.hasLibgraal(); 544 } 545 546 /** 547 * Check if libgraal is used as JIT compiler. 548 * 549 * @return true if libgraal is used as JIT compiler. 550 */ 551 protected String isLibgraalJIT() { 552 return "" + Compiler.isLibgraalJIT(); 553 } 554 555 /** 556 * Check if Compiler1 is present. 557 * 558 * @return true if Compiler1 is used as JIT compiler, either alone or as part of the tiered system. 559 */ 560 protected String isCompiler1Enabled() { 561 return "" + Compiler.isC1Enabled(); 562 } 563 564 /** 565 * Check if Compiler2 is present. 566 * 567 * @return true if Compiler2 is used as JIT compiler, either alone or as part of the tiered system. 568 */ 569 protected String isCompiler2Enabled() { 570 return "" + Compiler.isC2Enabled(); 571 } 572 573 protected String isPreviewEnabled() { 574 return "" + PreviewFeatures.isEnabled(); 575 } 576 /** 577 * A simple check for container support 578 * 579 * @return true if container is supported in a given environment 580 */ 581 protected String containerSupport() { 582 log("Entering containerSupport()"); 583 584 boolean isSupported = false; 585 if (Platform.isLinux()) { 586 // currently container testing is only supported for Linux, 587 // on certain platforms 588 589 String arch = System.getProperty("os.arch"); 590 591 if (Platform.isX64()) { 592 isSupported = true; 593 } else if (Platform.isAArch64()) { 594 isSupported = true; 595 } else if (Platform.isS390x()) { 596 isSupported = true; 597 } else if (arch.equals("ppc64le")) { 598 isSupported = true; 599 } 600 } 601 602 log("containerSupport(): platform check: isSupported = " + isSupported); 603 604 if (isSupported) { 605 try { 606 isSupported = checkProgramSupport("checkContainerSupport()", Container.ENGINE_COMMAND); 607 } catch (Exception e) { 608 isSupported = false; 609 } 610 } 611 612 log("containerSupport(): returning isSupported = " + isSupported); 613 return "" + isSupported; 614 } 615 616 /** 617 * A simple check for systemd support 618 * 619 * @return true if systemd is supported in a given environment 620 */ 621 protected String systemdSupport() { 622 log("Entering systemdSupport()"); 623 624 boolean isSupported = Platform.isLinux(); 625 if (isSupported) { 626 try { 627 isSupported = checkProgramSupport("checkSystemdSupport()", "systemd-run"); 628 } catch (Exception e) { 629 isSupported = false; 630 } 631 } 632 633 log("systemdSupport(): returning isSupported = " + isSupported); 634 return "" + isSupported; 635 } 636 637 // Configures process builder to redirect process stdout and stderr to a file. 638 // Returns file names for stdout and stderr. 639 private Map<String, String> redirectOutputToLogFile(String msg, ProcessBuilder pb, String fileNameBase) { 640 Map<String, String> result = new HashMap<>(); 641 String timeStamp = Instant.now().toString().replace(":", "-").replace(".", "-"); 642 643 String stdoutFileName = String.format("./%s-stdout--%s.log", fileNameBase, timeStamp); 644 pb.redirectOutput(new File(stdoutFileName)); 645 log(msg + ": child process stdout redirected to " + stdoutFileName); 646 result.put("stdout", stdoutFileName); 647 648 String stderrFileName = String.format("./%s-stderr--%s.log", fileNameBase, timeStamp); 649 pb.redirectError(new File(stderrFileName)); 650 log(msg + ": child process stderr redirected to " + stderrFileName); 651 result.put("stderr", stderrFileName); 652 653 return result; 654 } 655 656 private void printLogfileContent(Map<String, String> logFileNames) { 657 logFileNames.entrySet().stream() 658 .forEach(entry -> 659 { 660 log("------------- " + entry.getKey()); 661 try { 662 Files.lines(Path.of(entry.getValue())) 663 .forEach(line -> log(line)); 664 } catch (IOException ie) { 665 log("Exception while reading file: " + ie); 666 } 667 log("-------------"); 668 }); 669 } 670 671 private boolean checkProgramSupport(String logString, String cmd) throws IOException, InterruptedException { 672 log(logString + ": entering"); 673 ProcessBuilder pb = new ProcessBuilder("which", cmd); 674 Map<String, String> logFileNames = 675 redirectOutputToLogFile(logString + ": which " + cmd, 676 pb, "which-cmd"); 677 Process p = pb.start(); 678 p.waitFor(10, TimeUnit.SECONDS); 679 int exitValue = p.exitValue(); 680 681 log(String.format("%s: exitValue = %s, pid = %s", logString, exitValue, p.pid())); 682 if (exitValue != 0) { 683 printLogfileContent(logFileNames); 684 } 685 686 return (exitValue == 0); 687 } 688 689 /** 690 * Checks musl libc. 691 * 692 * @return true if musl libc is used. 693 */ 694 protected String isMusl() { 695 return Boolean.toString(WB.getLibcName().contains("musl")); 696 } 697 698 // Sanitizer support 699 protected String isAsanEnabled() { 700 return "" + WB.isAsanEnabled(); 701 } 702 703 protected String isUbsanEnabled() { 704 return "" + WB.isUbsanEnabled(); 705 } 706 707 private String implementor() { 708 try (InputStream in = new BufferedInputStream(new FileInputStream( 709 System.getProperty("java.home") + "/release"))) { 710 Properties properties = new Properties(); 711 properties.load(in); 712 String implementorProperty = properties.getProperty("IMPLEMENTOR"); 713 if (implementorProperty != null) { 714 return implementorProperty.replace("\"", ""); 715 } 716 return errorWithMessage("Can't get 'IMPLEMENTOR' property from 'release' file"); 717 } catch (IOException e) { 718 e.printStackTrace(); 719 return errorWithMessage("Failed to read 'release' file " + e); 720 } 721 } 722 723 private String jdkContainerized() { 724 String isEnabled = System.getenv("TEST_JDK_CONTAINERIZED"); 725 return "" + "true".equalsIgnoreCase(isEnabled); 726 } 727 728 private String packagedModules() { 729 // Some jlink tests require packaged modules being present (jmods). 730 // For a runtime linkable image build packaged modules aren't present 731 try { 732 Path jmodsDir = Path.of(System.getProperty("java.home"), "jmods"); 733 if (jmodsDir.toFile().exists()) { 734 return Boolean.TRUE.toString(); 735 } else { 736 return Boolean.FALSE.toString(); 737 } 738 } catch (Throwable t) { 739 return Boolean.FALSE.toString(); 740 } 741 } 742 743 /** 744 * Checks if we are in <i>almost</i> out-of-box configuration, i.e. the flags 745 * which JVM is started with don't affect its behavior "significantly". 746 * {@code TEST_VM_FLAGLESS} enviroment variable can be used to force this 747 * method to return true or false and allow or reject any flags. 748 * 749 * @return true if there are no JVM flags 750 */ 751 private String isFlagless() { 752 boolean result = true; 753 String flagless = System.getenv("TEST_VM_FLAGLESS"); 754 if (flagless != null) { 755 return "" + "true".equalsIgnoreCase(flagless); 756 } 757 758 List<String> allFlags = allFlags().toList(); 759 760 // check -XX flags 761 var ignoredXXFlags = Set.of( 762 // added by run-test framework 763 "MaxRAMPercentage", 764 // added by test environment 765 "CreateCoredumpOnCrash" 766 ); 767 result &= allFlags.stream() 768 .filter(s -> s.startsWith("-XX:")) 769 // map to names: 770 // remove -XX: 771 .map(s -> s.substring(4)) 772 // remove +/- from bool flags 773 .map(s -> s.charAt(0) == '+' || s.charAt(0) == '-' ? s.substring(1) : s) 774 // remove =.* from others 775 .map(s -> s.contains("=") ? s.substring(0, s.indexOf('=')) : s) 776 // skip known-to-be-there flags 777 .filter(s -> !ignoredXXFlags.contains(s)) 778 .findAny() 779 .isEmpty(); 780 781 // check -X flags 782 var ignoredXFlags = Set.of( 783 // default, yet still seen to be explicitly set 784 "mixed", 785 // -XmxmNNNm added by run-test framework for non-hotspot tests 786 "mx" 787 ); 788 result &= allFlags.stream() 789 .filter(s -> s.startsWith("-X") && !s.startsWith("-XX:")) 790 // map to names: 791 // remove -X 792 .map(s -> s.substring(2)) 793 // remove :.* from flags with values 794 .map(s -> s.contains(":") ? s.substring(0, s.indexOf(':')) : s) 795 // remove size like 4G, 768m which might be set for non-hotspot tests 796 .map(s -> s.replaceAll("(\\d+)[mMgGkK]", "")) 797 // skip known-to-be-there flags 798 .filter(s -> !ignoredXFlags.contains(s)) 799 .findAny() 800 .isEmpty(); 801 802 return "" + result; 803 } 804 805 private Stream<String> allFlags() { 806 return Stream.of((System.getProperty("test.vm.opts", "") + " " + System.getProperty("test.java.opts", "")).trim().split("\\s+")); 807 } 808 809 /* 810 * A string indicating the foreign linker that is currently being used. See jdk.internal.foreign.CABI 811 * for valid values. 812 * 813 * "FALLBACK" and "UNSUPPORTED" are special values. The former indicates the fallback linker is 814 * being used. The latter indicates an unsupported platform. 815 */ 816 private String jdkForeignLinker() { 817 return String.valueOf(CABI.current()); 818 } 819 820 private String isStatic() { 821 return Boolean.toString(WB.isStatic()); 822 } 823 824 /** 825 * Dumps the map to the file if the file name is given as the property. 826 * This functionality could be helpful to know context in the real 827 * execution. 828 * 829 * @param map 830 */ 831 protected static void dump(Map<String, String> map) { 832 String dumpFileName = System.getProperty("vmprops.dump"); 833 if (dumpFileName == null) { 834 return; 835 } 836 List<String> lines = new ArrayList<>(); 837 map.forEach((k, v) -> lines.add(k + ":" + v)); 838 Collections.sort(lines); 839 try { 840 Files.write(Paths.get(dumpFileName), lines, 841 StandardOpenOption.APPEND, StandardOpenOption.CREATE); 842 } catch (IOException e) { 843 throw new RuntimeException("Failed to dump properties into '" 844 + dumpFileName + "'", e); 845 } 846 } 847 848 /** 849 * Log diagnostic message. 850 * 851 * @param msg 852 */ 853 protected static void log(String msg) { 854 // Always log to a file. 855 logToFile(msg); 856 857 // Also log to stderr; guarded by property to avoid excessive verbosity. 858 // By jtreg design stderr produced here will be visible 859 // in the output of a parent process. Note: stdout should not be used 860 // for logging as jtreg parses that output directly and only echoes it 861 // in the event of a failure. 862 if (Boolean.getBoolean("jtreg.log.vmprops")) { 863 System.err.println("VMProps: " + msg); 864 } 865 } 866 867 /** 868 * Log diagnostic message to a file. 869 * 870 * @param msg 871 */ 872 protected static void logToFile(String msg) { 873 String fileName = "./vmprops.log"; 874 try { 875 Files.writeString(Paths.get(fileName), msg + "\n", Charset.forName("ISO-8859-1"), 876 StandardOpenOption.APPEND, StandardOpenOption.CREATE); 877 } catch (IOException e) { 878 throw new RuntimeException("Failed to log into '" + fileName + "'", e); 879 } 880 } 881 882 /** 883 * This method is for the testing purpose only. 884 * 885 * @param args 886 */ 887 public static void main(String args[]) { 888 Map<String, String> map = new VMProps().call(); 889 map.forEach((k, v) -> System.out.println(k + ": '" + v + "'")); 890 } 891 }