1 /*
2 * Copyright (c) 1996, 2016, 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 jdk.internal.misc;
27
28 import static java.lang.Thread.State.*;
29 import java.util.Map;
30 import java.util.Properties;
31
32 public class VM {
33
34 // the init level when the VM is fully initialized
35 private static final int JAVA_LANG_SYSTEM_INITED = 1;
36 private static final int MODULE_SYSTEM_INITED = 2;
37 private static final int SYSTEM_LOADER_INITIALIZING = 3;
38 private static final int SYSTEM_BOOTED = 4;
39 private static final int SYSTEM_SHUTDOWN = 5;
40
41
42 // 0, 1, 2, ...
43 private static volatile int initLevel;
44 private static final Object lock = new Object();
45
46 /**
47 * Sets the init level.
48 *
49 * @see java.lang.System#initPhase1
50 * @see java.lang.System#initPhase2
51 * @see java.lang.System#initPhase3
52 */
53 public static void initLevel(int value) {
54 synchronized (lock) {
55 if (value <= initLevel || value > SYSTEM_SHUTDOWN)
56 throw new InternalError("Bad level: " + value);
57 initLevel = value;
58 lock.notifyAll();
59 }
60 }
61
62 /**
63 * Returns the current init level.
64 */
65 public static int initLevel() {
66 return initLevel;
67 }
68
69 /**
70 * Waits for the init level to get the given value.
71 *
72 * @see java.lang.ref.Finalizer
73 */
74 public static void awaitInitLevel(int value) throws InterruptedException {
75 synchronized (lock) {
76 while (initLevel < value) {
77 lock.wait();
78 }
79 }
80 }
81
82 /**
83 * Returns {@code true} if the module system has been initialized.
84 * @see java.lang.System#initPhase2
85 */
86 public static boolean isModuleSystemInited() {
87 return VM.initLevel() >= MODULE_SYSTEM_INITED;
88 }
89
90 /**
91 * Returns {@code true} if the VM is fully initialized.
92 */
93 public static boolean isBooted() {
94 return initLevel >= SYSTEM_BOOTED;
95 }
96
97 /**
98 * Set shutdown state. Shutdown completes when all registered shutdown
99 * hooks have been run.
100 *
101 * @see java.lang.Shutdown
102 */
103 public static void shutdown() {
104 initLevel(SYSTEM_SHUTDOWN);
105 }
106
107 /**
108 * Returns {@code true} if the VM has been shutdown
109 */
110 public static boolean isShutdown() {
111 return initLevel == SYSTEM_SHUTDOWN;
112 }
113
114 // A user-settable upper limit on the maximum amount of allocatable direct
115 // buffer memory. This value may be changed during VM initialization if
116 // "java" is launched with "-XX:MaxDirectMemorySize=<size>".
117 //
118 // The initial value of this field is arbitrary; during JRE initialization
119 // it will be reset to the value specified on the command line, if any,
120 // otherwise to Runtime.getRuntime().maxMemory().
121 //
122 private static long directMemory = 64 * 1024 * 1024;
123
124 // Returns the maximum amount of allocatable direct buffer memory.
125 // The directMemory variable is initialized during system initialization
126 // in the saveAndRemoveProperties method.
127 //
128 public static long maxDirectMemory() {
129 return directMemory;
130 }
131
132 // User-controllable flag that determines if direct buffers should be page
133 // aligned. The "-XX:+PageAlignDirectMemory" option can be used to force
134 // buffers, allocated by ByteBuffer.allocateDirect, to be page aligned.
135 private static boolean pageAlignDirectMemory;
136
137 // Returns {@code true} if the direct buffers should be page aligned. This
138 // variable is initialized by saveAndRemoveProperties.
139 public static boolean isDirectMemoryPageAligned() {
140 return pageAlignDirectMemory;
141 }
142
143 /**
144 * Returns true if the given class loader is the bootstrap class loader
145 * or the platform class loader.
146 */
147 public static boolean isSystemDomainLoader(ClassLoader loader) {
148 return loader == null || loader == ClassLoader.getPlatformClassLoader();
149 }
150
151 /**
152 * Returns the system property of the specified key saved at
153 * system initialization time. This method should only be used
154 * for the system properties that are not changed during runtime.
155 *
156 * Note that the saved system properties do not include
157 * the ones set by java.lang.VersionProps.init().
158 */
159 public static String getSavedProperty(String key) {
160 if (savedProps == null)
161 throw new IllegalStateException("Not yet initialized");
162
163 return savedProps.get(key);
164 }
165
166 /**
167 * Gets an unmodifiable view of the system properties saved at system
168 * initialization time. This method should only be used
169 * for the system properties that are not changed during runtime.
170 *
171 * Note that the saved system properties do not include
172 * the ones set by java.lang.VersionProps.init().
173 */
174 public static Map<String, String> getSavedProperties() {
175 if (savedProps == null)
176 throw new IllegalStateException("Not yet initialized");
177
178 return savedProps;
179 }
180
181 private static Map<String, String> savedProps;
182
183 // Save a private copy of the system properties and remove
184 // the system properties that are not intended for public access.
185 //
186 // This method can only be invoked during system initialization.
187 public static void saveAndRemoveProperties(Properties props) {
188 if (initLevel() != 0)
189 throw new IllegalStateException("Wrong init level");
190
191 @SuppressWarnings({"rawtypes", "unchecked"})
192 Map<String, String> sp =
193 Map.ofEntries(props.entrySet().toArray(new Map.Entry[0]));
194 // only main thread is running at this time, so savedProps and
195 // its content will be correctly published to threads started later
196 savedProps = sp;
197
198 // Set the maximum amount of direct memory. This value is controlled
199 // by the vm option -XX:MaxDirectMemorySize=<size>.
200 // The maximum amount of allocatable direct buffer memory (in bytes)
201 // from the system property sun.nio.MaxDirectMemorySize set by the VM.
202 // The system property will be removed.
203 String s = (String)props.remove("sun.nio.MaxDirectMemorySize");
204 if (s != null) {
205 if (s.equals("-1")) {
206 // -XX:MaxDirectMemorySize not given, take default
207 directMemory = Runtime.getRuntime().maxMemory();
208 } else {
209 long l = Long.parseLong(s);
210 if (l > -1)
211 directMemory = l;
212 }
213 }
214
215 // Check if direct buffers should be page aligned
216 s = (String)props.remove("sun.nio.PageAlignDirectMemory");
217 if ("true".equals(s))
218 pageAlignDirectMemory = true;
219
220 // Remove other private system properties
221 // used by java.lang.Integer.IntegerCache
222 props.remove("java.lang.Integer.IntegerCache.high");
223
224 // used by sun.launcher.LauncherHelper
225 props.remove("sun.java.launcher.diag");
226
227 // used by jdk.internal.loader.ClassLoaders
228 props.remove("jdk.boot.class.path.append");
229 }
230
231 // Initialize any miscellaneous operating system settings that need to be
232 // set for the class libraries.
233 //
234 public static void initializeOSEnvironment() {
235 if (initLevel() == 0) {
236 OSEnvironment.initialize();
237 }
238 }
239
240 /* Current count of objects pending for finalization */
241 private static volatile int finalRefCount;
242
243 /* Peak count of objects pending for finalization */
244 private static volatile int peakFinalRefCount;
245
246 /*
247 * Gets the number of objects pending for finalization.
248 *
249 * @return the number of objects pending for finalization.
250 */
251 public static int getFinalRefCount() {
252 return finalRefCount;
253 }
254
255 /*
256 * Gets the peak number of objects pending for finalization.
257 *
258 * @return the peak number of objects pending for finalization.
259 */
260 public static int getPeakFinalRefCount() {
261 return peakFinalRefCount;
262 }
263
264 /*
265 * Add {@code n} to the objects pending for finalization count.
266 *
267 * @param n an integer value to be added to the objects pending
268 * for finalization count
269 */
270 public static void addFinalRefCount(int n) {
271 // The caller must hold lock to synchronize the update.
272
273 finalRefCount += n;
274 if (finalRefCount > peakFinalRefCount) {
275 peakFinalRefCount = finalRefCount;
276 }
277 }
278
279 /**
280 * Returns Thread.State for the given threadStatus
281 */
282 public static Thread.State toThreadState(int threadStatus) {
283 if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
284 return RUNNABLE;
285 } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
286 return BLOCKED;
287 } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
288 return WAITING;
289 } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
290 return TIMED_WAITING;
291 } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
292 return TERMINATED;
293 } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
294 return NEW;
295 } else {
296 return RUNNABLE;
297 }
298 }
299
300 /* The threadStatus field is set by the VM at state transition
301 * in the hotspot implementation. Its value is set according to
302 * the JVM TI specification GetThreadState function.
303 */
304 private static final int JVMTI_THREAD_STATE_ALIVE = 0x0001;
305 private static final int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
306 private static final int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
307 private static final int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
308 private static final int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
309 private static final int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
310
311 /*
312 * Returns the first user-defined class loader up the execution stack,
313 * or the platform class loader if only code from the platform or
314 * bootstrap class loader is on the stack.
315 */
316 public static ClassLoader latestUserDefinedLoader() {
317 ClassLoader loader = latestUserDefinedLoader0();
318 return loader != null ? loader : ClassLoader.getPlatformClassLoader();
319 }
320
321 /*
322 * Returns the first user-defined class loader up the execution stack,
323 * or null if only code from the platform or bootstrap class loader is
324 * on the stack. VM does not keep a reference of platform loader and so
325 * it returns null.
326 *
327 * This method should be replaced with StackWalker::walk and then we can
328 * remove the logic in the VM.
329 */
330 private static native ClassLoader latestUserDefinedLoader0();
331
332 /**
333 * Returns {@code true} if we are in a set UID program.
334 */
335 public static boolean isSetUID() {
336 long uid = getuid();
337 long euid = geteuid();
338 long gid = getgid();
339 long egid = getegid();
340 return uid != euid || gid != egid;
341 }
342
343 /**
344 * Returns the real user ID of the calling process,
345 * or -1 if the value is not available.
346 */
347 public static native long getuid();
348
349 /**
350 * Returns the effective user ID of the calling process,
351 * or -1 if the value is not available.
352 */
353 public static native long geteuid();
354
355 /**
356 * Returns the real group ID of the calling process,
357 * or -1 if the value is not available.
358 */
359 public static native long getgid();
360
361 /**
362 * Returns the effective group ID of the calling process,
363 * or -1 if the value is not available.
364 */
365 public static native long getegid();
366
367 /**
368 * Get a nanosecond time stamp adjustment in the form of a single long.
369 *
370 * This value can be used to create an instant using
371 * {@link java.time.Instant#ofEpochSecond(long, long)
372 * java.time.Instant.ofEpochSecond(offsetInSeconds,
373 * getNanoTimeAdjustment(offsetInSeconds))}.
374 * <p>
375 * The value returned has the best resolution available to the JVM on
376 * the current system.
377 * This is usually down to microseconds - or tenth of microseconds -
378 * depending on the OS/Hardware and the JVM implementation.
379 *
380 * @param offsetInSeconds The offset in seconds from which the nanosecond
381 * time stamp should be computed.
382 *
383 * @apiNote The offset should be recent enough - so that
384 * {@code offsetInSeconds} is within {@code +/- 2^32} seconds of the
385 * current UTC time. If the offset is too far off, {@code -1} will be
386 * returned. As such, {@code -1} must not be considered as a valid
387 * nano time adjustment, but as an exception value indicating
388 * that an offset closer to the current time should be used.
389 *
390 * @return A nanosecond time stamp adjustment in the form of a single long.
391 * If the offset is too far off the current time, this method returns -1.
392 * In that case, the caller should call this method again, passing a
393 * more accurate offset.
394 */
395 public static native long getNanoTimeAdjustment(long offsetInSeconds);
396
397 /**
398 * Returns the VM arguments for this runtime environment.
399 *
400 * @implNote
401 * The HotSpot JVM processes the input arguments from multiple sources
402 * in the following order:
403 * 1. JAVA_TOOL_OPTIONS environment variable
404 * 2. Options from JNI Invocation API
405 * 3. _JAVA_OPTIONS environment variable
406 *
407 * If VM options file is specified via -XX:VMOptionsFile, the vm options
408 * file is read and expanded in place of -XX:VMOptionFile option.
409 */
410 public static native String[] getRuntimeArguments();
411
412 static {
413 initialize();
414 }
415 private static native void initialize();
416 }