Use OperatingSystemMXBean implementation from JDK

pejovica · pejovica · commit 0340a554dc8f · 2022-03-11T18:37:38.000+01:00
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/LibManagementExtSupport.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/LibManagementExtSupport.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2022, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.oracle.svm.core.jdk.management;
+
+import static com.oracle.svm.core.c.function.CEntryPointOptions.NoEpilogue;
+import static com.oracle.svm.core.c.function.CEntryPointOptions.NoPrologue;
+import static com.oracle.svm.core.c.function.CEntryPointOptions.Publish;
+import static org.graalvm.nativeimage.c.function.CFunction.Transition.NO_TRANSITION;
+
+import org.graalvm.nativeimage.IsolateThread;
+import org.graalvm.nativeimage.StackValue;
+import org.graalvm.nativeimage.c.function.CEntryPoint;
+import org.graalvm.nativeimage.c.function.CFunction;
+import org.graalvm.nativeimage.c.function.CLibrary;
+import org.graalvm.nativeimage.c.type.CCharPointer;
+
+import com.oracle.svm.core.annotate.Uninterruptible;
+import com.oracle.svm.core.c.CGlobalData;
+import com.oracle.svm.core.c.CGlobalDataFactory;
+import com.oracle.svm.core.c.function.CEntryPointOptions;
+import com.oracle.svm.core.headers.LibC;
+
+public final class LibManagementExtSupport {
+    private static final CGlobalData<CCharPointer> ERRMSG_FORMAT = CGlobalDataFactory.createCString("errno: %d error: %s\n");
+
+    /**
+     * Reimplementation of the native {@code throw_internal_error} function in Java.
+     */
+    @Uninterruptible(reason = "No Java context.")
+    @CEntryPoint(name = "throw_internal_error", include = CEntryPoint.NotIncludedAutomatically.class)
+    @CEntryPointOptions(prologue = NoPrologue.class, epilogue = NoEpilogue.class, publishAs = Publish.SymbolOnly)
+    private static void throwInternalError(IsolateThread env, CCharPointer msg) {
+        /*
+         * Ported from `src/jdk.management/share/native/libmanagement_ext/management_ext.c`.
+         */
+        CCharPointer errmsg = StackValue.get(128);
+
+        sprintf(errmsg, ERRMSG_FORMAT.get(), LibC.errno(), msg);
+        jnuThrowInternalError(env, errmsg);
+    }
+
+    @CFunction(transition = NO_TRANSITION)
+    private static native int sprintf(CCharPointer str, CCharPointer format, int errno, CCharPointer msg);
+
+    @CLibrary(value = "java", requireStatic = true)
+    @CFunction(value = "JNU_ThrowInternalError", transition = NO_TRANSITION)
+    private static native void jnuThrowInternalError(IsolateThread env, CCharPointer msg);
+}
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/ManagementSupport.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/ManagementSupport.java
@@ -25,6 +25,7 @@
 package com.oracle.svm.core.jdk.management;
 
 import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
 import java.lang.management.PlatformManagedObject;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -33,6 +34,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Supplier;
 
 import javax.management.DynamicMBean;
 import javax.management.JMException;
@@ -48,10 +50,13 @@
 import org.graalvm.nativeimage.IsolateThread;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.impl.InternalPlatform;
 
