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