Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/ikvm/openjdk/sun/management/FileSystemImpl.java

@@ -0,0 +1,40 @@
+/*
+  Copyright (C) 2011 Jeroen Frijters
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jeroen Frijters
+  jeroen@frijters.net
+  
+*/
+package sun.management;
+
+import ikvm.internal.NotYetImplementedError;
+import java.io.File;
+
+public class FileSystemImpl extends FileSystem
+{
+    public boolean supportsFileSecurity(File f)
+    {
+        throw new NotYetImplementedError();
+    }
+
+    public boolean isAccessUserOnly(File f)
+    {
+        throw new NotYetImplementedError();
+    }
+}

external/ikvm/openjdk/sun/management/GcInfoBuilder.java

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2003, 2008, 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 sun.management;
+
+import ikvm.internal.NotYetImplementedError;
+
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.MemoryUsage;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import javax.management.openmbean.TabularType;
+import javax.management.openmbean.TabularData;
+import javax.management.openmbean.TabularDataSupport;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.CompositeDataSupport;
+import javax.management.openmbean.OpenDataException;
+import com.sun.management.GcInfo;
+
+/**
+ * Helper class to build composite data.
+ */
+public class GcInfoBuilder {
+    private final GarbageCollectorMXBean gc;
+    private final String[] poolNames;
+    private String[] allItemNames;
+
+    // GC-specific composite type:
+    // Each GarbageCollectorMXBean may have different GC-specific attributes
+    // the CompositeType for the GcInfo could be different.
+    private CompositeType gcInfoCompositeType;
+
+    // GC-specific items
+    private final int gcExtItemCount;
+    private final String[] gcExtItemNames;
+    private final String[] gcExtItemDescs;
+    private final char[] gcExtItemTypes;
+
+    GcInfoBuilder(GarbageCollectorMXBean gc, String[] poolNames) {
+        this.gc = gc;
+        this.poolNames = poolNames;
+        this.gcExtItemCount = getNumGcExtAttributes(gc);
+        this.gcExtItemNames = new String[gcExtItemCount];
+        this.gcExtItemDescs = new String[gcExtItemCount];
+        this.gcExtItemTypes = new char[gcExtItemCount];
+
+        // Fill the information about extension attributes
+        fillGcAttributeInfo(gc, gcExtItemCount, gcExtItemNames,
+                            gcExtItemTypes, gcExtItemDescs);
+
+        // lazily build the CompositeType for the GcInfo
+        // including the GC-specific extension attributes
+        this.gcInfoCompositeType = null;
+    }
+
+    GcInfo getLastGcInfo() {
+        MemoryUsage[] usageBeforeGC = new MemoryUsage[poolNames.length];
+        MemoryUsage[] usageAfterGC = new MemoryUsage[poolNames.length];
+        Object[] values = new Object[gcExtItemCount];
+
+        return getLastGcInfo0(gc, gcExtItemCount, values, gcExtItemTypes,
+                              usageBeforeGC, usageAfterGC);
+    }
+
+    public String[] getPoolNames() {
+        return poolNames;
+    }
+
+    int getGcExtItemCount() {
+        return gcExtItemCount;
+    }
+
+    // Returns the CompositeType for the GcInfo including
+    // the extension attributes
+    synchronized CompositeType getGcInfoCompositeType() {
+        if (gcInfoCompositeType != null)
+            return gcInfoCompositeType;
+
+        // First, fill with the attributes in the GcInfo
+        String[] gcInfoItemNames = GcInfoCompositeData.getBaseGcInfoItemNames();
+        OpenType[] gcInfoItemTypes = GcInfoCompositeData.getBaseGcInfoItemTypes();
+        int numGcInfoItems = gcInfoItemNames.length;
+
+        int itemCount = numGcInfoItems + gcExtItemCount;
+        allItemNames = new String[itemCount];
+        String[] allItemDescs = new String[itemCount];
+        OpenType[] allItemTypes = new OpenType[itemCount];
+
+        System.arraycopy(gcInfoItemNames, 0, allItemNames, 0, numGcInfoItems);
+        System.arraycopy(gcInfoItemNames, 0, allItemDescs, 0, numGcInfoItems);
+        System.arraycopy(gcInfoItemTypes, 0, allItemTypes, 0, numGcInfoItems);
+
+        // Then fill with the extension GC-specific attributes, if any.
+        if (gcExtItemCount > 0) {
+            fillGcAttributeInfo(gc, gcExtItemCount, gcExtItemNames,
+                                gcExtItemTypes, gcExtItemDescs);
+            System.arraycopy(gcExtItemNames, 0, allItemNames,
+                             numGcInfoItems, gcExtItemCount);
+            System.arraycopy(gcExtItemDescs, 0, allItemDescs,
+                             numGcInfoItems, gcExtItemCount);
+            for (int i = numGcInfoItems, j = 0; j < gcExtItemCount; i++, j++) {
+                switch (gcExtItemTypes[j]) {
+                    case 'Z':
+                        allItemTypes[i] = SimpleType.BOOLEAN;
+                        break;
+                    case 'B':
+                        allItemTypes[i] = SimpleType.BYTE;
+                        break;
+                    case 'C':
+                        allItemTypes[i] = SimpleType.CHARACTER;
+                        break;
+                    case 'S':
+                        allItemTypes[i] = SimpleType.SHORT;
+                        break;
+                    case 'I':
+                        allItemTypes[i] = SimpleType.INTEGER;
+                        break;
+                    case 'J':
+                        allItemTypes[i] = SimpleType.LONG;
+                        break;
+                    case 'F':
+                        allItemTypes[i] = SimpleType.FLOAT;
+                        break;
+                    case 'D':
+                        allItemTypes[i] = SimpleType.DOUBLE;
+                        break;
+                    default:
+                        throw new AssertionError(
+                            "Unsupported type [" + gcExtItemTypes[i] + "]");
+                }
+            }
+        }
+
+        CompositeType gict = null;
+        try {
+            final String typeName =
+                "sun.management." + gc.getName() + ".GcInfoCompositeType";
+
+            gict = new CompositeType(typeName,
+                                     "CompositeType for GC info for " +
+                                         gc.getName(),
+                                     allItemNames,
+                                     allItemDescs,
+                                     allItemTypes);
+        } catch (OpenDataException e) {
+            // shouldn't reach here
+            throw Util.newException(e);
+        }
+        gcInfoCompositeType = gict;
+
+        return gcInfoCompositeType;
+    }
+
+    synchronized String[] getItemNames() {
+        if (allItemNames == null) {
+            // initialize when forming the composite type
+            getGcInfoCompositeType();
+        }
+        return allItemNames;
+    }
+
+    // Retrieve information about extension attributes
+    private /*native*/ int getNumGcExtAttributes(GarbageCollectorMXBean gc){
+    	throw new NotYetImplementedError();
+    }
+    
+    private /*native*/ void fillGcAttributeInfo(GarbageCollectorMXBean gc,
+                                            int numAttributes,
+                                            String[] attributeNames,
+                                            char[] types,
+                                            String[] descriptions){
+    	throw new NotYetImplementedError();
+    }
+
+    /**
+     * Returns the last GcInfo
+     *
+     * @param gc GarbageCollectorMXBean that the gc info is associated with.
+     * @param numExtAtts number of extension attributes
+     * @param extAttValues Values of extension attributes to be filled.
+     * @param before Memory usage before GC to be filled.
+     * @param after Memory usage after GC to be filled.
+     */
+    private /*native*/ GcInfo getLastGcInfo0(GarbageCollectorMXBean gc,
+                                         int numExtAtts,
+                                         Object[] extAttValues,
+                                         char[] extAttTypes,
+                                         MemoryUsage[] before,
+                                         MemoryUsage[] after){
+    	throw new NotYetImplementedError();
+    }
+}