+import com.oracle.svm.core.SubstrateUtil;
 import com.oracle.svm.core.annotate.Uninterruptible;
 import com.oracle.svm.core.thread.ThreadListener;
 import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.core.util.VMError;
 import com.sun.jmx.mbeanserver.MXBeanLookup;
 
 /**
@@ -60,15 +65,14 @@
  * parts: The beans (implementations of {@link PlatformManagedObject}) themselves; and the singleton
  * {@link ManagementFactory#getPlatformMBeanServer() MBean server}.
  *
- * Support for {@link PlatformManagedObject}: All MXBean that provide VM introspection are allocated
- * eagerly at image build time, and stored in {@link #platformManagedObjectsMap} as well as
- * {@link #platformManagedObjectsSet}. The registration is decentralized: while some general beans
- * are registered in this class, the OS specific and GC specific beans are registered in the
- * respective OS or GC code. To find all registrations, look for the usages of
- * {@link #addPlatformManagedObjectSingleton} and {@link #addPlatformManagedObjectList}. Eager
- * allocation of all the beans avoids the complicated registry that the JDK maintains for lazy
- * loading (the code in PlatformComponent - note that this code and even the package of the class is
- * significantly different between JDK 8 and JDK 11).
+ * Support for {@link PlatformManagedObject}: All MXBean that provide VM introspection are
+ * registered (but not necessarily allocated) eagerly at image build time, and stored in
+ * {@link #platformManagedObjectsMap} as well as {@link #platformManagedObjectsSet}. The
+ * registration is decentralized: while some general beans are registered in this class, the GC
+ * specific beans are registered in the respective GC code. To find all registrations, look for the
+ * usages of {@link #addPlatformManagedObjectSingleton} and {@link #addPlatformManagedObjectList}.
+ * Eager registration of all the beans avoids the complicated registry that the JDK maintains for
+ * lazy loading (the code in PlatformComponent).
  *
  * Support for {@link ManagementFactory#getPlatformMBeanServer()}: The {@link MBeanServer} that
  * makes all MXBean available too is allocated lazily at run time. This has advantages and
@@ -113,6 +117,9 @@ public final class ManagementSupport implements ThreadListener {
     private final SubstrateRuntimeMXBean runtimeMXBean;
     private final SubstrateThreadMXBean threadMXBean;
 
+    /* Initialized lazily at run time. */
+    private OperatingSystemMXBean osMXBean;
+
     /** The singleton MBean server for the platform, initialized lazily at run time. */
     MBeanServer platformMBeanServer;
 
@@ -128,7 +135,7 @@ public final class ManagementSupport implements ThreadListener {
 
         /*
          * Register the platform objects defined in this package. Note that more platform objects
-         * are registered in OS and GC specific code.
+         * are registered in GC specific code.
          */
         addPlatformManagedObjectSingleton(java.lang.management.ClassLoadingMXBean.class, classLoadingMXBean);
         addPlatformManagedObjectSingleton(java.lang.management.CompilationMXBean.class, compilationMXBean);
@@ -140,6 +147,30 @@ public final class ManagementSupport implements ThreadListener {
          */
         addPlatformManagedObjectList(java.lang.management.MemoryPoolMXBean.class, Collections.emptyList());
         addPlatformManagedObjectList(java.lang.management.BufferPoolMXBean.class, Collections.emptyList());
+        /*
+         * Register the platform object for the OS using a supplier that lazily initializes it at
+         * run time.
+         */
+        doAddPlatformManagedObjectSingleton(getOsMXBeanInterface(), (PlatformManagedObjectSupplier) this::getOsMXBean);
+    }
+
+    private static Class<?> getOsMXBeanInterface() {
+        if (Platform.includedIn(InternalPlatform.PLATFORM_JNI.class)) {
+            return Platform.includedIn(Platform.WINDOWS.class)
+                            ? com.sun.management.OperatingSystemMXBean.class
+                            : com.sun.management.UnixOperatingSystemMXBean.class;
+        }
+        return java.lang.management.OperatingSystemMXBean.class;
+    }
+
+    private synchronized OperatingSystemMXBean getOsMXBean() {
+        if (osMXBean == null) {
+            Object osMXBeanImpl = Platform.includedIn(InternalPlatform.PLATFORM_JNI.class)
+                            ? new Target_com_sun_management_internal_OperatingSystemImpl(null)
+                            : new Target_sun_management_BaseOperatingSystemImpl(null);
+            osMXBean = SubstrateUtil.cast(osMXBeanImpl, OperatingSystemMXBean.class);
+        }
+        return osMXBean;
     }
 
     @Fold
@@ -251,7 +282,7 @@ synchronized MBeanServer getPlatformMBeanServer() {
             /* Modified version of JDK 11: ManagementFactory.getPlatformMBeanServer */
             platformMBeanServer = MBeanServerFactory.createMBeanServer();
             for (PlatformManagedObject platformManagedObject : platformManagedObjectsSet) {
-                addMXBean(platformMBeanServer, platformManagedObject);
+                addMXBean(platformMBeanServer, handleLazyPlatformManagedObjectSingleton(platformManagedObject));
             }
         }
         return platformMBeanServer;
@@ -287,7 +318,7 @@ <T extends PlatformManagedObject> T getPlatformMXBean(Class<T> mxbeanInterface)
         } else if (result instanceof List) {
             throw new IllegalArgumentException(mxbeanInterface.getName() + " can have more than one instance");
         }
