1 /*
   2  * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2016, 2018 SAP SE. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 // This file is organized as os_linux_x86.cpp.
  27 
  28 // no precompiled headers
  29 #include "jvm.h"
  30 #include "asm/assembler.inline.hpp"
  31 #include "classfile/classLoader.hpp"
  32 #include "classfile/systemDictionary.hpp"
  33 #include "classfile/vmSymbols.hpp"
  34 #include "code/icBuffer.hpp"
  35 #include "code/nativeInst.hpp"
  36 #include "code/vtableStubs.hpp"
  37 #include "compiler/disassembler.hpp"
  38 #include "interpreter/interpreter.hpp"
  39 #include "memory/allocation.inline.hpp"
  40 #include "nativeInst_s390.hpp"
  41 #include "os_share_linux.hpp"
  42 #include "prims/jniFastGetField.hpp"
  43 #include "prims/jvm_misc.hpp"
  44 #include "runtime/arguments.hpp"
  45 #include "runtime/extendedPC.hpp"
  46 #include "runtime/frame.inline.hpp"
  47 #include "runtime/interfaceSupport.inline.hpp"
  48 #include "runtime/java.hpp"
  49 #include "runtime/javaCalls.hpp"
  50 #include "runtime/mutexLocker.hpp"
  51 #include "runtime/osThread.hpp"
  52 #include "runtime/sharedRuntime.hpp"
  53 #include "runtime/stubRoutines.hpp"
  54 #include "runtime/thread.inline.hpp"
  55 #include "runtime/timer.hpp"
  56 #include "utilities/events.hpp"
  57 #include "utilities/debug.hpp"
  58 #include "utilities/vmError.hpp"
  59 
  60 // put OS-includes here
  61 # include <sys/types.h>
  62 # include <sys/mman.h>
  63 # include <pthread.h>
  64 # include <signal.h>
  65 # include <errno.h>
  66 # include <dlfcn.h>
  67 # include <stdlib.h>
  68 # include <stdio.h>
  69 # include <unistd.h>
  70 # include <sys/resource.h>
  71 # include <pthread.h>
  72 # include <sys/stat.h>
  73 # include <sys/time.h>
  74 # include <sys/utsname.h>
  75 # include <sys/socket.h>
  76 # include <sys/wait.h>
  77 # include <pwd.h>
  78 # include <poll.h>
  79 # include <ucontext.h>
  80 
  81 address os::current_stack_pointer() {
  82   intptr_t* csp;
  83 
  84   // Inline assembly for `z_lgr regno(csp), Z_SP' (Z_SP = Z_R15):
  85   __asm__ __volatile__ ("lgr %0, 15":"=r"(csp):);
  86 
  87   assert(((uint64_t)csp & (frame::alignment_in_bytes-1)) == 0, "SP must be aligned");
  88   return (address) csp;
  89 }
  90 
  91 char* os::non_memory_address_word() {
  92   // Must never look like an address returned by reserve_memory,
  93   // even in its subfields (as defined by the CPU immediate fields,
  94   // if the CPU splits constants across multiple instructions).
  95   return (char*) -1;
  96 }
  97 
  98 // Frame information (pc, sp, fp) retrieved via ucontext
  99 // always looks like a C-frame according to the frame
 100 // conventions in frame_s390.hpp.
 101 address os::Linux::ucontext_get_pc(const ucontext_t * uc) {
 102   return (address)uc->uc_mcontext.psw.addr;
 103 }
 104 
 105 void os::Linux::ucontext_set_pc(ucontext_t * uc, address pc) {
 106   uc->uc_mcontext.psw.addr = (unsigned long)pc;
 107 }
 108 
 109 static address ucontext_get_lr(const ucontext_t * uc) {
 110   return (address)uc->uc_mcontext.gregs[14/*LINK*/];
 111 }
 112 
 113 intptr_t* os::Linux::ucontext_get_sp(const ucontext_t * uc) {
 114   return (intptr_t*)uc->uc_mcontext.gregs[15/*REG_SP*/];
 115 }
 116 
 117 intptr_t* os::Linux::ucontext_get_fp(const ucontext_t * uc) {
 118   return NULL;
 119 }
 120 
 121 ExtendedPC os::fetch_frame_from_context(const void* ucVoid,
 122                     intptr_t** ret_sp, intptr_t** ret_fp) {
 123 
 124   ExtendedPC  epc;
 125   const ucontext_t* uc = (const ucontext_t*)ucVoid;
 126 
 127   if (uc != NULL) {
 128     epc = ExtendedPC(os::Linux::ucontext_get_pc(uc));
 129     if (ret_sp) { *ret_sp = os::Linux::ucontext_get_sp(uc); }
 130     if (ret_fp) { *ret_fp = os::Linux::ucontext_get_fp(uc); }
 131   } else {
 132     // Construct empty ExtendedPC for return value checking.
 133     epc = ExtendedPC(NULL);
 134     if (ret_sp) { *ret_sp = (intptr_t *)NULL; }
 135     if (ret_fp) { *ret_fp = (intptr_t *)NULL; }
 136   }
 137 
 138   return epc;
 139 }
 140 
 141 frame os::fetch_frame_from_context(const void* ucVoid) {
 142   intptr_t* sp;
 143   intptr_t* fp;
 144   ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
 145   return frame(sp, epc.pc());
 146 }
 147 
 148 bool os::Linux::get_frame_at_stack_banging_point(JavaThread* thread, ucontext_t* uc, frame* fr) {
 149   address pc = (address) os::Linux::ucontext_get_pc(uc);
 150   if (Interpreter::contains(pc)) {
 151     // Interpreter performs stack banging after the fixed frame header has
 152     // been generated while the compilers perform it before. To maintain
 153     // semantic consistency between interpreted and compiled frames, the
 154     // method returns the Java sender of the current frame.
 155     *fr = os::fetch_frame_from_context(uc);
 156     if (!fr->is_first_java_frame()) {
 157       assert(fr->safe_for_sender(thread), "Safety check");
 158       *fr = fr->java_sender();
 159     }
 160   } else {
 161     // More complex code with compiled code.
 162     assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above");
 163     CodeBlob* cb = CodeCache::find_blob(pc);
 164     if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) {
 165       // Not sure where the pc points to, fallback to default
 166       // stack overflow handling. In compiled code, we bang before
 167       // the frame is complete.
 168       return false;
 169     } else {
 170       intptr_t* sp = os::Linux::ucontext_get_sp(uc);
 171       address lr = ucontext_get_lr(uc);
 172       *fr = frame(sp, lr);
 173       if (!fr->is_java_frame()) {
 174         assert(fr->safe_for_sender(thread), "Safety check");
 175         assert(!fr->is_first_frame(), "Safety check");
 176         *fr = fr->java_sender();
 177       }
 178     }
 179   }
 180   assert(fr->is_java_frame(), "Safety check");
 181   return true;
 182 }
 183 
 184 frame os::get_sender_for_C_frame(frame* fr) {
 185   if (*fr->sp() == 0) {
 186     // fr is the last C frame.
 187     return frame();
 188   }
 189 
 190   // If its not one of our frames, the return pc is saved at gpr14
 191   // stack slot. The call_stub stores the return_pc to the stack slot
 192   // of gpr10.
 193   if ((Interpreter::code() != NULL && Interpreter::contains(fr->pc())) ||
 194       (CodeCache::contains(fr->pc()) && !StubRoutines::contains(fr->pc()))) {
 195     return frame(fr->sender_sp(), fr->sender_pc());
 196   } else {
 197     if (StubRoutines::contains(fr->pc())) {
 198       StubCodeDesc* desc = StubCodeDesc::desc_for(fr->pc());
 199       if (desc && !strcmp(desc->name(),"call_stub")) {
 200         return frame(fr->sender_sp(), fr->callstub_sender_pc());
 201       } else {
 202         return frame(fr->sender_sp(), fr->sender_pc());
 203       }
 204     } else {
 205       return frame(fr->sender_sp(), fr->native_sender_pc());
 206     }
 207   }
 208 }
 209 
 210 frame os::current_frame() {
 211   // Expected to return the stack pointer of this method.
 212   // But if inlined, returns the stack pointer of our caller!
 213   intptr_t* csp = (intptr_t*) *((intptr_t*) os::current_stack_pointer());
 214   assert (csp != NULL, "sp should not be NULL");
 215   // Pass a dummy pc. This way we don't have to load it from the
 216   // stack, since we don't know in which slot we can find it.
 217   frame topframe(csp, (address)0x8);
 218   if (os::is_first_C_frame(&topframe)) {
 219     // Stack is not walkable.
 220     return frame();
 221   } else {
 222     frame senderFrame = os::get_sender_for_C_frame(&topframe);
 223     assert(senderFrame.pc() != NULL, "Sender pc should not be NULL");
 224     // Return sender of sender of current topframe which hopefully
 225     // both have pc != NULL.
 226 #ifdef _NMT_NOINLINE_   // Is set in slowdebug builds.
 227     // Current_stack_pointer is not inlined, we must pop one more frame.
 228     frame tmp = os::get_sender_for_C_frame(&topframe);
 229     return os::get_sender_for_C_frame(&tmp);
 230 #else
 231     return os::get_sender_for_C_frame(&topframe);
 232 #endif
 233   }
 234 }
 235 
 236 // Utility functions
 237 
 238 extern "C" JNIEXPORT int
 239 JVM_handle_linux_signal(int sig,
 240                         siginfo_t* info,
 241                         void* ucVoid,
 242                         int abort_if_unrecognized) {
 243   ucontext_t* uc = (ucontext_t*) ucVoid;
 244 
 245   Thread* t = Thread::current_or_null_safe();
 246 
 247   // Must do this before SignalHandlerMark, if crash protection installed we will longjmp away
 248   // (no destructors can be run).
 249   os::ThreadCrashProtection::check_crash_protection(sig, t);
 250 
 251   SignalHandlerMark shm(t);
 252 
 253   // Note: it's not uncommon that JNI code uses signal/sigset to install
 254   // then restore certain signal handler (e.g. to temporarily block SIGPIPE,
 255   // or have a SIGILL handler when detecting CPU type). When that happens,
 256   // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
 257   // avoid unnecessary crash when libjsig is not preloaded, try handle signals
 258   // that do not require siginfo/ucontext first.
 259 
 260   if (sig == SIGPIPE) {
 261     if (os::Linux::chained_handler(sig, info, ucVoid)) {
 262       return true;
 263     } else {
 264       if (PrintMiscellaneous && (WizardMode || Verbose)) {
 265         warning("Ignoring SIGPIPE - see bug 4229104");
 266       }
 267       return true;
 268     }
 269   }
 270 
 271 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT
 272   if ((sig == SIGSEGV || sig == SIGBUS) && info != NULL && info->si_addr == g_assert_poison) {
 273     if (handle_assert_poison_fault(ucVoid, info->si_addr)) {
 274       return 1;
 275     }
 276   }
 277 #endif
 278 
 279   JavaThread* thread = NULL;
 280   VMThread* vmthread = NULL;
 281   if (os::Linux::signal_handlers_are_installed) {
 282     if (t != NULL) {
 283       if(t->is_Java_thread()) {
 284         thread = (JavaThread*)t;
 285       } else if(t->is_VM_thread()) {
 286         vmthread = (VMThread *)t;
 287       }
 288     }
 289   }
 290 
 291   // Moved SafeFetch32 handling outside thread!=NULL conditional block to make
 292   // it work if no associated JavaThread object exists.
 293   if (uc) {
 294     address const pc = os::Linux::ucontext_get_pc(uc);
 295     if (pc && StubRoutines::is_safefetch_fault(pc)) {
 296       os::Linux::ucontext_set_pc(uc, StubRoutines::continuation_for_safefetch_fault(pc));
 297       return true;
 298     }
 299   }
 300 
 301   // Decide if this trap can be handled by a stub.
 302   address stub    = NULL;
 303   address pc      = NULL;  // Pc as retrieved from PSW. Usually points past failing instruction.
 304   address trap_pc = NULL;  // Pc of the instruction causing the trap.
 305 
 306   //%note os_trap_1
 307   if (info != NULL && uc != NULL && thread != NULL) {
 308     pc = os::Linux::ucontext_get_pc(uc);
 309     if (TraceTraps) {
 310       tty->print_cr("     pc at " INTPTR_FORMAT, p2i(pc));
 311     }
 312     if ((unsigned long)(pc - (address)info->si_addr) <= (unsigned long)Assembler::instr_maxlen() ) {
 313       trap_pc = (address)info->si_addr;
 314       if (TraceTraps) {
 315         tty->print_cr("trap_pc at " INTPTR_FORMAT, p2i(trap_pc));
 316       }
 317     }
 318 
 319     // Handle ALL stack overflow variations here
 320     if (sig == SIGSEGV) {
 321       address addr = (address)info->si_addr; // Address causing SIGSEGV, usually mem ref target.
 322 
 323       // Check if fault address is within thread stack.
 324       if (thread->on_local_stack(addr)) {
 325         // stack overflow
 326         if (thread->in_stack_yellow_reserved_zone(addr)) {
 327           if (thread->thread_state() == _thread_in_Java) {
 328             if (thread->in_stack_reserved_zone(addr)) {
 329               frame fr;
 330               if (os::Linux::get_frame_at_stack_banging_point(thread, uc, &fr)) {
 331                 assert(fr.is_java_frame(), "Must be a Javac frame");
 332                 frame activation =
 333                   SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr);
 334                 if (activation.sp() != NULL) {
 335                   thread->disable_stack_reserved_zone();
 336                   if (activation.is_interpreted_frame()) {
 337                     thread->set_reserved_stack_activation((address)activation.fp());
 338                   } else {
 339                     thread->set_reserved_stack_activation((address)activation.unextended_sp());
 340                   }
 341                   return 1;
 342                 }
 343               }
 344             }
 345             // Throw a stack overflow exception.
 346             // Guard pages will be reenabled while unwinding the stack.
 347             thread->disable_stack_yellow_reserved_zone();
 348             stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
 349           } else {
 350             // Thread was in the vm or native code. Return and try to finish.
 351             thread->disable_stack_yellow_reserved_zone();
 352             return 1;
 353           }
 354         } else if (thread->in_stack_red_zone(addr)) {
 355           // Fatal red zone violation.  Disable the guard pages and fall through
 356           // to handle_unexpected_exception way down below.
 357           thread->disable_stack_red_zone();
 358           tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
 359 
 360           // This is a likely cause, but hard to verify. Let's just print
 361           // it as a hint.
 362           tty->print_raw_cr("Please check if any of your loaded .so files has "
 363                             "enabled executable stack (see man page execstack(8))");
 364         } else {
 365           // Accessing stack address below sp may cause SEGV if current
 366           // thread has MAP_GROWSDOWN stack. This should only happen when
 367           // current thread was created by user code with MAP_GROWSDOWN flag
 368           // and then attached to VM. See notes in os_linux.cpp.
 369           if (thread->osthread()->expanding_stack() == 0) {
 370              thread->osthread()->set_expanding_stack();
 371              if (os::Linux::manually_expand_stack(thread, addr)) {
 372                thread->osthread()->clear_expanding_stack();
 373                return 1;
 374              }
 375              thread->osthread()->clear_expanding_stack();
 376           } else {
 377              fatal("recursive segv. expanding stack.");
 378           }
 379         }
 380       }
 381     }
 382 
 383     if (thread->thread_state() == _thread_in_Java) {
 384       // Java thread running in Java code => find exception handler if any
 385       // a fault inside compiled code, the interpreter, or a stub
 386 
 387       // Handle signal from NativeJump::patch_verified_entry().
 388       if (sig == SIGILL && nativeInstruction_at(pc)->is_sigill_zombie_not_entrant()) {
 389         if (TraceTraps) {
 390           tty->print_cr("trap: zombie_not_entrant (SIGILL)");
 391         }
 392         stub = SharedRuntime::get_handle_wrong_method_stub();
 393       }
 394 
 395       else if (sig == SIGSEGV &&
 396                os::is_poll_address((address)info->si_addr)) {
 397         if (TraceTraps) {
 398           tty->print_cr("trap: safepoint_poll at " INTPTR_FORMAT " (SIGSEGV)", p2i(pc));
 399         }
 400         stub = SharedRuntime::get_poll_stub(pc);
 401 
 402         // Info->si_addr only points to the page base address, so we
 403         // must extract the real si_addr from the instruction and the
 404         // ucontext.
 405         assert(((NativeInstruction*)pc)->is_safepoint_poll(), "must be safepoint poll");
 406         const address real_si_addr = ((NativeInstruction*)pc)->get_poll_address(uc);
 407       }
 408 
 409       // SIGTRAP-based implicit null check in compiled code.
 410       else if ((sig == SIGFPE) &&
 411                TrapBasedNullChecks &&
 412                (trap_pc != NULL) &&
 413                Assembler::is_sigtrap_zero_check(trap_pc)) {
 414         if (TraceTraps) {
 415           tty->print_cr("trap: NULL_CHECK at " INTPTR_FORMAT " (SIGFPE)", p2i(trap_pc));
 416         }
 417         stub = SharedRuntime::continuation_for_implicit_exception(thread, trap_pc, SharedRuntime::IMPLICIT_NULL);
 418       }
 419 
 420       else if (sig == SIGSEGV && ImplicitNullChecks &&
 421                CodeCache::contains((void*) pc) &&
 422                MacroAssembler::uses_implicit_null_check(info->si_addr)) {
 423         if (TraceTraps) {
 424           tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", p2i(pc));
 425         }
 426         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
 427       }
 428 
 429       // SIGTRAP-based implicit range check in compiled code.
 430       else if (sig == SIGFPE && TrapBasedRangeChecks &&
 431                (trap_pc != NULL) &&
 432                Assembler::is_sigtrap_range_check(trap_pc)) {
 433         if (TraceTraps) {
 434           tty->print_cr("trap: RANGE_CHECK at " INTPTR_FORMAT " (SIGFPE)", p2i(trap_pc));
 435         }
 436         stub = SharedRuntime::continuation_for_implicit_exception(thread, trap_pc, SharedRuntime::IMPLICIT_NULL);
 437       }
 438 
 439       else if (sig == SIGFPE && info->si_code == FPE_INTDIV) {
 440         stub = SharedRuntime::continuation_for_implicit_exception(thread, trap_pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO);
 441       }
 442 
 443       else if (sig == SIGBUS) {
 444         // BugId 4454115: A read from a MappedByteBuffer can fault here if the
 445         // underlying file has been truncated. Do not crash the VM in such a case.
 446         CodeBlob* cb = CodeCache::find_blob_unsafe(pc);
 447         CompiledMethod* nm = (cb != NULL) ? cb->as_compiled_method_or_null() : NULL;
 448         if (nm != NULL && nm->has_unsafe_access()) {
 449           // We don't really need a stub here! Just set the pending exeption and
 450           // continue at the next instruction after the faulting read. Returning
 451           // garbage from this read is ok.
 452           thread->set_pending_unsafe_access_error();
 453           uc->uc_mcontext.psw.addr = ((unsigned long)pc) + Assembler::instr_len(pc);
 454           return true;
 455         }
 456       }
 457     }
 458 
 459     else { // thread->thread_state() != _thread_in_Java
 460       if ((sig == SIGILL) && VM_Version::is_determine_features_test_running()) {
 461         // SIGILL must be caused by VM_Version::determine_features()
 462         // when attempting to execute a non-existing instruction.
 463         //*(int *) (pc-6)=0; // Patch instruction to 0 to indicate that it causes a SIGILL.
 464                              // Flushing of icache is not necessary.
 465         stub = pc; // Continue with next instruction.
 466       } else if ((sig == SIGFPE) && VM_Version::is_determine_features_test_running()) {
 467         // SIGFPE is known to be caused by trying to execute a vector instruction
 468         // when the vector facility is installed, but operating system support is missing.
 469         VM_Version::reset_has_VectorFacility();
 470         stub = pc; // Continue with next instruction.
 471       } else if ((thread->thread_state() == _thread_in_vm ||
 472                   thread->thread_state() == _thread_in_native) &&
 473                  sig == SIGBUS && thread->doing_unsafe_access()) {
 474         // We don't really need a stub here! Just set the pending exeption and
 475         // continue at the next instruction after the faulting read. Returning
 476         // garbage from this read is ok.
 477         thread->set_pending_unsafe_access_error();
 478         os::Linux::ucontext_set_pc(uc, pc + Assembler::instr_len(pc));
 479         return true;
 480       }
 481     }
 482 
 483     // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
 484     // and the heap gets shrunk before the field access.
 485     if ((sig == SIGSEGV) || (sig == SIGBUS)) {
 486       address addr = JNI_FastGetField::find_slowcase_pc(pc);
 487       if (addr != (address)-1) {
 488         stub = addr;
 489       }
 490     }
 491   }
 492 
 493   if (stub != NULL) {
 494     // Save all thread context in case we need to restore it.
 495     if (thread != NULL) thread->set_saved_exception_pc(pc);
 496     os::Linux::ucontext_set_pc(uc, stub);
 497     return true;
 498   }
 499 
 500   // signal-chaining
 501   if (os::Linux::chained_handler(sig, info, ucVoid)) {
 502     return true;
 503   }
 504 
 505   if (!abort_if_unrecognized) {
 506     // caller wants another chance, so give it to him
 507     return false;
 508   }
 509 
 510   if (pc == NULL && uc != NULL) {
 511     pc = os::Linux::ucontext_get_pc(uc);
 512   }
 513 
 514   // unmask current signal
 515   sigset_t newset;
 516   sigemptyset(&newset);
 517   sigaddset(&newset, sig);
 518   sigprocmask(SIG_UNBLOCK, &newset, NULL);
 519 
 520   // Hand down correct pc for SIGILL, SIGFPE. pc from context
 521   // usually points to the instruction after the failing instruction.
 522   // Note: this should be combined with the trap_pc handling above,
 523   // because it handles the same issue.
 524   if (sig == SIGILL || sig == SIGFPE) {
 525     pc = (address)info->si_addr;
 526   }
 527 
 528   VMError::report_and_die(t, sig, pc, info, ucVoid);
 529 
 530   ShouldNotReachHere();
 531   return false;
 532 }
 533 
 534 void os::Linux::init_thread_fpu_state(void) {
 535   // Nothing to do on z/Architecture.
 536 }
 537 
 538 int os::Linux::get_fpu_control_word(void) {
 539   // Nothing to do on z/Architecture.
 540   return 0;
 541 }
 542 
 543 void os::Linux::set_fpu_control_word(int fpu_control) {
 544   // Nothing to do on z/Architecture.
 545 }
 546 
 547 ////////////////////////////////////////////////////////////////////////////////
 548 // thread stack
 549 
 550 // Minimum usable stack sizes required to get to user code. Space for
 551 // HotSpot guard pages is added later.
 552 size_t os::Posix::_compiler_thread_min_stack_allowed = (52 DEBUG_ONLY(+ 32)) * K;
 553 size_t os::Posix::_java_thread_min_stack_allowed = (32 DEBUG_ONLY(+ 8)) * K;
 554 size_t os::Posix::_vm_internal_thread_min_stack_allowed = 32 * K;
 555 
 556 // Return default stack size for thr_type.
 557 size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
 558   // Default stack size (compiler thread needs larger stack).
 559   size_t s = (thr_type == os::compiler_thread ? 4 * M : 1024 * K);
 560   return s;
 561 }
 562 
 563 /////////////////////////////////////////////////////////////////////////////
 564 // helper functions for fatal error handler
 565 
 566 void os::print_context(outputStream *st, const void *context) {
 567   if (context == NULL) return;
 568 
 569   const ucontext_t* uc = (const ucontext_t*)context;
 570 
 571   st->print_cr("Processor state:");
 572   st->print_cr("----------------");
 573   st->print_cr("        ip = " INTPTR_FORMAT " ", uc->uc_mcontext.psw.addr);
 574   st->print_cr(" proc mask = " INTPTR_FORMAT " ", uc->uc_mcontext.psw.mask);
 575   st->print_cr("   fpc reg = 0x%8.8x "          , uc->uc_mcontext.fpregs.fpc);
 576   st->cr();
 577 
 578   st->print_cr("General Purpose Registers:");
 579   st->print_cr("--------------------------");
 580   for( int i = 0; i < 16; i+=2 ) {
 581     st->print("  r%-2d = " INTPTR_FORMAT "  " ,  i,   uc->uc_mcontext.gregs[i]);
 582     st->print("  r%-2d = " INTPTR_FORMAT "  |",  i+1, uc->uc_mcontext.gregs[i+1]);
 583     st->print("  r%-2d = %23.1ld  "           ,  i,   uc->uc_mcontext.gregs[i]);
 584     st->print("  r%-2d = %23.1ld  "           ,  i+1, uc->uc_mcontext.gregs[i+1]);
 585     st->cr();
 586   }
 587   st->cr();
 588 
 589   st->print_cr("Access Registers:");
 590   st->print_cr("-----------------");
 591   for( int i = 0; i < 16; i+=2 ) {
 592     st->print("  ar%-2d = 0x%8.8x  ", i,   uc->uc_mcontext.aregs[i]);
 593     st->print("  ar%-2d = 0x%8.8x  ", i+1, uc->uc_mcontext.aregs[i+1]);
 594     st->cr();
 595   }
 596   st->cr();
 597 
 598   st->print_cr("Float Registers:");
 599   st->print_cr("----------------");
 600   for (int i = 0; i < 16; i += 2) {
 601     st->print("  fr%-2d = " INTPTR_FORMAT "  " , i,   (int64_t)(uc->uc_mcontext.fpregs.fprs[i].d));
 602     st->print("  fr%-2d = " INTPTR_FORMAT "  |", i+1, (int64_t)(uc->uc_mcontext.fpregs.fprs[i+1].d));
 603     st->print("  fr%-2d = %23.15e  "           , i,   (uc->uc_mcontext.fpregs.fprs[i].d));
 604     st->print("  fr%-2d = %23.15e  "           , i+1, (uc->uc_mcontext.fpregs.fprs[i+1].d));
 605     st->cr();
 606   }
 607   st->cr();
 608   st->cr();
 609 
 610   intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc);
 611   st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", p2i(sp));
 612   print_hex_dump(st, (address)sp, (address)(sp + 128), sizeof(intptr_t));
 613   st->cr();
 614 
 615   // Note: it may be unsafe to inspect memory near pc. For example, pc may
 616   // point to garbage if entry point in an nmethod is corrupted. Leave
 617   // this at the end, and hope for the best.
 618   address pc = os::Linux::ucontext_get_pc(uc);
 619   print_instructions(st, pc, /*intrsize=*/4);
 620   st->cr();
 621 }
 622 
 623 void os::print_register_info(outputStream *st, const void *context) {
 624   if (context == NULL) return;
 625 
 626   const ucontext_t *uc = (const ucontext_t*)context;
 627 
 628   st->print_cr("Register to memory mapping:");
 629   st->cr();
 630 
 631   st->print("pc ="); print_location(st, (intptr_t)uc->uc_mcontext.psw.addr);
 632   for (int i = 0; i < 16; i++) {
 633     st->print("r%-2d=", i);
 634     print_location(st, uc->uc_mcontext.gregs[i]);
 635   }
 636   st->cr();
 637 }
 638 
 639 #ifndef PRODUCT
 640 void os::verify_stack_alignment() {
 641 }
 642 #endif
 643 
 644 int os::extra_bang_size_in_bytes() {
 645   // z/Architecture does not require the additional stack bang.
 646   return 0;
 647 }