1 /*
   2  * Copyright (c) 1996, 2011, 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.misc;
  27 
  28 import static java.lang.Thread.State.*;
  29 import java.util.Properties;
  30 import java.util.HashMap;
  31 import java.util.Map;
  32 import java.util.Set;
  33 
  34 public class VM {
  35 
  36     /* The following methods used to be native methods that instruct
  37      * the VM to selectively suspend certain threads in low-memory
  38      * situations. They are inherently dangerous and not implementable
  39      * on native threads. We removed them in JDK 1.2. The skeletons
  40      * remain so that existing applications that use these methods
  41      * will still work.
  42      */
  43     private static boolean suspended = false;
  44 
  45     /** @deprecated */
  46     @Deprecated
  47     public static boolean threadsSuspended() {
  48         return suspended;
  49     }
  50 
  51     public static boolean allowThreadSuspension(ThreadGroup g, boolean b) {
  52         return g.allowThreadSuspension(b);
  53     }
  54 
  55     /** @deprecated */
  56     @Deprecated
  57     public static boolean suspendThreads() {
  58         suspended = true;
  59         return true;
  60     }
  61 
  62     // Causes any suspended threadgroups to be resumed.
  63     /** @deprecated */
  64     @Deprecated
  65     public static void unsuspendThreads() {
  66         suspended = false;
  67     }
  68 
  69     // Causes threadgroups no longer marked suspendable to be resumed.
  70     /** @deprecated */
  71     @Deprecated
  72     public static void unsuspendSomeThreads() {
  73     }
  74 
  75     /* Deprecated fields and methods -- Memory advice not supported in 1.2 */
  76 
  77     /** @deprecated */
  78     @Deprecated
  79     public static final int STATE_GREEN = 1;
  80 
  81     /** @deprecated */
  82     @Deprecated
  83     public static final int STATE_YELLOW = 2;
  84 
  85     /** @deprecated */
  86     @Deprecated
  87     public static final int STATE_RED = 3;
  88 
  89     /** @deprecated */
  90     @Deprecated
  91     public static final int getState() {
  92         return STATE_GREEN;
  93     }
  94 
  95     /** @deprecated */
  96     @Deprecated
  97     public static void registerVMNotification(VMNotification n) { }
  98 
  99     /** @deprecated */
 100     @Deprecated
 101     public static void asChange(int as_old, int as_new) { }
 102 
 103     /** @deprecated */
 104     @Deprecated
 105     public static void asChange_otherthread(int as_old, int as_new) { }
 106 
 107     /*
 108      * Not supported in 1.2 because these will have to be exported as
 109      * JVM functions, and we are not sure we want do that. Leaving
 110      * here so it can be easily resurrected -- just remove the //
 111      * comments.
 112      */
 113 
 114     /**
 115      * Resume Java profiling.  All profiling data is added to any
 116      * earlier profiling, unless <code>resetJavaProfiler</code> is
 117      * called in between.  If profiling was not started from the
 118      * command line, <code>resumeJavaProfiler</code> will start it.
 119      * <p>
 120      *
 121      * NOTE: Profiling must be enabled from the command line for a
 122      * java.prof report to be automatically generated on exit; if not,
 123      * writeJavaProfilerReport must be invoked to write a report.
 124      *
 125      * @see     resetJavaProfiler
 126      * @see     writeJavaProfilerReport
 127      */
 128 
 129     // public native static void resumeJavaProfiler();
 130 
 131     /**
 132      * Suspend Java profiling.
 133      */
 134     // public native static void suspendJavaProfiler();
 135 
 136     /**
 137      * Initialize Java profiling.  Any accumulated profiling
 138      * information is discarded.
 139      */
 140     // public native static void resetJavaProfiler();
 141 
 142     /**
 143      * Write the current profiling contents to the file "java.prof".
 144      * If the file already exists, it will be overwritten.
 145      */
 146     // public native static void writeJavaProfilerReport();
 147 
 148 
 149     private static volatile boolean booted = false;
 150 
 151     // Invoked by by System.initializeSystemClass just before returning.
 152     // Subsystems that are invoked during initialization can check this
 153     // property in order to avoid doing things that should wait until the
 154     // application class loader has been set up.
 155     //
 156     public static void booted() {
 157         booted = true;
 158     }
 159 
 160     public static boolean isBooted() {
 161         return booted;
 162     }
 163 
 164     // A user-settable upper limit on the maximum amount of allocatable direct
 165     // buffer memory.  This value may be changed during VM initialization if
 166     // "java" is launched with "-XX:MaxDirectMemorySize=<size>".
 167     //
 168     // The initial value of this field is arbitrary; during JRE initialization
 169     // it will be reset to the value specified on the command line, if any,
 170     // otherwise to Runtime.getRuntime.maxDirectMemory().
 171     //
 172     private static long directMemory = 64 * 1024 * 1024;
 173 
 174     // Returns the maximum amount of allocatable direct buffer memory.
 175     // The directMemory variable is initialized during system initialization
 176     // in the saveAndRemoveProperties method.
 177     //
 178     public static long maxDirectMemory() {
 179         return directMemory;
 180     }
 181 
 182     // User-controllable flag that determines if direct buffers should be page
 183     // aligned. The "-XX:+PageAlignDirectMemory" option can be used to force
 184     // buffers, allocated by ByteBuffer.allocateDirect, to be page aligned.
 185     private static boolean pageAlignDirectMemory;
 186 
 187     // Returns {@code true} if the direct buffers should be page aligned. This
 188     // variable is initialized by saveAndRemoveProperties.
 189     public static boolean isDirectMemoryPageAligned() {
 190         return pageAlignDirectMemory;
 191     }
 192 
 193     // A user-settable boolean to determine whether ClassLoader.loadClass should
 194     // accept array syntax.  This value may be changed during VM initialization
 195     // via the system property "sun.lang.ClassLoader.allowArraySyntax".
 196     //
 197     // The default for 1.5 is "true", array syntax is allowed.  In 1.6, the
 198     // default will be "false".  The presence of this system property to
 199     // control array syntax allows applications the ability to preview this new
 200     // behaviour.
 201     //
 202     private static boolean defaultAllowArraySyntax = false;
 203     private static boolean allowArraySyntax = defaultAllowArraySyntax;
 204 
 205     // The allowArraySyntax boolean is initialized during system initialization
 206     // in the saveAndRemoveProperties method.
 207     //
 208     // It is initialized based on the value of the system property
 209     // "sun.lang.ClassLoader.allowArraySyntax".  If the system property is not
 210     // provided, the default for 1.5 is "true".  In 1.6, the default will be
 211     // "false".  If the system property is provided, then the value of
 212     // allowArraySyntax will be equal to "true" if Boolean.parseBoolean()
 213     // returns "true".   Otherwise, the field will be set to "false".
 214     //
 215     public static boolean allowArraySyntax() {
 216         return allowArraySyntax;
 217     }
 218 
 219     /**
 220      * Returns the system property of the specified key saved at
 221      * system initialization time.  This method should only be used
 222      * for the system properties that are not changed during runtime.
 223      * It accesses a private copy of the system properties so
 224      * that user's locking of the system properties object will not
 225      * cause the library to deadlock.
 226      *
 227      * Note that the saved system properties do not include
 228      * the ones set by sun.misc.Version.init().
 229      *
 230      */
 231     public static String getSavedProperty(String key) {
 232         if (savedProps.isEmpty())
 233             throw new IllegalStateException("Should be non-empty if initialized");
 234 
 235         return savedProps.getProperty(key);
 236     }
 237 
 238     // TODO: the Property Management needs to be refactored and
 239     // the appropriate prop keys need to be accessible to the
 240     // calling classes to avoid duplication of keys.
 241     private static final Properties savedProps = new Properties();
 242 
 243     // Save a private copy of the system properties and remove
 244     // the system properties that are not intended for public access.
 245     //
 246     // This method can only be invoked during system initialization.
 247     public static void saveAndRemoveProperties(Properties props) {
 248         if (booted)
 249             throw new IllegalStateException("System initialization has completed");
 250 
 251         savedProps.putAll(props);
 252 
 253         // Set the maximum amount of direct memory.  This value is controlled
 254         // by the vm option -XX:MaxDirectMemorySize=<size>.
 255         // The maximum amount of allocatable direct buffer memory (in bytes)
 256         // from the system property sun.nio.MaxDirectMemorySize set by the VM.
 257         // The system property will be removed.
 258         String s = (String)props.remove("sun.nio.MaxDirectMemorySize");
 259         if (s != null) {
 260             if (s.equals("-1")) {
 261                 // -XX:MaxDirectMemorySize not given, take default
 262                 directMemory = Runtime.getRuntime().maxMemory();
 263             } else {
 264                 long l = Long.parseLong(s);
 265                 if (l > -1)
 266                     directMemory = l;
 267             }
 268         }
 269 
 270         // Check if direct buffers should be page aligned
 271         s = (String)props.remove("sun.nio.PageAlignDirectMemory");
 272         if ("true".equals(s))
 273             pageAlignDirectMemory = true;
 274 
 275         // Set a boolean to determine whether ClassLoader.loadClass accepts
 276         // array syntax.  This value is controlled by the system property
 277         // "sun.lang.ClassLoader.allowArraySyntax".
 278         s = props.getProperty("sun.lang.ClassLoader.allowArraySyntax");
 279         allowArraySyntax = (s == null
 280                                ? defaultAllowArraySyntax
 281                                : Boolean.parseBoolean(s));
 282 
 283         // Remove other private system properties
 284         // used by java.lang.Integer.IntegerCache
 285         props.remove("java.lang.Integer.IntegerCache.high");
 286 
 287         // used by java.util.zip.ZipFile
 288         props.remove("sun.zip.disableMemoryMapping");
 289 
 290         // used by sun.launcher.LauncherHelper
 291         props.remove("sun.java.launcher.diag");
 292     }
 293 
 294     // Initialize any miscellenous operating system settings that need to be
 295     // set for the class libraries.
 296     //
 297     public static void initializeOSEnvironment() {
 298         if (!booted) {
 299             OSEnvironment.initialize();
 300         }
 301     }
 302 
 303     /* Current count of objects pending for finalization */
 304     private static volatile int finalRefCount = 0;
 305 
 306     /* Peak count of objects pending for finalization */
 307     private static volatile int peakFinalRefCount = 0;
 308 
 309     /*
 310      * Gets the number of objects pending for finalization.
 311      *
 312      * @return the number of objects pending for finalization.
 313      */
 314     public static int getFinalRefCount() {
 315         return finalRefCount;
 316     }
 317 
 318     /*
 319      * Gets the peak number of objects pending for finalization.
 320      *
 321      * @return the peak number of objects pending for finalization.
 322      */
 323     public static int getPeakFinalRefCount() {
 324         return peakFinalRefCount;
 325     }
 326 
 327     /*
 328      * Add <tt>n</tt> to the objects pending for finalization count.
 329      *
 330      * @param n an integer value to be added to the objects pending
 331      * for finalization count
 332      */
 333     public static void addFinalRefCount(int n) {
 334         // The caller must hold lock to synchronize the update.
 335 
 336         finalRefCount += n;
 337         if (finalRefCount > peakFinalRefCount) {
 338             peakFinalRefCount = finalRefCount;
 339         }
 340     }
 341 
 342     /**
 343      * Returns Thread.State for the given threadStatus
 344      */
 345     public static Thread.State toThreadState(int threadStatus) {
 346         if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
 347             return RUNNABLE;
 348         } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
 349             return BLOCKED;
 350         } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
 351             return WAITING;
 352         } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
 353             return TIMED_WAITING;
 354         } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
 355             return TERMINATED;
 356         } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
 357             return NEW;
 358         } else {
 359             return RUNNABLE;
 360         }
 361     }
 362 
 363     /* The threadStatus field is set by the VM at state transition
 364      * in the hotspot implementation. Its value is set according to
 365      * the JVM TI specification GetThreadState function.
 366      */
 367     private final static int JVMTI_THREAD_STATE_ALIVE = 0x0001;
 368     private final static int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
 369     private final static int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
 370     private final static int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
 371     private final static int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
 372     private final static int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
 373 
 374     /*
 375      * Returns the first non-null class loader up the execution stack,
 376      * or null if only code from the null class loader is on the stack.
 377      */
 378     public static native ClassLoader latestUserDefinedLoader();
 379 
 380     static {
 381         initialize();
 382     }
 383     private native static void initialize();
 384 }