-        return mxbeanInterface.cast(result);
+        return mxbeanInterface.cast(handleLazyPlatformManagedObjectSingleton(result));
     }
 
     @SuppressWarnings("unchecked")
@@ -299,7 +330,33 @@ <T extends PlatformManagedObject> List<T> getPlatformMXBeans(Class<T> mxbeanInte
         if (result instanceof List) {
             return (List<T>) result;
         } else {
-            return Collections.singletonList(mxbeanInterface.cast(result));
+            return Collections.singletonList(mxbeanInterface.cast(handleLazyPlatformManagedObjectSingleton(result)));
         }
     }
+
+    /**
+     * A {@link PlatformManagedObject} supplier that is itself a {@link PlatformManagedObject} for
+     * easier integration with the rest of the {@link ManagementSupport} machinery.
+     *
+     * This in particular allows for transparent storage in {@link #platformManagedObjectsMap} and
+     * {@link #platformManagedObjectsSet} at the expense of
+     * {@linkplain #handleLazyPlatformManagedObjectSingleton special handling} when retrieving
+     * stored platform objects.
+     */
+    private interface PlatformManagedObjectSupplier extends Supplier<PlatformManagedObject>, PlatformManagedObject {
+        @Override
+        default ObjectName getObjectName() {
+            throw VMError.shouldNotReachHere();
+        }
+    }
+
+    /**
+     * Provides {@link PlatformManagedObjectSupplier} handling when retrieving singleton platform
+     * objects from {@link #platformManagedObjectsMap} and {@link #platformManagedObjectsSet}.
+     */
+    private static PlatformManagedObject handleLazyPlatformManagedObjectSingleton(Object object) {
+        assert object instanceof PlatformManagedObject;
+        return object instanceof PlatformManagedObjectSupplier ? ((PlatformManagedObjectSupplier) object).get()
+                        : (PlatformManagedObject) object;
+    }
 }
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/Target_com_sun_management_internal_OperatingSystemImpl.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/Target_com_sun_management_internal_OperatingSystemImpl.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.oracle.svm.core.jdk.management;
+
+import com.oracle.svm.core.SubstrateUtil;
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+
+import sun.management.VMManagement;
+
+@TargetClass(className = "com.sun.management.internal.OperatingSystemImpl")
+final class Target_com_sun_management_internal_OperatingSystemImpl {
+    @Substitute
+    Target_com_sun_management_internal_OperatingSystemImpl(@SuppressWarnings("unused") VMManagement vm) {
+        /* Workaround until we enable container support (GR-37365). */
+        SubstrateUtil.cast(this, Target_sun_management_BaseOperatingSystemImpl.class).loadavg = new double[1];
+    }
+}
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/Target_sun_management_BaseOperatingSystemImpl.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/management/Target_sun_management_BaseOperatingSystemImpl.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2022, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.oracle.svm.core.jdk.management;
+
+import com.oracle.svm.core.annotate.Alias;
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+
+import sun.management.VMManagement;
+
+@SuppressWarnings("static-method")
+@TargetClass(className = "sun.management.BaseOperatingSystemImpl")
+final class Target_sun_management_BaseOperatingSystemImpl {
+    @Alias double[] loadavg;
+
+    @Alias
+    Target_sun_management_BaseOperatingSystemImpl(@SuppressWarnings("unused") VMManagement vm) {
+    }
+
+    /*
+     * The following substitutions eliminate the use of the `BaseOperatingSystemImpl.jvm` field,
+     * which we set to `null` to avoid dealing with `VMManagementImpl` that we do not support.
+     */
+    @Substitute
+    public String getName() {
+        return System.getProperty("os.name");
+    }
+
+    @Substitute
+    public String getArch() {
+        return System.getProperty("os.arch");
+    }
+
+    @Substitute
+    public String getVersion() {
+        return System.getProperty("os.version");
+    }
+
+    @Substitute
+    public int getAvailableProcessors() {
+        return Runtime.getRuntime().availableProcessors();
+    }
+}
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jdk/JNIRegistrationManagementExt.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jdk/JNIRegistrationManagementExt.java