external/ikvm/openjdk/sun/management/ManagementFactoryHelper.java

@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2003, 2008, 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 sun.management;
+
+import java.lang.management.*;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanServer;
+import javax.management.MBeanRegistrationException;
+import javax.management.NotCompliantMBeanException;
+import javax.management.ObjectName;
+import javax.management.RuntimeOperationsException;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import sun.security.action.LoadLibraryAction;
+
+import sun.util.logging.LoggingSupport;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import com.sun.management.OSMBeanFactory;
+
+import static java.lang.management.ManagementFactory.*;
+
+/**
+ * ManagementFactoryHelper provides static factory methods to create
+ * instances of the management interface.
+ */
+public class ManagementFactoryHelper {
+    private ManagementFactoryHelper() {};
+
+    private static VMManagement jvm;
+
+    private static ClassLoadingImpl    classMBean = null;
+    private static MemoryImpl          memoryMBean = null;
+    private static ThreadImpl          threadMBean = null;
+    private static RuntimeImpl         runtimeMBean = null;
+    private static CompilationImpl     compileMBean = null;
+    private static OperatingSystemImpl osMBean = null;
+
+    public static synchronized ClassLoadingMXBean getClassLoadingMXBean() {
+        if (classMBean == null) {
+            classMBean = new ClassLoadingImpl(jvm);
+        }
+        return classMBean;
+    }
+
+    public static synchronized MemoryMXBean getMemoryMXBean() {
+        if (memoryMBean == null) {
+            memoryMBean = new MemoryImpl(jvm);
+        }
+        return memoryMBean;
+    }
+
+    public static synchronized ThreadMXBean getThreadMXBean() {
+        if (threadMBean == null) {
+            threadMBean = new ThreadImpl(jvm);
+        }
+        return threadMBean;
+    }
+
+    public static synchronized RuntimeMXBean getRuntimeMXBean() {
+        if (runtimeMBean == null) {
+            runtimeMBean = new RuntimeImpl(jvm);
+        }
+        return runtimeMBean;
+    }
+
+    public static synchronized CompilationMXBean getCompilationMXBean() {
+        if (compileMBean == null && jvm.getCompilerName() != null) {
+            compileMBean = new CompilationImpl(jvm);
+        }
+        return compileMBean;
+    }
+
+    public static synchronized OperatingSystemMXBean getOperatingSystemMXBean() {
+        if (osMBean == null) {
+            osMBean = (OperatingSystemImpl)
+                          OSMBeanFactory.getOperatingSystemMXBean(jvm);
+        }
+        return osMBean;
+    }
+
+    public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
+        MemoryPoolMXBean[] pools = MemoryImpl.getMemoryPools();
+        List<MemoryPoolMXBean> list = new ArrayList<MemoryPoolMXBean>(pools.length);
+        for (MemoryPoolMXBean p : pools) {
+            list.add(p);
+        }
+        return list;
+    }
+
+    public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
+        MemoryManagerMXBean[]  mgrs = MemoryImpl.getMemoryManagers();
+        List<MemoryManagerMXBean> result = new ArrayList<MemoryManagerMXBean>(mgrs.length);
+        for (MemoryManagerMXBean m : mgrs) {
+            result.add(m);
+        }
+        return result;
+    }
+
+    public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans() {
+        MemoryManagerMXBean[]  mgrs = MemoryImpl.getMemoryManagers();
+        List<GarbageCollectorMXBean> result = new ArrayList<GarbageCollectorMXBean>(mgrs.length);
+        for (MemoryManagerMXBean m : mgrs) {
+            if (GarbageCollectorMXBean.class.isInstance(m)) {
+                 result.add(GarbageCollectorMXBean.class.cast(m));
+            }
+        }
+        return result;
+    }
+
+    public static PlatformLoggingMXBean getPlatformLoggingMXBean() {
+        if (LoggingSupport.isAvailable()) {
+            return PlatformLoggingImpl.instance;
+        } else {
+            return null;
+        }
+    }
+
+    // The logging MXBean object is an instance of
+    // PlatformLoggingMXBean and java.util.logging.LoggingMXBean
+    // but it can't directly implement two MXBean interfaces
+    // as a compliant MXBean implements exactly one MXBean interface,
+    // or if it implements one interface that is a subinterface of
+    // all the others; otherwise, it is a non-compliant MXBean
+    // and MBeanServer will throw NotCompliantMBeanException.
+    // See the Definition of an MXBean section in javax.management.MXBean spec.
+    //
+    // To create a compliant logging MXBean, define a LoggingMXBean interface
+    // that extend PlatformLoggingMXBean and j.u.l.LoggingMXBean
+    interface LoggingMXBean
+        extends PlatformLoggingMXBean, java.util.logging.LoggingMXBean {
+    }
+
+    static class PlatformLoggingImpl implements LoggingMXBean
+    {
+        final static PlatformLoggingMXBean instance = new PlatformLoggingImpl();
+        final static String LOGGING_MXBEAN_NAME = "java.util.logging:type=Logging";
+
+        private volatile ObjectName objname;  // created lazily
+        @Override
+        public ObjectName getObjectName() {
+            ObjectName result = objname;
+            if (result == null) {
+                synchronized (this) {
+                    result = objname;
+                    if (result == null) {
+                        result = Util.newObjectName(LOGGING_MXBEAN_NAME);
+                        objname = result;
+                    }
+                }
+            }
+            return result;
+        }
+
+        @Override
+        public java.util.List<String> getLoggerNames() {
+            return LoggingSupport.getLoggerNames();
+        }
+
+        @Override
+        public String getLoggerLevel(String loggerName) {
+            return LoggingSupport.getLoggerLevel(loggerName);
+        }
+
+        @Override
+        public void setLoggerLevel(String loggerName, String levelName) {
+            LoggingSupport.setLoggerLevel(loggerName, levelName);
+        }
+
+        @Override
+        public String getParentLoggerName(String loggerName) {
+            return LoggingSupport.getParentLoggerName(loggerName);
+        }
+    }
+
+    private static List<BufferPoolMXBean> bufferPools = null;
+    public static synchronized List<BufferPoolMXBean> getBufferPoolMXBeans() {
+        if (bufferPools == null) {
+            bufferPools = new ArrayList<>(2);
+            bufferPools.add(createBufferPoolMXBean(sun.misc.SharedSecrets.getJavaNioAccess()
+                .getDirectBufferPool()));
+            bufferPools.add(createBufferPoolMXBean(sun.nio.ch.FileChannelImpl
+                .getMappedBufferPool()));
+        }
+        return bufferPools;
+    }
+
+    private final static String BUFFER_POOL_MXBEAN_NAME = "java.nio:type=BufferPool";
+
+    /**
+     * Creates management interface for the given buffer pool.
+     */
+    private static BufferPoolMXBean
+        createBufferPoolMXBean(final sun.misc.JavaNioAccess.BufferPool pool)
+    {
+        return new BufferPoolMXBean() {
+            private volatile ObjectName objname;  // created lazily
+            @Override
+            public ObjectName getObjectName() {
+                ObjectName result = objname;
+                if (result == null) {
+                    synchronized (this) {
+                        result = objname;
+                        if (result == null) {
+                            result = Util.newObjectName(BUFFER_POOL_MXBEAN_NAME +
+                                ",name=" + pool.getName());
+                            objname = result;
+                        }
+                    }
+                }
+                return result;
+            }
+            @Override
+            public String getName() {
+                return pool.getName();
+            }
+            @Override
+            public long getCount() {
+                return pool.getCount();
+            }
+            @Override
+            public long getTotalCapacity() {
+                return pool.getTotalCapacity();
+            }
+            @Override
+            public long getMemoryUsed() {
+                return pool.getMemoryUsed();
+            }
+        };
+    }
+
+    /**
+     * Registers a given MBean if not registered in the MBeanServer;
+     * otherwise, just return.
+     */
+    private static void addMBean(MBeanServer mbs, Object mbean, String mbeanName) {
+        try {
+            final ObjectName objName = Util.newObjectName(mbeanName);
+
+            // inner class requires these fields to be final
+            final MBeanServer mbs0 = mbs;
+            final Object mbean0 = mbean;
+            AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
+                public Void run() throws MBeanRegistrationException,
+                                         NotCompliantMBeanException {
+                    try {
+                        mbs0.registerMBean(mbean0, objName);
+                        return null;
+                    } catch (InstanceAlreadyExistsException e) {
+                        // if an instance with the object name exists in
+                        // the MBeanServer ignore the exception
+                    }
+                    return null;
+                }
+            });
+        } catch (PrivilegedActionException e) {
+            throw Util.newException(e.getException());
+        }
+    }
+
+    static void registerInternalMBeans(MBeanServer mbs) {
+    }
+
+    static void unregisterInternalMBeans(MBeanServer mbs) {
+    }
+
+    static {
+        jvm = new VMManagementImpl();
+    }
+
+    public static boolean isThreadSuspended(int state) {
+        return ((state & JMM_THREAD_STATE_FLAG_SUSPENDED) != 0);
+    }
+
+    public static boolean isThreadRunningNative(int state) {
+        return ((state & JMM_THREAD_STATE_FLAG_NATIVE) != 0);
+    }
+
+    public static Thread.State toThreadState(int state) {
+        // suspended and native bits may be set in state
+        int threadStatus = state & ~JMM_THREAD_STATE_FLAG_MASK;
+        return sun.misc.VM.toThreadState(threadStatus);
+    }
+
+    // These values are defined in jmm.h
+    private static final int JMM_THREAD_STATE_FLAG_MASK = 0xFFF00000;
+    private static final int JMM_THREAD_STATE_FLAG_SUSPENDED = 0x00100000;
+    private static final int JMM_THREAD_STATE_FLAG_NATIVE = 0x00400000;
+
+}

