1 /*
   2  * Copyright (c) 1996, 2012, 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     @SuppressWarnings("deprecation")
  52     public static boolean allowThreadSuspension(ThreadGroup g, boolean b) {
  53         return g.allowThreadSuspension(b);
  54     }
  55 
  56     /** @deprecated */
  57     @Deprecated
  58     public static boolean suspendThreads() {
  59         suspended = true;
  60         return true;
  61     }
  62 
  63     // Causes any suspended threadgroups to be resumed.
  64     /** @deprecated */
  65     @Deprecated
  66     public static void unsuspendThreads() {
  67         suspended = false;
  68     }
  69 
  70     // Causes threadgroups no longer marked suspendable to be resumed.
  71     /** @deprecated */
  72     @Deprecated
  73     public static void unsuspendSomeThreads() {
  74     }
  75 
  76     /* Deprecated fields and methods -- Memory advice not supported in 1.2 */
  77 
  78     /** @deprecated */
  79     @Deprecated
  80     public static final int STATE_GREEN = 1;
  81 
  82     /** @deprecated */
  83     @Deprecated
  84     public static final int STATE_YELLOW = 2;
  85 
  86     /** @deprecated */
  87     @Deprecated
  88     public static final int STATE_RED = 3;
  89 
  90     /** @deprecated */
  91     @Deprecated
  92     public static final int getState() {
  93         return STATE_GREEN;
  94     }
  95 
  96     /** @deprecated */
  97     @Deprecated
  98     public static void registerVMNotification(VMNotification n) { }
  99 
 100     /** @deprecated */
 101     @Deprecated
 102     public static void asChange(int as_old, int as_new) { }
 103 
 104     /** @deprecated */
 105     @Deprecated
 106     public static void asChange_otherthread(int as_old, int as_new) { }
 107 
 108     /*
 109      * Not supported in 1.2 because these will have to be exported as
 110      * JVM functions, and we are not sure we want do that. Leaving
 111      * here so it can be easily resurrected -- just remove the //
 112      * comments.
 113      */
 114 
 115     /**
 116      * Resume Java profiling.  All profiling data is added to any
 117      * earlier profiling, unless <code>resetJavaProfiler</code> is
 118      * called in between.  If profiling was not started from the
 119      * command line, <code>resumeJavaProfiler</code> will start it.
 120      * <p>
 121      *
 122      * NOTE: Profiling must be enabled from the command line for a
 123      * java.prof report to be automatically generated on exit; if not,
 124      * writeJavaProfilerReport must be invoked to write a report.
 125      *
 126      * @see     resetJavaProfiler
 127      * @see     writeJavaProfilerReport
 128      */
 129 
 130     // public native static void resumeJavaProfiler();
 131 
 132     /**
 133      * Suspend Java profiling.
 134      */
 135     // public native static void suspendJavaProfiler();
 136 
 137     /**
 138      * Initialize Java profiling.  Any accumulated profiling
 139      * information is discarded.
 140      */
 141     // public native static void resetJavaProfiler();
 142 
 143     /**
 144      * Write the current profiling contents to the file "java.prof".
 145      * If the file already exists, it will be overwritten.
 146      */
 147     // public native static void writeJavaProfilerReport();
 148 
 149 
 150     private static volatile boolean booted = false;
 151     private static final Object lock = new Object();
 152 
 153     // Invoked by by System.initializeSystemClass just before returning.
 154     // Subsystems that are invoked during initialization can check this
 155     // property in order to avoid doing things that should wait until the
 156     // application class loader has been set up.
 157     //
 158     public static void booted() {
 159         synchronized (lock) {
 160             booted = true;
 161             lock.notifyAll();
 162         }
 163     }
 164 
 165     public static boolean isBooted() {
 166         return booted;
 167     }
 168 
 169     // Waits until VM completes initialization
 170     //
 171     // This method is invoked by the Finalizer thread
 172     public static void awaitBooted() throws InterruptedException {
 173         synchronized (lock) {
 174             while (!booted) {
 175                 lock.wait();
 176             }
 177         }
 178     }
 179 
 180     // A user-settable upper limit on the maximum amount of allocatable direct
 181     // buffer memory.  This value may be changed during VM initialization if
 182     // "java" is launched with "-XX:MaxDirectMemorySize=<size>".
 183     //
 184     // The initial value of this field is arbitrary; during JRE initialization
 185     // it will be reset to the value specified on the command line, if any,
 186     // otherwise to Runtime.getRuntime().maxMemory().
 187     //
 188     private static long directMemory = 64 * 1024 * 1024;
 189 
 190     // Returns the maximum amount of allocatable direct buffer memory.
 191     // The directMemory variable is initialized during system initialization
 192     // in the saveVMSystemProperties method.
 193     //
 194     public static long maxDirectMemory() {
 195         return directMemory;
 196     }
 197 
 198     // User-controllable flag that determines if direct buffers should be page
 199     // aligned. The "-XX:+PageAlignDirectMemory" option can be used to force
 200     // buffers, allocated by ByteBuffer.allocateDirect, to be page aligned.
 201     private static boolean pageAlignDirectMemory;
 202 
 203     // Returns {@code true} if the direct buffers should be page aligned. This
 204     // variable is initialized by saveVMSystemProperties.
 205     public static boolean isDirectMemoryPageAligned() {
 206         return pageAlignDirectMemory;
 207     }
 208 
 209     // A user-settable boolean to determine whether ClassLoader.loadClass should
 210     // accept array syntax.  This value may be changed during VM initialization
 211     // via the system property "sun.lang.ClassLoader.allowArraySyntax".
 212     //
 213     // The default for 1.5 is "true", array syntax is allowed.  In 1.6+, the
 214     // default is "false".  The presence of this system property to
 215     // control array syntax allows applications the ability to preview this new
 216     // behaviour.
 217     //
 218     private static boolean defaultAllowArraySyntax = false;
 219     private static boolean allowArraySyntax = defaultAllowArraySyntax;
 220 
 221     // The allowArraySyntax boolean is initialized during system initialization
 222     // in the saveVMSystemProperties method.
 223     //
 224     // It is initialized based on the value of the system property
 225     // "sun.lang.ClassLoader.allowArraySyntax".  If the system property is not
 226     // provided, the default for 1.5 is "true".  In 1.6+, the default is
 227     // "false".  If the system property is provided, then the value of
 228     // allowArraySyntax will be equal to "true" if Boolean.parseBoolean()
 229     // returns "true".   Otherwise, the field will be set to "false".
 230     //
 231     public static boolean allowArraySyntax() {
 232         return allowArraySyntax;
 233     }
 234 
 235     /**
 236      * Returns true if the given class loader is in the system domain
 237      * in which all permissions are granted.
 238      */
 239     public static boolean isSystemDomainLoader(ClassLoader loader) {
 240         return loader == null;
 241     }
 242 
 243     /**
 244      * Returns the system property of the specified key saved at
 245      * system initialization time.  This method should only be used
 246      * for the system properties that are not changed during runtime.
 247      * It accesses a private copy of the system properties so
 248      * that user's locking of the system properties object will not
 249      * cause the library to deadlock.
 250      *
 251      * Note that the saved system properties do not include
 252      * the ones set by sun.misc.Version.init().
 253      *
 254      */
 255     public static String getSavedProperty(String key) {
 256         if (savedProps.isEmpty())
 257             throw new IllegalStateException("Should be non-empty if initialized");
 258 
 259         return savedProps.getProperty(key);
 260     }
 261 
 262     // TODO: the Property Management needs to be refactored and
 263     // the appropriate prop keys need to be accessible to the
 264     // calling classes to avoid duplication of keys.
 265     private static final Properties savedProps = new Properties();
 266 
 267     /**
 268      * Save a private copy of the system properties.
 269      *
 270      * @implNote This method can only be invoked during system initialization.
 271      */
 272     public static void saveVMSystemProperties(Properties props) {
 273         if (booted)
 274             throw new IllegalStateException("System initialization has completed");
 275 
 276         savedProps.putAll(props);
 277 
 278         // Set the maximum amount of direct memory.  This value is controlled
 279         // by the vm option -XX:MaxDirectMemorySize=<size>.
 280         // The maximum amount of allocatable direct buffer memory (in bytes)
 281         // from the system property sun.nio.MaxDirectMemorySize set by the VM.
 282         // The system property will be removed.
 283         String s = savedProps.getProperty("sun.nio.MaxDirectMemorySize");
 284         if (s != null) {
 285             if (s.equals("-1")) {
 286                 // -XX:MaxDirectMemorySize not given, take default
 287                 directMemory = Runtime.getRuntime().maxMemory();
 288             } else {
 289                 long l = Long.parseLong(s);
 290                 if (l > -1)
 291                     directMemory = l;
 292             }
 293         }
 294 
 295         // Check if direct buffers should be page aligned
 296         s = savedProps.getProperty("sun.nio.PageAlignDirectMemory");
 297         pageAlignDirectMemory = Boolean.parseBoolean(s);
 298 
 299         // Set a boolean to determine whether ClassLoader.loadClass accepts
 300         // array syntax.  This value is controlled by the system property
 301         // "sun.lang.ClassLoader.allowArraySyntax".
 302         s = savedProps.getProperty("sun.lang.ClassLoader.allowArraySyntax");
 303         allowArraySyntax = Boolean.parseBoolean(s);
 304    }
 305 
 306     /**
 307      * Returns a copy of the saved system properties with private implementation
 308      * properties removed.
 309      *
 310      * @return a newly created Properties instance containing only sanitized
 311      */
 312     public static Properties getSanitizedSavedProperties() {
 313         Properties sanitized = new Properties();
 314 
 315         sanitized.putAll(savedProps);
 316 
 317         // Remove implementation private system properties
 318 
 319         sanitized.remove("sun.nio.MaxDirectMemorySize");
 320 
 321         sanitized.remove("sun.nio.PageAlignDirectMemory");
 322 
 323         sanitized.remove("sun.lang.ClassLoader.allowArraySyntax");
 324 
 325         // used by java.lang.Integer.IntegerCache
 326         sanitized.remove("java.lang.Integer.IntegerCache.high");
 327 
 328         // used by java.util.zip.ZipFile
 329         sanitized.remove("sun.zip.disableMemoryMapping");
 330 
 331         // used by sun.launcher.LauncherHelper
 332         sanitized.remove("sun.java.launcher.diag");
 333 
 334         return sanitized;
 335      }
 336 
 337     // Initialize any miscellenous operating system settings that need to be
 338     // set for the class libraries.
 339     //
 340     public static void initializeOSEnvironment() {
 341         if (!booted) {
 342             OSEnvironment.initialize();
 343         }
 344     }
 345 
 346     /* Current count of objects pending for finalization */
 347     private static volatile int finalRefCount = 0;
 348 
 349     /* Peak count of objects pending for finalization */
 350     private static volatile int peakFinalRefCount = 0;
 351 
 352     /*
 353      * Gets the number of objects pending for finalization.
 354      *
 355      * @return the number of objects pending for finalization.
 356      */
 357     public static int getFinalRefCount() {
 358         return finalRefCount;
 359     }
 360 
 361     /*
 362      * Gets the peak number of objects pending for finalization.
 363      *
 364      * @return the peak number of objects pending for finalization.
 365      */
 366     public static int getPeakFinalRefCount() {
 367         return peakFinalRefCount;
 368     }
 369 
 370     /*
 371      * Add <tt>n</tt> to the objects pending for finalization count.
 372      *
 373      * @param n an integer value to be added to the objects pending
 374      * for finalization count
 375      */
 376     public static void addFinalRefCount(int n) {
 377         // The caller must hold lock to synchronize the update.
 378 
 379         finalRefCount += n;
 380         if (finalRefCount > peakFinalRefCount) {
 381             peakFinalRefCount = finalRefCount;
 382         }
 383     }
 384 
 385     /**
 386      * Returns Thread.State for the given threadStatus
 387      */
 388     public static Thread.State toThreadState(int threadStatus) {
 389         if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
 390             return RUNNABLE;
 391         } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
 392             return BLOCKED;
 393         } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
 394             return WAITING;
 395         } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
 396             return TIMED_WAITING;
 397         } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
 398             return TERMINATED;
 399         } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
 400             return NEW;
 401         } else {
 402             return RUNNABLE;
 403         }
 404     }
 405 
 406     /* The threadStatus field is set by the VM at state transition
 407      * in the hotspot implementation. Its value is set according to
 408      * the JVM TI specification GetThreadState function.
 409      */
 410     private final static int JVMTI_THREAD_STATE_ALIVE = 0x0001;
 411     private final static int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
 412     private final static int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
 413     private final static int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
 414     private final static int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
 415     private final static int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
 416 
 417     /*
 418      * Returns the first non-null class loader up the execution stack,
 419      * or null if only code from the null class loader is on the stack.
 420      */
 421     public static native ClassLoader latestUserDefinedLoader();
 422 
 423     static {
 424         initialize();
 425     }
 426     private native static void initialize();
 427 }