author | stuefe |
Fri, 19 Oct 2018 09:39:29 +0200 | |
changeset 52302 | 912b79d983d9 |
parent 52109 | 101c2b6eacbe |
child 52460 | f1bb77833b59 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
48635
612dfa1d8aad
8130039: Move the platform-specific [OS]Semaphore code
coleenp
parents:
48153
diff
changeset
|
2 |
* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5085
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5085
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5085
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_RUNTIME_OS_HPP |
26 |
#define SHARE_VM_RUNTIME_OS_HPP |
|
27 |
||
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47572
diff
changeset
|
28 |
#include "jvm.h" |
7397 | 29 |
#include "jvmtifiles/jvmti.h" |
48955
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
30 |
#include "metaprogramming/isRegisteredEnum.hpp" |
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
31 |
#include "metaprogramming/integralConstant.hpp" |
7397 | 32 |
#include "runtime/extendedPC.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49349
diff
changeset
|
33 |
#include "utilities/exceptions.hpp" |
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49349
diff
changeset
|
34 |
#include "utilities/ostream.hpp" |
40010 | 35 |
#include "utilities/macros.hpp" |
36 |
#ifndef _WINDOWS |
|
18943 | 37 |
# include <setjmp.h> |
7397 | 38 |
#endif |
40010 | 39 |
#ifdef __APPLE__ |
40 |
# include <mach/mach_time.h> |
|
10565 | 41 |
#endif |
7397 | 42 |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
43 |
class AgentLibrary; |
46589 | 44 |
class frame; |
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
45 |
|
1 | 46 |
// os defines the interface to operating system; this includes traditional |
47 |
// OS services (time, I/O) as well as other functionality with system- |
|
48 |
// dependent code. |
|
49 |
||
50 |
typedef void (*dll_func)(...); |
|
51 |
||
52 |
class Thread; |
|
53 |
class JavaThread; |
|
54 |
class Event; |
|
55 |
class DLL; |
|
56 |
class FileHandle; |
|
25946 | 57 |
class NativeCallStack; |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49349
diff
changeset
|
58 |
class methodHandle; |
25946 | 59 |
|
388 | 60 |
template<class E> class GrowableArray; |
1 | 61 |
|
62 |
// %%%%% Moved ThreadState, START_FN, OSThread to new osThread.hpp. -- Rose |
|
63 |
||
64 |
// Platform-independent error return values from OS functions |
|
65 |
enum OSReturn { |
|
66 |
OS_OK = 0, // Operation was successful |
|
67 |
OS_ERR = -1, // Operation failed |
|
68 |
OS_INTRPT = -2, // Operation was interrupted |
|
69 |
OS_TIMEOUT = -3, // Operation timed out |
|
70 |
OS_NOMEM = -5, // Operation failed for lack of memory |
|
71 |
OS_NORESOURCE = -6 // Operation failed for lack of nonmemory resource |
|
72 |
}; |
|
73 |
||
74 |
enum ThreadPriority { // JLS 20.20.1-3 |
|
75 |
NoPriority = -1, // Initial non-priority value |
|
76 |
MinPriority = 1, // Minimum priority |
|
77 |
NormPriority = 5, // Normal (non-daemon) priority |
|
78 |
NearMaxPriority = 9, // High priority, used for VMThread |
|
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11423
diff
changeset
|
79 |
MaxPriority = 10, // Highest priority, used for WatcherThread |
1 | 80 |
// ensures that VMThread doesn't starve profiler |
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11423
diff
changeset
|
81 |
CriticalPriority = 11 // Critical thread priority |
1 | 82 |
}; |
83 |
||
18069
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
84 |
// Executable parameter flag for os::commit_memory() and |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
85 |
// os::commit_memory_or_exit(). |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
86 |
const bool ExecMem = true; |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
87 |
|
1 | 88 |
// Typedef for structured exception handling support |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
31963
diff
changeset
|
89 |
typedef void (*java_call_t)(JavaValue* value, const methodHandle& method, JavaCallArguments* args, Thread* thread); |
1 | 90 |
|
25946 | 91 |
class MallocTracker; |
92 |
||
1 | 93 |
class os: AllStatic { |
20011
d74937287461
8024760: add more types, fields and constants to VMStructs
twisti
parents:
19697
diff
changeset
|
94 |
friend class VMStructs; |
35123
b0b89d83bcf5
8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents:
34305
diff
changeset
|
95 |
friend class JVMCIVMStructs; |
25946 | 96 |
friend class MallocTracker; |
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
4448
diff
changeset
|
97 |
public: |
1 | 98 |
enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel) |
99 |
||
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
4448
diff
changeset
|
100 |
private: |
1 | 101 |
static OSThread* _starting_thread; |
102 |
static address _polling_page; |
|
103 |
static volatile int32_t * _mem_serialize_page; |
|
104 |
static uintptr_t _serialize_page_mask; |
|
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
4448
diff
changeset
|
105 |
public: |
1 | 106 |
static size_t _page_sizes[page_sizes_max]; |
107 |
||
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
4448
diff
changeset
|
108 |
private: |
1 | 109 |
static void init_page_sizes(size_t default_page_size) { |
110 |
_page_sizes[0] = default_page_size; |
|
111 |
_page_sizes[1] = 0; // sentinel |
|
112 |
} |
|
113 |
||
13195 | 114 |
static char* pd_reserve_memory(size_t bytes, char* addr = 0, |
48153
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
115 |
size_t alignment_hint = 0); |
13195 | 116 |
static char* pd_attempt_reserve_memory_at(size_t bytes, char* addr); |
48153
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
117 |
static char* pd_attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc); |
13195 | 118 |
static void pd_split_reserved_memory(char *base, size_t size, |
119 |
size_t split, bool realloc); |
|
18069
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
120 |
static bool pd_commit_memory(char* addr, size_t bytes, bool executable); |
13195 | 121 |
static bool pd_commit_memory(char* addr, size_t size, size_t alignment_hint, |
18069
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
122 |
bool executable); |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
123 |
// Same as pd_commit_memory() that either succeeds or calls |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
124 |
// vm_exit_out_of_memory() with the specified mesg. |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
125 |
static void pd_commit_memory_or_exit(char* addr, size_t bytes, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
126 |
bool executable, const char* mesg); |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
127 |
static void pd_commit_memory_or_exit(char* addr, size_t size, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
128 |
size_t alignment_hint, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
129 |
bool executable, const char* mesg); |
13195 | 130 |
static bool pd_uncommit_memory(char* addr, size_t bytes); |
131 |
static bool pd_release_memory(char* addr, size_t bytes); |
|
132 |
||
133 |
static char* pd_map_memory(int fd, const char* file_name, size_t file_offset, |
|
134 |
char *addr, size_t bytes, bool read_only = false, |
|
135 |
bool allow_exec = false); |
|
136 |
static char* pd_remap_memory(int fd, const char* file_name, size_t file_offset, |
|
137 |
char *addr, size_t bytes, bool read_only, |
|
138 |
bool allow_exec); |
|
139 |
static bool pd_unmap_memory(char *addr, size_t bytes); |
|
140 |
static void pd_free_memory(char *addr, size_t bytes, size_t alignment_hint); |
|
141 |
static void pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint); |
|
142 |
||
28631 | 143 |
static size_t page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned); |
13195 | 144 |
|
31963
641ed52732ec
8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents:
31357
diff
changeset
|
145 |
// Get summary strings for system information in buffer provided |
641ed52732ec
8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents:
31357
diff
changeset
|
146 |
static void get_summary_cpu_info(char* buf, size_t buflen); |
641ed52732ec
8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents:
31357
diff
changeset
|
147 |
static void get_summary_os_info(char* buf, size_t buflen); |
641ed52732ec
8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents:
31357
diff
changeset
|
148 |
|
40011 | 149 |
static void initialize_initial_active_processor_count(); |
47903
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
150 |
|
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
151 |
LINUX_ONLY(static void pd_init_container_support();) |
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
152 |
|
1 | 153 |
public: |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
154 |
static void init(void); // Called before command line parsing |
47903
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
155 |
|
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
156 |
static void init_container_support() { // Called during command line parsing. |
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
157 |
LINUX_ONLY(pd_init_container_support();) |
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
158 |
} |
7f22774a5f42
8146115: Improve docker container detection and resource configuration usage
bobv
parents:
47765
diff
changeset
|
159 |
|
19986
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
160 |
static void init_before_ergo(void); // Called after command line parsing |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
161 |
// before VM ergonomics processing. |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
162 |
static jint init_2(void); // Called after command line parsing |
19986
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
163 |
// and VM ergonomics processing |
11417
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
164 |
static void init_globals(void) { // Called from init_globals() in init.cpp |
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
165 |
init_globals_ext(); |
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
166 |
} |
1 | 167 |
|
168 |
// File names are case-insensitive on windows only |
|
169 |
// Override me as needed |
|
50199
83d8b3a25f25
8199807: AppCDS performs overly restrictive path matching check.
jiangli
parents:
50184
diff
changeset
|
170 |
static int file_name_strncmp(const char* s1, const char* s2, size_t num); |
1 | 171 |
|
30125 | 172 |
// unset environment variable |
25946 | 173 |
static bool unsetenv(const char* name); |
174 |
||
1 | 175 |
static bool have_special_privileges(); |
176 |
||
177 |
static jlong javaTimeMillis(); |
|
178 |
static jlong javaTimeNanos(); |
|
179 |
static void javaTimeNanos_info(jvmtiTimerInfo *info_ptr); |
|
28737
ca4b6a6e5cc8
8068730: Increase the precision of the implementation of java.time.Clock.systemUTC()
dfuchs
parents:
28208
diff
changeset
|
180 |
static void javaTimeSystemUTC(jlong &seconds, jlong &nanos); |
1 | 181 |
static void run_periodic_checks(); |
22891
1f5d1fff23fa
6546236: Thread interrupt() of Thread.sleep() can be lost on Solaris due to race with signal handler
fparain
parents:
22758
diff
changeset
|
182 |
static bool supports_monotonic_clock(); |
1 | 183 |
|
184 |
// Returns the elapsed time in seconds since the vm started. |
|
185 |
static double elapsedTime(); |
|
186 |
||
187 |
// Returns real time in seconds since an arbitrary point |
|
188 |
// in the past. |
|
189 |
static bool getTimesSecs(double* process_real_time, |
|
190 |
double* process_user_time, |
|
191 |
double* process_system_time); |
|
192 |
||
193 |
// Interface to the performance counter |
|
194 |
static jlong elapsed_counter(); |
|
195 |
static jlong elapsed_frequency(); |
|
196 |
||
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
197 |
// The "virtual time" of a thread is the amount of time a thread has |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
198 |
// actually run. The first function indicates whether the OS supports |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
199 |
// this functionality for the current thread, and if so: |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
200 |
// * the second enables vtime tracking (if that is required). |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
201 |
// * the third tells whether vtime is enabled. |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
202 |
// * the fourth returns the elapsed virtual time for the current |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
203 |
// thread. |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
204 |
static bool supports_vtime(); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
205 |
static bool enable_vtime(); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
206 |
static bool vtime_enabled(); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
207 |
static double elapsedVTime(); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
388
diff
changeset
|
208 |
|
1 | 209 |
// Return current local time in a string (YYYY-MM-DD HH:MM:SS). |
210 |
// It is MT safe, but not async-safe, as reading time zone |
|
211 |
// information may require a lock on some platforms. |
|
2012
041fbc6030dd
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
1664
diff
changeset
|
212 |
static char* local_time_string(char *buf, size_t buflen); |
041fbc6030dd
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
1664
diff
changeset
|
213 |
static struct tm* localtime_pd (const time_t* clock, struct tm* res); |
42066 | 214 |
static struct tm* gmtime_pd (const time_t* clock, struct tm* res); |
1 | 215 |
// Fill in buffer with current local time as an ISO-8601 string. |
216 |
// E.g., YYYY-MM-DDThh:mm:ss.mmm+zzzz. |
|
217 |
// Returns buffer, or NULL if it failed. |
|
42066 | 218 |
static char* iso8601_time(char* buffer, size_t buffer_length, bool utc = false); |
1 | 219 |
|
220 |
// Interface for detecting multiprocessor system |
|
221 |
static inline bool is_MP() { |
|
26680
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
222 |
// During bootstrap if _processor_count is not yet initialized |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
223 |
// we claim to be MP as that is safest. If any platform has a |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
224 |
// stub generator that might be triggered in this phase and for |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
225 |
// which being declared MP when in fact not, is a problem - then |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
226 |
// the bootstrap routine for the stub generator needs to check |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
227 |
// the processor count directly and leave the bootstrap routine |
1f181bd352ce
8056183: os::is_MP() always reports true when NMT is enabled
dholmes
parents:
26557
diff
changeset
|
228 |
// in place until called after initialization has ocurred. |
51996
84743156e780
8188764: Obsolete AssumeMP and then remove all support for non-MP builds
dholmes
parents:
51376
diff
changeset
|
229 |
return (_processor_count != 1); |
1 | 230 |
} |
51996
84743156e780
8188764: Obsolete AssumeMP and then remove all support for non-MP builds
dholmes
parents:
51376
diff
changeset
|
231 |
|
1 | 232 |
static julong available_memory(); |
233 |
static julong physical_memory(); |
|
16605
ba13efd453bc
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
15228
diff
changeset
|
234 |
static bool has_allocatable_memory_limit(julong* limit); |
1 | 235 |
static bool is_server_class_machine(); |
236 |
||
50178
7b0291382aff
8203227: Introduce os::processor_id() for Linux and Solaris
pliden
parents:
49984
diff
changeset
|
237 |
// Returns the id of the processor on which the calling thread is currently executing. |
7b0291382aff
8203227: Introduce os::processor_id() for Linux and Solaris
pliden
parents:
49984
diff
changeset
|
238 |
// The returned value is guaranteed to be between 0 and (os::processor_count() - 1). |
7b0291382aff
8203227: Introduce os::processor_id() for Linux and Solaris
pliden
parents:
49984
diff
changeset
|
239 |
static uint processor_id(); |
7b0291382aff
8203227: Introduce os::processor_id() for Linux and Solaris
pliden
parents:
49984
diff
changeset
|
240 |
|
1 | 241 |
// number of CPUs |
242 |
static int processor_count() { |
|
243 |
return _processor_count; |
|
244 |
} |
|
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
4448
diff
changeset
|
245 |
static void set_processor_count(int count) { _processor_count = count; } |
1 | 246 |
|
247 |
// Returns the number of CPUs this process is currently allowed to run on. |
|
248 |
// Note that on some OSes this can change dynamically. |
|
249 |
static int active_processor_count(); |
|
250 |
||
40011 | 251 |
// At startup the number of active CPUs this process is allowed to run on. |
252 |
// This value does not change dynamically. May be different from active_processor_count(). |
|
253 |
static int initial_active_processor_count() { |
|
254 |
assert(_initial_active_processor_count > 0, "Initial active processor count not set yet."); |
|
255 |
return _initial_active_processor_count; |
|
256 |
} |
|
257 |
||
1 | 258 |
// Bind processes to processors. |
259 |
// This is a two step procedure: |
|
260 |
// first you generate a distribution of processes to processors, |
|
261 |
// then you bind processes according to that distribution. |
|
262 |
// Compute a distribution for number of processes to processors. |
|
263 |
// Stores the processor id's into the distribution array argument. |
|
264 |
// Returns true if it worked, false if it didn't. |
|
265 |
static bool distribute_processes(uint length, uint* distribution); |
|
266 |
// Binds the current process to a processor. |
|
267 |
// Returns true if it worked, false if it didn't. |
|
268 |
static bool bind_to_processor(uint processor_id); |
|
269 |
||
10739 | 270 |
// Give a name to the current thread. |
271 |
static void set_native_thread_name(const char *name); |
|
272 |
||
1 | 273 |
// Interface for stack banging (predetect possible stack overflow for |
274 |
// exception processing) There are guard pages, and above that shadow |
|
275 |
// pages for stack overflow checking. |
|
276 |
static bool uses_stack_guard_pages(); |
|
39390
edf6a424a8b7
8159335: Fix problems with stack overflow handling.
goetz
parents:
38263
diff
changeset
|
277 |
static bool must_commit_stack_guard_pages(); |
edf6a424a8b7
8159335: Fix problems with stack overflow handling.
goetz
parents:
38263
diff
changeset
|
278 |
static void map_stack_shadow_pages(address sp); |
edf6a424a8b7
8159335: Fix problems with stack overflow handling.
goetz
parents:
38263
diff
changeset
|
279 |
static bool stack_shadow_pages_available(Thread *thread, const methodHandle& method, address sp); |
1 | 280 |
|
49968 | 281 |
// Find committed memory region within specified range (start, start + size), |
282 |
// return true if found any |
|
283 |
static bool committed_in_range(address start, size_t size, address& committed_start, size_t& committed_size); |
|
284 |
||
1 | 285 |
// OS interface to Virtual Memory |
286 |
||
287 |
// Return the default page size. |
|
288 |
static int vm_page_size(); |
|
289 |
||
26700
8107d0778244
8049864: TestParallelHeapSizeFlags fails with unexpected heap size
ehelin
parents:
26589
diff
changeset
|
290 |
// Returns the page size to use for a region of memory. |
8107d0778244
8049864: TestParallelHeapSizeFlags fails with unexpected heap size
ehelin
parents:
26589
diff
changeset
|
291 |
// region_size / min_pages will always be greater than or equal to the |
28631 | 292 |
// returned value. The returned value will divide region_size. |
293 |
static size_t page_size_for_region_aligned(size_t region_size, size_t min_pages); |
|
294 |
||
295 |
// Returns the page size to use for a region of memory. |
|
296 |
// region_size / min_pages will always be greater than or equal to the |
|
297 |
// returned value. The returned value might not divide region_size. |
|
298 |
static size_t page_size_for_region_unaligned(size_t region_size, size_t min_pages); |
|
26700
8107d0778244
8049864: TestParallelHeapSizeFlags fails with unexpected heap size
ehelin
parents:
26589
diff
changeset
|
299 |
|
19986
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
300 |
// Return the largest page size that can be used |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
301 |
static size_t max_page_size() { |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
302 |
// The _page_sizes array is sorted in descending order. |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
303 |
return _page_sizes[0]; |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19697
diff
changeset
|
304 |
} |
1 | 305 |
|
52014
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51996
diff
changeset
|
306 |
// Return a lower bound for page sizes. Also works before os::init completed. |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51996
diff
changeset
|
307 |
static size_t min_page_size() { return 4 * K; } |
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51996
diff
changeset
|
308 |
|
37462 | 309 |
// Methods for tracing page sizes returned by the above method. |
310 |
// The region_{min,max}_size parameters should be the values |
|
1 | 311 |
// passed to page_size_for_region() and page_size should be the result of that |
312 |
// call. The (optional) base and size parameters should come from the |
|
313 |
// ReservedSpace base() and size() methods. |
|
37462 | 314 |
static void trace_page_sizes(const char* str, const size_t* page_sizes, int count); |
315 |
static void trace_page_sizes(const char* str, |
|
316 |
const size_t region_min_size, |
|
1 | 317 |
const size_t region_max_size, |
318 |
const size_t page_size, |
|
37462 | 319 |
const char* base, |
320 |
const size_t size); |
|
321 |
static void trace_page_sizes_for_requested_size(const char* str, |
|
322 |
const size_t requested_size, |
|
323 |
const size_t page_size, |
|
324 |
const size_t alignment, |
|
325 |
const char* base, |
|
326 |
const size_t size); |
|
1 | 327 |
|
328 |
static int vm_allocation_granularity(); |
|
329 |
static char* reserve_memory(size_t bytes, char* addr = 0, |
|
48153
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
330 |
size_t alignment_hint = 0, int file_desc = -1); |
17302
915323420691
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
17121
diff
changeset
|
331 |
static char* reserve_memory(size_t bytes, char* addr, |
915323420691
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
17121
diff
changeset
|
332 |
size_t alignment_hint, MEMFLAGS flags); |
48153
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
333 |
static char* reserve_memory_aligned(size_t size, size_t alignment, int file_desc = -1); |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
334 |
static char* attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc = -1); |
1 | 335 |
static void split_reserved_memory(char *base, size_t size, |
336 |
size_t split, bool realloc); |
|
18069
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
337 |
static bool commit_memory(char* addr, size_t bytes, bool executable); |
2268 | 338 |
static bool commit_memory(char* addr, size_t size, size_t alignment_hint, |
18069
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
339 |
bool executable); |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
340 |
// Same as commit_memory() that either succeeds or calls |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
341 |
// vm_exit_out_of_memory() with the specified mesg. |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
342 |
static void commit_memory_or_exit(char* addr, size_t bytes, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
343 |
bool executable, const char* mesg); |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
344 |
static void commit_memory_or_exit(char* addr, size_t size, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
345 |
size_t alignment_hint, |
e6d4971c8650
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
18025
diff
changeset
|
346 |
bool executable, const char* mesg); |
1 | 347 |
static bool uncommit_memory(char* addr, size_t bytes); |
348 |
static bool release_memory(char* addr, size_t bytes); |
|
823
9a5271881bc0
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
670
diff
changeset
|
349 |
|
28208 | 350 |
// Touch memory pages that cover the memory range from start to end (exclusive) |
351 |
// to make the OS back the memory range with actual memory. |
|
352 |
// Current implementation may not touch the last page if unaligned addresses |
|
353 |
// are passed. |
|
41178 | 354 |
static void pretouch_memory(void* start, void* end, size_t page_size = vm_page_size()); |
28208 | 355 |
|
823
9a5271881bc0
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
670
diff
changeset
|
356 |
enum ProtType { MEM_PROT_NONE, MEM_PROT_READ, MEM_PROT_RW, MEM_PROT_RWX }; |
9a5271881bc0
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
670
diff
changeset
|
357 |
static bool protect_memory(char* addr, size_t bytes, ProtType prot, |
1664
fc9ed50498fb
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
1388
diff
changeset
|
358 |
bool is_committed = true); |
823
9a5271881bc0
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
670
diff
changeset
|
359 |
|
1 | 360 |
static bool guard_memory(char* addr, size_t bytes); |
361 |
static bool unguard_memory(char* addr, size_t bytes); |
|
5085
4f0c435f8c3c
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
4493
diff
changeset
|
362 |
static bool create_stack_guard_pages(char* addr, size_t bytes); |
13195 | 363 |
static bool pd_create_stack_guard_pages(char* addr, size_t bytes); |
5085
4f0c435f8c3c
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
4493
diff
changeset
|
364 |
static bool remove_stack_guard_pages(char* addr, size_t bytes); |
48153
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
365 |
// Helper function to create a new file with template jvmheap.XXXXXX. |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
366 |
// Returns a valid fd on success or else returns -1 |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
367 |
static int create_file_for_heap(const char* dir); |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
368 |
// Map memory to the file referred by fd. This function is slightly different from map_memory() |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
369 |
// and is added to be used for implementation of -XX:AllocateHeapAt |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
370 |
static char* map_memory_to_file(char* base, size_t size, int fd); |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
371 |
// Replace existing reserved memory with file mapping |
cfa2c43e58c2
8190308: Implementation: JEP 316: Heap Allocation on Alternative Memory Devices
kkharbas
parents:
48005
diff
changeset
|
372 |
static char* replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd); |
5085
4f0c435f8c3c
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
4493
diff
changeset
|
373 |
|
1 | 374 |
static char* map_memory(int fd, const char* file_name, size_t file_offset, |
375 |
char *addr, size_t bytes, bool read_only = false, |
|
376 |
bool allow_exec = false); |
|
377 |
static char* remap_memory(int fd, const char* file_name, size_t file_offset, |
|
378 |
char *addr, size_t bytes, bool read_only, |
|
379 |
bool allow_exec); |
|
380 |
static bool unmap_memory(char *addr, size_t bytes); |
|
11402
739e52129c84
7124829: NUMA: memory leak on Linux with large pages
iveresov
parents:
11256
diff
changeset
|
381 |
static void free_memory(char *addr, size_t bytes, size_t alignment_hint); |
1 | 382 |
static void realign_memory(char *addr, size_t bytes, size_t alignment_hint); |
383 |
||
384 |
// NUMA-specific interface |
|
388 | 385 |
static bool numa_has_static_binding(); |
386 |
static bool numa_has_group_homing(); |
|
387 |
static void numa_make_local(char *addr, size_t bytes, int lgrp_hint); |
|
1 | 388 |
static void numa_make_global(char *addr, size_t bytes); |
389 |
static size_t numa_get_groups_num(); |
|
390 |
static size_t numa_get_leaf_groups(int *ids, size_t size); |
|
391 |
static bool numa_topology_changed(); |
|
392 |
static int numa_get_group_id(); |
|
393 |
||
394 |
// Page manipulation |
|
395 |
struct page_info { |
|
396 |
size_t size; |
|
397 |
int lgrp_id; |
|
398 |
}; |
|
399 |
static bool get_page_info(char *start, page_info* info); |
|
400 |
static char* scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found); |
|
401 |
||
402 |
static char* non_memory_address_word(); |
|
403 |
// reserve, commit and pin the entire memory region |
|
19546
f6b7c9e96ea3
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
18945
diff
changeset
|
404 |
static char* reserve_memory_special(size_t size, size_t alignment, |
f6b7c9e96ea3
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
18945
diff
changeset
|
405 |
char* addr, bool executable); |
1 | 406 |
static bool release_memory_special(char* addr, size_t bytes); |
9419
f0360dfe734d
7040485: Use transparent huge page on linux by default
iveresov
parents:
9125
diff
changeset
|
407 |
static void large_page_init(); |
1 | 408 |
static size_t large_page_size(); |
409 |
static bool can_commit_large_page_memory(); |
|
252
050143a0dbfb
6642862: Code cache allocation fails with large pages after 6588638
jcoomes
parents:
234
diff
changeset
|
410 |
static bool can_execute_large_page_memory(); |
1 | 411 |
|
412 |
// OS interface to polling page |
|
413 |
static address get_polling_page() { return _polling_page; } |
|
414 |
static void set_polling_page(address page) { _polling_page = page; } |
|
415 |
static bool is_poll_address(address addr) { return addr >= _polling_page && addr < (_polling_page + os::vm_page_size()); } |
|
416 |
static void make_polling_page_unreadable(); |
|
417 |
static void make_polling_page_readable(); |
|
418 |
||
51139
c95334202a14
8207342: error occurred during error reporting (printing register info)
mdoerr
parents:
50667
diff
changeset
|
419 |
// Check if pointer points to readable memory (by 4-byte read access) |
c95334202a14
8207342: error occurred during error reporting (printing register info)
mdoerr
parents:
50667
diff
changeset
|
420 |
static bool is_readable_pointer(const void* p); |
52014
1aa9beac610e
8210754: print_location is not reliable enough (printing register info)
mdoerr
parents:
51996
diff
changeset
|
421 |
static bool is_readable_range(const void* from, const void* to); |
51139
c95334202a14
8207342: error occurred during error reporting (printing register info)
mdoerr
parents:
50667
diff
changeset
|
422 |
|
1 | 423 |
// Routines used to serialize the thread state without using membars |
424 |
static void serialize_thread_states(); |
|
425 |
||
426 |
// Since we write to the serialize page from every thread, we |
|
427 |
// want stores to be on unique cache lines whenever possible |
|
428 |
// in order to minimize CPU cross talk. We pre-compute the |
|
429 |
// amount to shift the thread* to make this offset unique to |
|
430 |
// each thread. |
|
431 |
static int get_serialize_page_shift_count() { |
|
432 |
return SerializePageShiftCount; |
|
433 |
} |
|
434 |
||
435 |
static void set_serialize_page_mask(uintptr_t mask) { |
|
436 |
_serialize_page_mask = mask; |
|
437 |
} |
|
438 |
||
439 |
static unsigned int get_serialize_page_mask() { |
|
440 |
return _serialize_page_mask; |
|
441 |
} |
|
442 |
||
443 |
static void set_memory_serialize_page(address page); |
|
444 |
||
445 |
static address get_memory_serialize_page() { |
|
446 |
return (address)_mem_serialize_page; |
|
447 |
} |
|
448 |
||
449 |
static inline void write_memory_serialize_page(JavaThread *thread) { |
|
450 |
uintptr_t page_offset = ((uintptr_t)thread >> |
|
451 |
get_serialize_page_shift_count()) & |
|
452 |
get_serialize_page_mask(); |
|
453 |
*(volatile int32_t *)((uintptr_t)_mem_serialize_page+page_offset) = 1; |
|
454 |
} |
|
455 |
||
456 |
static bool is_memory_serialize_page(JavaThread *thread, address addr) { |
|
457 |
if (UseMembar) return false; |
|
4448 | 458 |
// Previously this function calculated the exact address of this |
459 |
// thread's serialize page, and checked if the faulting address |
|
460 |
// was equal. However, some platforms mask off faulting addresses |
|
461 |
// to the page size, so now we just check that the address is |
|
462 |
// within the page. This makes the thread argument unnecessary, |
|
22551 | 463 |
// but we retain the NULL check to preserve existing behavior. |
1 | 464 |
if (thread == NULL) return false; |
4448 | 465 |
address page = (address) _mem_serialize_page; |
466 |
return addr >= page && addr < (page + os::vm_page_size()); |
|
1 | 467 |
} |
468 |
||
469 |
static void block_on_serialize_page_trap(); |
|
470 |
||
471 |
// threads |
|
472 |
||
473 |
enum ThreadType { |
|
474 |
vm_thread, |
|
475 |
cgc_thread, // Concurrent GC thread |
|
476 |
pgc_thread, // Parallel GC thread |
|
42906
1a8db9cf1407
8170655: [posix] Fix minimum stack size computations
goetz
parents:
42066
diff
changeset
|
477 |
java_thread, // Java, CodeCacheSweeper, JVMTIAgent and Service threads. |
1 | 478 |
compiler_thread, |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
479 |
watcher_thread, |
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
480 |
os_thread |
1 | 481 |
}; |
482 |
||
483 |
static bool create_thread(Thread* thread, |
|
484 |
ThreadType thr_type, |
|
41070
496463b4e206
8140520: segfault on solaris-amd64 with "-XX:VMThreadStackSize=1" option
rdurbin
parents:
40667
diff
changeset
|
485 |
size_t req_stack_size = 0); |
48005
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
486 |
|
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
487 |
// The "main thread", also known as "starting thread", is the thread |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
488 |
// that loads/creates the JVM via JNI_CreateJavaVM. |
1 | 489 |
static bool create_main_thread(JavaThread* thread); |
48005
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
490 |
|
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
491 |
// The primordial thread is the initial process thread. The java |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
492 |
// launcher never uses the primordial thread as the main thread, but |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
493 |
// applications that host the JVM directly may do so. Some platforms |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
494 |
// need special-case handling of the primordial thread if it attaches |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
495 |
// to the VM. |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
496 |
static bool is_primordial_thread(void) |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
497 |
#if defined(_WINDOWS) || defined(BSD) |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
498 |
// No way to identify the primordial thread. |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
499 |
{ return false; } |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
500 |
#else |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
501 |
; |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
502 |
#endif |
9fd89aabb6cd
8189170: Add option to disable stack overflow checking in primordial thread for use with JNI_CreateJavaJVM
dholmes
parents:
47903
diff
changeset
|
503 |
|
1 | 504 |
static bool create_attached_thread(JavaThread* thread); |
505 |
static void pd_start_thread(Thread* thread); |
|
506 |
static void start_thread(Thread* thread); |
|
507 |
||
508 |
static void free_thread(OSThread* osthread); |
|
509 |
||
510 |
// thread id on Linux/64bit is 64bit, on Windows and Solaris, it's 32bit |
|
511 |
static intx current_thread_id(); |
|
512 |
static int current_process_id(); |
|
513 |
static int sleep(Thread* thread, jlong ms, bool interruptable); |
|
22533
76088853a2eb
8028280: ParkEvent leak when running modified runThese which only loads classes
dsimms
parents:
20022
diff
changeset
|
514 |
// Short standalone OS sleep suitable for slow path spin loop. |
76088853a2eb
8028280: ParkEvent leak when running modified runThese which only loads classes
dsimms
parents:
20022
diff
changeset
|
515 |
// Ignores Thread.interrupt() (so keep it short). |
76088853a2eb
8028280: ParkEvent leak when running modified runThese which only loads classes
dsimms
parents:
20022
diff
changeset
|
516 |
// ms = 0, will sleep for the least amount of time allowed by the OS. |
76088853a2eb
8028280: ParkEvent leak when running modified runThese which only loads classes
dsimms
parents:
20022
diff
changeset
|
517 |
static void naked_short_sleep(jlong ms); |
1 | 518 |
static void infinite_sleep(); // never returns, use with CAUTION |
25477
7dad9f95fd31
8047714: Fix for JDK-6546236 made Solaris os::yield() a no-op
fparain
parents:
25469
diff
changeset
|
519 |
static void naked_yield () ; |
1 | 520 |
static OSReturn set_priority(Thread* thread, ThreadPriority priority); |
521 |
static OSReturn get_priority(const Thread* const thread, ThreadPriority& priority); |
|
522 |
||
523 |
static void interrupt(Thread* thread); |
|
524 |
static bool is_interrupted(Thread* thread, bool clear_interrupted); |
|
525 |
||
526 |
static int pd_self_suspend_thread(Thread* thread); |
|
527 |
||
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
528 |
static ExtendedPC fetch_frame_from_context(const void* ucVoid, intptr_t** sp, intptr_t** fp); |
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
529 |
static frame fetch_frame_from_context(const void* ucVoid); |
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34633
diff
changeset
|
530 |
static frame fetch_frame_from_ucontext(Thread* thread, void* ucVoid); |
1 | 531 |
|
532 |
static void breakpoint(); |
|
34305
e399e6b44631
8136978: Much nearly duplicated code for vmError support
sebastian
parents:
33766
diff
changeset
|
533 |
static bool start_debugging(char *buf, int buflen); |
1 | 534 |
|
535 |
static address current_stack_pointer(); |
|
536 |
static address current_stack_base(); |
|
537 |
static size_t current_stack_size(); |
|
538 |
||
11961
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
11601
diff
changeset
|
539 |
static void verify_stack_alignment() PRODUCT_RETURN; |
0abd4cd26e5a
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
11601
diff
changeset
|
540 |
|
34305
e399e6b44631
8136978: Much nearly duplicated code for vmError support
sebastian
parents:
33766
diff
changeset
|
541 |
static bool message_box(const char* title, const char* message); |
1 | 542 |
static char* do_you_want_to_debug(const char* message); |
543 |
||
544 |
// run cmd in a separate process and return its exit code; or -1 on failures |
|
52109
101c2b6eacbe
8027434: "-XX:OnOutOfMemoryError" uses fork instead of vfork
mchinnathamb
parents:
52014
diff
changeset
|
545 |
static int fork_and_exec(char *cmd, bool use_vfork_if_available = false); |
1 | 546 |
|
26682
f339669ba825
8057744: (process) Synchronize exiting of threads and process [win]
igerasim
parents:
26680
diff
changeset
|
547 |
// Call ::exit() on all platforms but Windows |
f339669ba825
8057744: (process) Synchronize exiting of threads and process [win]
igerasim
parents:
26680
diff
changeset
|
548 |
static void exit(int num); |
1 | 549 |
|
550 |
// Terminate the VM, but don't exit the process |
|
551 |
static void shutdown(); |
|
552 |
||
553 |
// Terminate with an error. Default is to generate a core file on platforms |
|
554 |
// that support such things. This calls shutdown() and then aborts. |
|
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
555 |
static void abort(bool dump_core, void *siginfo, const void *context); |
1 | 556 |
static void abort(bool dump_core = true); |
557 |
||
558 |
// Die immediately, no exit hook, no abort hook, no cleanup. |
|
559 |
static void die(); |
|
560 |
||
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
561 |
// File i/o operations |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
562 |
static const int default_file_open_flags(); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
563 |
static int open(const char *path, int oflag, int mode); |
17121
e40a97c700d9
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
16610
diff
changeset
|
564 |
static FILE* open(int fd, const char* mode); |
49984
aa3afd9bda87
8176717: GC log file handle leaked to child processes
lkorinth
parents:
49968
diff
changeset
|
565 |
static FILE* fopen(const char* path, const char* mode); |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
566 |
static int close(int fd); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
567 |
static jlong lseek(int fd, jlong offset, int whence); |
50667
cc58f1fa0438
8203680: os::stat() on Posix platform does not need to copy input path
stuefe
parents:
50199
diff
changeset
|
568 |
// This function, on Windows, canonicalizes a given path (see os_windows.cpp for details). |
cc58f1fa0438
8203680: os::stat() on Posix platform does not need to copy input path
stuefe
parents:
50199
diff
changeset
|
569 |
// On Posix, this function is a noop: it does not change anything and just returns |
cc58f1fa0438
8203680: os::stat() on Posix platform does not need to copy input path
stuefe
parents:
50199
diff
changeset
|
570 |
// the input pointer. |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
571 |
static char* native_path(char *path); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
572 |
static int ftruncate(int fd, jlong length); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
573 |
static int fsync(int fd); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
574 |
static int available(int fd, jlong *bytes); |
38065
025c784d9333
8154921: Fix aix after "8146879: Add option for handling existing log files in UL"
goetz
parents:
37467
diff
changeset
|
575 |
static int get_fileno(FILE* fp); |
38263
a7488329ad27
8145934: Make ttyLocker equivalent for Unified Logging framework
mlarsson
parents:
38065
diff
changeset
|
576 |
static void flockfile(FILE* fp); |
a7488329ad27
8145934: Make ttyLocker equivalent for Unified Logging framework
mlarsson
parents:
38065
diff
changeset
|
577 |
static void funlockfile(FILE* fp); |
37465
1d5551f466ee
8146879: Add option for handling existing log files in UL
mlarsson
parents:
37462
diff
changeset
|
578 |
|
1d5551f466ee
8146879: Add option for handling existing log files in UL
mlarsson
parents:
37462
diff
changeset
|
579 |
static int compare_file_modified_times(const char* file1, const char* file2); |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
580 |
|
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
581 |
//File i/o operations |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
582 |
|
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
583 |
static size_t read(int fd, void *buf, unsigned int nBytes); |
27562 | 584 |
static size_t read_at(int fd, void *buf, unsigned int nBytes, jlong offset); |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
585 |
static size_t restartable_read(int fd, void *buf, unsigned int nBytes); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
586 |
static size_t write(int fd, const void *buf, unsigned int nBytes); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
587 |
|
1 | 588 |
// Reading directories. |
589 |
static DIR* opendir(const char* dirname); |
|
51106
f605c91e5219
8202353: os::readdir should use readdir instead of readdir_r
kbarrett
parents:
50667
diff
changeset
|
590 |
static struct dirent* readdir(DIR* dirp); |
1 | 591 |
static int closedir(DIR* dirp); |
592 |
||
593 |
// Dynamic library extension |
|
594 |
static const char* dll_file_extension(); |
|
595 |
||
596 |
static const char* get_temp_directory(); |
|
17121
e40a97c700d9
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
16610
diff
changeset
|
597 |
static const char* get_current_directory(char *buf, size_t buflen); |
1 | 598 |
|
47089
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
599 |
// Builds the platform-specific name of a library. |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
600 |
// Returns false if the buffer is too small. |
14471
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13859
diff
changeset
|
601 |
static bool dll_build_name(char* buffer, size_t size, |
47089
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
602 |
const char* fname); |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
603 |
|
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
604 |
// Builds a platform-specific full library path given an ld path and |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
605 |
// unadorned library name. Returns true if the buffer contains a full |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
606 |
// path to an existing file, false otherwise. If pathname is empty, |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
607 |
// uses the path to the current directory. |
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46589
diff
changeset
|
608 |
static bool dll_locate_lib(char* buffer, size_t size, |
950 | 609 |
const char* pathname, const char* fname); |
610 |
||
1 | 611 |
// Symbol lookup, find nearest function name; basically it implements |
612 |
// dladdr() for all platforms. Name of the nearest function is copied |
|
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
18069
diff
changeset
|
613 |
// to buf. Distance from its base address is optionally returned as offset. |
1 | 614 |
// If function name is not found, buf[0] is set to '\0' and offset is |
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
18069
diff
changeset
|
615 |
// set to -1 (if offset is non-NULL). |
1 | 616 |
static bool dll_address_to_function_name(address addr, char* buf, |
31352
a6ab7217b5cc
8079473: allow demangling to be optional in dll_address_to_function_name
bdelsart
parents:
31335
diff
changeset
|
617 |
int buflen, int* offset, |
a6ab7217b5cc
8079473: allow demangling to be optional in dll_address_to_function_name
bdelsart
parents:
31335
diff
changeset
|
618 |
bool demangle = true); |
1 | 619 |
|
620 |
// Locate DLL/DSO. On success, full path of the library is copied to |
|
18683
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
18069
diff
changeset
|
621 |
// buf, and offset is optionally set to be the distance between addr |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
18069
diff
changeset
|
622 |
// and the library's base address. On failure, buf[0] is set to '\0' |
a6418e038255
8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents:
18069
diff
changeset
|
623 |
// and offset is set to -1 (if offset is non-NULL). |
1 | 624 |
static bool dll_address_to_library_name(address addr, char* buf, |
625 |
int buflen, int* offset); |
|
626 |
||
627 |
// Find out whether the pc is in the static code for jvm.dll/libjvm.so. |
|
628 |
static bool address_is_in_vm(address addr); |
|
629 |
||
630 |
// Loads .dll/.so and |
|
631 |
// in case of error it checks if .dll/.so was built for the |
|
22551 | 632 |
// same architecture as HotSpot is running on |
1 | 633 |
static void* dll_load(const char *name, char *ebuf, int ebuflen); |
634 |
||
950 | 635 |
// lookup symbol in a shared library |
636 |
static void* dll_lookup(void* handle, const char* name); |
|
637 |
||
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
638 |
// Unload library |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
639 |
static void dll_unload(void *lib); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
640 |
|
26557
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
641 |
// Callback for loaded module information |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
642 |
// Input parameters: |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
643 |
// char* module_file_name, |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
644 |
// address module_base_addr, |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
645 |
// address module_top_addr, |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
646 |
// void* param |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
647 |
typedef int (*LoadedModulesCallbackFunc)(const char *, address, address, void *); |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
648 |
|
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
649 |
static int get_loaded_modules_info(LoadedModulesCallbackFunc callback, void *param); |
e399effe36f9
8056242: Add function to return structured information about loaded libraries.
sla
parents:
25949
diff
changeset
|
650 |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
651 |
// Return the handle of this process |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
652 |
static void* get_default_process_handle(); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
653 |
|
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
654 |
// Check for static linked agent library |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
655 |
static bool find_builtin_agent(AgentLibrary *agent_lib, const char *syms[], |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
656 |
size_t syms_len); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
657 |
|
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
658 |
// Find agent entry point |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
659 |
static void *find_agent_function(AgentLibrary *agent_lib, bool check_lib, |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
660 |
const char *syms[], size_t syms_len); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
661 |
|
49177
eebf559c9e0d
8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents:
48970
diff
changeset
|
662 |
// Provide C99 compliant versions of these functions, since some versions |
eebf559c9e0d
8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents:
48970
diff
changeset
|
663 |
// of some platforms don't. |
eebf559c9e0d
8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents:
48970
diff
changeset
|
664 |
static int vsnprintf(char* buf, size_t len, const char* fmt, va_list args) ATTRIBUTE_PRINTF(3, 0); |
eebf559c9e0d
8196882: VS2017 Hotspot Defined vsnprintf Function Causes C2084 Already Defined Compilation Error
kbarrett
parents:
48970
diff
changeset
|
665 |
static int snprintf(char* buf, size_t len, const char* fmt, ...) ATTRIBUTE_PRINTF(3, 4); |
33766
3290cae587f9
8138916: Logging write function does not allow for long enough messages
rprotacio
parents:
33593
diff
changeset
|
666 |
|
36174 | 667 |
// Get host name in buffer provided |
668 |
static bool get_host_name(char* buf, size_t buflen); |
|
669 |
||
1 | 670 |
// Print out system information; they are called by fatal error handler. |
671 |
// Output format may be different on different platforms. |
|
672 |
static void print_os_info(outputStream* st); |
|
12735
3e2e491f4f69
7165755: OS Information much longer on linux than other platforms
nloodin
parents:
11961
diff
changeset
|
673 |
static void print_os_info_brief(outputStream* st); |
31356
55ee785c49c5
8085865: hs_err improvement: Printing /proc/cpuinfo makes too long hs_err files
coleenp
parents:
31335
diff
changeset
|
674 |
static void print_cpu_info(outputStream* st, char* buf, size_t buflen); |
55ee785c49c5
8085865: hs_err improvement: Printing /proc/cpuinfo makes too long hs_err files
coleenp
parents:
31335
diff
changeset
|
675 |
static void pd_print_cpu_info(outputStream* st, char* buf, size_t buflen); |
31963
641ed52732ec
8026324: hs_err improvement: Add summary section to hs_err file
coleenp
parents:
31357
diff
changeset
|
676 |
static void print_summary_info(outputStream* st, char* buf, size_t buflen); |
1 | 677 |
static void print_memory_info(outputStream* st); |
678 |
static void print_dll_info(outputStream* st); |
|
30125 | 679 |
static void print_environment_variables(outputStream* st, const char** env_list); |
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
680 |
static void print_context(outputStream* st, const void* context); |
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
681 |
static void print_register_info(outputStream* st, const void* context); |
35176
11a9d4022d9e
8144219: [posix] Remove redundant code around os::print_siginfo()
stuefe
parents:
35077
diff
changeset
|
682 |
static void print_siginfo(outputStream* st, const void* siginfo); |
1 | 683 |
static void print_signal_handlers(outputStream* st, char* buf, size_t buflen); |
31335
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
30240
diff
changeset
|
684 |
static void print_date_and_time(outputStream* st, char* buf, size_t buflen); |
1 | 685 |
|
7108 | 686 |
static void print_location(outputStream* st, intptr_t x, bool verbose = false); |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
687 |
static size_t lasterror(char *buf, size_t len); |
11418
66ca80da30e2
7126185: Clean up lasterror handling, add os::get_last_error()
phh
parents:
11417
diff
changeset
|
688 |
static int get_last_error(); |
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
689 |
|
37113 | 690 |
// Replacement for strerror(). |
691 |
// Will return the english description of the error (e.g. "File not found", as |
|
692 |
// suggested in the POSIX standard. |
|
693 |
// Will return "Unknown error" for an unknown errno value. |
|
694 |
// Will not attempt to localize the returned string. |
|
695 |
// Will always return a valid string which is a static constant. |
|
696 |
// Will not change the value of errno. |
|
697 |
static const char* strerror(int e); |
|
698 |
||
699 |
// Will return the literalized version of the given errno (e.g. "EINVAL" |
|
700 |
// for EINVAL). |
|
701 |
// Will return "Unknown error" for an unknown errno value. |
|
702 |
// Will always return a valid string which is a static constant. |
|
703 |
// Will not change the value of errno. |
|
704 |
static const char* errno_name(int e); |
|
705 |
||
8476
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
706 |
// Determines whether the calling process is being debugged by a user-mode debugger. |
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
707 |
static bool is_debugger_attached(); |
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
708 |
|
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
709 |
// wait for a key press if PauseAtExit is set |
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
710 |
static void wait_for_keypress_at_exit(void); |
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8119
diff
changeset
|
711 |
|
1 | 712 |
// The following two functions are used by fatal error handler to trace |
713 |
// native (C) frames. They are not part of frame.hpp/frame.cpp because |
|
714 |
// frame.hpp/cpp assume thread is JavaThread, and also because different |
|
715 |
// OS/compiler may have different convention or provide different API to |
|
716 |
// walk C frames. |
|
717 |
// |
|
718 |
// We don't attempt to become a debugger, so we only follow frames if that |
|
719 |
// does not require a lookup in the unwind table, which is part of the binary |
|
720 |
// file but may be unsafe to read after a fatal error. So on x86, we can |
|
721 |
// only walk stack if %ebp is used as frame pointer; on ia64, it's not |
|
722 |
// possible to walk C stack without having the unwind table. |
|
723 |
static bool is_first_C_frame(frame *fr); |
|
724 |
static frame get_sender_for_C_frame(frame *fr); |
|
725 |
||
726 |
// return current frame. pc() and sp() are set to NULL on failure. |
|
727 |
static frame current_frame(); |
|
728 |
||
729 |
static void print_hex_dump(outputStream* st, address start, address end, int unitsize); |
|
730 |
||
731 |
// returns a string to describe the exception/signal; |
|
732 |
// returns NULL if exception_code is not an OS exception/signal. |
|
733 |
static const char* exception_name(int exception_code, char* buf, size_t buflen); |
|
734 |
||
34621
7676bec20997
8143291: Remove redundant coding around os::exception_name
stuefe
parents:
34305
diff
changeset
|
735 |
// Returns the signal number (e.g. 11) for a given signal name (SIGSEGV). |
7676bec20997
8143291: Remove redundant coding around os::exception_name
stuefe
parents:
34305
diff
changeset
|
736 |
static int get_signal_number(const char* signal_name); |
7676bec20997
8143291: Remove redundant coding around os::exception_name
stuefe
parents:
34305
diff
changeset
|
737 |
|
1 | 738 |
// Returns native Java library, loads if necessary |
739 |
static void* native_java_library(); |
|
740 |
||
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
741 |
// Fills in path to jvm.dll/libjvm.so (used by the Disassembler) |
1 | 742 |
static void jvm_path(char *buf, jint buflen); |
743 |
||
744 |
// JNI names |
|
745 |
static void print_jni_name_prefix_on(outputStream* st, int args_size); |
|
746 |
static void print_jni_name_suffix_on(outputStream* st, int args_size); |
|
747 |
||
748 |
// Init os specific system properties values |
|
749 |
static void init_system_properties_values(); |
|
750 |
||
751 |
// IO operations, non-JVM_ version. |
|
752 |
static int stat(const char* path, struct stat* sbuf); |
|
753 |
static bool dir_is_empty(const char* path); |
|
754 |
||
755 |
// IO operations on binary files |
|
756 |
static int create_binary_file(const char* path, bool rewrite_existing); |
|
757 |
static jlong current_file_offset(int fd); |
|
758 |
static jlong seek_to_file_offset(int fd, jlong offset); |
|
759 |
||
25946 | 760 |
// Retrieve native stack frames. |
761 |
// Parameter: |
|
762 |
// stack: an array to storage stack pointers. |
|
763 |
// frames: size of above array. |
|
764 |
// toSkip: number of stack frames to skip at the beginning. |
|
765 |
// Return: number of stack frames captured. |
|
766 |
static int get_native_stack(address* stack, int size, int toSkip = 0); |
|
13195 | 767 |
|
1 | 768 |
// General allocation (must be MT-safe) |
25946 | 769 |
static void* malloc (size_t size, MEMFLAGS flags, const NativeCallStack& stack); |
770 |
static void* malloc (size_t size, MEMFLAGS flags); |
|
771 |
static void* realloc (void *memblock, size_t size, MEMFLAGS flag, const NativeCallStack& stack); |
|
772 |
static void* realloc (void *memblock, size_t size, MEMFLAGS flag); |
|
773 |
||
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27473
diff
changeset
|
774 |
static void free (void *memblock); |
13195 | 775 |
static char* strdup(const char *, MEMFLAGS flags = mtInternal); // Like strdup |
25949 | 776 |
// Like strdup, but exit VM when strdup() returns NULL |
777 |
static char* strdup_check_oom(const char*, MEMFLAGS flags = mtInternal); |
|
1 | 778 |
|
779 |
#ifndef PRODUCT |
|
8320 | 780 |
static julong num_mallocs; // # of calls to malloc/realloc |
781 |
static julong alloc_bytes; // # of bytes allocated |
|
782 |
static julong num_frees; // # of calls to free |
|
783 |
static julong free_bytes; // # of bytes freed |
|
1 | 784 |
#endif |
785 |
||
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
786 |
// SocketInterface (ex HPI SocketInterface ) |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
787 |
static int socket(int domain, int type, int protocol); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
788 |
static int socket_close(int fd); |
11256
025cd1741566
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
10739
diff
changeset
|
789 |
static int recv(int fd, char* buf, size_t nBytes, uint flags); |
025cd1741566
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
10739
diff
changeset
|
790 |
static int send(int fd, char* buf, size_t nBytes, uint flags); |
025cd1741566
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
10739
diff
changeset
|
791 |
static int raw_send(int fd, char* buf, size_t nBytes, uint flags); |
025cd1741566
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
10739
diff
changeset
|
792 |
static int connect(int fd, struct sockaddr* him, socklen_t len); |
025cd1741566
7091417: recvfrom's 6th input should be of type socklen_t
phh
parents:
10739
diff
changeset
|
793 |
static struct hostent* get_host_by_name(char* name); |
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
794 |
|
1 | 795 |
// Support for signals (see JVM_RaiseSignal, JVM_RegisterSignal) |
50184
1a4101ebec92
8202014: Possible to receive signal before signal semaphore created
coleenp
parents:
50178
diff
changeset
|
796 |
static void initialize_jdk_signal_support(TRAPS); |
1 | 797 |
static void signal_notify(int signal_number); |
798 |
static void* signal(int signal_number, void* handler); |
|
799 |
static void signal_raise(int signal_number); |
|
800 |
static int signal_wait(); |
|
801 |
static void* user_handler(); |
|
802 |
static void terminate_signal_thread(); |
|
803 |
static int sigexitnum_pd(); |
|
804 |
||
805 |
// random number generation |
|
46587
6c97f34cb194
8182554: Code for os::random() assumes long is 32 bits
coleenp
parents:
46273
diff
changeset
|
806 |
static int random(); // return 32bit pseudorandom number |
6c97f34cb194
8182554: Code for os::random() assumes long is 32 bits
coleenp
parents:
46273
diff
changeset
|
807 |
static void init_random(unsigned int initval); // initialize random sequence |
1 | 808 |
|
809 |
// Structured OS Exception support |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
31963
diff
changeset
|
810 |
static void os_exception_wrapper(java_call_t f, JavaValue* value, const methodHandle& method, JavaCallArguments* args, Thread* thread); |
1 | 811 |
|
30240
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
812 |
// On Posix compatible OS it will simply check core dump limits while on Windows |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
813 |
// it will check if dump file can be created. Check or prepare a core dump to be |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
814 |
// taken at a later point in the same thread in os::abort(). Use the caller |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
815 |
// provided buffer as a scratch buffer. The status message which will be written |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
816 |
// into the error log either is file location or a short error message, depending |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
817 |
// on the checking result. |
a7ba42fa1df6
8074354: Make CreateMinidumpOnCrash a new name and available on all platforms
minqi
parents:
30125
diff
changeset
|
818 |
static void check_dump_limit(char* buffer, size_t bufferSize); |
8119
81eef1b06988
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
8107
diff
changeset
|
819 |
|
13198
271c557a7623
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
13195
diff
changeset
|
820 |
// Get the default path to the core file |
271c557a7623
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
13195
diff
changeset
|
821 |
// Returns the length of the string |
271c557a7623
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
13195
diff
changeset
|
822 |
static int get_core_path(char* buffer, size_t bufferSize); |
271c557a7623
7129724: MAC: Core file location is wrong in crash report
mikael
parents:
13195
diff
changeset
|
823 |
|
1 | 824 |
// JVMTI & JVM monitoring and management support |
825 |
// The thread_cpu_time() and current_thread_cpu_time() are only |
|
826 |
// supported if is_thread_cpu_time_supported() returns true. |
|
827 |
// They are not supported on Solaris T1. |
|
828 |
||
829 |
// Thread CPU Time - return the fast estimate on a platform |
|
830 |
// On Solaris - call gethrvtime (fast) - user time only |
|
831 |
// On Linux - fast clock_gettime where available - user+sys |
|
832 |
// - otherwise: very slow /proc fs - user+sys |
|
833 |
// On Windows - GetThreadTimes - user+sys |
|
834 |
static jlong current_thread_cpu_time(); |
|
835 |
static jlong thread_cpu_time(Thread* t); |
|
836 |
||
837 |
// Thread CPU Time with user_sys_cpu_time parameter. |
|
838 |
// |
|
839 |
// If user_sys_cpu_time is true, user+sys time is returned. |
|
840 |
// Otherwise, only user time is returned |
|
841 |
static jlong current_thread_cpu_time(bool user_sys_cpu_time); |
|
842 |
static jlong thread_cpu_time(Thread* t, bool user_sys_cpu_time); |
|
843 |
||
844 |
// Return a bunch of info about the timers. |
|
845 |
// Note that the returned info for these two functions may be different |
|
846 |
// on some platforms |
|
847 |
static void current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr); |
|
848 |
static void thread_cpu_time_info(jvmtiTimerInfo *info_ptr); |
|
849 |
||
850 |
static bool is_thread_cpu_time_supported(); |
|
851 |
||
852 |
// System loadavg support. Returns -1 if load average cannot be obtained. |
|
853 |
static int loadavg(double loadavg[], int nelem); |
|
854 |
||
855 |
// Hook for os specific jvm options that we don't want to abort on seeing |
|
856 |
static bool obsolete_option(const JavaVMOption *option); |
|
857 |
||
26576
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
25949
diff
changeset
|
858 |
// Amount beyond the callee frame size that we bang the stack. |
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
25949
diff
changeset
|
859 |
static int extra_bang_size_in_bytes(); |
a9429d24d429
8050147: StoreLoad barrier interferes with stack usages
shade
parents:
25949
diff
changeset
|
860 |
|
36508 | 861 |
static char** split_path(const char* path, int* n); |
862 |
||
11417
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
863 |
// Extensions |
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
864 |
#include "runtime/os_ext.hpp" |
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
865 |
|
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
866 |
public: |
18943 | 867 |
class CrashProtectionCallback : public StackObj { |
868 |
public: |
|
869 |
virtual void call() = 0; |
|
870 |
}; |
|
11417
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
871 |
|
1 | 872 |
// Platform dependent stuff |
40010 | 873 |
#ifndef _WINDOWS |
22827 | 874 |
# include "os_posix.hpp" |
875 |
#endif |
|
40010 | 876 |
#include OS_CPU_HEADER(os) |
877 |
#include OS_HEADER(os) |
|
7397 | 878 |
|
22758
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
879 |
#ifndef OS_NATIVE_THREAD_CREATION_FAILED_MSG |
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
880 |
#define OS_NATIVE_THREAD_CREATION_FAILED_MSG "unable to create native thread: possibly out of memory or process/resource limits reached" |
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
881 |
#endif |
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
882 |
|
11417
4ecc3253bec4
7125934: Add a fast unordered timestamp capability to Hotspot on x86/x64
phh
parents:
11256
diff
changeset
|
883 |
public: |
19952
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
884 |
#ifndef PLATFORM_PRINT_NATIVE_STACK |
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
885 |
// No platform-specific code for printing the native stack. |
35077
8b86440d3bf1
8145114: const-correctness for ucontext_t* reading functions
stuefe
parents:
35071
diff
changeset
|
886 |
static bool platform_print_native_stack(outputStream* st, const void* context, |
19952
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
887 |
char *buf, int buf_size) { |
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
888 |
return false; |
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
889 |
} |
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
890 |
#endif |
bc974e92f881
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
19697
diff
changeset
|
891 |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
892 |
// debugging support (mostly used by debug.cpp but also fatal error handler) |
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5547
diff
changeset
|
893 |
static bool find(address pc, outputStream* st = tty); // OS specific function to make sense out of an address |
1 | 894 |
|
895 |
static bool dont_yield(); // when true, JVM_Yield() is nop |
|
896 |
static void print_statistics(); |
|
897 |
||
898 |
// Thread priority helpers (implemented in OS-specific part) |
|
899 |
static OSReturn set_native_priority(Thread* thread, int native_prio); |
|
900 |
static OSReturn get_native_priority(const Thread* const thread, int* priority_ptr); |
|
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11423
diff
changeset
|
901 |
static int java_to_os_priority[CriticalPriority + 1]; |
1 | 902 |
// Hint to the underlying OS that a task switch would not be good. |
903 |
// Void return because it's a hint and can fail. |
|
22758
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
904 |
static const char* native_thread_creation_failed_msg() { |
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
905 |
return OS_NATIVE_THREAD_CREATION_FAILED_MSG; |
c6b6abb73544
7182040: volano29 limited by os resource on Linux - need better diagnostic message
iklam
parents:
22556
diff
changeset
|
906 |
} |
1 | 907 |
|
908 |
// Used at creation if requested by the diagnostic flag PauseAtStartup. |
|
909 |
// Causes the VM to wait until an external stimulus has been applied |
|
910 |
// (for Unix, that stimulus is a signal, for Windows, an external |
|
911 |
// ResumeThread call) |
|
912 |
static void pause(); |
|
913 |
||
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
914 |
// Builds a platform dependent Agent_OnLoad_<libname> function name |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
915 |
// which is used to find statically linked in agents. |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
916 |
static char* build_agent_function_name(const char *sym, const char *cname, |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
917 |
bool is_absolute_path); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18945
diff
changeset
|
918 |
|
18025 | 919 |
class SuspendedThreadTaskContext { |
920 |
public: |
|
921 |
SuspendedThreadTaskContext(Thread* thread, void *ucontext) : _thread(thread), _ucontext(ucontext) {} |
|
922 |
Thread* thread() const { return _thread; } |
|
923 |
void* ucontext() const { return _ucontext; } |
|
924 |
private: |
|
925 |
Thread* _thread; |
|
926 |
void* _ucontext; |
|
927 |
}; |
|
928 |
||
929 |
class SuspendedThreadTask { |
|
930 |
public: |
|
931 |
SuspendedThreadTask(Thread* thread) : _thread(thread), _done(false) {} |
|
932 |
void run(); |
|
933 |
bool is_done() { return _done; } |
|
934 |
virtual void do_task(const SuspendedThreadTaskContext& context) = 0; |
|
935 |
protected: |
|
48970
c81bab0287ab
8197789: os::SuspendedThreadTask causes references to global operator delete
coleenp
parents:
48955
diff
changeset
|
936 |
~SuspendedThreadTask() {} |
18025 | 937 |
private: |
938 |
void internal_do_task(); |
|
939 |
Thread* _thread; |
|
940 |
bool _done; |
|
941 |
}; |
|
942 |
||
40010 | 943 |
#ifndef _WINDOWS |
18025 | 944 |
// Suspend/resume support |
945 |
// Protocol: |
|
946 |
// |
|
947 |
// a thread starts in SR_RUNNING |
|
948 |
// |
|
949 |
// SR_RUNNING can go to |
|
950 |
// * SR_SUSPEND_REQUEST when the WatcherThread wants to suspend it |
|
951 |
// SR_SUSPEND_REQUEST can go to |
|
952 |
// * SR_RUNNING if WatcherThread decides it waited for SR_SUSPENDED too long (timeout) |
|
953 |
// * SR_SUSPENDED if the stopped thread receives the signal and switches state |
|
954 |
// SR_SUSPENDED can go to |
|
955 |
// * SR_WAKEUP_REQUEST when the WatcherThread has done the work and wants to resume |
|
956 |
// SR_WAKEUP_REQUEST can go to |
|
957 |
// * SR_RUNNING when the stopped thread receives the signal |
|
958 |
// * SR_WAKEUP_REQUEST on timeout (resend the signal and try again) |
|
959 |
class SuspendResume { |
|
960 |
public: |
|
961 |
enum State { |
|
962 |
SR_RUNNING, |
|
963 |
SR_SUSPEND_REQUEST, |
|
964 |
SR_SUSPENDED, |
|
965 |
SR_WAKEUP_REQUEST |
|
966 |
}; |
|
967 |
||
968 |
private: |
|
969 |
volatile State _state; |
|
970 |
||
971 |
private: |
|
972 |
/* try to switch state from state "from" to state "to" |
|
973 |
* returns the state set after the method is complete |
|
974 |
*/ |
|
975 |
State switch_state(State from, State to); |
|
976 |
||
977 |
public: |
|
978 |
SuspendResume() : _state(SR_RUNNING) { } |
|
979 |
||
980 |
State state() const { return _state; } |
|
981 |
||
982 |
State request_suspend() { |
|
983 |
return switch_state(SR_RUNNING, SR_SUSPEND_REQUEST); |
|
984 |
} |
|
985 |
||
986 |
State cancel_suspend() { |
|
987 |
return switch_state(SR_SUSPEND_REQUEST, SR_RUNNING); |
|
988 |
} |
|
989 |
||
990 |
State suspended() { |
|
991 |
return switch_state(SR_SUSPEND_REQUEST, SR_SUSPENDED); |
|
992 |
} |
|
993 |
||
994 |
State request_wakeup() { |
|
995 |
return switch_state(SR_SUSPENDED, SR_WAKEUP_REQUEST); |
|
996 |
} |
|
997 |
||
998 |
State running() { |
|
999 |
return switch_state(SR_WAKEUP_REQUEST, SR_RUNNING); |
|
1000 |
} |
|
1001 |
||
1002 |
bool is_running() const { |
|
1003 |
return _state == SR_RUNNING; |
|
1004 |
} |
|
1005 |
||
1006 |
bool is_suspend_request() const { |
|
1007 |
return _state == SR_SUSPEND_REQUEST; |
|
1008 |
} |
|
1009 |
||
1010 |
bool is_suspended() const { |
|
1011 |
return _state == SR_SUSPENDED; |
|
1012 |
} |
|
1013 |
}; |
|
40010 | 1014 |
#endif // !WINDOWS |
18025 | 1015 |
|
1016 |
||
1 | 1017 |
protected: |
46587
6c97f34cb194
8182554: Code for os::random() assumes long is 32 bits
coleenp
parents:
46273
diff
changeset
|
1018 |
static volatile unsigned int _rand_seed; // seed for random number generator |
40011 | 1019 |
static int _processor_count; // number of processors |
1020 |
static int _initial_active_processor_count; // number of active processors during initialization. |
|
1 | 1021 |
|
1022 |
static char* format_boot_path(const char* format_string, |
|
1023 |
const char* home, |
|
1024 |
int home_len, |
|
1025 |
char fileSep, |
|
1026 |
char pathSep); |
|
1027 |
static bool set_boot_path(char fileSep, char pathSep); |
|
18943 | 1028 |
|
1 | 1029 |
}; |
1030 |
||
48955
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
1031 |
#ifndef _WINDOWS |
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
1032 |
template<> struct IsRegisteredEnum<os::SuspendResume::State> : public TrueType {}; |
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
1033 |
#endif // !_WINDOWS |
e22914003cf0
8194691: Cleanup unnecessary casts in Atomic/OrderAccess uses
kbarrett
parents:
48813
diff
changeset
|
1034 |
|
1 | 1035 |
// Note that "PAUSE" is almost always used with synchronization |
1036 |
// so arguably we should provide Atomic::SpinPause() instead |
|
1037 |
// of the global SpinPause() with C linkage. |
|
1038 |
// It'd also be eligible for inlining on many platforms. |
|
1039 |
||
18740 | 1040 |
extern "C" int SpinPause(); |
7397 | 1041 |
|
1042 |
#endif // SHARE_VM_RUNTIME_OS_HPP |