1 /*
   2  * Copyright (c) 2013, 2020, 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 jdk.test.lib;
  25 
  26 import java.io.File;
  27 import java.io.IOException;
  28 import java.io.RandomAccessFile;
  29 import java.nio.file.Path;
  30 import java.nio.file.Paths;
  31 import java.util.regex.Pattern;
  32 import java.security.AccessController;
  33 import java.security.PrivilegedAction;
  34 import java.security.PrivilegedActionException;
  35 import java.security.PrivilegedExceptionAction;
  36 
  37 public class Platform {
  38     public  static final String vmName      = privilegedGetProperty("java.vm.name");
  39     public  static final String vmInfo      = privilegedGetProperty("java.vm.info");
  40     private static final String osVersion   = privilegedGetProperty("os.version");
  41     private static       int osVersionMajor = -1;
  42     private static       int osVersionMinor = -1;
  43     private static final String osName      = privilegedGetProperty("os.name");
  44     private static final String dataModel   = privilegedGetProperty("sun.arch.data.model");
  45     private static final String vmVersion   = privilegedGetProperty("java.vm.version");
  46     private static final String jdkDebug    = privilegedGetProperty("jdk.debug");
  47     private static final String osArch      = privilegedGetProperty("os.arch");
  48     private static final String userName    = privilegedGetProperty("user.name");
  49     private static final String compiler    = privilegedGetProperty("sun.management.compiler");
  50     private static final String testJdk     = privilegedGetProperty("test.jdk");
  51 
  52     private static String privilegedGetProperty(String key) {
  53         return AccessController.doPrivileged((
  54                 PrivilegedAction<String>) () -> System.getProperty(key));
  55     }
  56 
  57     public static boolean isClient() {
  58         return vmName.endsWith(" Client VM");
  59     }
  60 
  61     public static boolean isServer() {
  62         return vmName.endsWith(" Server VM");
  63     }
  64 
  65     public static boolean isZero() {
  66         return vmName.endsWith(" Zero VM");
  67     }
  68 
  69     public static boolean isMinimal() {
  70         return vmName.endsWith(" Minimal VM");
  71     }
  72 
  73     public static boolean isEmbedded() {
  74         return vmName.contains("Embedded");
  75     }
  76 
  77     public static boolean isEmulatedClient() {
  78         return vmInfo.contains(" emulated-client");
  79     }
  80 
  81     public static boolean isTieredSupported() {
  82         return compiler.contains("Tiered Compilers");
  83     }
  84 
  85     public static boolean isInt() {
  86         return vmInfo.contains("interpreted");
  87     }
  88 
  89     public static boolean isMixed() {
  90         return vmInfo.contains("mixed");
  91     }
  92 
  93     public static boolean isComp() {
  94         return vmInfo.contains("compiled");
  95     }
  96 
  97     public static boolean is32bit() {
  98         return dataModel.equals("32");
  99     }
 100 
 101     public static boolean is64bit() {
 102         return dataModel.equals("64");
 103     }
 104 
 105     public static boolean isAix() {
 106         return isOs("aix");
 107     }
 108 
 109     public static boolean isLinux() {
 110         return isOs("linux");
 111     }
 112 
 113     public static boolean isOSX() {
 114         return isOs("mac");
 115     }
 116 
 117     public static boolean isSolaris() {
 118         return isOs("sunos");
 119     }
 120 
 121     public static boolean isWindows() {
 122         return isOs("win");
 123     }
 124 
 125     private static boolean isOs(String osname) {
 126         return osName.toLowerCase().startsWith(osname.toLowerCase());
 127     }
 128 
 129     public static String getOsName() {
 130         return osName;
 131     }
 132 
 133     // Os version support.
 134     private static void init_version() {
 135         String[] osVersionTokens = osVersion.split("\\.");
 136         try {
 137             if (osVersionTokens.length > 0) {
 138                 osVersionMajor = Integer.parseInt(osVersionTokens[0]);
 139                 if (osVersionTokens.length > 1) {
 140                     osVersionMinor = Integer.parseInt(osVersionTokens[1]);
 141                 }
 142             }
 143         } catch (NumberFormatException e) {
 144             osVersionMajor = osVersionMinor = 0;
 145         }
 146     }
 147 
 148     public static String getOsVersion() {
 149         return osVersion;
 150     }
 151 
 152     // Returns major version number from os.version system property.
 153     // E.g. 5 on Solaris 10 and 3 on SLES 11.3 (for the linux kernel version).
 154     public static int getOsVersionMajor() {
 155         if (osVersionMajor == -1) init_version();
 156         return osVersionMajor;
 157     }
 158 
 159     // Returns minor version number from os.version system property.
 160     // E.g. 10 on Solaris 10 and 0 on SLES 11.3 (for the linux kernel version).
 161     public static int getOsVersionMinor() {
 162         if (osVersionMinor == -1) init_version();
 163         return osVersionMinor;
 164     }
 165 
 166     public static boolean isDebugBuild() {
 167         return (jdkDebug.toLowerCase().contains("debug"));
 168     }
 169 
 170     public static boolean isSlowDebugBuild() {
 171         return (jdkDebug.toLowerCase().equals("slowdebug"));
 172     }
 173 
 174     public static boolean isFastDebugBuild() {
 175         return (jdkDebug.toLowerCase().equals("fastdebug"));
 176     }
 177 
 178     public static String getVMVersion() {
 179         return vmVersion;
 180     }
 181 
 182     public static boolean isAArch64() {
 183         return isArch("aarch64");
 184     }
 185 
 186     public static boolean isARM() {
 187         return isArch("arm.*");
 188     }
 189 
 190     public static boolean isPPC() {
 191         return isArch("ppc.*");
 192     }
 193 
 194     // Returns true for IBM z System running linux.
 195     public static boolean isS390x() {
 196         return isArch("s390.*") || isArch("s/390.*") || isArch("zArch_64");
 197     }
 198 
 199     // Returns true for sparc and sparcv9.
 200     public static boolean isSparc() {
 201         return isArch("sparc.*");
 202     }
 203 
 204     public static boolean isX64() {
 205         // On OSX it's 'x86_64' and on other (Linux, Windows and Solaris) platforms it's 'amd64'
 206         return isArch("(amd64)|(x86_64)");
 207     }
 208 
 209     public static boolean isX86() {
 210         // On Linux it's 'i386', Windows 'x86' without '_64' suffix.
 211         return isArch("(i386)|(x86(?!_64))");
 212     }
 213 
 214     public static String getOsArch() {
 215         return osArch;
 216     }
 217 
 218     /**
 219      * Return a boolean for whether SA and jhsdb are ported/available
 220      * on this platform.
 221      */
 222     public static boolean hasSA() {
 223         if (isAix()) {
 224             return false; // SA not implemented.
 225         } else if (isLinux()) {
 226             if (isS390x() || isARM()) {
 227                 return false; // SA not implemented.
 228             }
 229         }
 230         // Other platforms expected to work:
 231         return true;
 232     }
 233 
 234     /**
 235      * Return a boolean for whether we expect to be able to attach
 236      * the SA to our own processes on this system.  This requires
 237      * that SA is ported/available on this platform.
 238      */
 239     public static boolean shouldSAAttach() throws IOException {
 240         if (!hasSA()) return false;
 241         if (isLinux()) {
 242             return canPtraceAttachLinux();
 243         } else if (isOSX()) {
 244             return canAttachOSX();
 245         } else {
 246             // Other platforms expected to work:
 247             return true;
 248         }
 249     }
 250 
 251     /**
 252      * On Linux, first check the SELinux boolean "deny_ptrace" and return false
 253      * as we expect to be denied if that is "1".  Then expect permission to attach
 254      * if we are root, so return true.  Then return false for an expected denial
 255      * if "ptrace_scope" is 1, and true otherwise.
 256      */
 257     private static boolean canPtraceAttachLinux() throws IOException {
 258         // SELinux deny_ptrace:
 259         File deny_ptrace = new File("/sys/fs/selinux/booleans/deny_ptrace");
 260         if (deny_ptrace.exists()) {
 261             try (RandomAccessFile file = AccessController.doPrivileged(
 262                     (PrivilegedExceptionAction<RandomAccessFile>) () -> new RandomAccessFile(deny_ptrace, "r"))) {
 263                 if (file.readByte() != '0') {
 264                     return false;
 265                 }
 266             } catch (PrivilegedActionException e) {
 267                 IOException t = (IOException) e.getException();
 268                 throw t;
 269             }
 270         }
 271 
 272         // YAMA enhanced security ptrace_scope:
 273         // 0 - a process can PTRACE_ATTACH to any other process running under the same uid
 274         // 1 - restricted ptrace: a process must be a children of the inferior or user is root
 275         // 2 - only processes with CAP_SYS_PTRACE may use ptrace or user is root
 276         // 3 - no attach: no processes may use ptrace with PTRACE_ATTACH
 277         File ptrace_scope = new File("/proc/sys/kernel/yama/ptrace_scope");
 278         if (ptrace_scope.exists()) {
 279             try (RandomAccessFile file = AccessController.doPrivileged(
 280                     (PrivilegedExceptionAction<RandomAccessFile>) () -> new RandomAccessFile(ptrace_scope, "r"))) {
 281                 byte yama_scope = file.readByte();
 282                 if (yama_scope == '3') {
 283                     return false;
 284                 }
 285 
 286                 if (!userName.equals("root") && yama_scope != '0') {
 287                     return false;
 288                 }
 289             } catch (PrivilegedActionException e) {
 290                 IOException t = (IOException) e.getException();
 291                 throw t;
 292             }
 293         }
 294         // Otherwise expect to be permitted:
 295         return true;
 296     }
 297 
 298     /**
 299      * On OSX, expect permission to attach only if we are root.
 300      */
 301     private static boolean canAttachOSX() {
 302         return userName.equals("root");
 303     }
 304 
 305     private static boolean isArch(String archnameRE) {
 306         return Pattern.compile(archnameRE, Pattern.CASE_INSENSITIVE)
 307                       .matcher(osArch)
 308                       .matches();
 309     }
 310 
 311     /**
 312      * Returns file extension of shared library, e.g. "so" on linux, "dll" on windows.
 313      * @return file extension
 314      */
 315     public static String sharedLibraryExt() {
 316         if (isWindows()) {
 317             return "dll";
 318         } else if (isOSX()) {
 319             return "dylib";
 320         } else {
 321             return "so";
 322         }
 323     }
 324 
 325     /*
 326      * Returns name of system variable containing paths to shared native libraries.
 327      */
 328     public static String sharedLibraryPathVariableName() {
 329         if (isWindows()) {
 330             return "PATH";
 331         } else if (isOSX()) {
 332             return "DYLD_LIBRARY_PATH";
 333         } else if (isAix()) {
 334             return "LIBPATH";
 335         } else {
 336             return "LD_LIBRARY_PATH";
 337         }
 338     }
 339 
 340     /**
 341      * Returns absolute path to directory containing JVM shared library.
 342      */
 343     public static Path jvmLibDir() {
 344         Path dir = Paths.get(testJdk);
 345         if (Platform.isWindows()) {
 346             return dir.resolve("bin")
 347                 .resolve(variant())
 348                 .toAbsolutePath();
 349         } else {
 350             return dir.resolve("lib")
 351                 .resolve(variant())
 352                 .toAbsolutePath();
 353         }
 354     }
 355 
 356     private static String variant() {
 357         if (Platform.isServer()) {
 358             return "server";
 359         } else if (Platform.isClient()) {
 360             return "client";
 361         } else if (Platform.isMinimal()) {
 362             return "minimal";
 363         } else {
 364             throw new Error("TESTBUG: unsupported vm variant");
 365         }
 366     }
 367 
 368 
 369     public static boolean isDefaultCDSArchiveSupported() {
 370         return (is64bit()  &&
 371                 isServer() &&
 372                 (isLinux()   ||
 373                  isOSX()     ||
 374                  isSolaris() ||
 375                  isWindows()) &&
 376                 !isZero()    &&
 377                 !isMinimal() &&
 378                 !isAArch64() &&
 379                 !isARM());
 380     }
 381 
 382     /*
 383      * This should match the #if condition in ClassListParser::load_class_from_source().
 384      */
 385     public static boolean areCustomLoadersSupportedForCDS() {
 386         return (is64bit() && (isLinux() || isSolaris() || isOSX()));
 387     }
 388 }
--- EOF ---