Mercurial > hg > truffle
annotate src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp @ 20304:a22acf6d7598
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Mon, 21 Jul 2014 10:00:31 +0200 |
| parents | fbc0575cc9e4 |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 133 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
11153
diff
changeset
|
2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. |
| 133 | 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:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
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:
1490
diff
changeset
|
21 * questions. |
| 133 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 // no precompiled headers |
|
7204
f0c2369fda5a
8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
6842
diff
changeset
|
26 #include "asm/macroAssembler.hpp" |
| 1972 | 27 #include "classfile/classLoader.hpp" |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "classfile/vmSymbols.hpp" | |
| 30 #include "code/icBuffer.hpp" | |
| 31 #include "code/vtableStubs.hpp" | |
| 32 #include "interpreter/interpreter.hpp" | |
| 33 #include "jvm_linux.h" | |
| 34 #include "memory/allocation.inline.hpp" | |
| 35 #include "mutex_linux.inline.hpp" | |
| 36 #include "nativeInst_sparc.hpp" | |
| 37 #include "os_share_linux.hpp" | |
| 38 #include "prims/jniFastGetField.hpp" | |
| 39 #include "prims/jvm.h" | |
| 40 #include "prims/jvm_misc.hpp" | |
| 41 #include "runtime/arguments.hpp" | |
| 42 #include "runtime/extendedPC.hpp" | |
| 43 #include "runtime/frame.inline.hpp" | |
| 44 #include "runtime/interfaceSupport.hpp" | |
| 45 #include "runtime/java.hpp" | |
| 46 #include "runtime/javaCalls.hpp" | |
| 47 #include "runtime/mutexLocker.hpp" | |
| 48 #include "runtime/osThread.hpp" | |
| 49 #include "runtime/sharedRuntime.hpp" | |
| 50 #include "runtime/stubRoutines.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6842
diff
changeset
|
51 #include "runtime/thread.inline.hpp" |
| 1972 | 52 #include "runtime/timer.hpp" |
| 53 #include "utilities/events.hpp" | |
| 54 #include "utilities/vmError.hpp" | |
| 133 | 55 |
| 56 // Linux/Sparc has rather obscure naming of registers in sigcontext | |
| 57 // different between 32 and 64 bits | |
| 58 #ifdef _LP64 | |
| 59 #define SIG_PC(x) ((x)->sigc_regs.tpc) | |
| 60 #define SIG_NPC(x) ((x)->sigc_regs.tnpc) | |
| 61 #define SIG_REGS(x) ((x)->sigc_regs) | |
| 62 #else | |
| 63 #define SIG_PC(x) ((x)->si_regs.pc) | |
| 64 #define SIG_NPC(x) ((x)->si_regs.npc) | |
| 65 #define SIG_REGS(x) ((x)->si_regs) | |
| 66 #endif | |
| 67 | |
| 68 // those are to reference registers in sigcontext | |
| 69 enum { | |
| 70 CON_G0 = 0, | |
| 71 CON_G1, | |
| 72 CON_G2, | |
| 73 CON_G3, | |
| 74 CON_G4, | |
| 75 CON_G5, | |
| 76 CON_G6, | |
| 77 CON_G7, | |
| 78 CON_O0, | |
| 79 CON_O1, | |
| 80 CON_O2, | |
| 81 CON_O3, | |
| 82 CON_O4, | |
| 83 CON_O5, | |
| 84 CON_O6, | |
| 85 CON_O7, | |
| 86 }; | |
| 87 | |
| 88 static inline void set_cont_address(sigcontext* ctx, address addr) { | |
| 89 SIG_PC(ctx) = (intptr_t)addr; | |
| 90 SIG_NPC(ctx) = (intptr_t)(addr+4); | |
| 91 } | |
| 92 | |
| 93 // For Forte Analyzer AsyncGetCallTrace profiling support - thread is | |
| 94 // currently interrupted by SIGPROF. | |
| 95 // os::Solaris::fetch_frame_from_ucontext() tries to skip nested | |
| 96 // signal frames. Currently we don't do that on Linux, so it's the | |
| 97 // same as os::fetch_frame_from_context(). | |
| 98 ExtendedPC os::Linux::fetch_frame_from_ucontext(Thread* thread, | |
| 99 ucontext_t* uc, | |
| 100 intptr_t** ret_sp, | |
| 101 intptr_t** ret_fp) { | |
| 102 assert(thread != NULL, "just checking"); | |
| 103 assert(ret_sp != NULL, "just checking"); | |
| 104 assert(ret_fp != NULL, "just checking"); | |
| 105 | |
| 106 return os::fetch_frame_from_context(uc, ret_sp, ret_fp); | |
| 107 } | |
| 108 | |
| 109 ExtendedPC os::fetch_frame_from_context(void* ucVoid, | |
| 110 intptr_t** ret_sp, | |
| 111 intptr_t** ret_fp) { | |
| 112 ucontext_t* uc = (ucontext_t*) ucVoid; | |
| 113 ExtendedPC epc; | |
| 114 | |
| 115 if (uc != NULL) { | |
| 116 epc = ExtendedPC(os::Linux::ucontext_get_pc(uc)); | |
| 117 if (ret_sp) { | |
| 118 *ret_sp = os::Linux::ucontext_get_sp(uc); | |
| 119 } | |
| 120 if (ret_fp) { | |
|
20207
fbc0575cc9e4
8050167: linux-sparcv9: hs_err file does not show any stack information
zgu
parents:
20206
diff
changeset
|
121 *ret_fp = (intptr_t*)NULL; |
| 133 | 122 } |
| 123 } else { | |
| 124 // construct empty ExtendedPC for return value checking | |
| 125 epc = ExtendedPC(NULL); | |
| 126 if (ret_sp) { | |
| 127 *ret_sp = (intptr_t*) NULL; | |
| 128 } | |
| 129 if (ret_fp) { | |
| 130 *ret_fp = (intptr_t*) NULL; | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 return epc; | |
| 135 } | |
| 136 | |
| 137 frame os::fetch_frame_from_context(void* ucVoid) { | |
| 138 intptr_t* sp; | |
|
20207
fbc0575cc9e4
8050167: linux-sparcv9: hs_err file does not show any stack information
zgu
parents:
20206
diff
changeset
|
139 ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, NULL); |
|
fbc0575cc9e4
8050167: linux-sparcv9: hs_err file does not show any stack information
zgu
parents:
20206
diff
changeset
|
140 return frame(sp, frame::unpatchable, epc.pc()); |
| 133 | 141 } |
| 142 | |
| 143 frame os::get_sender_for_C_frame(frame* fr) { | |
|
20206
1cddf026d2cc
8050165: linux-sparcv9: NMT detail causes assert((intptr_t*)younger_sp[FP->sp_offset_in_saved_window()] == (intptr_t*)((intptr_t)sp - STACK_BIAS)) failed: younger_sp must be valid
zgu
parents:
17940
diff
changeset
|
144 return frame(fr->sender_sp(), frame::unpatchable, fr->sender_pc()); |
| 133 | 145 } |
| 146 | |
| 147 frame os::current_frame() { | |
| 148 intptr_t* sp = StubRoutines::Sparc::flush_callers_register_windows_func()(); | |
| 149 frame myframe(sp, frame::unpatchable, | |
| 150 CAST_FROM_FN_PTR(address, os::current_frame)); | |
| 151 if (os::is_first_C_frame(&myframe)) { | |
| 152 // stack is not walkable | |
| 153 return frame(NULL, frame::unpatchable, NULL); | |
| 154 } else { | |
| 155 return os::get_sender_for_C_frame(&myframe); | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 address os::current_stack_pointer() { | |
| 160 register void *sp __asm__ ("sp"); | |
| 161 return (address)sp; | |
| 162 } | |
| 163 | |
| 164 static void current_stack_region(address* bottom, size_t* size) { | |
| 165 if (os::Linux::is_initial_thread()) { | |
| 166 // initial thread needs special handling because pthread_getattr_np() | |
| 167 // may return bogus value. | |
| 168 *bottom = os::Linux::initial_thread_stack_bottom(); | |
| 169 *size = os::Linux::initial_thread_stack_size(); | |
| 170 } else { | |
| 171 pthread_attr_t attr; | |
| 172 | |
| 173 int rslt = pthread_getattr_np(pthread_self(), &attr); | |
| 174 | |
| 175 // JVM needs to know exact stack location, abort if it fails | |
| 176 if (rslt != 0) { | |
| 177 if (rslt == ENOMEM) { | |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
8710
diff
changeset
|
178 vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np"); |
| 133 | 179 } else { |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
196
diff
changeset
|
180 fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt)); |
| 133 | 181 } |
| 182 } | |
| 183 | |
| 184 if (pthread_attr_getstack(&attr, (void**)bottom, size) != 0) { | |
| 185 fatal("Can not locate current stack attributes!"); | |
| 186 } | |
| 187 | |
| 188 pthread_attr_destroy(&attr); | |
| 189 } | |
| 190 assert(os::current_stack_pointer() >= *bottom && | |
| 191 os::current_stack_pointer() < *bottom + *size, "just checking"); | |
| 192 } | |
| 193 | |
| 194 address os::current_stack_base() { | |
| 195 address bottom; | |
| 196 size_t size; | |
| 197 current_stack_region(&bottom, &size); | |
| 198 return bottom + size; | |
| 199 } | |
| 200 | |
| 201 size_t os::current_stack_size() { | |
| 202 // stack size includes normal stack and HotSpot guard pages | |
| 203 address bottom; | |
| 204 size_t size; | |
| 205 current_stack_region(&bottom, &size); | |
| 206 return size; | |
| 207 } | |
| 208 | |
| 209 char* os::non_memory_address_word() { | |
| 210 // Must never look like an address returned by reserve_memory, | |
| 211 // even in its subfields (as defined by the CPU immediate fields, | |
| 212 // if the CPU splits constants across multiple instructions). | |
| 213 // On SPARC, 0 != %hi(any real address), because there is no | |
| 214 // allocation in the first 1Kb of the virtual address space. | |
| 215 return (char*) 0; | |
| 216 } | |
| 217 | |
|
6768
716e6ef4482a
7190089: NMT ON: NMT failed assertion on thread's stack base address
zgu
parents:
5903
diff
changeset
|
218 void os::initialize_thread(Thread* thr) {} |
| 133 | 219 |
| 220 void os::print_context(outputStream *st, void *context) { | |
| 221 if (context == NULL) return; | |
| 222 | |
| 223 ucontext_t* uc = (ucontext_t*)context; | |
| 224 sigcontext* sc = (sigcontext*)context; | |
| 225 st->print_cr("Registers:"); | |
| 226 | |
| 1907 | 227 st->print_cr(" G1=" INTPTR_FORMAT " G2=" INTPTR_FORMAT |
| 228 " G3=" INTPTR_FORMAT " G4=" INTPTR_FORMAT, | |
| 229 SIG_REGS(sc).u_regs[CON_G1], | |
| 230 SIG_REGS(sc).u_regs[CON_G2], | |
| 231 SIG_REGS(sc).u_regs[CON_G3], | |
| 232 SIG_REGS(sc).u_regs[CON_G4]); | |
| 233 st->print_cr(" G5=" INTPTR_FORMAT " G6=" INTPTR_FORMAT | |
| 234 " G7=" INTPTR_FORMAT " Y=" INTPTR_FORMAT, | |
| 235 SIG_REGS(sc).u_regs[CON_G5], | |
| 236 SIG_REGS(sc).u_regs[CON_G6], | |
| 237 SIG_REGS(sc).u_regs[CON_G7], | |
| 238 SIG_REGS(sc).y); | |
| 133 | 239 st->print_cr(" O0=" INTPTR_FORMAT " O1=" INTPTR_FORMAT |
| 240 " O2=" INTPTR_FORMAT " O3=" INTPTR_FORMAT, | |
| 241 SIG_REGS(sc).u_regs[CON_O0], | |
| 242 SIG_REGS(sc).u_regs[CON_O1], | |
| 243 SIG_REGS(sc).u_regs[CON_O2], | |
| 244 SIG_REGS(sc).u_regs[CON_O3]); | |
| 245 st->print_cr(" O4=" INTPTR_FORMAT " O5=" INTPTR_FORMAT | |
| 246 " O6=" INTPTR_FORMAT " O7=" INTPTR_FORMAT, | |
| 247 SIG_REGS(sc).u_regs[CON_O4], | |
| 248 SIG_REGS(sc).u_regs[CON_O5], | |
| 249 SIG_REGS(sc).u_regs[CON_O6], | |
| 250 SIG_REGS(sc).u_regs[CON_O7]); | |
| 251 | |
| 1907 | 252 |
| 253 intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc); | |
| 254 st->print_cr(" L0=" INTPTR_FORMAT " L1=" INTPTR_FORMAT | |
| 255 " L2=" INTPTR_FORMAT " L3=" INTPTR_FORMAT, | |
| 256 sp[L0->sp_offset_in_saved_window()], | |
| 257 sp[L1->sp_offset_in_saved_window()], | |
| 258 sp[L2->sp_offset_in_saved_window()], | |
| 259 sp[L3->sp_offset_in_saved_window()]); | |
| 260 st->print_cr(" L4=" INTPTR_FORMAT " L5=" INTPTR_FORMAT | |
| 261 " L6=" INTPTR_FORMAT " L7=" INTPTR_FORMAT, | |
| 262 sp[L4->sp_offset_in_saved_window()], | |
| 263 sp[L5->sp_offset_in_saved_window()], | |
| 264 sp[L6->sp_offset_in_saved_window()], | |
| 265 sp[L7->sp_offset_in_saved_window()]); | |
| 266 st->print_cr(" I0=" INTPTR_FORMAT " I1=" INTPTR_FORMAT | |
| 267 " I2=" INTPTR_FORMAT " I3=" INTPTR_FORMAT, | |
| 268 sp[I0->sp_offset_in_saved_window()], | |
| 269 sp[I1->sp_offset_in_saved_window()], | |
| 270 sp[I2->sp_offset_in_saved_window()], | |
| 271 sp[I3->sp_offset_in_saved_window()]); | |
| 272 st->print_cr(" I4=" INTPTR_FORMAT " I5=" INTPTR_FORMAT | |
| 273 " I6=" INTPTR_FORMAT " I7=" INTPTR_FORMAT, | |
| 274 sp[I4->sp_offset_in_saved_window()], | |
| 275 sp[I5->sp_offset_in_saved_window()], | |
| 276 sp[I6->sp_offset_in_saved_window()], | |
| 277 sp[I7->sp_offset_in_saved_window()]); | |
| 133 | 278 |
| 279 st->print_cr(" PC=" INTPTR_FORMAT " nPC=" INTPTR_FORMAT, | |
| 280 SIG_PC(sc), | |
| 281 SIG_NPC(sc)); | |
| 282 st->cr(); | |
| 283 st->cr(); | |
| 284 | |
| 285 st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp); | |
| 286 print_hex_dump(st, (address)sp, (address)(sp + 32), sizeof(intptr_t)); | |
| 287 st->cr(); | |
| 288 | |
| 289 // Note: it may be unsafe to inspect memory near pc. For example, pc may | |
| 290 // point to garbage if entry point in an nmethod is corrupted. Leave | |
| 291 // this at the end, and hope for the best. | |
| 292 address pc = os::Linux::ucontext_get_pc(uc); | |
| 293 st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc); | |
| 1907 | 294 print_hex_dump(st, pc - 32, pc + 32, sizeof(char)); |
| 295 } | |
| 296 | |
| 297 | |
| 298 void os::print_register_info(outputStream *st, void *context) { | |
| 299 if (context == NULL) return; | |
| 300 | |
| 301 ucontext_t *uc = (ucontext_t*)context; | |
| 17940 | 302 sigcontext* sc = (sigcontext*)context; |
| 1907 | 303 intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc); |
| 304 | |
| 305 st->print_cr("Register to memory mapping:"); | |
| 306 st->cr(); | |
| 307 | |
| 308 // this is only for the "general purpose" registers | |
| 17940 | 309 st->print("G1="); print_location(st, SIG_REGS(sc).u_regs[CON_G1]); |
| 310 st->print("G2="); print_location(st, SIG_REGS(sc).u_regs[CON_G2]); | |
| 311 st->print("G3="); print_location(st, SIG_REGS(sc).u_regs[CON_G3]); | |
| 312 st->print("G4="); print_location(st, SIG_REGS(sc).u_regs[CON_G4]); | |
| 313 st->print("G5="); print_location(st, SIG_REGS(sc).u_regs[CON_G5]); | |
| 314 st->print("G6="); print_location(st, SIG_REGS(sc).u_regs[CON_G6]); | |
| 315 st->print("G7="); print_location(st, SIG_REGS(sc).u_regs[CON_G7]); | |
| 1907 | 316 st->cr(); |
| 317 | |
| 17940 | 318 st->print("O0="); print_location(st, SIG_REGS(sc).u_regs[CON_O0]); |
| 319 st->print("O1="); print_location(st, SIG_REGS(sc).u_regs[CON_O1]); | |
| 320 st->print("O2="); print_location(st, SIG_REGS(sc).u_regs[CON_O2]); | |
| 321 st->print("O3="); print_location(st, SIG_REGS(sc).u_regs[CON_O3]); | |
| 322 st->print("O4="); print_location(st, SIG_REGS(sc).u_regs[CON_O4]); | |
| 323 st->print("O5="); print_location(st, SIG_REGS(sc).u_regs[CON_O5]); | |
| 324 st->print("O6="); print_location(st, SIG_REGS(sc).u_regs[CON_O6]); | |
| 325 st->print("O7="); print_location(st, SIG_REGS(sc).u_regs[CON_O7]); | |
| 1907 | 326 st->cr(); |
| 327 | |
| 328 st->print("L0="); print_location(st, sp[L0->sp_offset_in_saved_window()]); | |
| 329 st->print("L1="); print_location(st, sp[L1->sp_offset_in_saved_window()]); | |
| 330 st->print("L2="); print_location(st, sp[L2->sp_offset_in_saved_window()]); | |
| 331 st->print("L3="); print_location(st, sp[L3->sp_offset_in_saved_window()]); | |
| 332 st->print("L4="); print_location(st, sp[L4->sp_offset_in_saved_window()]); | |
| 333 st->print("L5="); print_location(st, sp[L5->sp_offset_in_saved_window()]); | |
| 334 st->print("L6="); print_location(st, sp[L6->sp_offset_in_saved_window()]); | |
| 335 st->print("L7="); print_location(st, sp[L7->sp_offset_in_saved_window()]); | |
| 336 st->cr(); | |
| 337 | |
| 338 st->print("I0="); print_location(st, sp[I0->sp_offset_in_saved_window()]); | |
| 339 st->print("I1="); print_location(st, sp[I1->sp_offset_in_saved_window()]); | |
| 340 st->print("I2="); print_location(st, sp[I2->sp_offset_in_saved_window()]); | |
| 341 st->print("I3="); print_location(st, sp[I3->sp_offset_in_saved_window()]); | |
| 342 st->print("I4="); print_location(st, sp[I4->sp_offset_in_saved_window()]); | |
| 343 st->print("I5="); print_location(st, sp[I5->sp_offset_in_saved_window()]); | |
| 344 st->print("I6="); print_location(st, sp[I6->sp_offset_in_saved_window()]); | |
| 345 st->print("I7="); print_location(st, sp[I7->sp_offset_in_saved_window()]); | |
| 346 st->cr(); | |
| 133 | 347 } |
| 348 | |
| 349 | |
| 350 address os::Linux::ucontext_get_pc(ucontext_t* uc) { | |
| 351 return (address) SIG_PC((sigcontext*)uc); | |
| 352 } | |
| 353 | |
| 354 intptr_t* os::Linux::ucontext_get_sp(ucontext_t *uc) { | |
| 355 return (intptr_t*) | |
| 356 ((intptr_t)SIG_REGS((sigcontext*)uc).u_regs[CON_O6] + STACK_BIAS); | |
| 357 } | |
| 358 | |
| 359 // not used on Sparc | |
| 360 intptr_t* os::Linux::ucontext_get_fp(ucontext_t *uc) { | |
| 361 ShouldNotReachHere(); | |
| 362 return NULL; | |
| 363 } | |
| 364 | |
| 365 // Utility functions | |
| 366 | |
| 367 inline static bool checkPrefetch(sigcontext* uc, address pc) { | |
| 11127 | 368 if (StubRoutines::is_safefetch_fault(pc)) { |
| 369 set_cont_address(uc, address(StubRoutines::continuation_for_safefetch_fault(pc))); | |
| 133 | 370 return true; |
| 371 } | |
| 372 return false; | |
| 373 } | |
| 374 | |
| 375 inline static bool checkOverflow(sigcontext* uc, | |
| 376 address pc, | |
| 377 address addr, | |
| 378 JavaThread* thread, | |
| 379 address* stub) { | |
| 380 // check if fault address is within thread stack | |
| 381 if (addr < thread->stack_base() && | |
| 382 addr >= thread->stack_base() - thread->stack_size()) { | |
| 383 // stack overflow | |
| 384 if (thread->in_stack_yellow_zone(addr)) { | |
| 385 thread->disable_stack_yellow_zone(); | |
| 386 if (thread->thread_state() == _thread_in_Java) { | |
| 387 // Throw a stack overflow exception. Guard pages will be reenabled | |
| 388 // while unwinding the stack. | |
| 389 *stub = | |
| 390 SharedRuntime::continuation_for_implicit_exception(thread, | |
| 391 pc, | |
| 392 SharedRuntime::STACK_OVERFLOW); | |
| 393 } else { | |
| 394 // Thread was in the vm or native code. Return and try to finish. | |
| 395 return true; | |
| 396 } | |
| 397 } else if (thread->in_stack_red_zone(addr)) { | |
| 398 // Fatal red zone violation. Disable the guard pages and fall through | |
| 399 // to handle_unexpected_exception way down below. | |
| 400 thread->disable_stack_red_zone(); | |
| 401 tty->print_raw_cr("An irrecoverable stack overflow has occurred."); | |
|
8710
9058789475af
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
7206
diff
changeset
|
402 |
|
9058789475af
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
7206
diff
changeset
|
403 // This is a likely cause, but hard to verify. Let's just print |
|
9058789475af
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
7206
diff
changeset
|
404 // it as a hint. |
|
9058789475af
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
7206
diff
changeset
|
405 tty->print_raw_cr("Please check if any of your loaded .so files has " |
|
9058789475af
7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents:
7206
diff
changeset
|
406 "enabled executable stack (see man page execstack(8))"); |
| 133 | 407 } else { |
| 408 // Accessing stack address below sp may cause SEGV if current | |
| 409 // thread has MAP_GROWSDOWN stack. This should only happen when | |
| 410 // current thread was created by user code with MAP_GROWSDOWN flag | |
| 411 // and then attached to VM. See notes in os_linux.cpp. | |
| 412 if (thread->osthread()->expanding_stack() == 0) { | |
| 413 thread->osthread()->set_expanding_stack(); | |
| 414 if (os::Linux::manually_expand_stack(thread, addr)) { | |
| 415 thread->osthread()->clear_expanding_stack(); | |
| 416 return true; | |
| 417 } | |
| 418 thread->osthread()->clear_expanding_stack(); | |
| 419 } else { | |
| 420 fatal("recursive segv. expanding stack."); | |
| 421 } | |
| 422 } | |
| 423 } | |
| 424 return false; | |
| 425 } | |
| 426 | |
| 427 inline static bool checkPollingPage(address pc, address fault, address* stub) { | |
| 428 if (fault == os::get_polling_page()) { | |
| 429 *stub = SharedRuntime::get_poll_stub(pc); | |
| 430 return true; | |
| 431 } | |
| 432 return false; | |
| 433 } | |
| 434 | |
| 435 inline static bool checkByteBuffer(address pc, address* stub) { | |
| 436 // BugId 4454115: A read from a MappedByteBuffer can fault | |
| 437 // here if the underlying file has been truncated. | |
| 438 // Do not crash the VM in such a case. | |
| 439 CodeBlob* cb = CodeCache::find_blob_unsafe(pc); | |
| 440 nmethod* nm = cb->is_nmethod() ? (nmethod*)cb : NULL; | |
| 441 if (nm != NULL && nm->has_unsafe_access()) { | |
| 442 *stub = StubRoutines::handler_for_unsafe_access(); | |
| 443 return true; | |
| 444 } | |
| 445 return false; | |
| 446 } | |
| 447 | |
| 448 inline static bool checkVerifyOops(address pc, address fault, address* stub) { | |
| 449 if (pc >= MacroAssembler::_verify_oop_implicit_branch[0] | |
| 450 && pc < MacroAssembler::_verify_oop_implicit_branch[1] ) { | |
| 451 *stub = MacroAssembler::_verify_oop_implicit_branch[2]; | |
| 452 warning("fixed up memory fault in +VerifyOops at address " | |
| 453 INTPTR_FORMAT, fault); | |
| 454 return true; | |
| 455 } | |
| 456 return false; | |
| 457 } | |
| 458 | |
| 459 inline static bool checkFPFault(address pc, int code, | |
| 460 JavaThread* thread, address* stub) { | |
| 461 if (code == FPE_INTDIV || code == FPE_FLTDIV) { | |
| 462 *stub = | |
| 463 SharedRuntime:: | |
| 464 continuation_for_implicit_exception(thread, | |
| 465 pc, | |
| 466 SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO); | |
| 467 return true; | |
| 468 } | |
| 469 return false; | |
| 470 } | |
| 471 | |
| 472 inline static bool checkNullPointer(address pc, intptr_t fault, | |
| 473 JavaThread* thread, address* stub) { | |
| 474 if (!MacroAssembler::needs_explicit_null_check(fault)) { | |
| 475 // Determination of interpreter/vtable stub/compiled code null | |
| 476 // exception | |
| 477 *stub = | |
| 478 SharedRuntime:: | |
| 479 continuation_for_implicit_exception(thread, pc, | |
| 480 SharedRuntime::IMPLICIT_NULL); | |
| 481 return true; | |
| 482 } | |
| 483 return false; | |
| 484 } | |
| 485 | |
| 486 inline static bool checkFastJNIAccess(address pc, address* stub) { | |
| 487 address addr = JNI_FastGetField::find_slowcase_pc(pc); | |
| 488 if (addr != (address)-1) { | |
| 489 *stub = addr; | |
| 490 return true; | |
| 491 } | |
| 492 return false; | |
| 493 } | |
| 494 | |
| 495 inline static bool checkSerializePage(JavaThread* thread, address addr) { | |
| 496 return os::is_memory_serialize_page(thread, addr); | |
| 497 } | |
| 498 | |
| 499 inline static bool checkZombie(sigcontext* uc, address* pc, address* stub) { | |
| 500 if (nativeInstruction_at(*pc)->is_zombie()) { | |
| 501 // zombie method (ld [%g0],%o7 instruction) | |
| 502 *stub = SharedRuntime::get_handle_wrong_method_stub(); | |
| 503 | |
| 504 // At the stub it needs to look like a call from the caller of this | |
| 505 // method (not a call from the segv site). | |
| 506 *pc = (address)SIG_REGS(uc).u_regs[CON_O7]; | |
| 507 return true; | |
| 508 } | |
| 509 return false; | |
| 510 } | |
| 511 | |
| 512 inline static bool checkICMiss(sigcontext* uc, address* pc, address* stub) { | |
| 513 #ifdef COMPILER2 | |
| 514 if (nativeInstruction_at(*pc)->is_ic_miss_trap()) { | |
| 515 #ifdef ASSERT | |
| 516 #ifdef TIERED | |
| 17940 | 517 CodeBlob* cb = CodeCache::find_blob_unsafe(*pc); |
| 133 | 518 assert(cb->is_compiled_by_c2(), "Wrong compiler"); |
| 519 #endif // TIERED | |
| 520 #endif // ASSERT | |
| 521 // Inline cache missed and user trap "Tne G0+ST_RESERVED_FOR_USER_0+2" taken. | |
| 522 *stub = SharedRuntime::get_ic_miss_stub(); | |
| 523 // At the stub it needs to look like a call from the caller of this | |
| 524 // method (not a call from the segv site). | |
| 525 *pc = (address)SIG_REGS(uc).u_regs[CON_O7]; | |
| 526 return true; | |
| 527 } | |
| 528 #endif // COMPILER2 | |
| 529 return false; | |
| 530 } | |
| 531 | |
| 2191 | 532 extern "C" JNIEXPORT int |
| 133 | 533 JVM_handle_linux_signal(int sig, |
| 534 siginfo_t* info, | |
| 535 void* ucVoid, | |
| 536 int abort_if_unrecognized) { | |
| 537 // in fact this isn't ucontext_t* at all, but struct sigcontext* | |
| 538 // but Linux porting layer uses ucontext_t, so to minimize code change | |
| 539 // we cast as needed | |
| 540 ucontext_t* ucFake = (ucontext_t*) ucVoid; | |
| 541 sigcontext* uc = (sigcontext*)ucVoid; | |
| 542 | |
| 543 Thread* t = ThreadLocalStorage::get_thread_slow(); | |
| 544 | |
| 11151 | 545 // Must do this before SignalHandlerMark, if crash protection installed we will longjmp away |
| 546 // (no destructors can be run) | |
| 547 os::WatcherThreadCrashProtection::check_crash_protection(sig, t); | |
| 548 | |
| 133 | 549 SignalHandlerMark shm(t); |
| 550 | |
| 551 // Note: it's not uncommon that JNI code uses signal/sigset to install | |
| 552 // then restore certain signal handler (e.g. to temporarily block SIGPIPE, | |
| 553 // or have a SIGILL handler when detecting CPU type). When that happens, | |
| 554 // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To | |
| 555 // avoid unnecessary crash when libjsig is not preloaded, try handle signals | |
| 556 // that do not require siginfo/ucontext first. | |
| 557 | |
| 558 if (sig == SIGPIPE || sig == SIGXFSZ) { | |
| 559 // allow chained handler to go first | |
| 560 if (os::Linux::chained_handler(sig, info, ucVoid)) { | |
| 561 return true; | |
| 562 } else { | |
| 563 if (PrintMiscellaneous && (WizardMode || Verbose)) { | |
| 564 char buf[64]; | |
| 565 warning("Ignoring %s - see bugs 4229104 or 646499219", | |
| 566 os::exception_name(sig, buf, sizeof(buf))); | |
| 567 } | |
| 568 return true; | |
| 569 } | |
| 570 } | |
| 571 | |
| 572 JavaThread* thread = NULL; | |
| 573 VMThread* vmthread = NULL; | |
| 574 if (os::Linux::signal_handlers_are_installed) { | |
| 575 if (t != NULL ){ | |
| 576 if(t->is_Java_thread()) { | |
| 577 thread = (JavaThread*)t; | |
| 578 } | |
| 579 else if(t->is_VM_thread()){ | |
| 580 vmthread = (VMThread *)t; | |
| 581 } | |
| 582 } | |
| 583 } | |
| 584 | |
| 585 // decide if this trap can be handled by a stub | |
| 586 address stub = NULL; | |
| 587 address pc = NULL; | |
| 588 address npc = NULL; | |
| 589 | |
| 590 //%note os_trap_1 | |
| 591 if (info != NULL && uc != NULL && thread != NULL) { | |
| 592 pc = address(SIG_PC(uc)); | |
| 593 npc = address(SIG_NPC(uc)); | |
| 594 | |
| 595 // Check to see if we caught the safepoint code in the | |
| 596 // process of write protecting the memory serialization page. | |
| 597 // It write enables the page immediately after protecting it | |
| 598 // so we can just return to retry the write. | |
| 599 if ((sig == SIGSEGV) && checkSerializePage(thread, (address)info->si_addr)) { | |
| 600 // Block current thread until the memory serialize page permission restored. | |
| 601 os::block_on_serialize_page_trap(); | |
| 602 return 1; | |
| 603 } | |
| 604 | |
| 605 if (checkPrefetch(uc, pc)) { | |
| 606 return 1; | |
| 607 } | |
| 608 | |
| 609 // Handle ALL stack overflow variations here | |
| 610 if (sig == SIGSEGV) { | |
| 611 if (checkOverflow(uc, pc, (address)info->si_addr, thread, &stub)) { | |
| 612 return 1; | |
| 613 } | |
| 614 } | |
| 615 | |
| 616 if (sig == SIGBUS && | |
| 617 thread->thread_state() == _thread_in_vm && | |
| 618 thread->doing_unsafe_access()) { | |
| 619 stub = StubRoutines::handler_for_unsafe_access(); | |
| 620 } | |
| 621 | |
| 622 if (thread->thread_state() == _thread_in_Java) { | |
| 623 do { | |
| 624 // Java thread running in Java code => find exception handler if any | |
| 625 // a fault inside compiled code, the interpreter, or a stub | |
| 626 | |
| 627 if ((sig == SIGSEGV) && checkPollingPage(pc, (address)info->si_addr, &stub)) { | |
| 628 break; | |
| 629 } | |
| 630 | |
| 631 if ((sig == SIGBUS) && checkByteBuffer(pc, &stub)) { | |
| 632 break; | |
| 633 } | |
| 634 | |
| 635 if ((sig == SIGSEGV || sig == SIGBUS) && | |
| 636 checkVerifyOops(pc, (address)info->si_addr, &stub)) { | |
| 637 break; | |
| 638 } | |
| 639 | |
| 640 if ((sig == SIGSEGV) && checkZombie(uc, &pc, &stub)) { | |
| 641 break; | |
| 642 } | |
| 643 | |
| 644 if ((sig == SIGILL) && checkICMiss(uc, &pc, &stub)) { | |
| 645 break; | |
| 646 } | |
| 647 | |
| 648 if ((sig == SIGFPE) && checkFPFault(pc, info->si_code, thread, &stub)) { | |
| 649 break; | |
| 650 } | |
| 651 | |
| 652 if ((sig == SIGSEGV) && | |
| 653 checkNullPointer(pc, (intptr_t)info->si_addr, thread, &stub)) { | |
| 654 break; | |
| 655 } | |
| 656 } while (0); | |
| 657 | |
| 658 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in | |
| 659 // and the heap gets shrunk before the field access. | |
| 660 if ((sig == SIGSEGV) || (sig == SIGBUS)) { | |
| 661 checkFastJNIAccess(pc, &stub); | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 if (stub != NULL) { | |
| 666 // save all thread context in case we need to restore it | |
| 667 thread->set_saved_exception_pc(pc); | |
| 668 thread->set_saved_exception_npc(npc); | |
| 669 set_cont_address(uc, stub); | |
| 670 return true; | |
| 671 } | |
| 672 } | |
| 673 | |
| 674 // signal-chaining | |
| 675 if (os::Linux::chained_handler(sig, info, ucVoid)) { | |
| 676 return true; | |
| 677 } | |
| 678 | |
| 679 if (!abort_if_unrecognized) { | |
| 680 // caller wants another chance, so give it to him | |
| 681 return false; | |
| 682 } | |
| 683 | |
| 684 if (pc == NULL && uc != NULL) { | |
| 685 pc = os::Linux::ucontext_get_pc((ucontext_t*)uc); | |
| 686 } | |
| 687 | |
| 688 // unmask current signal | |
| 689 sigset_t newset; | |
| 690 sigemptyset(&newset); | |
| 691 sigaddset(&newset, sig); | |
| 692 sigprocmask(SIG_UNBLOCK, &newset, NULL); | |
| 693 | |
| 694 VMError err(t, sig, pc, info, ucVoid); | |
| 695 err.report_and_die(); | |
| 696 | |
| 697 ShouldNotReachHere(); | |
| 698 } | |
| 699 | |
| 700 void os::Linux::init_thread_fpu_state(void) { | |
| 701 // Nothing to do | |
| 702 } | |
| 703 | |
| 704 int os::Linux::get_fpu_control_word() { | |
| 705 return 0; | |
| 706 } | |
| 707 | |
| 708 void os::Linux::set_fpu_control_word(int fpu) { | |
| 709 // nothing | |
| 710 } | |
| 711 | |
| 712 bool os::is_allocatable(size_t bytes) { | |
| 713 #ifdef _LP64 | |
| 714 return true; | |
| 715 #else | |
| 716 if (bytes < 2 * G) { | |
| 717 return true; | |
| 718 } | |
| 719 | |
| 720 char* addr = reserve_memory(bytes, NULL); | |
| 721 | |
| 722 if (addr != NULL) { | |
| 723 release_memory(addr, bytes); | |
| 724 } | |
| 725 | |
| 726 return addr != NULL; | |
| 727 #endif // _LP64 | |
| 728 } | |
| 729 | |
| 730 /////////////////////////////////////////////////////////////////////////////// | |
| 731 // thread stack | |
| 732 | |
| 733 size_t os::Linux::min_stack_allowed = 128 * K; | |
| 734 | |
| 735 // pthread on Ubuntu is always in floating stack mode | |
| 736 bool os::Linux::supports_variable_stack_size() { return true; } | |
| 737 | |
| 738 // return default stack size for thr_type | |
| 739 size_t os::Linux::default_stack_size(os::ThreadType thr_type) { | |
| 740 // default stack size (compiler thread needs larger stack) | |
| 741 size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M); | |
| 742 return s; | |
| 743 } | |
| 744 | |
| 745 size_t os::Linux::default_guard_size(os::ThreadType thr_type) { | |
| 746 // Creating guard page is very expensive. Java thread has HotSpot | |
| 747 // guard page, only enable glibc guard page for non-Java threads. | |
| 748 return (thr_type == java_thread ? 0 : page_size()); | |
| 749 } | |
|
5903
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
750 |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
751 #ifndef PRODUCT |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
752 void os::verify_stack_alignment() { |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
753 } |
|
da4be62fb889
7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents:
2426
diff
changeset
|
754 #endif |