Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/os.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 24cee90e9453 |
| children | f08d439fab8c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_OS_HPP |
| 26 #define SHARE_VM_RUNTIME_OS_HPP | |
| 27 | |
| 28 #include "jvmtifiles/jvmti.h" | |
| 29 #include "runtime/atomic.hpp" | |
| 30 #include "runtime/extendedPC.hpp" | |
| 31 #include "runtime/handles.hpp" | |
| 32 #include "utilities/top.hpp" | |
| 33 #ifdef TARGET_OS_FAMILY_linux | |
| 34 # include "jvm_linux.h" | |
| 35 #endif | |
| 36 #ifdef TARGET_OS_FAMILY_solaris | |
| 37 # include "jvm_solaris.h" | |
| 38 #endif | |
| 39 #ifdef TARGET_OS_FAMILY_windows | |
| 40 # include "jvm_windows.h" | |
| 41 #endif | |
| 42 | |
| 0 | 43 // os defines the interface to operating system; this includes traditional |
| 44 // OS services (time, I/O) as well as other functionality with system- | |
| 45 // dependent code. | |
| 46 | |
| 47 typedef void (*dll_func)(...); | |
| 48 | |
| 49 class Thread; | |
| 50 class JavaThread; | |
| 51 class Event; | |
| 52 class DLL; | |
| 53 class FileHandle; | |
| 141 | 54 template<class E> class GrowableArray; |
| 0 | 55 |
| 56 // %%%%% Moved ThreadState, START_FN, OSThread to new osThread.hpp. -- Rose | |
| 57 | |
| 58 // Platform-independent error return values from OS functions | |
| 59 enum OSReturn { | |
| 60 OS_OK = 0, // Operation was successful | |
| 61 OS_ERR = -1, // Operation failed | |
| 62 OS_INTRPT = -2, // Operation was interrupted | |
| 63 OS_TIMEOUT = -3, // Operation timed out | |
| 64 OS_NOMEM = -5, // Operation failed for lack of memory | |
| 65 OS_NORESOURCE = -6 // Operation failed for lack of nonmemory resource | |
| 66 }; | |
| 67 | |
| 68 enum ThreadPriority { // JLS 20.20.1-3 | |
| 69 NoPriority = -1, // Initial non-priority value | |
| 70 MinPriority = 1, // Minimum priority | |
| 71 NormPriority = 5, // Normal (non-daemon) priority | |
| 72 NearMaxPriority = 9, // High priority, used for VMThread | |
| 73 MaxPriority = 10 // Highest priority, used for WatcherThread | |
| 74 // ensures that VMThread doesn't starve profiler | |
| 75 }; | |
| 76 | |
| 77 // Typedef for structured exception handling support | |
| 78 typedef void (*java_call_t)(JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread); | |
| 79 | |
| 80 class os: AllStatic { | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
81 public: |
| 0 | 82 enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel) |
| 83 | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
84 private: |
| 0 | 85 static OSThread* _starting_thread; |
| 86 static address _polling_page; | |
| 87 static volatile int32_t * _mem_serialize_page; | |
| 88 static uintptr_t _serialize_page_mask; | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
89 public: |
| 0 | 90 static size_t _page_sizes[page_sizes_max]; |
| 91 | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
92 private: |
| 0 | 93 static void init_page_sizes(size_t default_page_size) { |
| 94 _page_sizes[0] = default_page_size; | |
| 95 _page_sizes[1] = 0; // sentinel | |
| 96 } | |
| 97 | |
| 98 public: | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
99 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
100 static void init(void); // Called before command line parsing |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
101 static jint init_2(void); // Called after command line parsing |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
102 static void init_3(void); // Called at the end of vm init |
| 0 | 103 |
| 104 // File names are case-insensitive on windows only | |
| 105 // Override me as needed | |
| 106 static int file_name_strcmp(const char* s1, const char* s2); | |
| 107 | |
| 108 static bool getenv(const char* name, char* buffer, int len); | |
| 109 static bool have_special_privileges(); | |
| 110 | |
| 111 static jlong javaTimeMillis(); | |
| 112 static jlong javaTimeNanos(); | |
| 113 static void javaTimeNanos_info(jvmtiTimerInfo *info_ptr); | |
| 114 static void run_periodic_checks(); | |
| 115 | |
| 116 | |
| 117 // Returns the elapsed time in seconds since the vm started. | |
| 118 static double elapsedTime(); | |
| 119 | |
| 120 // Returns real time in seconds since an arbitrary point | |
| 121 // in the past. | |
| 122 static bool getTimesSecs(double* process_real_time, | |
| 123 double* process_user_time, | |
| 124 double* process_system_time); | |
| 125 | |
| 126 // Interface to the performance counter | |
| 127 static jlong elapsed_counter(); | |
| 128 static jlong elapsed_frequency(); | |
| 129 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
130 // The "virtual time" of a thread is the amount of time a thread has |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
131 // actually run. The first function indicates whether the OS supports |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
132 // this functionality for the current thread, and if so: |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
133 // * the second enables vtime tracking (if that is required). |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
134 // * the third tells whether vtime is enabled. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
135 // * the fourth returns the elapsed virtual time for the current |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
136 // thread. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
137 static bool supports_vtime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
138 static bool enable_vtime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
139 static bool vtime_enabled(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
140 static double elapsedVTime(); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
141
diff
changeset
|
141 |
| 0 | 142 // Return current local time in a string (YYYY-MM-DD HH:MM:SS). |
| 143 // It is MT safe, but not async-safe, as reading time zone | |
| 144 // information may require a lock on some platforms. | |
|
548
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
145 static char* local_time_string(char *buf, size_t buflen); |
|
773234c55e8c
6800586: -XX:+PrintGCDateStamps is using mt-unsafe localtime function
ysr
parents:
477
diff
changeset
|
146 static struct tm* localtime_pd (const time_t* clock, struct tm* res); |
| 0 | 147 // Fill in buffer with current local time as an ISO-8601 string. |
| 148 // E.g., YYYY-MM-DDThh:mm:ss.mmm+zzzz. | |
| 149 // Returns buffer, or NULL if it failed. | |
| 150 static char* iso8601_time(char* buffer, size_t buffer_length); | |
| 151 | |
| 152 // Interface for detecting multiprocessor system | |
| 153 static inline bool is_MP() { | |
| 154 assert(_processor_count > 0, "invalid processor count"); | |
| 155 return _processor_count > 1; | |
| 156 } | |
| 157 static julong available_memory(); | |
| 158 static julong physical_memory(); | |
| 159 static julong allocatable_physical_memory(julong size); | |
| 160 static bool is_server_class_machine(); | |
| 161 | |
| 162 // number of CPUs | |
| 163 static int processor_count() { | |
| 164 return _processor_count; | |
| 165 } | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
1078
diff
changeset
|
166 static void set_processor_count(int count) { _processor_count = count; } |
| 0 | 167 |
| 168 // Returns the number of CPUs this process is currently allowed to run on. | |
| 169 // Note that on some OSes this can change dynamically. | |
| 170 static int active_processor_count(); | |
| 171 | |
| 172 // Bind processes to processors. | |
| 173 // This is a two step procedure: | |
| 174 // first you generate a distribution of processes to processors, | |
| 175 // then you bind processes according to that distribution. | |
| 176 // Compute a distribution for number of processes to processors. | |
| 177 // Stores the processor id's into the distribution array argument. | |
| 178 // Returns true if it worked, false if it didn't. | |
| 179 static bool distribute_processes(uint length, uint* distribution); | |
| 180 // Binds the current process to a processor. | |
| 181 // Returns true if it worked, false if it didn't. | |
| 182 static bool bind_to_processor(uint processor_id); | |
| 183 | |
| 184 // Interface for stack banging (predetect possible stack overflow for | |
| 185 // exception processing) There are guard pages, and above that shadow | |
| 186 // pages for stack overflow checking. | |
| 187 static bool uses_stack_guard_pages(); | |
| 188 static bool allocate_stack_guard_pages(); | |
| 189 static void bang_stack_shadow_pages(); | |
| 190 static bool stack_shadow_pages_available(Thread *thread, methodHandle method); | |
| 191 | |
| 192 // OS interface to Virtual Memory | |
| 193 | |
| 194 // Return the default page size. | |
| 195 static int vm_page_size(); | |
| 196 | |
| 197 // Return the page size to use for a region of memory. The min_pages argument | |
| 198 // is a hint intended to limit fragmentation; it says the returned page size | |
| 199 // should be <= region_max_size / min_pages. Because min_pages is a hint, | |
| 200 // this routine may return a size larger than region_max_size / min_pages. | |
| 201 // | |
| 202 // The current implementation ignores min_pages if a larger page size is an | |
| 203 // exact multiple of both region_min_size and region_max_size. This allows | |
| 204 // larger pages to be used when doing so would not cause fragmentation; in | |
| 205 // particular, a single page can be used when region_min_size == | |
| 206 // region_max_size == a supported page size. | |
| 207 static size_t page_size_for_region(size_t region_min_size, | |
| 208 size_t region_max_size, | |
| 209 uint min_pages); | |
| 210 | |
| 3859 | 211 // Methods for tracing page sizes returned by the above method; enabled by |
| 0 | 212 // TracePageSizes. The region_{min,max}_size parameters should be the values |
| 213 // passed to page_size_for_region() and page_size should be the result of that | |
| 214 // call. The (optional) base and size parameters should come from the | |
| 215 // ReservedSpace base() and size() methods. | |
| 3859 | 216 static void trace_page_sizes(const char* str, const size_t* page_sizes, |
| 217 int count) PRODUCT_RETURN; | |
| 0 | 218 static void trace_page_sizes(const char* str, const size_t region_min_size, |
| 219 const size_t region_max_size, | |
| 220 const size_t page_size, | |
| 221 const char* base = NULL, | |
| 222 const size_t size = 0) PRODUCT_RETURN; | |
| 223 | |
| 224 static int vm_allocation_granularity(); | |
| 225 static char* reserve_memory(size_t bytes, char* addr = 0, | |
| 226 size_t alignment_hint = 0); | |
| 227 static char* attempt_reserve_memory_at(size_t bytes, char* addr); | |
| 228 static void split_reserved_memory(char *base, size_t size, | |
| 229 size_t split, bool realloc); | |
| 656 | 230 static bool commit_memory(char* addr, size_t bytes, |
| 231 bool executable = false); | |
| 232 static bool commit_memory(char* addr, size_t size, size_t alignment_hint, | |
| 233 bool executable = false); | |
| 0 | 234 static bool uncommit_memory(char* addr, size_t bytes); |
| 235 static bool release_memory(char* addr, size_t bytes); | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
236 |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
237 enum ProtType { MEM_PROT_NONE, MEM_PROT_READ, MEM_PROT_RW, MEM_PROT_RWX }; |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
238 static bool protect_memory(char* addr, size_t bytes, ProtType prot, |
|
477
24fda36852ce
6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents:
356
diff
changeset
|
239 bool is_committed = true); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
196
diff
changeset
|
240 |
| 0 | 241 static bool guard_memory(char* addr, size_t bytes); |
| 242 static bool unguard_memory(char* addr, size_t bytes); | |
|
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
243 static bool create_stack_guard_pages(char* addr, size_t bytes); |
|
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
244 static bool remove_stack_guard_pages(char* addr, size_t bytes); |
|
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1123
diff
changeset
|
245 |
| 0 | 246 static char* map_memory(int fd, const char* file_name, size_t file_offset, |
| 247 char *addr, size_t bytes, bool read_only = false, | |
| 248 bool allow_exec = false); | |
| 249 static char* remap_memory(int fd, const char* file_name, size_t file_offset, | |
| 250 char *addr, size_t bytes, bool read_only, | |
| 251 bool allow_exec); | |
| 252 static bool unmap_memory(char *addr, size_t bytes); | |
| 253 static void free_memory(char *addr, size_t bytes); | |
| 254 static void realign_memory(char *addr, size_t bytes, size_t alignment_hint); | |
| 255 | |
| 256 // NUMA-specific interface | |
| 141 | 257 static bool numa_has_static_binding(); |
| 258 static bool numa_has_group_homing(); | |
| 259 static void numa_make_local(char *addr, size_t bytes, int lgrp_hint); | |
| 0 | 260 static void numa_make_global(char *addr, size_t bytes); |
| 261 static size_t numa_get_groups_num(); | |
| 262 static size_t numa_get_leaf_groups(int *ids, size_t size); | |
| 263 static bool numa_topology_changed(); | |
| 264 static int numa_get_group_id(); | |
| 265 | |
| 266 // Page manipulation | |
| 267 struct page_info { | |
| 268 size_t size; | |
| 269 int lgrp_id; | |
| 270 }; | |
| 271 static bool get_page_info(char *start, page_info* info); | |
| 272 static char* scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found); | |
| 273 | |
| 274 static char* non_memory_address_word(); | |
| 275 // reserve, commit and pin the entire memory region | |
| 656 | 276 static char* reserve_memory_special(size_t size, char* addr = NULL, |
| 277 bool executable = false); | |
| 0 | 278 static bool release_memory_special(char* addr, size_t bytes); |
|
3318
188c9a5d6a6d
7040485: Use transparent huge page on linux by default
iveresov
parents:
2469
diff
changeset
|
279 static void large_page_init(); |
| 0 | 280 static size_t large_page_size(); |
| 281 static bool can_commit_large_page_memory(); | |
|
79
82db0859acbe
6642862: Code cache allocation fails with large pages after 6588638
jcoomes
parents:
61
diff
changeset
|
282 static bool can_execute_large_page_memory(); |
| 0 | 283 |
| 284 // OS interface to polling page | |
| 285 static address get_polling_page() { return _polling_page; } | |
| 286 static void set_polling_page(address page) { _polling_page = page; } | |
| 287 static bool is_poll_address(address addr) { return addr >= _polling_page && addr < (_polling_page + os::vm_page_size()); } | |
| 288 static void make_polling_page_unreadable(); | |
| 289 static void make_polling_page_readable(); | |
| 290 | |
| 291 // Routines used to serialize the thread state without using membars | |
| 292 static void serialize_thread_states(); | |
| 293 | |
| 294 // Since we write to the serialize page from every thread, we | |
| 295 // want stores to be on unique cache lines whenever possible | |
| 296 // in order to minimize CPU cross talk. We pre-compute the | |
| 297 // amount to shift the thread* to make this offset unique to | |
| 298 // each thread. | |
| 299 static int get_serialize_page_shift_count() { | |
| 300 return SerializePageShiftCount; | |
| 301 } | |
| 302 | |
| 303 static void set_serialize_page_mask(uintptr_t mask) { | |
| 304 _serialize_page_mask = mask; | |
| 305 } | |
| 306 | |
| 307 static unsigned int get_serialize_page_mask() { | |
| 308 return _serialize_page_mask; | |
| 309 } | |
| 310 | |
| 311 static void set_memory_serialize_page(address page); | |
| 312 | |
| 313 static address get_memory_serialize_page() { | |
| 314 return (address)_mem_serialize_page; | |
| 315 } | |
| 316 | |
| 317 static inline void write_memory_serialize_page(JavaThread *thread) { | |
| 318 uintptr_t page_offset = ((uintptr_t)thread >> | |
| 319 get_serialize_page_shift_count()) & | |
| 320 get_serialize_page_mask(); | |
| 321 *(volatile int32_t *)((uintptr_t)_mem_serialize_page+page_offset) = 1; | |
| 322 } | |
| 323 | |
| 324 static bool is_memory_serialize_page(JavaThread *thread, address addr) { | |
| 325 if (UseMembar) return false; | |
| 1078 | 326 // Previously this function calculated the exact address of this |
| 327 // thread's serialize page, and checked if the faulting address | |
| 328 // was equal. However, some platforms mask off faulting addresses | |
| 329 // to the page size, so now we just check that the address is | |
| 330 // within the page. This makes the thread argument unnecessary, | |
| 331 // but we retain the NULL check to preserve existing behaviour. | |
| 0 | 332 if (thread == NULL) return false; |
| 1078 | 333 address page = (address) _mem_serialize_page; |
| 334 return addr >= page && addr < (page + os::vm_page_size()); | |
| 0 | 335 } |
| 336 | |
| 337 static void block_on_serialize_page_trap(); | |
| 338 | |
| 339 // threads | |
| 340 | |
| 341 enum ThreadType { | |
| 342 vm_thread, | |
| 343 cgc_thread, // Concurrent GC thread | |
| 344 pgc_thread, // Parallel GC thread | |
| 345 java_thread, | |
| 346 compiler_thread, | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
347 watcher_thread, |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
348 os_thread |
| 0 | 349 }; |
| 350 | |
| 351 static bool create_thread(Thread* thread, | |
| 352 ThreadType thr_type, | |
| 353 size_t stack_size = 0); | |
| 354 static bool create_main_thread(JavaThread* thread); | |
| 355 static bool create_attached_thread(JavaThread* thread); | |
| 356 static void pd_start_thread(Thread* thread); | |
| 357 static void start_thread(Thread* thread); | |
| 358 | |
| 359 static void initialize_thread(); | |
| 360 static void free_thread(OSThread* osthread); | |
| 361 | |
| 362 // thread id on Linux/64bit is 64bit, on Windows and Solaris, it's 32bit | |
| 363 static intx current_thread_id(); | |
| 364 static int current_process_id(); | |
| 365 static int sleep(Thread* thread, jlong ms, bool interruptable); | |
| 366 static int naked_sleep(); | |
| 367 static void infinite_sleep(); // never returns, use with CAUTION | |
| 368 static void yield(); // Yields to all threads with same priority | |
| 369 enum YieldResult { | |
| 370 YIELD_SWITCHED = 1, // caller descheduled, other ready threads exist & ran | |
| 371 YIELD_NONEREADY = 0, // No other runnable/ready threads. | |
| 372 // platform-specific yield return immediately | |
| 373 YIELD_UNKNOWN = -1 // Unknown: platform doesn't support _SWITCHED or _NONEREADY | |
| 374 // YIELD_SWITCHED and YIELD_NONREADY imply the platform supports a "strong" | |
| 375 // yield that can be used in lieu of blocking. | |
| 376 } ; | |
| 377 static YieldResult NakedYield () ; | |
| 378 static void yield_all(int attempts = 0); // Yields to all other threads including lower priority | |
| 379 static void loop_breaker(int attempts); // called from within tight loops to possibly influence time-sharing | |
| 380 static OSReturn set_priority(Thread* thread, ThreadPriority priority); | |
| 381 static OSReturn get_priority(const Thread* const thread, ThreadPriority& priority); | |
| 382 | |
| 383 static void interrupt(Thread* thread); | |
| 384 static bool is_interrupted(Thread* thread, bool clear_interrupted); | |
| 385 | |
| 386 static int pd_self_suspend_thread(Thread* thread); | |
| 387 | |
| 388 static ExtendedPC fetch_frame_from_context(void* ucVoid, intptr_t** sp, intptr_t** fp); | |
| 389 static frame fetch_frame_from_context(void* ucVoid); | |
| 390 | |
| 391 static ExtendedPC get_thread_pc(Thread *thread); | |
| 392 static void breakpoint(); | |
| 393 | |
| 394 static address current_stack_pointer(); | |
| 395 static address current_stack_base(); | |
| 396 static size_t current_stack_size(); | |
| 397 | |
| 398 static int message_box(const char* title, const char* message); | |
| 399 static char* do_you_want_to_debug(const char* message); | |
| 400 | |
| 401 // run cmd in a separate process and return its exit code; or -1 on failures | |
| 402 static int fork_and_exec(char *cmd); | |
| 403 | |
| 404 // Set file to send error reports. | |
| 405 static void set_error_file(const char *logfile); | |
| 406 | |
| 407 // os::exit() is merged with vm_exit() | |
| 408 // static void exit(int num); | |
| 409 | |
| 410 // Terminate the VM, but don't exit the process | |
| 411 static void shutdown(); | |
| 412 | |
| 413 // Terminate with an error. Default is to generate a core file on platforms | |
| 414 // that support such things. This calls shutdown() and then aborts. | |
| 415 static void abort(bool dump_core = true); | |
| 416 | |
| 417 // Die immediately, no exit hook, no abort hook, no cleanup. | |
| 418 static void die(); | |
| 419 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
420 // File i/o operations |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
421 static const int default_file_open_flags(); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
422 static int open(const char *path, int oflag, int mode); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
423 static int close(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
424 static jlong lseek(int fd, jlong offset, int whence); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
425 static char* native_path(char *path); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
426 static int ftruncate(int fd, jlong length); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
427 static int fsync(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
428 static int available(int fd, jlong *bytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
429 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
430 //File i/o operations |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
431 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
432 static size_t read(int fd, void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
433 static size_t restartable_read(int fd, void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
434 static size_t write(int fd, const void *buf, unsigned int nBytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
435 |
| 0 | 436 // Reading directories. |
| 437 static DIR* opendir(const char* dirname); | |
| 438 static int readdir_buf_size(const char *path); | |
| 439 static struct dirent* readdir(DIR* dirp, dirent* dbuf); | |
| 440 static int closedir(DIR* dirp); | |
| 441 | |
| 442 // Dynamic library extension | |
| 443 static const char* dll_file_extension(); | |
| 444 | |
| 445 static const char* get_temp_directory(); | |
| 446 static const char* get_current_directory(char *buf, int buflen); | |
| 447 | |
| 242 | 448 // Builds a platform-specific full library path given a ld path and lib name |
| 449 static void dll_build_name(char* buffer, size_t size, | |
| 450 const char* pathname, const char* fname); | |
| 451 | |
| 0 | 452 // Symbol lookup, find nearest function name; basically it implements |
| 453 // dladdr() for all platforms. Name of the nearest function is copied | |
| 454 // to buf. Distance from its base address is returned as offset. | |
| 455 // If function name is not found, buf[0] is set to '\0' and offset is | |
| 456 // set to -1. | |
| 457 static bool dll_address_to_function_name(address addr, char* buf, | |
| 458 int buflen, int* offset); | |
| 459 | |
| 460 // Locate DLL/DSO. On success, full path of the library is copied to | |
| 461 // buf, and offset is set to be the distance between addr and the | |
| 462 // library's base address. On failure, buf[0] is set to '\0' and | |
| 463 // offset is set to -1. | |
| 464 static bool dll_address_to_library_name(address addr, char* buf, | |
| 465 int buflen, int* offset); | |
| 466 | |
| 467 // Find out whether the pc is in the static code for jvm.dll/libjvm.so. | |
| 468 static bool address_is_in_vm(address addr); | |
| 469 | |
| 470 // Loads .dll/.so and | |
| 471 // in case of error it checks if .dll/.so was built for the | |
| 472 // same architecture as Hotspot is running on | |
| 473 static void* dll_load(const char *name, char *ebuf, int ebuflen); | |
| 474 | |
| 242 | 475 // lookup symbol in a shared library |
| 476 static void* dll_lookup(void* handle, const char* name); | |
| 477 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
478 // Unload library |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
479 static void dll_unload(void *lib); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
480 |
| 0 | 481 // Print out system information; they are called by fatal error handler. |
| 482 // Output format may be different on different platforms. | |
| 483 static void print_os_info(outputStream* st); | |
| 484 static void print_cpu_info(outputStream* st); | |
|
3800
bf6481e5f96d
7061225: os::print_cpu_info() should support os-specific data
jcoomes
parents:
3318
diff
changeset
|
485 static void pd_print_cpu_info(outputStream* st); |
| 0 | 486 static void print_memory_info(outputStream* st); |
| 487 static void print_dll_info(outputStream* st); | |
| 488 static void print_environment_variables(outputStream* st, const char** env_list, char* buffer, int len); | |
| 489 static void print_context(outputStream* st, void* context); | |
| 1907 | 490 static void print_register_info(outputStream* st, void* context); |
| 0 | 491 static void print_siginfo(outputStream* st, void* siginfo); |
| 492 static void print_signal_handlers(outputStream* st, char* buf, size_t buflen); | |
| 493 static void print_date_and_time(outputStream* st); | |
| 494 | |
| 1907 | 495 static void print_location(outputStream* st, intptr_t x, bool verbose = false); |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
496 static size_t lasterror(char *buf, size_t len); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
497 |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
498 // Determines whether the calling process is being debugged by a user-mode debugger. |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
499 static bool is_debugger_attached(); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
500 |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
501 // wait for a key press if PauseAtExit is set |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
502 static void wait_for_keypress_at_exit(void); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
503 |
| 0 | 504 // The following two functions are used by fatal error handler to trace |
| 505 // native (C) frames. They are not part of frame.hpp/frame.cpp because | |
| 506 // frame.hpp/cpp assume thread is JavaThread, and also because different | |
| 507 // OS/compiler may have different convention or provide different API to | |
| 508 // walk C frames. | |
| 509 // | |
| 510 // We don't attempt to become a debugger, so we only follow frames if that | |
| 511 // does not require a lookup in the unwind table, which is part of the binary | |
| 512 // file but may be unsafe to read after a fatal error. So on x86, we can | |
| 513 // only walk stack if %ebp is used as frame pointer; on ia64, it's not | |
| 514 // possible to walk C stack without having the unwind table. | |
| 515 static bool is_first_C_frame(frame *fr); | |
| 516 static frame get_sender_for_C_frame(frame *fr); | |
| 517 | |
| 518 // return current frame. pc() and sp() are set to NULL on failure. | |
| 519 static frame current_frame(); | |
| 520 | |
| 521 static void print_hex_dump(outputStream* st, address start, address end, int unitsize); | |
| 522 | |
| 523 // returns a string to describe the exception/signal; | |
| 524 // returns NULL if exception_code is not an OS exception/signal. | |
| 525 static const char* exception_name(int exception_code, char* buf, size_t buflen); | |
| 526 | |
| 527 // Returns native Java library, loads if necessary | |
| 528 static void* native_java_library(); | |
| 529 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
530 // Fills in path to jvm.dll/libjvm.so (used by the Disassembler) |
| 0 | 531 static void jvm_path(char *buf, jint buflen); |
| 532 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
533 // Returns true if we are running in a headless jre. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
534 static bool is_headless_jre(); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
535 |
| 0 | 536 // JNI names |
| 537 static void print_jni_name_prefix_on(outputStream* st, int args_size); | |
| 538 static void print_jni_name_suffix_on(outputStream* st, int args_size); | |
| 539 | |
| 540 // File conventions | |
| 541 static const char* file_separator(); | |
| 542 static const char* line_separator(); | |
| 543 static const char* path_separator(); | |
| 544 | |
| 545 // Init os specific system properties values | |
| 546 static void init_system_properties_values(); | |
| 547 | |
| 548 // IO operations, non-JVM_ version. | |
| 549 static int stat(const char* path, struct stat* sbuf); | |
| 550 static bool dir_is_empty(const char* path); | |
| 551 | |
| 552 // IO operations on binary files | |
| 553 static int create_binary_file(const char* path, bool rewrite_existing); | |
| 554 static jlong current_file_offset(int fd); | |
| 555 static jlong seek_to_file_offset(int fd, jlong offset); | |
| 556 | |
| 557 // Thread Local Storage | |
| 558 static int allocate_thread_local_storage(); | |
| 559 static void thread_local_storage_at_put(int index, void* value); | |
| 560 static void* thread_local_storage_at(int index); | |
| 561 static void free_thread_local_storage(int index); | |
| 562 | |
| 563 // General allocation (must be MT-safe) | |
| 564 static void* malloc (size_t size); | |
| 565 static void* realloc (void *memblock, size_t size); | |
| 566 static void free (void *memblock); | |
| 567 static bool check_heap(bool force = false); // verify C heap integrity | |
| 568 static char* strdup(const char *); // Like strdup | |
| 569 | |
| 570 #ifndef PRODUCT | |
| 2250 | 571 static julong num_mallocs; // # of calls to malloc/realloc |
| 572 static julong alloc_bytes; // # of bytes allocated | |
| 573 static julong num_frees; // # of calls to free | |
| 574 static julong free_bytes; // # of bytes freed | |
| 0 | 575 #endif |
| 576 | |
|
1980
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
577 // SocketInterface (ex HPI SocketInterface ) |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
578 static int socket(int domain, int type, int protocol); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
579 static int socket_close(int fd); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
580 static int socket_shutdown(int fd, int howto); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
581 static int recv(int fd, char *buf, int nBytes, int flags); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
582 static int send(int fd, char *buf, int nBytes, int flags); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
583 static int raw_send(int fd, char *buf, int nBytes, int flags); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
584 static int timeout(int fd, long timeout); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
585 static int listen(int fd, int count); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
586 static int connect(int fd, struct sockaddr *him, int len); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
587 static int bind(int fd, struct sockaddr *him, int len); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
588 static int accept(int fd, struct sockaddr *him, int *len); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
589 static int recvfrom(int fd, char *buf, int nbytes, int flags, |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
590 struct sockaddr *from, int *fromlen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
591 static int get_sock_name(int fd, struct sockaddr *him, int *len); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
592 static int sendto(int fd, char *buf, int len, int flags, |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
593 struct sockaddr *to, int tolen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
594 static int socket_available(int fd, jint *pbytes); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
595 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
596 static int get_sock_opt(int fd, int level, int optname, |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
597 char *optval, int* optlen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
598 static int set_sock_opt(int fd, int level, int optname, |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
599 const char *optval, int optlen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
600 static int get_host_name(char* name, int namelen); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
601 |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
602 static struct hostent* get_host_by_name(char* name); |
|
828eafbd85cc
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
1972
diff
changeset
|
603 |
| 0 | 604 // Printing 64 bit integers |
| 605 static const char* jlong_format_specifier(); | |
| 606 static const char* julong_format_specifier(); | |
| 607 | |
| 608 // Support for signals (see JVM_RaiseSignal, JVM_RegisterSignal) | |
| 609 static void signal_init(); | |
| 610 static void signal_init_pd(); | |
| 611 static void signal_notify(int signal_number); | |
| 612 static void* signal(int signal_number, void* handler); | |
| 613 static void signal_raise(int signal_number); | |
| 614 static int signal_wait(); | |
| 615 static int signal_lookup(); | |
| 616 static void* user_handler(); | |
| 617 static void terminate_signal_thread(); | |
| 618 static int sigexitnum_pd(); | |
| 619 | |
| 620 // random number generation | |
| 621 static long random(); // return 32bit pseudorandom number | |
| 622 static void init_random(long initval); // initialize random sequence | |
| 623 | |
| 624 // Structured OS Exception support | |
| 625 static void os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread); | |
| 626 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
627 // On Windows this will create an actual minidump, on Linux/Solaris it will simply check core dump limits |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
628 static void check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2192
diff
changeset
|
629 |
| 0 | 630 // JVMTI & JVM monitoring and management support |
| 631 // The thread_cpu_time() and current_thread_cpu_time() are only | |
| 632 // supported if is_thread_cpu_time_supported() returns true. | |
| 633 // They are not supported on Solaris T1. | |
| 634 | |
| 635 // Thread CPU Time - return the fast estimate on a platform | |
| 636 // On Solaris - call gethrvtime (fast) - user time only | |
| 637 // On Linux - fast clock_gettime where available - user+sys | |
| 638 // - otherwise: very slow /proc fs - user+sys | |
| 639 // On Windows - GetThreadTimes - user+sys | |
| 640 static jlong current_thread_cpu_time(); | |
| 641 static jlong thread_cpu_time(Thread* t); | |
| 642 | |
| 643 // Thread CPU Time with user_sys_cpu_time parameter. | |
| 644 // | |
| 645 // If user_sys_cpu_time is true, user+sys time is returned. | |
| 646 // Otherwise, only user time is returned | |
| 647 static jlong current_thread_cpu_time(bool user_sys_cpu_time); | |
| 648 static jlong thread_cpu_time(Thread* t, bool user_sys_cpu_time); | |
| 649 | |
| 650 // Return a bunch of info about the timers. | |
| 651 // Note that the returned info for these two functions may be different | |
| 652 // on some platforms | |
| 653 static void current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr); | |
| 654 static void thread_cpu_time_info(jvmtiTimerInfo *info_ptr); | |
| 655 | |
| 656 static bool is_thread_cpu_time_supported(); | |
| 657 | |
| 658 // System loadavg support. Returns -1 if load average cannot be obtained. | |
| 659 static int loadavg(double loadavg[], int nelem); | |
| 660 | |
| 661 // Hook for os specific jvm options that we don't want to abort on seeing | |
| 662 static bool obsolete_option(const JavaVMOption *option); | |
| 663 | |
|
2469
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2304
diff
changeset
|
664 // Read file line by line. If line is longer than bsize, |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2304
diff
changeset
|
665 // rest of line is skipped. Returns number of bytes read or -1 on EOF |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2304
diff
changeset
|
666 static int get_line_chars(int fd, char *buf, const size_t bsize); |
|
677234770800
7017193: Small memory leak in get_stack_bounds os::create_stack_guard_pages
dsamersoff
parents:
2304
diff
changeset
|
667 |
| 0 | 668 // Platform dependent stuff |
| 1972 | 669 #ifdef TARGET_OS_FAMILY_linux |
| 670 # include "os_linux.hpp" | |
| 671 #endif | |
| 672 #ifdef TARGET_OS_FAMILY_solaris | |
| 673 # include "os_solaris.hpp" | |
| 674 #endif | |
| 675 #ifdef TARGET_OS_FAMILY_windows | |
| 676 # include "os_windows.hpp" | |
| 677 #endif | |
| 678 #ifdef TARGET_OS_ARCH_linux_x86 | |
| 679 # include "os_linux_x86.hpp" | |
| 680 #endif | |
| 681 #ifdef TARGET_OS_ARCH_linux_sparc | |
| 682 # include "os_linux_sparc.hpp" | |
| 683 #endif | |
| 684 #ifdef TARGET_OS_ARCH_linux_zero | |
| 685 # include "os_linux_zero.hpp" | |
| 686 #endif | |
| 687 #ifdef TARGET_OS_ARCH_solaris_x86 | |
| 688 # include "os_solaris_x86.hpp" | |
| 689 #endif | |
| 690 #ifdef TARGET_OS_ARCH_solaris_sparc | |
| 691 # include "os_solaris_sparc.hpp" | |
| 692 #endif | |
| 693 #ifdef TARGET_OS_ARCH_windows_x86 | |
| 694 # include "os_windows_x86.hpp" | |
| 695 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
696 #ifdef TARGET_OS_ARCH_linux_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
697 # include "os_linux_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
698 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
699 #ifdef TARGET_OS_ARCH_linux_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
700 # include "os_linux_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1980
diff
changeset
|
701 #endif |
| 1972 | 702 |
| 0 | 703 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
704 // debugging support (mostly used by debug.cpp but also fatal error handler) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
705 static bool find(address pc, outputStream* st = tty); // OS specific function to make sense out of an address |
| 0 | 706 |
| 707 static bool dont_yield(); // when true, JVM_Yield() is nop | |
| 708 static void print_statistics(); | |
| 709 | |
| 710 // Thread priority helpers (implemented in OS-specific part) | |
| 711 static OSReturn set_native_priority(Thread* thread, int native_prio); | |
| 712 static OSReturn get_native_priority(const Thread* const thread, int* priority_ptr); | |
| 713 static int java_to_os_priority[MaxPriority + 1]; | |
| 714 // Hint to the underlying OS that a task switch would not be good. | |
| 715 // Void return because it's a hint and can fail. | |
| 716 static void hint_no_preempt(); | |
| 717 | |
| 718 // Used at creation if requested by the diagnostic flag PauseAtStartup. | |
| 719 // Causes the VM to wait until an external stimulus has been applied | |
| 720 // (for Unix, that stimulus is a signal, for Windows, an external | |
| 721 // ResumeThread call) | |
| 722 static void pause(); | |
| 723 | |
| 724 protected: | |
| 725 static long _rand_seed; // seed for random number generator | |
| 726 static int _processor_count; // number of processors | |
| 727 | |
| 728 static char* format_boot_path(const char* format_string, | |
| 729 const char* home, | |
| 730 int home_len, | |
| 731 char fileSep, | |
| 732 char pathSep); | |
| 733 static bool set_boot_path(char fileSep, char pathSep); | |
| 691 | 734 static char** split_path(const char* path, int* n); |
| 0 | 735 }; |
| 736 | |
| 737 // Note that "PAUSE" is almost always used with synchronization | |
| 738 // so arguably we should provide Atomic::SpinPause() instead | |
| 739 // of the global SpinPause() with C linkage. | |
| 740 // It'd also be eligible for inlining on many platforms. | |
| 741 | |
| 742 extern "C" int SpinPause () ; | |
| 743 extern "C" int SafeFetch32 (int * adr, int errValue) ; | |
| 744 extern "C" intptr_t SafeFetchN (intptr_t * adr, intptr_t errValue) ; | |
| 1972 | 745 |
| 746 #endif // SHARE_VM_RUNTIME_OS_HPP |