Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/os.hpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | c636758ea616 |
| children | 06ae47d9d088 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7433
diff
changeset
|
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_OS_HPP |
| 26 #define SHARE_VM_RUNTIME_OS_HPP | |
| 27 | |
| 28 #include "jvmtifiles/jvmti.h" | |
| 29 #include "runtime/atomic.hpp" | |
| 30 #include "runtime/extendedPC.hpp" | |
| 31 #include "runtime/handles.hpp" | |
| 32 #include "utilities/top.hpp" | |
| 33 #ifdef TARGET_OS_FAMILY_linux | |
| 34 # include "jvm_linux.h" | |
| 11151 | 35 # include <setjmp.h> |
| 1972 | 36 #endif |
| 37 #ifdef TARGET_OS_FAMILY_solaris | |
| 38 # include "jvm_solaris.h" | |
| 11151 | 39 # include <setjmp.h> |
| 1972 | 40 #endif |
| 41 #ifdef TARGET_OS_FAMILY_windows | |
| 42 # include "jvm_windows.h" | |
| 43 #endif | |
| 3960 | 44 #ifdef TARGET_OS_FAMILY_bsd |
| 45 # include "jvm_bsd.h" | |
| 11151 | 46 # include <setjmp.h> |
| 3960 | 47 #endif |
| 1972 | 48 |
|
12117
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
49 class AgentLibrary; |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
50 |
| 0 | 51 // os defines the interface to operating system; this includes traditional |
| 52 // OS services (time, I/O) as well as other functionality with system- | |
| 53 // dependent code. | |
| 54 | |
| 55 typedef void (*dll_func)(...); | |
| 56 | |
| 57 class Thread; | |
| 58 class JavaThread; | |
| 59 class Event; | |
| 60 class DLL; | |
| 61 class FileHandle; | |
| 141 | 62 template<class E> class GrowableArray; |
| 0 | 63 |
| 64 // %%%%% Moved ThreadState, START_FN, OSThread to new osThread.hpp. -- Rose | |
| 65 | |
| 66 // Platform-independent error return values from OS functions | |
| 67 enum OSReturn { | |
| 68 OS_OK = 0, // Operation was successful | |
| 69 OS_ERR = -1, // Operation failed | |
| 70 OS_INTRPT = -2, // Operation was interrupted | |
| 71 OS_TIMEOUT = -3, // Operation timed out | |
| 72 OS_NOMEM = -5, // Operation failed for lack of memory | |
| 73 OS_NORESOURCE = -6 // Operation failed for lack of nonmemory resource | |
| 74 }; | |
| 75 | |
| 76 enum ThreadPriority { // JLS 20.20.1-3 | |
| 77 NoPriority = -1, // Initial non-priority value | |
| 78 MinPriority = 1, // Minimum priority | |
| 79 NormPriority = 5, // Normal (non-daemon) priority | |
| 80 NearMaxPriority = 9, // High priority, used for VMThread | |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4755
diff
changeset
|
81 MaxPriority = 10, // Highest priority, used for WatcherThread |
| 0 | 82 // ensures that VMThread doesn't starve profiler |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4755
diff
changeset
|
83 CriticalPriority = 11 // Critical thread priority |
| 0 | 84 }; |
| 85 | |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
86 // Executable parameter flag for os::commit_memory() and |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
87 // os::commit_memory_or_exit(). |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
88 const bool ExecMem = true; |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
89 |
| 0 | 90 // Typedef for structured exception handling support |
| 91 typedef void (*java_call_t)(JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread); | |
| 92 | |
| 93 class os: AllStatic { | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
94 public: |
| 0 | 95 enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel) |
| 96 | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
97 private: |
| 0 | 98 static OSThread* _starting_thread; |
| 99 static address _polling_page; | |
| 100 static volatile int32_t * _mem_serialize_page; | |
| 101 static uintptr_t _serialize_page_mask; | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
102 public: |
| 0 | 103 static size_t _page_sizes[page_sizes_max]; |
| 104 | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
105 private: |
| 0 | 106 static void init_page_sizes(size_t default_page_size) { |
| 107 _page_sizes[0] = default_page_size; | |
| 108 _page_sizes[1] = 0; // sentinel | |
| 109 } | |
| 110 | |
| 6197 | 111 static char* pd_reserve_memory(size_t bytes, char* addr = 0, |
| 112 size_t alignment_hint = 0); | |
| 113 static char* pd_attempt_reserve_memory_at(size_t bytes, char* addr); | |
| 114 static void pd_split_reserved_memory(char *base, size_t size, | |
| 115 size_t split, bool realloc); | |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
116 static bool pd_commit_memory(char* addr, size_t bytes, bool executable); |
| 6197 | 117 static bool pd_commit_memory(char* addr, size_t size, size_t alignment_hint, |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
118 bool executable); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
119 // Same as pd_commit_memory() that either succeeds or calls |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
120 // vm_exit_out_of_memory() with the specified mesg. |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
121 static void pd_commit_memory_or_exit(char* addr, size_t bytes, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
122 bool executable, const char* mesg); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
123 static void pd_commit_memory_or_exit(char* addr, size_t size, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
124 size_t alignment_hint, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
125 bool executable, const char* mesg); |
| 6197 | 126 static bool pd_uncommit_memory(char* addr, size_t bytes); |
| 127 static bool pd_release_memory(char* addr, size_t bytes); | |
| 128 | |
| 129 static char* pd_map_memory(int fd, const char* file_name, size_t file_offset, | |
| 130 char *addr, size_t bytes, bool read_only = false, | |
| 131 bool allow_exec = false); | |
| 132 static char* pd_remap_memory(int fd, const char* file_name, size_t file_offset, | |
| 133 char *addr, size_t bytes, bool read_only, | |
| 134 bool allow_exec); | |
| 135 static bool pd_unmap_memory(char *addr, size_t bytes); | |
| 136 static void pd_free_memory(char *addr, size_t bytes, size_t alignment_hint); | |
| 137 static void pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint); | |
| 138 | |
| 139 | |
| 0 | 140 public: |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
141 static void init(void); // Called before command line parsing |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
142 static void init_before_ergo(void); // Called after command line parsing |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
143 // before VM ergonomics processing. |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
144 static jint init_2(void); // Called after command line parsing |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
145 // and VM ergonomics processing |
|
4749
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
146 static void init_globals(void) { // Called from init_globals() in init.cpp |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
147 init_globals_ext(); |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
148 } |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
149 static void init_3(void); // Called at the end of vm init |
| 0 | 150 |
| 151 // File names are case-insensitive on windows only | |
| 152 // Override me as needed | |
| 153 static int file_name_strcmp(const char* s1, const char* s2); | |
| 154 | |
| 155 static bool getenv(const char* name, char* buffer, int len); | |
| 156 static bool have_special_privileges(); | |
| 157 | |
| 158 static jlong javaTimeMillis(); | |
| 159 static jlong javaTimeNanos(); | |
| 160 static void javaTimeNanos_info(jvmtiTimerInfo *info_ptr); | |
| 161 static void run_periodic_checks(); | |
| 162 | |
| 163 | |
| 164 // Returns the elapsed time in seconds since the vm started. | |
| 165 static double elapsedTime(); | |
| 166 | |
| 167 // Returns real time in seconds since an arbitrary point | |
| 168 // in the past. | |
| 169 static bool getTimesSecs(double* process_real_time, | |
| 170 double* process_user_time, | |
| 171 double* process_system_time); | |
| 172 | |
| 173 // Interface to the performance counter | |
| 174 static jlong elapsed_counter(); | |
| 175 static jlong elapsed_frequency(); | |
| 176 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
177 // The "virtual time" of a thread is the amount of time a thread has |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
178 // actually run. The first function indicates whether the OS supports |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
179 // this functionality for the current thread, and if so: |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
180 // * the second enables vtime tracking (if that is required). |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
181 // * the third tells whether vtime is enabled. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
182 // * the fourth returns the elapsed virtual time for the current |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
183 // thread. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
184 static bool supports_vtime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
185 static bool enable_vtime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
186 static bool vtime_enabled(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
187 static double elapsedVTime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
188 |
| 0 | 189 // Return current local time in a string (YYYY-MM-DD HH:MM:SS). |
| 190 // It is MT safe, but not async-safe, as reading time zone | |
| 191 // information may require a lock on some platforms. | |
|
548
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
192 static char* local_time_string(char *buf, size_t buflen); |
|
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
193 static struct tm* localtime_pd (const time_t* clock, struct tm* res); |
| 0 | 194 // Fill in buffer with current local time as an ISO-8601 string. |
| 195 // E.g., YYYY-MM-DDThh:mm:ss.mmm+zzzz. | |
| 196 // Returns buffer, or NULL if it failed. | |
| 197 static char* iso8601_time(char* buffer, size_t buffer_length); | |
| 198 | |
| 199 // Interface for detecting multiprocessor system | |
| 200 static inline bool is_MP() { | |
| 201 assert(_processor_count > 0, "invalid processor count"); | |
|
8845
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
7623
diff
changeset
|
202 return _processor_count > 1 || AssumeMP; |
| 0 | 203 } |
| 204 static julong available_memory(); | |
| 205 static julong physical_memory(); | |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
7623
diff
changeset
|
206 static bool has_allocatable_memory_limit(julong* limit); |
| 0 | 207 static bool is_server_class_machine(); |
| 208 | |
| 209 // number of CPUs | |
| 210 static int processor_count() { | |
| 211 return _processor_count; | |
| 212 } | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
213 static void set_processor_count(int count) { _processor_count = count; } |
| 0 | 214 |
| 215 // Returns the number of CPUs this process is currently allowed to run on. | |
| 216 // Note that on some OSes this can change dynamically. | |
| 217 static int active_processor_count(); | |
| 218 | |
| 219 // Bind processes to processors. | |
| 220 // This is a two step procedure: | |
| 221 // first you generate a distribution of processes to processors, | |
| 222 // then you bind processes according to that distribution. | |
| 223 // Compute a distribution for number of processes to processors. | |
| 224 // Stores the processor id's into the distribution array argument. | |
| 225 // Returns true if it worked, false if it didn't. | |
| 226 static bool distribute_processes(uint length, uint* distribution); | |
| 227 // Binds the current process to a processor. | |
| 228 // Returns true if it worked, false if it didn't. | |
| 229 static bool bind_to_processor(uint processor_id); | |
| 230 | |
| 4006 | 231 // Give a name to the current thread. |
| 232 static void set_native_thread_name(const char *name); | |
| 233 | |
| 0 | 234 // Interface for stack banging (predetect possible stack overflow for |
| 235 // exception processing) There are guard pages, and above that shadow | |
| 236 // pages for stack overflow checking. | |
| 237 static bool uses_stack_guard_pages(); | |
| 238 static bool allocate_stack_guard_pages(); | |
| 239 static void bang_stack_shadow_pages(); | |
| 240 static bool stack_shadow_pages_available(Thread *thread, methodHandle method); | |
| 241 | |
| 242 // OS interface to Virtual Memory | |
| 243 | |
| 244 // Return the default page size. | |
| 245 static int vm_page_size(); | |
| 246 | |
| 247 // Return the page size to use for a region of memory. The min_pages argument | |
| 248 // is a hint intended to limit fragmentation; it says the returned page size | |
| 249 // should be <= region_max_size / min_pages. Because min_pages is a hint, | |
| 250 // this routine may return a size larger than region_max_size / min_pages. | |
| 251 // | |
| 252 // The current implementation ignores min_pages if a larger page size is an | |
| 253 // exact multiple of both region_min_size and region_max_size. This allows | |
| 254 // larger pages to be used when doing so would not cause fragmentation; in | |
| 255 // particular, a single page can be used when region_min_size == | |
| 256 // region_max_size == a supported page size. | |
| 257 static size_t page_size_for_region(size_t region_min_size, | |
| 258 size_t region_max_size, | |
| 259 uint min_pages); | |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
260 // Return the largest page size that can be used |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
261 static size_t max_page_size() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
262 // The _page_sizes array is sorted in descending order. |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
263 return _page_sizes[0]; |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12147
diff
changeset
|
264 } |
| 0 | 265 |
| 3859 | 266 // Methods for tracing page sizes returned by the above method; enabled by |
| 0 | 267 // TracePageSizes. The region_{min,max}_size parameters should be the values |
| 268 // passed to page_size_for_region() and page_size should be the result of that | |
| 269 // call. The (optional) base and size parameters should come from the | |
| 270 // ReservedSpace base() and size() methods. | |
| 3859 | 271 static void trace_page_sizes(const char* str, const size_t* page_sizes, |
| 272 int count) PRODUCT_RETURN; | |
| 0 | 273 static void trace_page_sizes(const char* str, const size_t region_min_size, |
| 274 const size_t region_max_size, | |
| 275 const size_t page_size, | |
| 276 const char* base = NULL, | |
| 277 const size_t size = 0) PRODUCT_RETURN; | |
| 278 | |
| 279 static int vm_allocation_granularity(); | |
| 280 static char* reserve_memory(size_t bytes, char* addr = 0, | |
| 281 size_t alignment_hint = 0); | |
|
10221
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
10195
diff
changeset
|
282 static char* reserve_memory(size_t bytes, char* addr, |
|
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
10195
diff
changeset
|
283 size_t alignment_hint, MEMFLAGS flags); |
|
7433
730cc4ddd550
7173959: Jvm crashed during coherence exabus (tmb) testing
brutisso
parents:
6966
diff
changeset
|
284 static char* reserve_memory_aligned(size_t size, size_t alignment); |
| 0 | 285 static char* attempt_reserve_memory_at(size_t bytes, char* addr); |
| 286 static void split_reserved_memory(char *base, size_t size, | |
| 287 size_t split, bool realloc); | |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
288 static bool commit_memory(char* addr, size_t bytes, bool executable); |
| 656 | 289 static bool commit_memory(char* addr, size_t size, size_t alignment_hint, |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
290 bool executable); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
291 // Same as commit_memory() that either succeeds or calls |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
292 // vm_exit_out_of_memory() with the specified mesg. |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
293 static void commit_memory_or_exit(char* addr, size_t bytes, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
294 bool executable, const char* mesg); |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
295 static void commit_memory_or_exit(char* addr, size_t size, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
296 size_t alignment_hint, |
|
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10405
diff
changeset
|
297 bool executable, const char* mesg); |
| 0 | 298 static bool uncommit_memory(char* addr, size_t bytes); |
| 299 static bool release_memory(char* addr, size_t bytes); | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
300 |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
301 enum ProtType { MEM_PROT_NONE, MEM_PROT_READ, MEM_PROT_RW, MEM_PROT_RWX }; |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
302 static bool protect_memory(char* addr, size_t bytes, ProtType prot, |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
356
diff
changeset
|
303 bool is_committed = true); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
304 |
| 0 | 305 static bool guard_memory(char* addr, size_t bytes); |
| 306 static bool unguard_memory(char* addr, size_t bytes); | |
|
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
307 static bool create_stack_guard_pages(char* addr, size_t bytes); |
| 6197 | 308 static bool pd_create_stack_guard_pages(char* addr, size_t bytes); |
|
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
309 static bool remove_stack_guard_pages(char* addr, size_t bytes); |
|
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
310 |
| 0 | 311 static char* map_memory(int fd, const char* file_name, size_t file_offset, |
| 312 char *addr, size_t bytes, bool read_only = false, | |
| 313 bool allow_exec = false); | |
| 314 static char* remap_memory(int fd, const char* file_name, size_t file_offset, | |
| 315 char *addr, size_t bytes, bool read_only, | |
| 316 bool allow_exec); | |
| 317 static bool unmap_memory(char *addr, size_t bytes); | |
|
4734
20bfb6d15a94
7124829: NUMA: memory leak on Linux with large pages
iveresov
parents:
4717
diff
changeset
|
318 static void free_memory(char *addr, size_t bytes, size_t alignment_hint); |
| 0 | 319 static void realign_memory(char *addr, size_t bytes, size_t alignment_hint); |
| 320 | |
| 321 // NUMA-specific interface | |
| 141 | 322 static bool numa_has_static_binding(); |
| 323 static bool numa_has_group_homing(); | |
| 324 static void numa_make_local(char *addr, size_t bytes, int lgrp_hint); | |
| 0 | 325 static void numa_make_global(char *addr, size_t bytes); |
| 326 static size_t numa_get_groups_num(); | |
| 327 static size_t numa_get_leaf_groups(int *ids, size_t size); | |
| 328 static bool numa_topology_changed(); | |
| 329 static int numa_get_group_id(); | |
| 330 | |
| 331 // Page manipulation | |
| 332 struct page_info { | |
| 333 size_t size; | |
| 334 int lgrp_id; | |
| 335 }; | |
| 336 static bool get_page_info(char *start, page_info* info); | |
| 337 static char* scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found); | |
| 338 | |
| 339 static char* non_memory_address_word(); | |
| 340 // reserve, commit and pin the entire memory region | |
|
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
11153
diff
changeset
|
341 static char* reserve_memory_special(size_t size, size_t alignment, |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
11153
diff
changeset
|
342 char* addr, bool executable); |
| 0 | 343 static bool release_memory_special(char* addr, size_t bytes); |
|
3318
188c9a5d6a6d
7040485: Use transparent huge page on linux by default
iveresov
parents:
2469
diff
changeset
|
344 static void large_page_init(); |
| 0 | 345 static size_t large_page_size(); |
| 346 static bool can_commit_large_page_memory(); | |
|
79
82db0859acbe
6642862: Code cache allocation fails with large pages after 6588638
jcoomes
parents:
61
diff
changeset
|
347 static bool can_execute_large_page_memory(); |
| 0 | 348 |
| 349 // OS interface to polling page | |
| 350 static address get_polling_page() { return _polling_page; } | |
| 351 static void set_polling_page(address page) { _polling_page = page; } | |
| 352 static bool is_poll_address(address addr) { return addr >= _polling_page && addr < (_polling_page + os::vm_page_size()); } | |
| 353 static void make_polling_page_unreadable(); | |
| 354 static void make_polling_page_readable(); | |
| 355 | |
| 356 // Routines used to serialize the thread state without using membars | |
| 357 static void serialize_thread_states(); | |
| 358 | |
| 359 // Since we write to the serialize page from every thread, we | |
| 360 // want stores to be on unique cache lines whenever possible | |
| 361 // in order to minimize CPU cross talk. We pre-compute the | |
| 362 // amount to shift the thread* to make this offset unique to | |
| 363 // each thread. | |
| 364 static int get_serialize_page_shift_count() { | |
| 365 return SerializePageShiftCount; | |
| 366 } | |
| 367 | |
| 368 static void set_serialize_page_mask(uintptr_t mask) { | |
| 369 _serialize_page_mask = mask; | |
| 370 } | |
| 371 | |
| 372 static unsigned int get_serialize_page_mask() { | |
| 373 return _serialize_page_mask; | |
| 374 } | |
| 375 | |
| 376 static void set_memory_serialize_page(address page); | |
| 377 | |
| 378 static address get_memory_serialize_page() { | |
| 379 return (address)_mem_serialize_page; | |
| 380 } | |
| 381 | |
| 382 static inline void write_memory_serialize_page(JavaThread *thread) { | |
| 383 uintptr_t page_offset = ((uintptr_t)thread >> | |
| 384 get_serialize_page_shift_count()) & | |
| 385 get_serialize_page_mask(); | |
| 386 *(volatile int32_t *)((uintptr_t)_mem_serialize_page+page_offset) = 1; | |
| 387 } | |
| 388 | |
| 389 static bool is_memory_serialize_page(JavaThread *thread, address addr) { | |
| 390 if (UseMembar) return false; | |
| 1078 | 391 // Previously this function calculated the exact address of this |
| 392 // thread's serialize page, and checked if the faulting address | |
| 393 // was equal. However, some platforms mask off faulting addresses | |
| 394 // to the page size, so now we just check that the address is | |
| 395 // within the page. This makes the thread argument unnecessary, | |
| 396 // but we retain the NULL check to preserve existing behaviour. | |
| 0 | 397 if (thread == NULL) return false; |
| 1078 | 398 address page = (address) _mem_serialize_page; |
| 399 return addr >= page && addr < (page + os::vm_page_size()); | |
| 0 | 400 } |
| 401 | |
| 402 static void block_on_serialize_page_trap(); | |
| 403 | |
| 404 // threads | |
| 405 | |
| 406 enum ThreadType { | |
| 407 vm_thread, | |
| 408 cgc_thread, // Concurrent GC thread | |
| 409 pgc_thread, // Parallel GC thread | |
| 410 java_thread, | |
| 411 compiler_thread, | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
412 watcher_thread, |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
413 os_thread |
| 0 | 414 }; |
| 415 | |
| 416 static bool create_thread(Thread* thread, | |
| 417 ThreadType thr_type, | |
| 418 size_t stack_size = 0); | |
| 419 static bool create_main_thread(JavaThread* thread); | |
| 420 static bool create_attached_thread(JavaThread* thread); | |
| 421 static void pd_start_thread(Thread* thread); | |
| 422 static void start_thread(Thread* thread); | |
| 423 | |
|
6768
716e6ef4482a
7190089: NMT ON: NMT failed assertion on thread's stack base address
zgu
parents:
6200
diff
changeset
|
424 static void initialize_thread(Thread* thr); |
| 0 | 425 static void free_thread(OSThread* osthread); |
| 426 | |
| 427 // thread id on Linux/64bit is 64bit, on Windows and Solaris, it's 32bit | |
| 428 static intx current_thread_id(); | |
| 429 static int current_process_id(); | |
| 430 static int sleep(Thread* thread, jlong ms, bool interruptable); | |
| 431 static int naked_sleep(); | |
| 432 static void infinite_sleep(); // never returns, use with CAUTION | |
| 433 static void yield(); // Yields to all threads with same priority | |
| 434 enum YieldResult { | |
| 435 YIELD_SWITCHED = 1, // caller descheduled, other ready threads exist & ran | |
| 436 YIELD_NONEREADY = 0, // No other runnable/ready threads. | |
| 437 // platform-specific yield return immediately | |
| 438 YIELD_UNKNOWN = -1 // Unknown: platform doesn't support _SWITCHED or _NONEREADY | |
| 439 // YIELD_SWITCHED and YIELD_NONREADY imply the platform supports a "strong" | |
| 440 // yield that can be used in lieu of blocking. | |
| 441 } ; | |
| 442 static YieldResult NakedYield () ; | |
| 443 static void yield_all(int attempts = 0); // Yields to all other threads including lower priority | |
| 444 static void loop_breaker(int attempts); // called from within tight loops to possibly influence time-sharing | |
| 445 static OSReturn set_priority(Thread* thread, ThreadPriority priority); | |
| 446 static OSReturn get_priority(const Thread* const thread, ThreadPriority& priority); | |
| 447 | |
| 448 static void interrupt(Thread* thread); | |
| 449 static bool is_interrupted(Thread* thread, bool clear_interrupted); | |
| 450 | |
| 451 static int pd_self_suspend_thread(Thread* thread); | |
| 452 | |
| 453 static ExtendedPC fetch_frame_from_context(void* ucVoid, intptr_t** sp, intptr_t** fp); | |
| 454 static frame fetch_frame_from_context(void* ucVoid); | |
| 455 | |
| 456 static ExtendedPC get_thread_pc(Thread *thread); | |
| 457 static void breakpoint(); | |
| 458 | |
| 459 static address current_stack_pointer(); | |
| 460 static address current_stack_base(); | |
| 461 static size_t current_stack_size(); | |
| 462 | |
|
5903
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
4854
diff
changeset
|
463 static void verify_stack_alignment() PRODUCT_RETURN; |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
4854
diff
changeset
|
464 |
| 0 | 465 static int message_box(const char* title, const char* message); |
| 466 static char* do_you_want_to_debug(const char* message); | |
| 467 | |
| 468 // run cmd in a separate process and return its exit code; or -1 on failures | |
| 469 static int fork_and_exec(char *cmd); | |
| 470 | |
| 471 // Set file to send error reports. | |
| 472 static void set_error_file(const char *logfile); | |
| 473 | |
| 474 // os::exit() is merged with vm_exit() | |
| 475 // static void exit(int num); | |
| 476 | |
| 477 // Terminate the VM, but don't exit the process | |
| 478 static void shutdown(); | |
| 479 | |
| 480 // Terminate with an error. Default is to generate a core file on platforms | |
| 481 // that support such things. This calls shutdown() and then aborts. | |
| 482 static void abort(bool dump_core = true); | |
| 483 | |
| 484 // Die immediately, no exit hook, no abort hook, no cleanup. | |
| 485 static void die(); | |
| 486 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
487 // File i/o operations |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
488 static const int default_file_open_flags(); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
489 static int open(const char *path, int oflag, int mode); |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
8859
diff
changeset
|
490 static FILE* open(int fd, const char* mode); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
491 static int close(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
492 static jlong lseek(int fd, jlong offset, int whence); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
493 static char* native_path(char *path); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
494 static int ftruncate(int fd, jlong length); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
495 static int fsync(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
496 static int available(int fd, jlong *bytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
497 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
498 //File i/o operations |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
499 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
500 static size_t read(int fd, void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
501 static size_t restartable_read(int fd, void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
502 static size_t write(int fd, const void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
503 |
| 0 | 504 // Reading directories. |
| 505 static DIR* opendir(const char* dirname); | |
| 506 static int readdir_buf_size(const char *path); | |
| 507 static struct dirent* readdir(DIR* dirp, dirent* dbuf); | |
| 508 static int closedir(DIR* dirp); | |
| 509 | |
| 510 // Dynamic library extension | |
| 511 static const char* dll_file_extension(); | |
| 512 | |
| 513 static const char* get_temp_directory(); | |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
8859
diff
changeset
|
514 static const char* get_current_directory(char *buf, size_t buflen); |
| 0 | 515 |
| 242 | 516 // Builds a platform-specific full library path given a ld path and lib name |
|
6966
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6768
diff
changeset
|
517 // Returns true if buffer contains full path to existing file, false otherwise |
|
6cb0d32b828b
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
6768
diff
changeset
|
518 static bool dll_build_name(char* buffer, size_t size, |
| 242 | 519 const char* pathname, const char* fname); |
| 520 | |
| 0 | 521 // Symbol lookup, find nearest function name; basically it implements |
| 522 // dladdr() for all platforms. Name of the nearest function is copied | |
|
11092
59b052799158
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
10969
diff
changeset
|
523 // to buf. Distance from its base address is optionally returned as offset. |
| 0 | 524 // If function name is not found, buf[0] is set to '\0' and offset is |
|
11092
59b052799158
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
10969
diff
changeset
|
525 // set to -1 (if offset is non-NULL). |
| 0 | 526 static bool dll_address_to_function_name(address addr, char* buf, |
| 527 int buflen, int* offset); | |
| 528 | |
| 529 // Locate DLL/DSO. On success, full path of the library is copied to | |
|
11092
59b052799158
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
10969
diff
changeset
|
530 // buf, and offset is optionally set to be the distance between addr |
|
59b052799158
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
10969
diff
changeset
|
531 // and the library's base address. On failure, buf[0] is set to '\0' |
|
59b052799158
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
10969
diff
changeset
|
532 // and offset is set to -1 (if offset is non-NULL). |
| 0 | 533 static bool dll_address_to_library_name(address addr, char* buf, |
| 534 int buflen, int* offset); | |
| 535 | |
| 536 // Find out whether the pc is in the static code for jvm.dll/libjvm.so. | |
| 537 static bool address_is_in_vm(address addr); | |
| 538 | |
| 539 // Loads .dll/.so and | |
| 540 // in case of error it checks if .dll/.so was built for the | |
| 541 // same architecture as Hotspot is running on | |
| 542 static void* dll_load(const char *name, char *ebuf, int ebuflen); | |
| 543 | |
| 242 | 544 // lookup symbol in a shared library |
| 545 static void* dll_lookup(void* handle, const char* name); | |
| 546 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
547 // Unload library |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
548 static void dll_unload(void *lib); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
549 |
|
12117
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
550 // Return the handle of this process |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
551 static void* get_default_process_handle(); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
552 |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
553 // Check for static linked agent library |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
554 static bool find_builtin_agent(AgentLibrary *agent_lib, const char *syms[], |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
555 size_t syms_len); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
556 |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
557 // Find agent entry point |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
558 static void *find_agent_function(AgentLibrary *agent_lib, bool check_lib, |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
559 const char *syms[], size_t syms_len); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
560 |
| 0 | 561 // Print out system information; they are called by fatal error handler. |
| 562 // Output format may be different on different platforms. | |
| 563 static void print_os_info(outputStream* st); | |
|
6080
7432b9db36ff
7165755: OS Information much longer on linux than other platforms
nloodin
parents:
5903
diff
changeset
|
564 static void print_os_info_brief(outputStream* st); |
| 0 | 565 static void print_cpu_info(outputStream* st); |
|
3800
bf6481e5f96d
7061225: os::print_cpu_info() should support os-specific data
jcoomes
parents:
3318
diff
changeset
|
566 static void pd_print_cpu_info(outputStream* st); |
| 0 | 567 static void print_memory_info(outputStream* st); |
| 568 static void print_dll_info(outputStream* st); | |
| 569 static void print_environment_variables(outputStream* st, const char** env_list, char* buffer, int len); | |
| 570 static void print_context(outputStream* st, void* context); | |
| 1907 | 571 static void print_register_info(outputStream* st, void* context); |
| 0 | 572 static void print_siginfo(outputStream* st, void* siginfo); |
| 573 static void print_signal_handlers(outputStream* st, char* buf, size_t buflen); | |
| 574 static void print_date_and_time(outputStream* st); | |
| 575 | |
| 1907 | 576 static void print_location(outputStream* st, intptr_t x, bool verbose = false); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
577 static size_t lasterror(char *buf, size_t len); |
|
4750
b16494a69d3d
7126185: Clean up lasterror handling, add os::get_last_error()
phh
parents:
4749
diff
changeset
|
578 static int get_last_error(); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
579 |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
580 // Determines whether the calling process is being debugged by a user-mode debugger. |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
581 static bool is_debugger_attached(); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
582 |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
583 // wait for a key press if PauseAtExit is set |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
584 static void wait_for_keypress_at_exit(void); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
585 |
| 0 | 586 // The following two functions are used by fatal error handler to trace |
| 587 // native (C) frames. They are not part of frame.hpp/frame.cpp because | |
| 588 // frame.hpp/cpp assume thread is JavaThread, and also because different | |
| 589 // OS/compiler may have different convention or provide different API to | |
| 590 // walk C frames. | |
| 591 // | |
| 592 // We don't attempt to become a debugger, so we only follow frames if that | |
| 593 // does not require a lookup in the unwind table, which is part of the binary | |
| 594 // file but may be unsafe to read after a fatal error. So on x86, we can | |
| 595 // only walk stack if %ebp is used as frame pointer; on ia64, it's not | |
| 596 // possible to walk C stack without having the unwind table. | |
| 597 static bool is_first_C_frame(frame *fr); | |
| 598 static frame get_sender_for_C_frame(frame *fr); | |
| 599 | |
| 600 // return current frame. pc() and sp() are set to NULL on failure. | |
| 601 static frame current_frame(); | |
| 602 | |
| 603 static void print_hex_dump(outputStream* st, address start, address end, int unitsize); | |
| 604 | |
| 605 // returns a string to describe the exception/signal; | |
| 606 // returns NULL if exception_code is not an OS exception/signal. | |
| 607 static const char* exception_name(int exception_code, char* buf, size_t buflen); | |
| 608 | |
| 609 // Returns native Java library, loads if necessary | |
| 610 static void* native_java_library(); | |
| 611 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
612 // Fills in path to jvm.dll/libjvm.so (used by the Disassembler) |
| 0 | 613 static void jvm_path(char *buf, jint buflen); |
| 614 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
615 // Returns true if we are running in a headless jre. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
616 static bool is_headless_jre(); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
617 |
| 0 | 618 // JNI names |
| 619 static void print_jni_name_prefix_on(outputStream* st, int args_size); | |
| 620 static void print_jni_name_suffix_on(outputStream* st, int args_size); | |
| 621 | |
| 622 // File conventions | |
| 623 static const char* file_separator(); | |
| 624 static const char* line_separator(); | |
| 625 static const char* path_separator(); | |
| 626 | |
| 627 // Init os specific system properties values | |
| 628 static void init_system_properties_values(); | |
| 629 | |
| 630 // IO operations, non-JVM_ version. | |
| 631 static int stat(const char* path, struct stat* sbuf); | |
| 632 static bool dir_is_empty(const char* path); | |
| 633 | |
| 634 // IO operations on binary files | |
| 635 static int create_binary_file(const char* path, bool rewrite_existing); | |
| 636 static jlong current_file_offset(int fd); | |
| 637 static jlong seek_to_file_offset(int fd, jlong offset); | |
| 638 | |
| 639 // Thread Local Storage | |
| 640 static int allocate_thread_local_storage(); | |
| 641 static void thread_local_storage_at_put(int index, void* value); | |
| 642 static void* thread_local_storage_at(int index); | |
| 643 static void free_thread_local_storage(int index); | |
| 644 | |
| 6197 | 645 // Stack walk |
| 646 static address get_caller_pc(int n = 0); | |
| 647 | |
| 0 | 648 // General allocation (must be MT-safe) |
| 6197 | 649 static void* malloc (size_t size, MEMFLAGS flags, address caller_pc = 0); |
| 650 static void* realloc (void *memblock, size_t size, MEMFLAGS flags, address caller_pc = 0); | |
| 651 static void free (void *memblock, MEMFLAGS flags = mtNone); | |
| 0 | 652 static bool check_heap(bool force = false); // verify C heap integrity |
| 6197 | 653 static char* strdup(const char *, MEMFLAGS flags = mtInternal); // Like strdup |
| 0 | 654 |
| 655 #ifndef PRODUCT | |
| 2250 | 656 static julong num_mallocs; // # of calls to malloc/realloc |
| 657 static julong alloc_bytes; // # of bytes allocated | |
| 658 static julong num_frees; // # of calls to free | |
| 659 static julong free_bytes; // # of bytes freed | |
| 0 | 660 #endif |
| 661 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
662 // SocketInterface (ex HPI SocketInterface ) |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
663 static int socket(int domain, int type, int protocol); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
664 static int socket_close(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
665 static int socket_shutdown(int fd, int howto); |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
666 static int recv(int fd, char* buf, size_t nBytes, uint flags); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
667 static int send(int fd, char* buf, size_t nBytes, uint flags); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
668 static int raw_send(int fd, char* buf, size_t nBytes, uint flags); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
669 static int timeout(int fd, long timeout); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
670 static int listen(int fd, int count); |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
671 static int connect(int fd, struct sockaddr* him, socklen_t len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
672 static int bind(int fd, struct sockaddr* him, socklen_t len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
673 static int accept(int fd, struct sockaddr* him, socklen_t* len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
674 static int recvfrom(int fd, char* buf, size_t nbytes, uint flags, |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
675 struct sockaddr* from, socklen_t* fromlen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
676 static int get_sock_name(int fd, struct sockaddr* him, socklen_t* len); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
677 static int sendto(int fd, char* buf, size_t len, uint flags, |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
678 struct sockaddr* to, socklen_t tolen); |
|
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
679 static int socket_available(int fd, jint* pbytes); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
680 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
681 static int get_sock_opt(int fd, int level, int optname, |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
682 char* optval, socklen_t* optlen); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
683 static int set_sock_opt(int fd, int level, int optname, |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
684 const char* optval, socklen_t optlen); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
685 static int get_host_name(char* name, int namelen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
686 |
|
4717
11c26bfcf8c7
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
4006
diff
changeset
|
687 static struct hostent* get_host_by_name(char* name); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
688 |
| 0 | 689 // Support for signals (see JVM_RaiseSignal, JVM_RegisterSignal) |
| 690 static void signal_init(); | |
| 691 static void signal_init_pd(); | |
| 692 static void signal_notify(int signal_number); | |
| 693 static void* signal(int signal_number, void* handler); | |
| 694 static void signal_raise(int signal_number); | |
| 695 static int signal_wait(); | |
| 696 static int signal_lookup(); | |
| 697 static void* user_handler(); | |
| 698 static void terminate_signal_thread(); | |
| 699 static int sigexitnum_pd(); | |
| 700 | |
| 701 // random number generation | |
| 702 static long random(); // return 32bit pseudorandom number | |
| 703 static void init_random(long initval); // initialize random sequence | |
| 704 | |
| 705 // Structured OS Exception support | |
| 706 static void os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread); | |
| 707 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
708 // On Windows this will create an actual minidump, on Linux/Solaris it will simply check core dump limits |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
709 static void check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
710 |
|
6200
65906dc96aa1
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
6197
diff
changeset
|
711 // Get the default path to the core file |
|
65906dc96aa1
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
6197
diff
changeset
|
712 // Returns the length of the string |
|
65906dc96aa1
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
6197
diff
changeset
|
713 static int get_core_path(char* buffer, size_t bufferSize); |
|
65906dc96aa1
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
6197
diff
changeset
|
714 |
| 0 | 715 // JVMTI & JVM monitoring and management support |
| 716 // The thread_cpu_time() and current_thread_cpu_time() are only | |
| 717 // supported if is_thread_cpu_time_supported() returns true. | |
| 718 // They are not supported on Solaris T1. | |
| 719 | |
| 720 // Thread CPU Time - return the fast estimate on a platform | |
| 721 // On Solaris - call gethrvtime (fast) - user time only | |
| 722 // On Linux - fast clock_gettime where available - user+sys | |
| 723 // - otherwise: very slow /proc fs - user+sys | |
| 724 // On Windows - GetThreadTimes - user+sys | |
| 725 static jlong current_thread_cpu_time(); | |
| 726 static jlong thread_cpu_time(Thread* t); | |
| 727 | |
| 728 // Thread CPU Time with user_sys_cpu_time parameter. | |
| 729 // | |
| 730 // If user_sys_cpu_time is true, user+sys time is returned. | |
| 731 // Otherwise, only user time is returned | |
| 732 static jlong current_thread_cpu_time(bool user_sys_cpu_time); | |
| 733 static jlong thread_cpu_time(Thread* t, bool user_sys_cpu_time); | |
| 734 | |
| 735 // Return a bunch of info about the timers. | |
| 736 // Note that the returned info for these two functions may be different | |
| 737 // on some platforms | |
| 738 static void current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr); | |
| 739 static void thread_cpu_time_info(jvmtiTimerInfo *info_ptr); | |
| 740 | |
| 741 static bool is_thread_cpu_time_supported(); | |
| 742 | |
| 743 // System loadavg support. Returns -1 if load average cannot be obtained. | |
| 744 static int loadavg(double loadavg[], int nelem); | |
| 745 | |
| 746 // Hook for os specific jvm options that we don't want to abort on seeing | |
| 747 static bool obsolete_option(const JavaVMOption *option); | |
| 748 | |
|
4749
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
749 // Extensions |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
750 #include "runtime/os_ext.hpp" |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
751 |
|
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
752 public: |
| 11151 | 753 class CrashProtectionCallback : public StackObj { |
| 754 public: | |
| 755 virtual void call() = 0; | |
| 756 }; | |
|
4749
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
757 |
| 0 | 758 // Platform dependent stuff |
| 1972 | 759 #ifdef TARGET_OS_FAMILY_linux |
| 760 # include "os_linux.hpp" | |
|
6080
7432b9db36ff
7165755: OS Information much longer on linux than other platforms
nloodin
parents:
5903
diff
changeset
|
761 # include "os_posix.hpp" |
| 1972 | 762 #endif |
| 763 #ifdef TARGET_OS_FAMILY_solaris | |
| 764 # include "os_solaris.hpp" | |
|
6080
7432b9db36ff
7165755: OS Information much longer on linux than other platforms
nloodin
parents:
5903
diff
changeset
|
765 # include "os_posix.hpp" |
| 1972 | 766 #endif |
| 767 #ifdef TARGET_OS_FAMILY_windows | |
| 768 # include "os_windows.hpp" | |
| 769 #endif | |
| 3960 | 770 #ifdef TARGET_OS_FAMILY_bsd |
|
6080
7432b9db36ff
7165755: OS Information much longer on linux than other platforms
nloodin
parents:
5903
diff
changeset
|
771 # include "os_posix.hpp" |
| 3960 | 772 # include "os_bsd.hpp" |
| 773 #endif | |
| 1972 | 774 #ifdef TARGET_OS_ARCH_linux_x86 |
| 775 # include "os_linux_x86.hpp" | |
| 776 #endif | |
| 777 #ifdef TARGET_OS_ARCH_linux_sparc | |
| 778 # include "os_linux_sparc.hpp" | |
| 779 #endif | |
| 780 #ifdef TARGET_OS_ARCH_linux_zero | |
| 781 # include "os_linux_zero.hpp" | |
| 782 #endif | |
| 783 #ifdef TARGET_OS_ARCH_solaris_x86 | |
| 784 # include "os_solaris_x86.hpp" | |
| 785 #endif | |
| 786 #ifdef TARGET_OS_ARCH_solaris_sparc | |
| 787 # include "os_solaris_sparc.hpp" | |
| 788 #endif | |
| 789 #ifdef TARGET_OS_ARCH_windows_x86 | |
| 790 # include "os_windows_x86.hpp" | |
| 791 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
792 #ifdef TARGET_OS_ARCH_linux_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
793 # include "os_linux_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
794 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
795 #ifdef TARGET_OS_ARCH_linux_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
796 # include "os_linux_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
797 #endif |
| 3960 | 798 #ifdef TARGET_OS_ARCH_bsd_x86 |
| 799 # include "os_bsd_x86.hpp" | |
| 800 #endif | |
| 801 #ifdef TARGET_OS_ARCH_bsd_zero | |
| 802 # include "os_bsd_zero.hpp" | |
| 803 #endif | |
| 1972 | 804 |
|
4749
7ab5f6318694
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
4717
diff
changeset
|
805 public: |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
806 // debugging support (mostly used by debug.cpp but also fatal error handler) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
807 static bool find(address pc, outputStream* st = tty); // OS specific function to make sense out of an address |
| 0 | 808 |
| 809 static bool dont_yield(); // when true, JVM_Yield() is nop | |
| 810 static void print_statistics(); | |
| 811 | |
| 812 // Thread priority helpers (implemented in OS-specific part) | |
| 813 static OSReturn set_native_priority(Thread* thread, int native_prio); | |
| 814 static OSReturn get_native_priority(const Thread* const thread, int* priority_ptr); | |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4755
diff
changeset
|
815 static int java_to_os_priority[CriticalPriority + 1]; |
| 0 | 816 // Hint to the underlying OS that a task switch would not be good. |
| 817 // Void return because it's a hint and can fail. | |
| 818 static void hint_no_preempt(); | |
| 819 | |
| 820 // Used at creation if requested by the diagnostic flag PauseAtStartup. | |
| 821 // Causes the VM to wait until an external stimulus has been applied | |
| 822 // (for Unix, that stimulus is a signal, for Windows, an external | |
| 823 // ResumeThread call) | |
| 824 static void pause(); | |
| 825 | |
|
12117
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
826 // Builds a platform dependent Agent_OnLoad_<libname> function name |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
827 // which is used to find statically linked in agents. |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
828 static char* build_agent_function_name(const char *sym, const char *cname, |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
829 bool is_absolute_path); |
|
f92b82d454fa
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
11153
diff
changeset
|
830 |
| 10405 | 831 class SuspendedThreadTaskContext { |
| 832 public: | |
| 833 SuspendedThreadTaskContext(Thread* thread, void *ucontext) : _thread(thread), _ucontext(ucontext) {} | |
| 834 Thread* thread() const { return _thread; } | |
| 835 void* ucontext() const { return _ucontext; } | |
| 836 private: | |
| 837 Thread* _thread; | |
| 838 void* _ucontext; | |
| 839 }; | |
| 840 | |
| 841 class SuspendedThreadTask { | |
| 842 public: | |
| 843 SuspendedThreadTask(Thread* thread) : _thread(thread), _done(false) {} | |
| 844 virtual ~SuspendedThreadTask() {} | |
| 845 void run(); | |
| 846 bool is_done() { return _done; } | |
| 847 virtual void do_task(const SuspendedThreadTaskContext& context) = 0; | |
| 848 protected: | |
| 849 private: | |
| 850 void internal_do_task(); | |
| 851 Thread* _thread; | |
| 852 bool _done; | |
| 853 }; | |
| 854 | |
| 855 #ifndef TARGET_OS_FAMILY_windows | |
| 856 // Suspend/resume support | |
| 857 // Protocol: | |
| 858 // | |
| 859 // a thread starts in SR_RUNNING | |
| 860 // | |
| 861 // SR_RUNNING can go to | |
| 862 // * SR_SUSPEND_REQUEST when the WatcherThread wants to suspend it | |
| 863 // SR_SUSPEND_REQUEST can go to | |
| 864 // * SR_RUNNING if WatcherThread decides it waited for SR_SUSPENDED too long (timeout) | |
| 865 // * SR_SUSPENDED if the stopped thread receives the signal and switches state | |
| 866 // SR_SUSPENDED can go to | |
| 867 // * SR_WAKEUP_REQUEST when the WatcherThread has done the work and wants to resume | |
| 868 // SR_WAKEUP_REQUEST can go to | |
| 869 // * SR_RUNNING when the stopped thread receives the signal | |
| 870 // * SR_WAKEUP_REQUEST on timeout (resend the signal and try again) | |
| 871 class SuspendResume { | |
| 872 public: | |
| 873 enum State { | |
| 874 SR_RUNNING, | |
| 875 SR_SUSPEND_REQUEST, | |
| 876 SR_SUSPENDED, | |
| 877 SR_WAKEUP_REQUEST | |
| 878 }; | |
| 879 | |
| 880 private: | |
| 881 volatile State _state; | |
| 882 | |
| 883 private: | |
| 884 /* try to switch state from state "from" to state "to" | |
| 885 * returns the state set after the method is complete | |
| 886 */ | |
| 887 State switch_state(State from, State to); | |
| 888 | |
| 889 public: | |
| 890 SuspendResume() : _state(SR_RUNNING) { } | |
| 891 | |
| 892 State state() const { return _state; } | |
| 893 | |
| 894 State request_suspend() { | |
| 895 return switch_state(SR_RUNNING, SR_SUSPEND_REQUEST); | |
| 896 } | |
| 897 | |
| 898 State cancel_suspend() { | |
| 899 return switch_state(SR_SUSPEND_REQUEST, SR_RUNNING); | |
| 900 } | |
| 901 | |
| 902 State suspended() { | |
| 903 return switch_state(SR_SUSPEND_REQUEST, SR_SUSPENDED); | |
| 904 } | |
| 905 | |
| 906 State request_wakeup() { | |
| 907 return switch_state(SR_SUSPENDED, SR_WAKEUP_REQUEST); | |
| 908 } | |
| 909 | |
| 910 State running() { | |
| 911 return switch_state(SR_WAKEUP_REQUEST, SR_RUNNING); | |
| 912 } | |
| 913 | |
| 914 bool is_running() const { | |
| 915 return _state == SR_RUNNING; | |
| 916 } | |
| 917 | |
| 918 bool is_suspend_request() const { | |
| 919 return _state == SR_SUSPEND_REQUEST; | |
| 920 } | |
| 921 | |
| 922 bool is_suspended() const { | |
| 923 return _state == SR_SUSPENDED; | |
| 924 } | |
| 925 }; | |
| 926 #endif | |
| 927 | |
| 928 | |
| 0 | 929 protected: |
| 930 static long _rand_seed; // seed for random number generator | |
| 931 static int _processor_count; // number of processors | |
| 932 | |
| 933 static char* format_boot_path(const char* format_string, | |
| 934 const char* home, | |
| 935 int home_len, | |
| 936 char fileSep, | |
| 937 char pathSep); | |
| 938 static bool set_boot_path(char fileSep, char pathSep); | |
| 691 | 939 static char** split_path(const char* path, int* n); |
| 11151 | 940 |
| 0 | 941 }; |
| 942 | |
| 943 // Note that "PAUSE" is almost always used with synchronization | |
| 944 // so arguably we should provide Atomic::SpinPause() instead | |
| 945 // of the global SpinPause() with C linkage. | |
| 946 // It'd also be eligible for inlining on many platforms. | |
| 947 | |
| 11127 | 948 extern "C" int SpinPause(); |
| 1972 | 949 |
| 950 #endif // SHARE_VM_RUNTIME_OS_HPP |