1 /*
2 * Copyright (c) 1996, 2015, 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 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 saveAndRemoveProperties 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 saveAndRemoveProperties.
205 public static boolean isDirectMemoryPageAligned() {
206 return pageAlignDirectMemory;
207 }
208
209 /**
210 * Returns true if the given class loader is in the system domain
211 * in which all permissions are granted.
212 */
213 public static boolean isSystemDomainLoader(ClassLoader loader) {
214 return loader == null;
215 }
216
217 /**
218 * Returns the system property of the specified key saved at
219 * system initialization time. This method should only be used
220 * for the system properties that are not changed during runtime.
221 * It accesses a private copy of the system properties so
222 * that user's locking of the system properties object will not
223 * cause the library to deadlock.
224 *
225 * Note that the saved system properties do not include
226 * the ones set by sun.misc.Version.init().
227 *
228 */
229 public static String getSavedProperty(String key) {
230 if (savedProps.isEmpty())
231 throw new IllegalStateException("Should be non-empty if initialized");
232
233 return savedProps.getProperty(key);
234 }
235
236 // TODO: the Property Management needs to be refactored and
237 // the appropriate prop keys need to be accessible to the
238 // calling classes to avoid duplication of keys.
239 private static final Properties savedProps = new Properties();
240
241 // Save a private copy of the system properties and remove
242 // the system properties that are not intended for public access.
243 //
244 // This method can only be invoked during system initialization.
245 public static void saveAndRemoveProperties(Properties props) {
246 if (booted)
247 throw new IllegalStateException("System initialization has completed");
248
249 savedProps.putAll(props);
250
251 // Set the maximum amount of direct memory. This value is controlled
252 // by the vm option -XX:MaxDirectMemorySize=<size>.
253 // The maximum amount of allocatable direct buffer memory (in bytes)
254 // from the system property sun.nio.MaxDirectMemorySize set by the VM.
255 // The system property will be removed.
256 String s = (String)props.remove("sun.nio.MaxDirectMemorySize");
257 if (s != null) {
258 if (s.equals("-1")) {
259 // -XX:MaxDirectMemorySize not given, take default
260 directMemory = Runtime.getRuntime().maxMemory();
261 } else {
262 long l = Long.parseLong(s);
263 if (l > -1)
264 directMemory = l;
265 }
266 }
267
268 // Check if direct buffers should be page aligned
269 s = (String)props.remove("sun.nio.PageAlignDirectMemory");
270 if ("true".equals(s))
271 pageAlignDirectMemory = true;
272
273 // Remove other private system properties
274 // used by java.lang.Integer.IntegerCache
275 props.remove("java.lang.Integer.IntegerCache.high");
276
277 // used by java.util.zip.ZipFile
278 props.remove("sun.zip.disableMemoryMapping");
279
280 // used by sun.launcher.LauncherHelper
281 props.remove("sun.java.launcher.diag");
282 }
283
284 // Initialize any miscellenous operating system settings that need to be
285 // set for the class libraries.
286 //
287 public static void initializeOSEnvironment() {
288 if (!booted) {
289 OSEnvironment.initialize();
290 }
291 }
292
293 /* Current count of objects pending for finalization */
294 private static volatile int finalRefCount = 0;
295
296 /* Peak count of objects pending for finalization */
297 private static volatile int peakFinalRefCount = 0;
298
299 /*
300 * Gets the number of objects pending for finalization.
301 *
302 * @return the number of objects pending for finalization.
303 */
304 public static int getFinalRefCount() {
305 return finalRefCount;
306 }
307
308 /*
309 * Gets the peak number of objects pending for finalization.
310 *
311 * @return the peak number of objects pending for finalization.
312 */
313 public static int getPeakFinalRefCount() {
314 return peakFinalRefCount;
315 }
316
317 /*
318 * Add <tt>n</tt> to the objects pending for finalization count.
319 *
320 * @param n an integer value to be added to the objects pending
321 * for finalization count
322 */
323 public static void addFinalRefCount(int n) {
324 // The caller must hold lock to synchronize the update.
325
326 finalRefCount += n;
327 if (finalRefCount > peakFinalRefCount) {
328 peakFinalRefCount = finalRefCount;
329 }
330 }
331
332 /**
333 * Returns Thread.State for the given threadStatus
334 */
335 public static Thread.State toThreadState(int threadStatus) {
336 if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
337 return RUNNABLE;
338 } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
339 return BLOCKED;
340 } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
341 return WAITING;
342 } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
343 return TIMED_WAITING;
344 } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
345 return TERMINATED;
346 } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
347 return NEW;
348 } else {
349 return RUNNABLE;
350 }
351 }
352
353 /* The threadStatus field is set by the VM at state transition
354 * in the hotspot implementation. Its value is set according to
355 * the JVM TI specification GetThreadState function.
356 */
357 private final static int JVMTI_THREAD_STATE_ALIVE = 0x0001;
358 private final static int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
359 private final static int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
360 private final static int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
361 private final static int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
362 private final static int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
363
364 /*
365 * Returns the first non-null class loader up the execution stack,
366 * or null if only code from the null class loader is on the stack.
367 */
368 public static native ClassLoader latestUserDefinedLoader();
369
370 /**
371 * Returns {@code true} if we are in a set UID program.
372 */
373 public static boolean isSetUID() {
374 long uid = getuid();
375 long euid = geteuid();
376 long gid = getgid();
377 long egid = getegid();
378 return uid != euid || gid != egid;
379 }
380
381 /**
382 * Returns the real user ID of the calling process,
383 * or -1 if the value is not available.
384 */
385 public static native long getuid();
386
387 /**
388 * Returns the effective user ID of the calling process,
389 * or -1 if the value is not available.
390 */
391 public static native long geteuid();
392
393 /**
394 * Returns the real group ID of the calling process,
395 * or -1 if the value is not available.
396 */
397 public static native long getgid();
398
399 /**
400 * Returns the effective group ID of the calling process,
401 * or -1 if the value is not available.
402 */
403 public static native long getegid();
404
405 /**
406 * Get a nanosecond time stamp adjustment in the form of a single long.
407 *
408 * This value can be used to create an instant using
409 * {@link java.time.Instant#ofEpochSecond(long, long)
410 * java.time.Instant.ofEpochSecond(offsetInSeconds,
411 * getNanoTimeAdjustment(offsetInSeconds))}.
412 * <p>
413 * The value returned has the best resolution available to the JVM on
414 * the current system.
415 * This is usually down to microseconds - or tenth of microseconds -
416 * depending on the OS/Hardware and the JVM implementation.
417 *
418 * @param offsetInSeconds The offset in seconds from which the nanosecond
419 * time stamp should be computed.
420 *
421 * @apiNote The offset should be recent enough - so that
422 * {@code offsetInSeconds} is within {@code +/- 2^32} seconds of the
423 * current UTC time. If the offset is too far off, {@code -1} will be
424 * returned. As such, {@code -1} must not be considered as a valid
425 * nano time adjustment, but as an exception value indicating
426 * that an offset closer to the current time should be used.
427 *
428 * @return A nanosecond time stamp adjustment in the form of a single long.
429 * If the offset is too far off the current time, this method returns -1.
430 * In that case, the caller should call this method again, passing a
431 * more accurate offset.
432 */
433 public static native long getNanoTimeAdjustment(long offsetInSeconds);
434
435 static {
436 initialize();
437 }
438 private native static void initialize();
439 }