1 /*
2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 // no precompiled headers
26 #include "assembler_x86.inline.hpp"
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_x86.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/hpi.hpp"
45 #include "runtime/interfaceSupport.hpp"
46 #include "runtime/java.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/mutexLocker.hpp"
49 #include "runtime/osThread.hpp"
50 #include "runtime/sharedRuntime.hpp"
51 #include "runtime/stubRoutines.hpp"
52 #include "runtime/timer.hpp"
53 #include "thread_linux.inline.hpp"
54 #include "utilities/events.hpp"
55 #include "utilities/vmError.hpp"
56 #ifdef COMPILER1
57 #include "c1/c1_Runtime1.hpp"
58 #endif
59 #ifdef COMPILER2
60 #include "opto/runtime.hpp"
61 #endif
62
63 // put OS-includes here
64 # include <sys/types.h>
65 # include <sys/mman.h>
66 # include <pthread.h>
67 # include <signal.h>
68 # include <errno.h>
69 # include <dlfcn.h>
70 # include <stdlib.h>
71 # include <stdio.h>
72 # include <unistd.h>
73 # include <sys/resource.h>
74 # include <pthread.h>
75 # include <sys/stat.h>
76 # include <sys/time.h>
77 # include <sys/utsname.h>
78 # include <sys/socket.h>
79 # include <sys/wait.h>
80 # include <pwd.h>
81 # include <poll.h>
82 # include <ucontext.h>
83 # include <fpu_control.h>
84
85 #ifdef AMD64
86 #define REG_SP REG_RSP
87 #define REG_PC REG_RIP
88 #define REG_FP REG_RBP
89 #define SPELL_REG_SP "rsp"
90 #define SPELL_REG_FP "rbp"
91 #else
92 #define REG_SP REG_UESP
93 #define REG_PC REG_EIP
94 #define REG_FP REG_EBP
95 #define SPELL_REG_SP "esp"
96 #define SPELL_REG_FP "ebp"
97 #endif // AMD64
98
99 address os::current_stack_pointer() {
100 #ifdef SPARC_WORKS
101 register void *esp;
102 __asm__("mov %%"SPELL_REG_SP", %0":"=r"(esp));
103 return (address) ((char*)esp + sizeof(long)*2);
104 #else
105 register void *esp __asm__ (SPELL_REG_SP);
106 return (address) esp;
107 #endif
108 }
109
110 char* os::non_memory_address_word() {
111 // Must never look like an address returned by reserve_memory,
112 // even in its subfields (as defined by the CPU immediate fields,
113 // if the CPU splits constants across multiple instructions).
114
115 return (char*) -1;
116 }
117
118 void os::initialize_thread() {
119 // Nothing to do.
120 }
121
122 address os::Linux::ucontext_get_pc(ucontext_t * uc) {
123 return (address)uc->uc_mcontext.gregs[REG_PC];
124 }
125
126 intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) {
127 return (intptr_t*)uc->uc_mcontext.gregs[REG_SP];
128 }
129
130 intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) {
131 return (intptr_t*)uc->uc_mcontext.gregs[REG_FP];
132 }
133
134 // For Forte Analyzer AsyncGetCallTrace profiling support - thread
135 // is currently interrupted by SIGPROF.
136 // os::Solaris::fetch_frame_from_ucontext() tries to skip nested signal
137 // frames. Currently we don't do that on Linux, so it's the same as
138 // os::fetch_frame_from_context().
139 ExtendedPC os::Linux::fetch_frame_from_ucontext(Thread* thread,
140 ucontext_t* uc, intptr_t** ret_sp, intptr_t** ret_fp) {
141
142 assert(thread != NULL, "just checking");
143 assert(ret_sp != NULL, "just checking");
144 assert(ret_fp != NULL, "just checking");
145
146 return os::fetch_frame_from_context(uc, ret_sp, ret_fp);
147 }
148
149 ExtendedPC os::fetch_frame_from_context(void* ucVoid,
150 intptr_t** ret_sp, intptr_t** ret_fp) {
151
152 ExtendedPC epc;
153 ucontext_t* uc = (ucontext_t*)ucVoid;
154
155 if (uc != NULL) {
156 epc = ExtendedPC(os::Linux::ucontext_get_pc(uc));
157 if (ret_sp) *ret_sp = os::Linux::ucontext_get_sp(uc);
158 if (ret_fp) *ret_fp = os::Linux::ucontext_get_fp(uc);
159 } else {
160 // construct empty ExtendedPC for return value checking
161 epc = ExtendedPC(NULL);
162 if (ret_sp) *ret_sp = (intptr_t *)NULL;
163 if (ret_fp) *ret_fp = (intptr_t *)NULL;
164 }
165
166 return epc;
167 }
168
169 frame os::fetch_frame_from_context(void* ucVoid) {
170 intptr_t* sp;
171 intptr_t* fp;
172 ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
173 return frame(sp, fp, epc.pc());
174 }
175
176 // By default, gcc always save frame pointer (%ebp/%rbp) on stack. It may get
177 // turned off by -fomit-frame-pointer,
178 frame os::get_sender_for_C_frame(frame* fr) {
179 return frame(fr->sender_sp(), fr->link(), fr->sender_pc());
180 }
181
182 intptr_t* _get_previous_fp() {
183 #ifdef SPARC_WORKS
184 register intptr_t **ebp;
185 __asm__("mov %%"SPELL_REG_FP", %0":"=r"(ebp));
186 #else
187 register intptr_t **ebp __asm__ (SPELL_REG_FP);
188 #endif
189 return (intptr_t*) *ebp; // we want what it points to.
190 }
191
192
193 frame os::current_frame() {
194 intptr_t* fp = _get_previous_fp();
195 frame myframe((intptr_t*)os::current_stack_pointer(),
196 (intptr_t*)fp,
197 CAST_FROM_FN_PTR(address, os::current_frame));
198 if (os::is_first_C_frame(&myframe)) {
199 // stack is not walkable
200 return frame(NULL, NULL, NULL);
201 } else {
202 return os::get_sender_for_C_frame(&myframe);
203 }
204 }
205
206 // Utility functions
207
208 // From IA32 System Programming Guide
209 enum {
210 trap_page_fault = 0xE
211 };
212
213 extern "C" void Fetch32PFI () ;
214 extern "C" void Fetch32Resume () ;
215 #ifdef AMD64
216 extern "C" void FetchNPFI () ;
217 extern "C" void FetchNResume () ;
218 #endif // AMD64
219
220 extern "C" int
221 JVM_handle_linux_signal(int sig,
222 siginfo_t* info,
223 void* ucVoid,
224 int abort_if_unrecognized) {
225 ucontext_t* uc = (ucontext_t*) ucVoid;
226
227 Thread* t = ThreadLocalStorage::get_thread_slow();
228
229 SignalHandlerMark shm(t);
230
231 // Note: it's not uncommon that JNI code uses signal/sigset to install
232 // then restore certain signal handler (e.g. to temporarily block SIGPIPE,
233 // or have a SIGILL handler when detecting CPU type). When that happens,
234 // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
235 // avoid unnecessary crash when libjsig is not preloaded, try handle signals
236 // that do not require siginfo/ucontext first.
237
238 if (sig == SIGPIPE || sig == SIGXFSZ) {
239 // allow chained handler to go first
240 if (os::Linux::chained_handler(sig, info, ucVoid)) {
241 return true;
242 } else {
243 if (PrintMiscellaneous && (WizardMode || Verbose)) {
244 char buf[64];
245 warning("Ignoring %s - see bugs 4229104 or 646499219",
246 os::exception_name(sig, buf, sizeof(buf)));
247 }
248 return true;
249 }
250 }
251
252 JavaThread* thread = NULL;
253 VMThread* vmthread = NULL;
254 if (os::Linux::signal_handlers_are_installed) {
255 if (t != NULL ){
256 if(t->is_Java_thread()) {
257 thread = (JavaThread*)t;
258 }
259 else if(t->is_VM_thread()){
260 vmthread = (VMThread *)t;
261 }
262 }
263 }
264 /*
265 NOTE: does not seem to work on linux.
266 if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) {
267 // can't decode this kind of signal
268 info = NULL;
269 } else {
270 assert(sig == info->si_signo, "bad siginfo");
271 }
272 */
273 // decide if this trap can be handled by a stub
274 address stub = NULL;
275
276 address pc = NULL;
277
278 //%note os_trap_1
279 if (info != NULL && uc != NULL && thread != NULL) {
280 pc = (address) os::Linux::ucontext_get_pc(uc);
281
282 if (pc == (address) Fetch32PFI) {
283 uc->uc_mcontext.gregs[REG_PC] = intptr_t(Fetch32Resume) ;
284 return 1 ;
285 }
286 #ifdef AMD64
287 if (pc == (address) FetchNPFI) {
288 uc->uc_mcontext.gregs[REG_PC] = intptr_t (FetchNResume) ;
289 return 1 ;
290 }
291 #endif // AMD64
292
293 // Handle ALL stack overflow variations here
294 if (sig == SIGSEGV) {
295 address addr = (address) info->si_addr;
296
297 // check if fault address is within thread stack
298 if (addr < thread->stack_base() &&
299 addr >= thread->stack_base() - thread->stack_size()) {
300 // stack overflow
301 if (thread->in_stack_yellow_zone(addr)) {
302 thread->disable_stack_yellow_zone();
303 if (thread->thread_state() == _thread_in_Java) {
304 // Throw a stack overflow exception. Guard pages will be reenabled
305 // while unwinding the stack.
306 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
307 } else {
308 // Thread was in the vm or native code. Return and try to finish.
309 return 1;
310 }
311 } else if (thread->in_stack_red_zone(addr)) {
312 // Fatal red zone violation. Disable the guard pages and fall through
313 // to handle_unexpected_exception way down below.
314 thread->disable_stack_red_zone();
315 tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
316 } else {
317 // Accessing stack address below sp may cause SEGV if current
318 // thread has MAP_GROWSDOWN stack. This should only happen when
319 // current thread was created by user code with MAP_GROWSDOWN flag
320 // and then attached to VM. See notes in os_linux.cpp.
321 if (thread->osthread()->expanding_stack() == 0) {
322 thread->osthread()->set_expanding_stack();
323 if (os::Linux::manually_expand_stack(thread, addr)) {
324 thread->osthread()->clear_expanding_stack();
325 return 1;
326 }
327 thread->osthread()->clear_expanding_stack();
328 } else {
329 fatal("recursive segv. expanding stack.");
330 }
331 }
332 }
333 }
334
335 if (thread->thread_state() == _thread_in_Java) {
336 // Java thread running in Java code => find exception handler if any
337 // a fault inside compiled code, the interpreter, or a stub
338
339 if (sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) {
340 stub = SharedRuntime::get_poll_stub(pc);
341 } else if (sig == SIGBUS /* && info->si_code == BUS_OBJERR */) {
342 // BugId 4454115: A read from a MappedByteBuffer can fault
343 // here if the underlying file has been truncated.
344 // Do not crash the VM in such a case.
345 CodeBlob* cb = CodeCache::find_blob_unsafe(pc);
346 nmethod* nm = cb->is_nmethod() ? (nmethod*)cb : NULL;
347 if (nm != NULL && nm->has_unsafe_access()) {
348 stub = StubRoutines::handler_for_unsafe_access();
349 }
350 }
351 else
352
353 #ifdef AMD64
354 if (sig == SIGFPE &&
355 (info->si_code == FPE_INTDIV || info->si_code == FPE_FLTDIV)) {
356 stub =
357 SharedRuntime::
358 continuation_for_implicit_exception(thread,
359 pc,
360 SharedRuntime::
361 IMPLICIT_DIVIDE_BY_ZERO);
362 #else
363 if (sig == SIGFPE /* && info->si_code == FPE_INTDIV */) {
364 // HACK: si_code does not work on linux 2.2.12-20!!!
365 int op = pc[0];
366 if (op == 0xDB) {
367 // FIST
368 // TODO: The encoding of D2I in i486.ad can cause an exception
369 // prior to the fist instruction if there was an invalid operation
370 // pending. We want to dismiss that exception. From the win_32
371 // side it also seems that if it really was the fist causing
372 // the exception that we do the d2i by hand with different
373 // rounding. Seems kind of weird.
374 // NOTE: that we take the exception at the NEXT floating point instruction.
375 assert(pc[0] == 0xDB, "not a FIST opcode");
376 assert(pc[1] == 0x14, "not a FIST opcode");
377 assert(pc[2] == 0x24, "not a FIST opcode");
378 return true;
379 } else if (op == 0xF7) {
380 // IDIV
381 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO);
382 } else {
383 // TODO: handle more cases if we are using other x86 instructions
384 // that can generate SIGFPE signal on linux.
385 tty->print_cr("unknown opcode 0x%X with SIGFPE.", op);
386 fatal("please update this code.");
387 }
388 #endif // AMD64
389 } else if (sig == SIGSEGV &&
390 !MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) {
391 // Determination of interpreter/vtable stub/compiled code null exception
392 stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
393 }
394 } else if (thread->thread_state() == _thread_in_vm &&
395 sig == SIGBUS && /* info->si_code == BUS_OBJERR && */
396 thread->doing_unsafe_access()) {
397 stub = StubRoutines::handler_for_unsafe_access();
398 }
399
400 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
401 // and the heap gets shrunk before the field access.
402 if ((sig == SIGSEGV) || (sig == SIGBUS)) {
403 address addr = JNI_FastGetField::find_slowcase_pc(pc);
404 if (addr != (address)-1) {
405 stub = addr;
406 }
407 }
408
409 // Check to see if we caught the safepoint code in the
410 // process of write protecting the memory serialization page.
411 // It write enables the page immediately after protecting it
412 // so we can just return to retry the write.
413 if ((sig == SIGSEGV) &&
414 os::is_memory_serialize_page(thread, (address) info->si_addr)) {
415 // Block current thread until the memory serialize page permission restored.
416 os::block_on_serialize_page_trap();
417 return true;
418 }
419 }
420
421 #ifndef AMD64
422 // Execution protection violation
423 //
424 // This should be kept as the last step in the triage. We don't
425 // have a dedicated trap number for a no-execute fault, so be
426 // conservative and allow other handlers the first shot.
427 //
428 // Note: We don't test that info->si_code == SEGV_ACCERR here.
429 // this si_code is so generic that it is almost meaningless; and
430 // the si_code for this condition may change in the future.
431 // Furthermore, a false-positive should be harmless.
432 if (UnguardOnExecutionViolation > 0 &&
433 (sig == SIGSEGV || sig == SIGBUS) &&
434 uc->uc_mcontext.gregs[REG_TRAPNO] == trap_page_fault) {
435 int page_size = os::vm_page_size();
436 address addr = (address) info->si_addr;
437 address pc = os::Linux::ucontext_get_pc(uc);
438 // Make sure the pc and the faulting address are sane.
439 //
440 // If an instruction spans a page boundary, and the page containing
441 // the beginning of the instruction is executable but the following
442 // page is not, the pc and the faulting address might be slightly
443 // different - we still want to unguard the 2nd page in this case.
444 //
445 // 15 bytes seems to be a (very) safe value for max instruction size.
446 bool pc_is_near_addr =
447 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
448 bool instr_spans_page_boundary =
449 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
450 (intptr_t) page_size) > 0);
451
452 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
453 static volatile address last_addr =
454 (address) os::non_memory_address_word();
455
456 // In conservative mode, don't unguard unless the address is in the VM
457 if (addr != last_addr &&
458 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
459
460 // Set memory to RWX and retry
461 address page_start =
462 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
463 bool res = os::protect_memory((char*) page_start, page_size,
464 os::MEM_PROT_RWX);
465
466 if (PrintMiscellaneous && Verbose) {
467 char buf[256];
468 jio_snprintf(buf, sizeof(buf), "Execution protection violation "
469 "at " INTPTR_FORMAT
470 ", unguarding " INTPTR_FORMAT ": %s, errno=%d", addr,
471 page_start, (res ? "success" : "failed"), errno);
472 tty->print_raw_cr(buf);
473 }
474 stub = pc;
475
476 // Set last_addr so if we fault again at the same address, we don't end
477 // up in an endless loop.
478 //
479 // There are two potential complications here. Two threads trapping at
480 // the same address at the same time could cause one of the threads to
481 // think it already unguarded, and abort the VM. Likely very rare.
482 //
483 // The other race involves two threads alternately trapping at
484 // different addresses and failing to unguard the page, resulting in
485 // an endless loop. This condition is probably even more unlikely than
486 // the first.
487 //
488 // Although both cases could be avoided by using locks or thread local
489 // last_addr, these solutions are unnecessary complication: this
490 // handler is a best-effort safety net, not a complete solution. It is
491 // disabled by default and should only be used as a workaround in case
492 // we missed any no-execute-unsafe VM code.
493
494 last_addr = addr;
495 }
496 }
497 }
498 #endif // !AMD64
499
500 if (stub != NULL) {
501 // save all thread context in case we need to restore it
502 if (thread != NULL) thread->set_saved_exception_pc(pc);
503
504 uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub;
505 return true;
506 }
507
508 // signal-chaining
509 if (os::Linux::chained_handler(sig, info, ucVoid)) {
510 return true;
511 }
512
513 if (!abort_if_unrecognized) {
514 // caller wants another chance, so give it to him
515 return false;
516 }
517
518 if (pc == NULL && uc != NULL) {
519 pc = os::Linux::ucontext_get_pc(uc);
520 }
521
522 // unmask current signal
523 sigset_t newset;
524 sigemptyset(&newset);
525 sigaddset(&newset, sig);
526 sigprocmask(SIG_UNBLOCK, &newset, NULL);
527
528 VMError err(t, sig, pc, info, ucVoid);
529 err.report_and_die();
530
531 ShouldNotReachHere();
532 }
533
534 void os::Linux::init_thread_fpu_state(void) {
535 #ifndef AMD64
536 // set fpu to 53 bit precision
537 set_fpu_control_word(0x27f);
538 #endif // !AMD64
539 }
540
541 int os::Linux::get_fpu_control_word(void) {
542 #ifdef AMD64
543 return 0;
544 #else
545 int fpu_control;
546 _FPU_GETCW(fpu_control);
547 return fpu_control & 0xffff;
548 #endif // AMD64
549 }
550
551 void os::Linux::set_fpu_control_word(int fpu_control) {
552 #ifndef AMD64
553 _FPU_SETCW(fpu_control);
554 #endif // !AMD64
555 }
556
557 // Check that the linux kernel version is 2.4 or higher since earlier
558 // versions do not support SSE without patches.
559 bool os::supports_sse() {
560 #ifdef AMD64
561 return true;
562 #else
563 struct utsname uts;
564 if( uname(&uts) != 0 ) return false; // uname fails?
565 char *minor_string;
566 int major = strtol(uts.release,&minor_string,10);
567 int minor = strtol(minor_string+1,NULL,10);
568 bool result = (major > 2 || (major==2 && minor >= 4));
569 #ifndef PRODUCT
570 if (PrintMiscellaneous && Verbose) {
571 tty->print("OS version is %d.%d, which %s support SSE/SSE2\n",
572 major,minor, result ? "DOES" : "does NOT");
573 }
574 #endif
575 return result;
576 #endif // AMD64
577 }
578
579 bool os::is_allocatable(size_t bytes) {
580 #ifdef AMD64
581 // unused on amd64?
582 return true;
583 #else
584
585 if (bytes < 2 * G) {
586 return true;
587 }
588
589 char* addr = reserve_memory(bytes, NULL);
590
591 if (addr != NULL) {
592 release_memory(addr, bytes);
593 }
594
595 return addr != NULL;
596 #endif // AMD64
597 }
598
599 ////////////////////////////////////////////////////////////////////////////////
600 // thread stack
601
602 #ifdef AMD64
603 size_t os::Linux::min_stack_allowed = 64 * K;
604
605 // amd64: pthread on amd64 is always in floating stack mode
606 bool os::Linux::supports_variable_stack_size() { return true; }
607 #else
608 size_t os::Linux::min_stack_allowed = (48 DEBUG_ONLY(+4))*K;
609
610 #ifdef __GNUC__
611 #define GET_GS() ({int gs; __asm__ volatile("movw %%gs, %w0":"=q"(gs)); gs&0xffff;})
612 #endif
613
614 // Test if pthread library can support variable thread stack size. LinuxThreads
615 // in fixed stack mode allocates 2M fixed slot for each thread. LinuxThreads
616 // in floating stack mode and NPTL support variable stack size.
617 bool os::Linux::supports_variable_stack_size() {
618 if (os::Linux::is_NPTL()) {
619 // NPTL, yes
620 return true;
621
622 } else {
623 // Note: We can't control default stack size when creating a thread.
624 // If we use non-default stack size (pthread_attr_setstacksize), both
625 // floating stack and non-floating stack LinuxThreads will return the
626 // same value. This makes it impossible to implement this function by
627 // detecting thread stack size directly.
628 //
629 // An alternative approach is to check %gs. Fixed-stack LinuxThreads
630 // do not use %gs, so its value is 0. Floating-stack LinuxThreads use
631 // %gs (either as LDT selector or GDT selector, depending on kernel)
632 // to access thread specific data.
633 //
634 // Note that %gs is a reserved glibc register since early 2001, so
635 // applications are not allowed to change its value (Ulrich Drepper from
636 // Redhat confirmed that all known offenders have been modified to use
637 // either %fs or TSD). In the worst case scenario, when VM is embedded in
638 // a native application that plays with %gs, we might see non-zero %gs
639 // even LinuxThreads is running in fixed stack mode. As the result, we'll
640 // return true and skip _thread_safety_check(), so we may not be able to
641 // detect stack-heap collisions. But otherwise it's harmless.
642 //
643 #ifdef __GNUC__
644 return (GET_GS() != 0);
645 #else
646 return false;
647 #endif
648 }
649 }
650 #endif // AMD64
651
652 // return default stack size for thr_type
653 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
654 // default stack size (compiler thread needs larger stack)
655 #ifdef AMD64
656 size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
657 #else
658 size_t s = (thr_type == os::compiler_thread ? 2 * M : 512 * K);
659 #endif // AMD64
660 return s;
661 }
662
663 size_t os::Linux::default_guard_size(os::ThreadType thr_type) {
664 // Creating guard page is very expensive. Java thread has HotSpot
665 // guard page, only enable glibc guard page for non-Java threads.
666 return (thr_type == java_thread ? 0 : page_size());
667 }
668
669 // Java thread:
670 //
671 // Low memory addresses
672 // +------------------------+
673 // | |\ JavaThread created by VM does not have glibc
674 // | glibc guard page | - guard, attached Java thread usually has
675 // | |/ 1 page glibc guard.
676 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size()
677 // | |\
678 // | HotSpot Guard Pages | - red and yellow pages
679 // | |/
680 // +------------------------+ JavaThread::stack_yellow_zone_base()
681 // | |\
682 // | Normal Stack | -
683 // | |/
684 // P2 +------------------------+ Thread::stack_base()
685 //
686 // Non-Java thread:
687 //
688 // Low memory addresses
689 // +------------------------+
690 // | |\
691 // | glibc guard page | - usually 1 page
692 // | |/
693 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size()
694 // | |\
695 // | Normal Stack | -
696 // | |/
697 // P2 +------------------------+ Thread::stack_base()
698 //
699 // ** P1 (aka bottom) and size ( P2 = P1 - size) are the address and stack size returned from
700 // pthread_attr_getstack()
701
702 static void current_stack_region(address * bottom, size_t * size) {
703 if (os::Linux::is_initial_thread()) {
704 // initial thread needs special handling because pthread_getattr_np()
705 // may return bogus value.
706 *bottom = os::Linux::initial_thread_stack_bottom();
707 *size = os::Linux::initial_thread_stack_size();
708 } else {
709 pthread_attr_t attr;
710
711 int rslt = pthread_getattr_np(pthread_self(), &attr);
712
713 // JVM needs to know exact stack location, abort if it fails
714 if (rslt != 0) {
715 if (rslt == ENOMEM) {
716 vm_exit_out_of_memory(0, "pthread_getattr_np");
717 } else {
718 fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
719 }
720 }
721
722 if (pthread_attr_getstack(&attr, (void **)bottom, size) != 0) {
723 fatal("Can not locate current stack attributes!");
724 }
725
726 pthread_attr_destroy(&attr);
727
728 }
729 assert(os::current_stack_pointer() >= *bottom &&
730 os::current_stack_pointer() < *bottom + *size, "just checking");
731 }
732
733 address os::current_stack_base() {
734 address bottom;
735 size_t size;
736 current_stack_region(&bottom, &size);
737 return (bottom + size);
738 }
739
740 size_t os::current_stack_size() {
741 // stack size includes normal stack and HotSpot guard pages
742 address bottom;
743 size_t size;
744 current_stack_region(&bottom, &size);
745 return size;
746 }
747
748 /////////////////////////////////////////////////////////////////////////////
749 // helper functions for fatal error handler
750
751 void os::print_context(outputStream *st, void *context) {
752 if (context == NULL) return;
753
754 ucontext_t *uc = (ucontext_t*)context;
755 st->print_cr("Registers:");
756
757 // this is horrendously verbose but the layout of the registers in the
758 // context does not match how we defined our abstract Register set, so
759 // we can't just iterate through the gregs area
760
761 #ifdef AMD64
762 st->print( "RAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RAX]);
763 st->print(", RBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBX]);
764 st->print(", RCX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RCX]);
765 st->print(", RDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDX]);
766 st->cr();
767 st->print( "RSP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSP]);
768 st->print(", RBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBP]);
769 st->print(", RSI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSI]);
770 st->print(", RDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDI]);
771 st->cr();
772 st->print( "R8 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R8]);
773 st->print(", R9 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R9]);
774 st->print(", R10=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R10]);
775 st->print(", R11=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R11]);
776 st->cr();
777 st->print( "R12=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R12]);
778 st->print(", R13=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R13]);
779 st->print(", R14=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R14]);
780 st->print(", R15=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R15]);
781 st->cr();
782 st->print( "RIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RIP]);
783 st->print(", EFL=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EFL]);
784 st->print(", CSGSFS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_CSGSFS]);
785 st->print(", ERR=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ERR]);
786 st->cr();
787 st->print(" TRAPNO=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_TRAPNO]);
788
789 st->cr();
790 st->cr();
791
792 st->print_cr("Register to memory mapping:");
793 st->cr();
794
795 // this is only for the "general purpose" registers
796
797 st->print_cr("RAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RAX]);
798 print_location(st, uc->uc_mcontext.gregs[REG_RAX]);
799 st->cr();
800 st->print_cr("RBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBX]);
801 print_location(st, uc->uc_mcontext.gregs[REG_RBX]);
802 st->cr();
803 st->print_cr("RCX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RCX]);
804 print_location(st, uc->uc_mcontext.gregs[REG_RCX]);
805 st->cr();
806 st->print_cr("RDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDX]);
807 print_location(st, uc->uc_mcontext.gregs[REG_RDX]);
808 st->cr();
809 st->print_cr("RSP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSP]);
810 print_location(st, uc->uc_mcontext.gregs[REG_RSP]);
811 st->cr();
812 st->print_cr("RBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBP]);
813 print_location(st, uc->uc_mcontext.gregs[REG_RBP]);
814 st->cr();
815 st->print_cr("RSI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSI]);
816 print_location(st, uc->uc_mcontext.gregs[REG_RSI]);
817 st->cr();
818 st->print_cr("RDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDI]);
819 print_location(st, uc->uc_mcontext.gregs[REG_RDI]);
820 st->cr();
821 st->print_cr("R8 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R8]);
822 print_location(st, uc->uc_mcontext.gregs[REG_R8]);
823 st->cr();
824 st->print_cr("R9 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R9]);
825 print_location(st, uc->uc_mcontext.gregs[REG_R9]);
826 st->cr();
827 st->print_cr("R10=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R10]);
828 print_location(st, uc->uc_mcontext.gregs[REG_R10]);
829 st->cr();
830 st->print_cr("R11=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R11]);
831 print_location(st, uc->uc_mcontext.gregs[REG_R11]);
832 st->cr();
833 st->print_cr("R12=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R12]);
834 print_location(st, uc->uc_mcontext.gregs[REG_R12]);
835 st->cr();
836 st->print_cr("R13=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R13]);
837 print_location(st, uc->uc_mcontext.gregs[REG_R13]);
838 st->cr();
839 st->print_cr("R14=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R14]);
840 print_location(st, uc->uc_mcontext.gregs[REG_R14]);
841 st->cr();
842 st->print_cr("R15=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R15]);
843 print_location(st, uc->uc_mcontext.gregs[REG_R15]);
844
845 #else
846 st->print( "EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EAX]);
847 st->print(", EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBX]);
848 st->print(", ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ECX]);
849 st->print(", EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDX]);
850 st->cr();
851 st->print( "ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_UESP]);
852 st->print(", EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBP]);
853 st->print(", ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ESI]);
854 st->print(", EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDI]);
855 st->cr();
856 st->print( "EIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EIP]);
857 st->print(", CR2=" INTPTR_FORMAT, uc->uc_mcontext.cr2);
858 st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EFL]);
859
860 st->cr();
861 st->cr();
862
863 st->print_cr("Register to memory mapping:");
864 st->cr();
865
866 // this is only for the "general purpose" registers
867
868 st->print_cr("EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EAX]);
869 print_location(st, uc->uc_mcontext.gregs[REG_EAX]);
870 st->cr();
871 st->print_cr("EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBX]);
872 print_location(st, uc->uc_mcontext.gregs[REG_EBX]);
873 st->cr();
874 st->print_cr("ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ECX]);
875 print_location(st, uc->uc_mcontext.gregs[REG_ECX]);
876 st->cr();
877 st->print_cr("EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDX]);
878 print_location(st, uc->uc_mcontext.gregs[REG_EDX]);
879 st->cr();
880 st->print_cr("ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ESP]);
881 print_location(st, uc->uc_mcontext.gregs[REG_ESP]);
882 st->cr();
883 st->print_cr("EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EBP]);
884 print_location(st, uc->uc_mcontext.gregs[REG_EBP]);
885 st->cr();
886 st->print_cr("ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_ESI]);
887 print_location(st, uc->uc_mcontext.gregs[REG_ESI]);
888 st->cr();
889 st->print_cr("EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_EDI]);
890 print_location(st, uc->uc_mcontext.gregs[REG_EDI]);
891
892 #endif // AMD64
893 st->cr();
894 st->cr();
895
896 intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc);
897 st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp);
898 print_hex_dump(st, (address)sp, (address)(sp + 8*sizeof(intptr_t)), sizeof(intptr_t));
899 st->cr();
900
901 // Note: it may be unsafe to inspect memory near pc. For example, pc may
902 // point to garbage if entry point in an nmethod is corrupted. Leave
903 // this at the end, and hope for the best.
904 address pc = os::Linux::ucontext_get_pc(uc);
905 st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc);
906 print_hex_dump(st, pc - 16, pc + 16, sizeof(char));
907 }
908
909 void os::setup_fpu() {
910 #ifndef AMD64
911 address fpu_cntrl = StubRoutines::addr_fpu_cntrl_wrd_std();
912 __asm__ volatile ( "fldcw (%0)" :
913 : "r" (fpu_cntrl) : "memory");
914 #endif // !AMD64
915 }