Mercurial > hg > truffle
annotate src/os/solaris/vm/os_solaris.hpp @ 4582:b24386206122
Made all vm builds go into subdirectories, even product builds to simplify building the various types of VMs (server, client and graal).
Made HotSpot build jobs use the number of CPUs on the host machine.
| author | Doug Simon <doug.simon@oracle.com> |
|---|---|
| date | Mon, 13 Feb 2012 23:13:37 +0100 |
| parents | f95d63e2154a |
| children | 7432b9db36ff |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, 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:
641
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
641
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:
641
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef OS_SOLARIS_VM_OS_SOLARIS_HPP |
| 26 #define OS_SOLARIS_VM_OS_SOLARIS_HPP | |
| 27 | |
| 0 | 28 // Solaris_OS defines the interface to Solaris operating systems |
| 29 | |
| 30 class Solaris { | |
| 31 friend class os; | |
| 32 | |
| 33 private: | |
| 34 | |
| 35 // Support for "new" libthread APIs for getting & setting thread context (2.8) | |
| 36 #define TRS_VALID 0 | |
| 37 #define TRS_NONVOLATILE 1 | |
| 38 #define TRS_LWPID 2 | |
| 39 #define TRS_INVALID 3 | |
| 40 | |
| 41 // _T2_libthread is true if we believe we are running with the newer | |
| 42 // SunSoft lib/lwp/libthread: default Solaris 9, available Solaris 8 | |
| 43 // which is a lightweight libthread that also supports all T1 | |
| 44 static bool _T2_libthread; | |
| 45 // These refer to new libthread interface functions | |
| 46 // They get intialized if we dynamically detect new libthread | |
| 47 static int_fnP_thread_t_iP_uP_stack_tP_gregset_t _thr_getstate; | |
| 48 static int_fnP_thread_t_i_gregset_t _thr_setstate; | |
| 49 static int_fnP_thread_t_i _thr_setmutator; | |
| 50 static int_fnP_thread_t _thr_suspend_mutator; | |
| 51 static int_fnP_thread_t _thr_continue_mutator; | |
| 52 // libthread_init sets the above, if the new functionality is detected | |
| 53 | |
| 54 // initialized to libthread or lwp synchronization primitives depending on UseLWPSychronization | |
| 55 static int_fnP_mutex_tP _mutex_lock; | |
| 56 static int_fnP_mutex_tP _mutex_trylock; | |
| 57 static int_fnP_mutex_tP _mutex_unlock; | |
| 58 static int_fnP_mutex_tP_i_vP _mutex_init; | |
| 59 static int_fnP_mutex_tP _mutex_destroy; | |
| 60 static int _mutex_scope; | |
| 61 | |
| 62 static int_fnP_cond_tP_mutex_tP_timestruc_tP _cond_timedwait; | |
| 63 static int_fnP_cond_tP_mutex_tP _cond_wait; | |
| 64 static int_fnP_cond_tP _cond_signal; | |
| 65 static int_fnP_cond_tP _cond_broadcast; | |
| 66 static int_fnP_cond_tP_i_vP _cond_init; | |
| 67 static int_fnP_cond_tP _cond_destroy; | |
| 68 static int _cond_scope; | |
| 69 | |
| 70 typedef uintptr_t lgrp_cookie_t; | |
| 71 typedef id_t lgrp_id_t; | |
|
144
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
72 typedef int lgrp_rsrc_t; |
| 0 | 73 typedef enum lgrp_view { |
| 74 LGRP_VIEW_CALLER, /* what's available to the caller */ | |
| 75 LGRP_VIEW_OS /* what's available to operating system */ | |
| 76 } lgrp_view_t; | |
| 77 | |
|
641
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
78 typedef uint_t (*getisax_func_t)(uint32_t* array, uint_t n); |
|
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
79 |
| 0 | 80 typedef lgrp_id_t (*lgrp_home_func_t)(idtype_t idtype, id_t id); |
| 81 typedef lgrp_cookie_t (*lgrp_init_func_t)(lgrp_view_t view); | |
| 82 typedef int (*lgrp_fini_func_t)(lgrp_cookie_t cookie); | |
| 83 typedef lgrp_id_t (*lgrp_root_func_t)(lgrp_cookie_t cookie); | |
| 84 typedef int (*lgrp_children_func_t)(lgrp_cookie_t cookie, lgrp_id_t parent, | |
| 85 lgrp_id_t *lgrp_array, uint_t lgrp_array_size); | |
|
144
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
86 typedef int (*lgrp_resources_func_t)(lgrp_cookie_t cookie, lgrp_id_t lgrp, |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
87 lgrp_id_t *lgrp_array, uint_t lgrp_array_size, |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
88 lgrp_rsrc_t type); |
| 0 | 89 typedef int (*lgrp_nlgrps_func_t)(lgrp_cookie_t cookie); |
| 90 typedef int (*lgrp_cookie_stale_func_t)(lgrp_cookie_t cookie); | |
| 91 typedef int (*meminfo_func_t)(const uint64_t inaddr[], int addr_count, | |
| 92 const uint_t info_req[], int info_count, | |
| 93 uint64_t outdata[], uint_t validity[]); | |
| 94 | |
|
641
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
95 static getisax_func_t _getisax; |
|
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
96 |
| 0 | 97 static lgrp_home_func_t _lgrp_home; |
| 98 static lgrp_init_func_t _lgrp_init; | |
| 99 static lgrp_fini_func_t _lgrp_fini; | |
| 100 static lgrp_root_func_t _lgrp_root; | |
| 101 static lgrp_children_func_t _lgrp_children; | |
|
144
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
102 static lgrp_resources_func_t _lgrp_resources; |
| 0 | 103 static lgrp_nlgrps_func_t _lgrp_nlgrps; |
| 104 static lgrp_cookie_stale_func_t _lgrp_cookie_stale; | |
| 105 static lgrp_cookie_t _lgrp_cookie; | |
| 106 | |
| 107 static meminfo_func_t _meminfo; | |
| 108 | |
| 109 // Large Page Support--mpss. | |
| 110 static bool set_mpss_range(caddr_t start, size_t bytes, size_t align); | |
| 111 | |
| 112 static void init_thread_fpu_state(void); | |
| 113 | |
| 114 static void try_enable_extended_io(); | |
| 115 | |
| 116 // For signal-chaining | |
| 117 static unsigned long sigs; // mask of signals that have | |
| 118 // preinstalled signal handlers | |
| 119 static struct sigaction *(*get_signal_action)(int); | |
| 120 static struct sigaction *get_preinstalled_handler(int); | |
| 121 static int (*get_libjsig_version)(); | |
| 122 static void save_preinstalled_handler(int, struct sigaction&); | |
| 123 static void check_signal_handler(int sig); | |
| 124 // For overridable signals | |
| 125 static int _SIGinterrupt; // user-overridable INTERRUPT_SIGNAL | |
| 126 static int _SIGasync; // user-overridable ASYNC_SIGNAL | |
| 127 static void set_SIGinterrupt(int newsig) { _SIGinterrupt = newsig; } | |
| 128 static void set_SIGasync(int newsig) { _SIGasync = newsig; } | |
| 129 | |
| 130 | |
| 131 public: | |
| 132 // Large Page Support--ISM. | |
| 133 static bool largepage_range(char* addr, size_t size); | |
| 134 | |
| 135 static int SIGinterrupt() { return _SIGinterrupt; } | |
| 136 static int SIGasync() { return _SIGasync; } | |
| 137 static address handler_start, handler_end; // start and end pc of thr_sighndlrinfo | |
| 138 | |
| 139 static bool valid_stack_address(Thread* thread, address sp); | |
| 140 static bool valid_ucontext(Thread* thread, ucontext_t* valid, ucontext_t* suspect); | |
| 141 static ucontext_t* get_valid_uc_in_signal_handler(Thread* thread, | |
| 142 ucontext_t* uc); | |
| 143 | |
| 144 static ExtendedPC ucontext_get_ExtendedPC(ucontext_t* uc); | |
| 145 static intptr_t* ucontext_get_sp(ucontext_t* uc); | |
| 146 // ucontext_get_fp() is only used by Solaris X86 (see note below) | |
| 147 static intptr_t* ucontext_get_fp(ucontext_t* uc); | |
| 148 | |
| 149 // For Analyzer Forte AsyncGetCallTrace profiling support: | |
| 150 // Parameter ret_fp is only used by Solaris X86. | |
| 151 // | |
| 152 // We should have different declarations of this interface in | |
| 153 // os_solaris_i486.hpp and os_solaris_sparc.hpp, but that file | |
| 154 // provides extensions to the os class and not the Solaris class. | |
| 155 static ExtendedPC fetch_frame_from_ucontext(Thread* thread, ucontext_t* uc, | |
| 156 intptr_t** ret_sp, intptr_t** ret_fp); | |
| 157 | |
| 158 static void hotspot_sigmask(Thread* thread); | |
| 159 | |
| 160 protected: | |
| 161 // Solaris-specific interface goes here | |
| 162 static julong available_memory(); | |
| 163 static julong physical_memory() { return _physical_memory; } | |
| 164 static julong _physical_memory; | |
| 165 static void initialize_system_info(); | |
| 166 static int _dev_zero_fd; | |
| 167 static int get_dev_zero_fd() { return _dev_zero_fd; } | |
| 168 static void set_dev_zero_fd(int fd) { _dev_zero_fd = fd; } | |
| 169 static char* mmap_chunk(char *addr, size_t size, int flags, int prot); | |
|
60
8d84e28e68ba
6204603: Modify hotspot to use new Solaris mmap semantics for class data archive file
sbohne
parents:
0
diff
changeset
|
170 static char* anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed); |
| 0 | 171 static bool mpss_sanity_check(bool warn, size_t * page_size); |
| 172 static bool ism_sanity_check (bool warn, size_t * page_size); | |
| 173 | |
| 174 // Workaround for 4352906. thr_stksegment sometimes returns | |
| 175 // a bad value for the primordial thread's stack base when | |
| 176 // it is called more than one time. | |
| 177 // Workaround is to cache the initial value to avoid further | |
| 178 // calls to thr_stksegment. | |
| 179 // It appears that someone (Hotspot?) is trashing the user's | |
| 180 // proc_t structure (note that this is a system struct). | |
| 181 static address _main_stack_base; | |
| 182 | |
| 183 public: | |
| 184 static void libthread_init(); | |
| 185 static void synchronization_init(); | |
|
462
85f1b9537f70
6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents:
196
diff
changeset
|
186 static bool liblgrp_init(); |
| 0 | 187 // Load miscellaneous symbols. |
| 188 static void misc_sym_init(); | |
| 189 // This boolean allows users to forward their own non-matching signals | |
| 190 // to JVM_handle_solaris_signal, harmlessly. | |
| 191 static bool signal_handlers_are_installed; | |
| 192 | |
| 193 static void signal_sets_init(); | |
| 194 static void install_signal_handlers(); | |
| 195 static void set_signal_handler(int sig, bool set_installed, bool oktochain); | |
| 196 static void init_signal_mem(); | |
| 197 static bool is_sig_ignored(int sig); | |
| 198 static void set_our_sigflags(int, int); | |
| 199 static int get_our_sigflags(int); | |
| 200 | |
| 201 // For signal-chaining | |
| 202 static bool libjsig_is_loaded; // libjsig that interposes sigaction(), | |
| 203 // signal(), sigset() is loaded | |
| 204 static struct sigaction *get_chained_signal_action(int sig); | |
| 205 static bool chained_handler(int sig, siginfo_t *siginfo, void *context); | |
| 206 | |
| 207 // The following allow us to link against both the old and new libthread (2.8) | |
| 208 // and exploit the new libthread functionality if available. | |
| 209 | |
| 210 static bool T2_libthread() { return _T2_libthread; } | |
| 211 static void set_T2_libthread(bool T2_libthread) { _T2_libthread = T2_libthread; } | |
| 212 | |
| 213 static int thr_getstate(thread_t tid, int *flag, unsigned *lwp, stack_t *ss, gregset_t rs) | |
| 214 { return _thr_getstate(tid, flag, lwp, ss, rs); } | |
| 215 static void set_thr_getstate(int_fnP_thread_t_iP_uP_stack_tP_gregset_t func) | |
| 216 { _thr_getstate = func; } | |
| 217 | |
| 218 static int thr_setstate(thread_t tid, int flag, gregset_t rs) { return _thr_setstate(tid, flag, rs); } | |
| 219 static void set_thr_setstate(int_fnP_thread_t_i_gregset_t func) { _thr_setstate = func; } | |
| 220 | |
| 221 static int thr_setmutator(thread_t tid, int enabled) { return _thr_setmutator(tid, enabled); } | |
| 222 static void set_thr_setmutator(int_fnP_thread_t_i func) { _thr_setmutator = func; } | |
| 223 | |
| 224 static int thr_suspend_mutator(thread_t tid) { return _thr_suspend_mutator(tid); } | |
| 225 static void set_thr_suspend_mutator(int_fnP_thread_t func) { _thr_suspend_mutator = func; } | |
| 226 | |
| 227 static int thr_continue_mutator(thread_t tid) { return _thr_continue_mutator(tid); } | |
| 228 static void set_thr_continue_mutator(int_fnP_thread_t func) { _thr_continue_mutator = func; } | |
| 229 | |
| 230 // Allows us to switch between lwp and thread -based synchronization | |
| 231 static int mutex_lock(mutex_t *mx) { return _mutex_lock(mx); } | |
| 232 static int mutex_trylock(mutex_t *mx) { return _mutex_trylock(mx); } | |
| 233 static int mutex_unlock(mutex_t *mx) { return _mutex_unlock(mx); } | |
| 234 static int mutex_init(mutex_t *mx) { return _mutex_init(mx, os::Solaris::mutex_scope(), NULL); } | |
| 235 static int mutex_destroy(mutex_t *mx) { return _mutex_destroy(mx); } | |
| 236 static int mutex_scope() { return _mutex_scope; } | |
| 237 | |
| 238 static void set_mutex_lock(int_fnP_mutex_tP func) { _mutex_lock = func; } | |
| 239 static void set_mutex_trylock(int_fnP_mutex_tP func) { _mutex_trylock = func; } | |
| 240 static void set_mutex_unlock(int_fnP_mutex_tP func) { _mutex_unlock = func; } | |
| 241 static void set_mutex_init(int_fnP_mutex_tP_i_vP func) { _mutex_init = func; } | |
| 242 static void set_mutex_destroy(int_fnP_mutex_tP func) { _mutex_destroy = func; } | |
| 243 static void set_mutex_scope(int scope) { _mutex_scope = scope; } | |
| 244 | |
| 245 static int cond_timedwait(cond_t *cv, mutex_t *mx, timestruc_t *abst) | |
| 246 { return _cond_timedwait(cv, mx, abst); } | |
| 247 static int cond_wait(cond_t *cv, mutex_t *mx) { return _cond_wait(cv, mx); } | |
| 248 static int cond_signal(cond_t *cv) { return _cond_signal(cv); } | |
| 249 static int cond_broadcast(cond_t *cv) { return _cond_broadcast(cv); } | |
| 250 static int cond_init(cond_t *cv) { return _cond_init(cv, os::Solaris::cond_scope(), NULL); } | |
| 251 static int cond_destroy(cond_t *cv) { return _cond_destroy(cv); } | |
| 252 static int cond_scope() { return _cond_scope; } | |
| 253 | |
| 254 static void set_cond_timedwait(int_fnP_cond_tP_mutex_tP_timestruc_tP func) | |
| 255 { _cond_timedwait = func; } | |
| 256 static void set_cond_wait(int_fnP_cond_tP_mutex_tP func) { _cond_wait = func; } | |
| 257 static void set_cond_signal(int_fnP_cond_tP func) { _cond_signal = func; } | |
| 258 static void set_cond_broadcast(int_fnP_cond_tP func) { _cond_broadcast = func; } | |
| 259 static void set_cond_init(int_fnP_cond_tP_i_vP func) { _cond_init = func; } | |
| 260 static void set_cond_destroy(int_fnP_cond_tP func) { _cond_destroy = func; } | |
| 261 static void set_cond_scope(int scope) { _cond_scope = scope; } | |
| 262 | |
| 263 static void set_lgrp_home(lgrp_home_func_t func) { _lgrp_home = func; } | |
| 264 static void set_lgrp_init(lgrp_init_func_t func) { _lgrp_init = func; } | |
| 265 static void set_lgrp_fini(lgrp_fini_func_t func) { _lgrp_fini = func; } | |
| 266 static void set_lgrp_root(lgrp_root_func_t func) { _lgrp_root = func; } | |
|
144
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
267 static void set_lgrp_children(lgrp_children_func_t func) { _lgrp_children = func; } |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
268 static void set_lgrp_resources(lgrp_resources_func_t func) { _lgrp_resources = func; } |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
269 static void set_lgrp_nlgrps(lgrp_nlgrps_func_t func) { _lgrp_nlgrps = func; } |
| 0 | 270 static void set_lgrp_cookie_stale(lgrp_cookie_stale_func_t func) { _lgrp_cookie_stale = func; } |
| 271 static void set_lgrp_cookie(lgrp_cookie_t cookie) { _lgrp_cookie = cookie; } | |
| 272 | |
| 273 static id_t lgrp_home(idtype_t type, id_t id) { return _lgrp_home != NULL ? _lgrp_home(type, id) : -1; } | |
| 274 static lgrp_cookie_t lgrp_init(lgrp_view_t view) { return _lgrp_init != NULL ? _lgrp_init(view) : 0; } | |
| 275 static int lgrp_fini(lgrp_cookie_t cookie) { return _lgrp_fini != NULL ? _lgrp_fini(cookie) : -1; } | |
| 276 static lgrp_id_t lgrp_root(lgrp_cookie_t cookie) { return _lgrp_root != NULL ? _lgrp_root(cookie) : -1; }; | |
| 277 static int lgrp_children(lgrp_cookie_t cookie, lgrp_id_t parent, | |
| 278 lgrp_id_t *lgrp_array, uint_t lgrp_array_size) { | |
| 279 return _lgrp_children != NULL ? _lgrp_children(cookie, parent, lgrp_array, lgrp_array_size) : -1; | |
| 280 } | |
|
144
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
281 static int lgrp_resources(lgrp_cookie_t cookie, lgrp_id_t lgrp, |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
282 lgrp_id_t *lgrp_array, uint_t lgrp_array_size, |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
283 lgrp_rsrc_t type) { |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
284 return _lgrp_resources != NULL ? _lgrp_resources(cookie, lgrp, lgrp_array, lgrp_array_size, type) : -1; |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
285 } |
|
e3729351c946
6697534: Premature GC and invalid lgrp selection with NUMA-aware allocator.
iveresov
parents:
60
diff
changeset
|
286 |
| 0 | 287 static int lgrp_nlgrps(lgrp_cookie_t cookie) { return _lgrp_nlgrps != NULL ? _lgrp_nlgrps(cookie) : -1; } |
| 288 static int lgrp_cookie_stale(lgrp_cookie_t cookie) { | |
| 289 return _lgrp_cookie_stale != NULL ? _lgrp_cookie_stale(cookie) : -1; | |
| 290 } | |
| 291 static lgrp_cookie_t lgrp_cookie() { return _lgrp_cookie; } | |
| 292 | |
|
641
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
293 static bool supports_getisax() { return _getisax != NULL; } |
|
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
294 static uint_t getisax(uint32_t* array, uint_t n); |
|
6af0a709d52b
6812587: Use auxv to determine SPARC hardware features on Solaris
twisti
parents:
462
diff
changeset
|
295 |
| 0 | 296 static void set_meminfo(meminfo_func_t func) { _meminfo = func; } |
| 297 static int meminfo (const uint64_t inaddr[], int addr_count, | |
| 298 const uint_t info_req[], int info_count, | |
| 299 uint64_t outdata[], uint_t validity[]) { | |
| 300 return _meminfo != NULL ? _meminfo(inaddr, addr_count, info_req, info_count, | |
| 301 outdata, validity) : -1; | |
| 302 } | |
| 303 | |
| 304 enum { | |
| 305 clear_interrupted = true | |
| 306 }; | |
| 307 static void setup_interruptible(JavaThread* thread); | |
| 308 static void setup_interruptible_already_blocked(JavaThread* thread); | |
| 309 static JavaThread* setup_interruptible(); | |
| 310 static void cleanup_interruptible(JavaThread* thread); | |
| 311 | |
| 312 // perf counter incrementers used by _INTERRUPTIBLE | |
| 313 | |
| 314 static void bump_interrupted_before_count(); | |
| 315 static void bump_interrupted_during_count(); | |
| 316 | |
| 317 #ifdef ASSERT | |
| 318 static JavaThread* setup_interruptible_native(); | |
| 319 static void cleanup_interruptible_native(JavaThread* thread); | |
| 320 #endif | |
| 321 | |
| 322 static sigset_t* unblocked_signals(); | |
| 323 static sigset_t* vm_signals(); | |
| 324 static sigset_t* allowdebug_blocked_signals(); | |
| 325 | |
| 326 // %%% Following should be promoted to os.hpp: | |
| 327 // Trace number of created threads | |
| 328 static jint _os_thread_limit; | |
| 329 static volatile jint _os_thread_count; | |
| 330 | |
| 331 // Minimum stack size a thread can be created with (allowing | |
| 332 // the VM to completely create the thread and enter user code) | |
| 333 | |
| 334 static size_t min_stack_allowed; | |
| 335 | |
| 336 // Stack overflow handling | |
| 337 | |
| 338 static int max_register_window_saves_before_flushing(); | |
| 339 | |
| 340 // Stack repair handling | |
| 341 | |
| 342 // none present | |
| 343 | |
| 344 }; | |
| 345 | |
| 346 class PlatformEvent : public CHeapObj { | |
| 347 private: | |
| 348 double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line | |
| 349 volatile int _Event ; | |
| 350 int _nParked ; | |
| 351 int _pipev [2] ; | |
| 352 mutex_t _mutex [1] ; | |
| 353 cond_t _cond [1] ; | |
| 354 double PostPad [2] ; | |
| 355 | |
| 356 protected: | |
| 357 // Defining a protected ctor effectively gives us an abstract base class. | |
| 358 // That is, a PlatformEvent can never be instantiated "naked" but only | |
| 359 // as a part of a ParkEvent (recall that ParkEvent extends PlatformEvent). | |
| 360 // TODO-FIXME: make dtor private | |
| 361 ~PlatformEvent() { guarantee (0, "invariant") ; } | |
| 362 PlatformEvent() { | |
| 363 int status; | |
| 364 status = os::Solaris::cond_init(_cond); | |
| 365 assert_status(status == 0, status, "cond_init"); | |
| 366 status = os::Solaris::mutex_init(_mutex); | |
| 367 assert_status(status == 0, status, "mutex_init"); | |
| 368 _Event = 0 ; | |
| 369 _nParked = 0 ; | |
| 370 _pipev[0] = _pipev[1] = -1 ; | |
| 371 } | |
| 372 | |
| 373 public: | |
| 374 // Exercise caution using reset() and fired() -- they may require MEMBARs | |
| 375 void reset() { _Event = 0 ; } | |
| 376 int fired() { return _Event; } | |
| 377 void park () ; | |
| 378 int park (jlong millis) ; | |
| 379 int TryPark () ; | |
| 380 void unpark () ; | |
| 381 } ; | |
| 382 | |
| 383 class PlatformParker : public CHeapObj { | |
| 384 protected: | |
| 385 mutex_t _mutex [1] ; | |
| 386 cond_t _cond [1] ; | |
| 387 | |
| 388 public: // TODO-FIXME: make dtor private | |
| 389 ~PlatformParker() { guarantee (0, "invariant") ; } | |
| 390 | |
| 391 public: | |
| 392 PlatformParker() { | |
| 393 int status; | |
| 394 status = os::Solaris::cond_init(_cond); | |
| 395 assert_status(status == 0, status, "cond_init"); | |
| 396 status = os::Solaris::mutex_init(_mutex); | |
| 397 assert_status(status == 0, status, "mutex_init"); | |
| 398 } | |
| 399 } ; | |
| 1972 | 400 |
| 401 #endif // OS_SOLARIS_VM_OS_SOLARIS_HPP |