external/ikvm/openjdk/sun/management/VMManagementImpl.java

@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2003, 2011, 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 sun.management;
+
+import sun.misc.Perf;
+import sun.management.counter.*;
+import java.nio.ByteBuffer;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.List;
+import java.util.Arrays;
+import java.util.Collections;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import sun.security.action.GetPropertyAction;
+
+/**
+ * Implementation of VMManagement interface that accesses the management
+ * attributes and operations locally within the same Java virtual
+ * machine.
+ */
+class VMManagementImpl implements VMManagement {
+
+    private static String version = "1.2";
+
+    private static boolean compTimeMonitoringSupport;
+    private static boolean threadContentionMonitoringSupport;
+    private static boolean currentThreadCpuTimeSupport;
+    private static boolean otherThreadCpuTimeSupport;
+    private static boolean bootClassPathSupport;
+    private static boolean objectMonitorUsageSupport;
+    private static boolean synchronizerUsageSupport;
+    private static boolean threadAllocatedMemorySupport;
+    private static boolean gcNotificationSupport;
+
+    // Optional supports
+    public boolean isCompilationTimeMonitoringSupported() {
+        return compTimeMonitoringSupport;
+    }
+
+    public boolean isThreadContentionMonitoringSupported() {
+        return threadContentionMonitoringSupport;
+    }
+
+    public boolean isCurrentThreadCpuTimeSupported() {
+        return currentThreadCpuTimeSupport;
+    }
+
+    public boolean isOtherThreadCpuTimeSupported() {
+        return otherThreadCpuTimeSupport;
+    }
+
+    public boolean isBootClassPathSupported() {
+        return bootClassPathSupport;
+    }
+
+    public boolean isObjectMonitorUsageSupported() {
+        return objectMonitorUsageSupport;
+    }
+
+    public boolean isSynchronizerUsageSupported() {
+        return synchronizerUsageSupport;
+    }
+
+    public boolean isThreadAllocatedMemorySupported() {
+        return threadAllocatedMemorySupport;
+    }
+
+    public boolean isGcNotificationSupported() {
+        return gcNotificationSupport;
+    }
+
+    public boolean isThreadContentionMonitoringEnabled() {
+        return false;
+    }
+
+    public boolean isThreadCpuTimeEnabled() {
+        return false;
+    }
+
+    public boolean isThreadAllocatedMemoryEnabled() {
+        return false;
+    }
+
+    // Class Loading Subsystem
+    public int    getLoadedClassCount() {
+        long count = getTotalClassCount() - getUnloadedClassCount();
+        return (int) count;
+    }
+    public long getTotalClassCount() {
+        throw new Error("Not implemented");
+    }
+    public long getUnloadedClassCount() {
+        throw new Error("Not implemented");
+    }
+
+    public boolean getVerboseClass() {
+        return false;
+    }
+
+    // Memory Subsystem
+    public boolean getVerboseGC() {
+        return false;
+    }
+
+    // Runtime Subsystem
+    public String   getManagementVersion() {
+        return version;
+    }
+
+    public String getVmId() {
+        int pid = getProcessId();
+        String hostname = "localhost";
+        try {
+            hostname = InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException e) {
+            // ignore
+        }
+
+        return pid + "@" + hostname;
+    }
+    private int getProcessId() {
+        return cli.System.Diagnostics.Process.GetCurrentProcess().get_Id();
+    }
+
+    public String   getVmName() {
+        return System.getProperty("java.vm.name");
+    }
+
+    public String   getVmVendor() {
+        return System.getProperty("java.vm.vendor");
+    }
+    public String   getVmVersion() {
+        return System.getProperty("java.vm.version");
+    }
+    public String   getVmSpecName()  {
+        return System.getProperty("java.vm.specification.name");
+    }
+    public String   getVmSpecVendor() {
+        return System.getProperty("java.vm.specification.vendor");
+    }
+    public String   getVmSpecVersion() {
+        return System.getProperty("java.vm.specification.version");
+    }
+    public String   getClassPath() {
+        return System.getProperty("java.class.path");
+    }
+    public String   getLibraryPath()  {
+        return System.getProperty("java.library.path");
+    }
+
+    public String   getBootClassPath( ) {
+        PrivilegedAction<String> pa
+            = new GetPropertyAction("sun.boot.class.path");
+        String result =  AccessController.doPrivileged(pa);
+        return result;
+    }
+
+    private List<String> vmArgs = null;
+    public synchronized List<String> getVmArguments() {
+        if (vmArgs == null) {
+            String[] args = getVmArguments0();
+            List<String> l = ((args != null && args.length != 0) ? Arrays.asList(args) :
+                                        Collections.<String>emptyList());
+            vmArgs = Collections.unmodifiableList(l);
+        }
+        return vmArgs;
+    }
+    public String[] getVmArguments0() {
+        return new String[0];
+    }
+
+    public long getStartupTime() {
+        return (long)(cli.System.Diagnostics.Process.GetCurrentProcess().get_StartTime().ToUniversalTime().Subtract(new cli.System.DateTime(1970, 1, 1))).get_TotalMilliseconds();
+    }
+    public int getAvailableProcessors() {
+        return cli.System.Environment.get_ProcessorCount();
+    }
+
+    // Compilation Subsystem
+    public String   getCompilerName() {
+        String name =  AccessController.doPrivileged(
+            new PrivilegedAction<String>() {
+                public String run() {
+                    return System.getProperty("sun.management.compiler");
+                }
+            });
+        return name;
+    }
+    public long getTotalCompileTime() {
+        throw new Error("Not implemented");
+    }
+
+    // Thread Subsystem
+    public long getTotalThreadCount() {
+        throw new Error("Not implemented");
+    }
+    public int  getLiveThreadCount() {
+        throw new Error("Not implemented");
+    }
+    public int  getPeakThreadCount() {
+        throw new Error("Not implemented");
+    }
+    public int  getDaemonThreadCount() {
+        throw new Error("Not implemented");
+    }
+
+    // Operating System
+    public String getOsName() {
+        return System.getProperty("os.name");
+    }
+    public String getOsArch() {
+        return System.getProperty("os.arch");
+    }
+    public String getOsVersion() {
+        return System.getProperty("os.version");
+    }
+
+    // Hotspot-specific runtime support
+    public long getSafepointCount() {
+        throw new Error("Not implemented");
+    }
+    public long getTotalSafepointTime() {
+        throw new Error("Not implemented");
+    }
+    public long getSafepointSyncTime() {
+        throw new Error("Not implemented");
+    }
+    public long getTotalApplicationNonStoppedTime() {
+        throw new Error("Not implemented");
+    }
+
+    public long getLoadedClassSize() {
+        throw new Error("Not implemented");
+    }
+    public long getUnloadedClassSize() {
+        throw new Error("Not implemented");
+    }
+    public long getClassLoadingTime() {
+        throw new Error("Not implemented");
+    }
+    public long getMethodDataSize() {
+        throw new Error("Not implemented");
+    }
+    public long getInitializedClassCount() {
+        throw new Error("Not implemented");
+    }
+    public long getClassInitializationTime() {
+        throw new Error("Not implemented");
+    }
+    public long getClassVerificationTime() {
+        throw new Error("Not implemented");
+    }
+
+    public List<Counter> getInternalCounters(String pattern) {
+        return Collections.emptyList();
+    }
+}