blob: 22f8eec7d120f0619bd81cc95d60231cc275d068 [file]
/*
* Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.vm.ci.services;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Supplier;
import jdk.internal.misc.TerminatingThreadLocal;
import jdk.internal.misc.VM;
import jdk.internal.misc.Unsafe;
import jdk.internal.util.Architecture;
import jdk.internal.util.OperatingSystem;
/**
* Provides utilities needed by JVMCI clients.
*/
public final class Services {
/**
* Guards code that should only be run in a JVMCI shared library. Such code must be directly
* guarded by an {@code if} statement on this field - the guard cannot be behind a method call.
*
* The value of this field in a JVMCI shared library runtime must be {@code true}.
*/
public static final boolean IS_IN_NATIVE_IMAGE;
static {
/*
* Prevents javac from constant folding use of this field. It is set to true by the process
* that builds the shared library.
*/
IS_IN_NATIVE_IMAGE = false;
}
private Services() {
}
/**
* Lazily initialized in {@link #getSavedProperties}.
*/
private static volatile Map<String, String> savedProperties;
/**
* Gets an unmodifiable copy of the system properties as of VM startup.
*
* If running on Hotspot, this will be the system properties parsed by {@code arguments.cpp}
* plus {@code java.specification.version}, {@code os.name} and {@code os.arch}. The latter two
* are forced to be the real OS and architecture. That is, values for these two properties set
* on the command line are ignored.
*/
public static Map<String, String> getSavedProperties() {
if (savedProperties == null) {
synchronized (Services.class) {
if (savedProperties == null) {
savedProperties = initProperties();
}
}
}
return savedProperties;
}
/**
* Helper method equivalent to {@link #getSavedProperties()}{@code .getOrDefault(name, def)}.
*/
public static String getSavedProperty(String name, String def) {
return Services.getSavedProperties().getOrDefault(name, def);
}
/**
* Helper method equivalent to {@link #getSavedProperties()}{@code .get(name)}.
*/
public static String getSavedProperty(String name) {
return Services.getSavedProperties().get(name);
}
/**
* Causes the JVMCI subsystem to be initialized if it isn't already initialized.
*/
public static void initializeJVMCI() {
try {
Class.forName("jdk.vm.ci.runtime.JVMCI");
} catch (ClassNotFoundException e) {
throw new InternalError(e);
}
}
/**
* Opens all JVMCI packages to {@code otherModule}.
*/
static void openJVMCITo(Module otherModule) {
Module jvmci = Services.class.getModule();
if (jvmci != otherModule) {
Set<String> packages = jvmci.getPackages();
for (String pkg : packages) {
boolean opened = jvmci.isOpen(pkg, otherModule);
if (!opened) {
jvmci.addOpens(pkg, otherModule);
}
}
}
}
/**
* Creates a thread-local variable that notifies {@code onThreadTermination} when a thread
* terminates and it has been initialized in the terminating thread (even if it was initialized
* with a null value). A typical use is to release resources associated with a thread.
*
* @param initialValue a supplier to be used to determine the initial value
* @param onThreadTermination a consumer invoked by a thread when terminating and the
* thread-local has an associated value for the terminating thread. The current
* thread's value of the thread-local variable is passed as a parameter to the
* consumer.
*/
public static <T> ThreadLocal<T> createTerminatingThreadLocal(Supplier<T> initialValue, Consumer<T> onThreadTermination) {
Objects.requireNonNull(initialValue, "initialValue must be non null.");
Objects.requireNonNull(onThreadTermination, "onThreadTermination must be non null.");
return new TerminatingThreadLocal<>() {
@Override
protected T initialValue() {
return initialValue.get();
}
@Override
protected void threadTerminated(T value) {
onThreadTermination.accept(value);
}
};
}
static String toJavaString(Unsafe unsafe, long cstring) {
if (cstring == 0) {
return null;
}
int len = 0;
for (long p = cstring; unsafe.getByte(p) != 0; p++) {
len++;
}
byte[] buf = new byte[len];
for (int i = 0; i < len; i++) {
buf[i] = unsafe.getByte(cstring + i);
}
return new String(buf, java.nio.charset.StandardCharsets.UTF_8);
}
/**
* Gets the value of {@code Arguments::systemProperties()} and puts the offsets
* of {@code SystemProperty} fields into {@code offsets}. The values returned in
* {@code offsets} are:
*
* <pre>
* [ next, // SystemProperty::next_offset_in_bytes()
* key, // SystemProperty::key_offset_in_bytes()
* value // PathString::value_offset_in_bytes()
* ]
* </pre>
*
* Ideally this would be done with vmstructs but that code is in {@code jdk.vm.ci.hotspot}.
*/
private static native long readSystemPropertiesInfo(int[] offsets);
/**
* Parses the native {@code Arguments::systemProperties()} data structure using Unsafe to
* create a properties map. This parsing is safe as argument parsing in completed in
* early VM start before this code can be executed, making {@code Arguments::systemProperties()}
* effectively read-only by now.
*/
private static Map<String, String> initProperties() {
int[] offsets = new int[3];
long systemProperties = readSystemPropertiesInfo(offsets);
int nextOffset = offsets[0];
int keyOffset = offsets[1];
int valueOffset = offsets[2];
int count = 0;
Unsafe unsafe = Unsafe.getUnsafe();
for (long prop = systemProperties; prop != 0; prop = unsafe.getLong(prop + nextOffset)) {
if (unsafe.getLong(prop + valueOffset) != 0) {
count++;
} else {
// Some internal properties (e.g. jdk.boot.class.path.append) can have a null
// value and should just be ignored. Note that null is different than the empty string.
}
}
Map<String, SystemProperties.Value> props = new HashMap<>(count + 1);
int i = 0;
for (long prop = systemProperties; prop != 0; prop = unsafe.getLong(prop + nextOffset)) {
String key = toJavaString(unsafe, unsafe.getLong(prop + keyOffset));
long valueAddress = unsafe.getLong(prop + valueOffset);
if (valueAddress != 0) {
props.put(key, new SystemProperties.Value(unsafe, valueAddress));
i++;
}
}
if (i != count) {
throw new InternalError(i + " != " + count);
}
if (!props.containsKey("java.specification.version")) {
SystemProperties.Value v = Objects.requireNonNull(props.get("java.vm.specification.version"));
props.put("java.specification.version", v);
}
SystemProperties res = new SystemProperties(unsafe, sanitizeOSArch(props));
if ("true".equals(res.get("debug.jvmci.PrintSavedProperties"))) {
System.out.println("[Saved system properties]");
for (Map.Entry<String, String> e : res.entrySet()) {
System.out.printf("%s=%s%n", e.getKey(), e.getValue());
}
}
return res;
}
// Force os.name and os.arch to reflect the actual OS and architecture.
// JVMCI configures itself based on these values and needs to be isolated
// from apps that set them on the command line.
private static Map<String, SystemProperties.Value> sanitizeOSArch(Map<String, SystemProperties.Value> props) {
props.put("os.arch", new SystemProperties.Value(realArch()));
props.put("os.name", new SystemProperties.Value(realOS()));
return props;
}
private static String realOS() {
OperatingSystem os = OperatingSystem.current();
switch (os) {
case LINUX: return "Linux";
case MACOS: return "Mac OS X";
case AIX: return "AIX";
case WINDOWS: {
String osName = System.getProperty("os.name");
if (osName.startsWith("Windows")) {
// Use original value which is often more "complete"
// E.g. "Windows Server 2012"
return osName;
}
return "Windows";
}
default: throw new InternalError("missing case for " + os);
}
}
private static String realArch() {
Architecture arch = Architecture.current();
switch (arch) {
case X64: return "x86_64";
case X86: return "x86";
case AARCH64: return "aarch64";
case RISCV64: return "riscv64";
case ARM: return "arm";
case S390: return "s390";
case PPC64: return "ppc64";
case OTHER: return "other";
default: throw new InternalError("missing case for " + arch);
}
}
}