1 /*
   2  * Copyright (c) 1999, 2014, 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 "asm/macroAssembler.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_solaris.h"
  34 #include "memory/allocation.inline.hpp"
  35 #include "mutex_solaris.inline.hpp"
  36 #include "os_share_solaris.hpp"
  37 #include "prims/jniFastGetField.hpp"
  38 #include "prims/jvm.h"
  39 #include "prims/jvm_misc.hpp"
  40 #include "runtime/arguments.hpp"
  41 #include "runtime/atomic.inline.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"
  51 #include "runtime/thread.inline.hpp"
  52 #include "runtime/timer.hpp"
  53 #include "utilities/events.hpp"
  54 #include "utilities/vmError.hpp"
  55 
  56 // put OS-includes here
  57 # include <sys/types.h>
  58 # include <sys/mman.h>
  59 # include <pthread.h>
  60 # include <signal.h>
  61 # include <setjmp.h>
  62 # include <errno.h>
  63 # include <dlfcn.h>
  64 # include <stdio.h>
  65 # include <unistd.h>
  66 # include <sys/resource.h>
  67 # include <thread.h>
  68 # include <sys/stat.h>
  69 # include <sys/time.h>
  70 # include <sys/filio.h>
  71 # include <sys/utsname.h>
  72 # include <sys/systeminfo.h>
  73 # include <sys/socket.h>
  74 # include <sys/trap.h>
  75 # include <sys/lwp.h>
  76 # include <pwd.h>
  77 # include <poll.h>
  78 # include <sys/lwp.h>
  79 # include <procfs.h>     //  see comment in <sys/procfs.h>
  80 
  81 #ifndef AMD64
  82 // QQQ seems useless at this point
  83 # define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later
  84 #endif // AMD64
  85 # include <sys/procfs.h>     //  see comment in <sys/procfs.h>
  86 
  87 
  88 #define MAX_PATH (2 * K)
  89 
  90 // Minimum stack size for the VM.  It's easier to document a constant value
  91 // but it's different for x86 and sparc because the page sizes are different.
  92 #ifdef AMD64
  93 size_t os::Solaris::min_stack_allowed = 224*K;
  94 #define REG_SP REG_RSP
  95 #define REG_PC REG_RIP
  96 #define REG_FP REG_RBP
  97 #else
  98 size_t os::Solaris::min_stack_allowed = 64*K;
  99 #define REG_SP UESP
 100 #define REG_PC EIP
 101 #define REG_FP EBP
 102 // 4900493 counter to prevent runaway LDTR refresh attempt
 103 
 104 static volatile int ldtr_refresh = 0;
 105 // the libthread instruction that faults because of the stale LDTR
 106 
 107 static const unsigned char movlfs[] = { 0x8e, 0xe0    // movl %eax,%fs
 108                        };
 109 #endif // AMD64
 110 
 111 char* os::non_memory_address_word() {
 112   // Must never look like an address returned by reserve_memory,
 113   // even in its subfields (as defined by the CPU immediate fields,
 114   // if the CPU splits constants across multiple instructions).
 115   return (char*) -1;
 116 }
 117 
 118 //
 119 // Validate a ucontext retrieved from walking a uc_link of a ucontext.
 120 // There are issues with libthread giving out uc_links for different threads
 121 // on the same uc_link chain and bad or circular links.
 122 //
 123 bool os::Solaris::valid_ucontext(Thread* thread, ucontext_t* valid, ucontext_t* suspect) {
 124   if (valid >= suspect ||
 125       valid->uc_stack.ss_flags != suspect->uc_stack.ss_flags ||
 126       valid->uc_stack.ss_sp    != suspect->uc_stack.ss_sp    ||
 127       valid->uc_stack.ss_size  != suspect->uc_stack.ss_size) {
 128     DEBUG_ONLY(tty->print_cr("valid_ucontext: failed test 1");)
 129     return false;
 130   }
 131 
 132   if (thread->is_Java_thread()) {
 133     if (!valid_stack_address(thread, (address)suspect)) {
 134       DEBUG_ONLY(tty->print_cr("valid_ucontext: uc_link not in thread stack");)
 135       return false;
 136     }
 137     if (!valid_stack_address(thread,  (address) suspect->uc_mcontext.gregs[REG_SP])) {
 138       DEBUG_ONLY(tty->print_cr("valid_ucontext: stackpointer not in thread stack");)
 139       return false;
 140     }
 141   }
 142   return true;
 143 }
 144 
 145 // We will only follow one level of uc_link since there are libthread
 146 // issues with ucontext linking and it is better to be safe and just
 147 // let caller retry later.
 148 ucontext_t* os::Solaris::get_valid_uc_in_signal_handler(Thread *thread,
 149   ucontext_t *uc) {
 150 
 151   ucontext_t *retuc = NULL;
 152 
 153   if (uc != NULL) {
 154     if (uc->uc_link == NULL) {
 155       // cannot validate without uc_link so accept current ucontext
 156       retuc = uc;
 157     } else if (os::Solaris::valid_ucontext(thread, uc, uc->uc_link)) {
 158       // first ucontext is valid so try the next one
 159       uc = uc->uc_link;
 160       if (uc->uc_link == NULL) {
 161         // cannot validate without uc_link so accept current ucontext
 162         retuc = uc;
 163       } else if (os::Solaris::valid_ucontext(thread, uc, uc->uc_link)) {
 164         // the ucontext one level down is also valid so return it
 165         retuc = uc;
 166       }
 167     }
 168   }
 169   return retuc;
 170 }
 171 
 172 // Assumes ucontext is valid
 173 ExtendedPC os::Solaris::ucontext_get_ExtendedPC(ucontext_t *uc) {
 174   return ExtendedPC((address)uc->uc_mcontext.gregs[REG_PC]);
 175 }
 176 
 177 // Assumes ucontext is valid
 178 intptr_t* os::Solaris::ucontext_get_sp(ucontext_t *uc) {
 179   return (intptr_t*)uc->uc_mcontext.gregs[REG_SP];
 180 }
 181 
 182 // Assumes ucontext is valid
 183 intptr_t* os::Solaris::ucontext_get_fp(ucontext_t *uc) {
 184   return (intptr_t*)uc->uc_mcontext.gregs[REG_FP];
 185 }
 186 
 187 address os::Solaris::ucontext_get_pc(ucontext_t *uc) {
 188   return (address) uc->uc_mcontext.gregs[REG_PC];
 189 }
 190 
 191 // For Forte Analyzer AsyncGetCallTrace profiling support - thread
 192 // is currently interrupted by SIGPROF.
 193 //
 194 // The difference between this and os::fetch_frame_from_context() is that
 195 // here we try to skip nested signal frames.
 196 ExtendedPC os::Solaris::fetch_frame_from_ucontext(Thread* thread,
 197   ucontext_t* uc, intptr_t** ret_sp, intptr_t** ret_fp) {
 198 
 199   assert(thread != NULL, "just checking");
 200   assert(ret_sp != NULL, "just checking");
 201   assert(ret_fp != NULL, "just checking");
 202 
 203   ucontext_t *luc = os::Solaris::get_valid_uc_in_signal_handler(thread, uc);
 204   return os::fetch_frame_from_context(luc, ret_sp, ret_fp);
 205 }
 206 
 207 ExtendedPC os::fetch_frame_from_context(void* ucVoid,
 208                     intptr_t** ret_sp, intptr_t** ret_fp) {
 209 
 210   ExtendedPC  epc;
 211   ucontext_t *uc = (ucontext_t*)ucVoid;
 212 
 213   if (uc != NULL) {
 214     epc = os::Solaris::ucontext_get_ExtendedPC(uc);
 215     if (ret_sp) *ret_sp = os::Solaris::ucontext_get_sp(uc);
 216     if (ret_fp) *ret_fp = os::Solaris::ucontext_get_fp(uc);
 217   } else {
 218     // construct empty ExtendedPC for return value checking
 219     epc = ExtendedPC(NULL);
 220     if (ret_sp) *ret_sp = (intptr_t *)NULL;
 221     if (ret_fp) *ret_fp = (intptr_t *)NULL;
 222   }
 223 
 224   return epc;
 225 }
 226 
 227 frame os::fetch_frame_from_context(void* ucVoid) {
 228   intptr_t* sp;
 229   intptr_t* fp;
 230   ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
 231   return frame(sp, fp, epc.pc());
 232 }
 233 
 234 frame os::get_sender_for_C_frame(frame* fr) {
 235   return frame(fr->sender_sp(), fr->link(), fr->sender_pc());
 236 }
 237 
 238 extern "C" intptr_t *_get_current_sp();  // in .il file
 239 
 240 address os::current_stack_pointer() {
 241   return (address)_get_current_sp();
 242 }
 243 
 244 extern "C" intptr_t *_get_current_fp();  // in .il file
 245 
 246 frame os::current_frame() {
 247   intptr_t* fp = _get_current_fp();  // it's inlined so want current fp
 248   frame myframe((intptr_t*)os::current_stack_pointer(),
 249                 (intptr_t*)fp,
 250                 CAST_FROM_FN_PTR(address, os::current_frame));
 251   if (os::is_first_C_frame(&myframe)) {
 252     // stack is not walkable
 253     frame ret; // This will be a null useless frame
 254     return ret;
 255   } else {
 256     return os::get_sender_for_C_frame(&myframe);
 257   }
 258 }
 259 
 260 #ifndef AMD64
 261 
 262 // Detecting SSE support by OS
 263 // From solaris_i486.s
 264 extern "C" bool sse_check();
 265 extern "C" bool sse_unavailable();
 266 
 267 enum { SSE_UNKNOWN, SSE_NOT_SUPPORTED, SSE_SUPPORTED};
 268 static int sse_status = SSE_UNKNOWN;
 269 
 270 
 271 static void  check_for_sse_support() {
 272   if (!VM_Version::supports_sse()) {
 273     sse_status = SSE_NOT_SUPPORTED;
 274     return;
 275   }
 276   // looking for _sse_hw in libc.so, if it does not exist or
 277   // the value (int) is 0, OS has no support for SSE
 278   int *sse_hwp;
 279   void *h;
 280 
 281   if ((h=dlopen("/usr/lib/libc.so", RTLD_LAZY)) == NULL) {
 282     //open failed, presume no support for SSE
 283     sse_status = SSE_NOT_SUPPORTED;
 284     return;
 285   }
 286   if ((sse_hwp = (int *)dlsym(h, "_sse_hw")) == NULL) {
 287     sse_status = SSE_NOT_SUPPORTED;
 288   } else if (*sse_hwp == 0) {
 289     sse_status = SSE_NOT_SUPPORTED;
 290   }
 291   dlclose(h);
 292 
 293   if (sse_status == SSE_UNKNOWN) {
 294     bool (*try_sse)() = (bool (*)())sse_check;
 295     sse_status = (*try_sse)() ? SSE_SUPPORTED : SSE_NOT_SUPPORTED;
 296   }
 297 
 298 }
 299 
 300 #endif // AMD64
 301 
 302 bool os::supports_sse() {
 303 #ifdef AMD64
 304   return true;
 305 #else
 306   if (sse_status == SSE_UNKNOWN)
 307     check_for_sse_support();
 308   return sse_status == SSE_SUPPORTED;
 309 #endif // AMD64
 310 }
 311 
 312 bool os::is_allocatable(size_t bytes) {
 313 #ifdef AMD64
 314   return true;
 315 #else
 316 
 317   if (bytes < 2 * G) {
 318     return true;
 319   }
 320 
 321   char* addr = reserve_memory(bytes, NULL);
 322 
 323   if (addr != NULL) {
 324     release_memory(addr, bytes);
 325   }
 326 
 327   return addr != NULL;
 328 #endif // AMD64
 329 
 330 }
 331 
 332 extern "C" JNIEXPORT int
 333 JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid,
 334                           int abort_if_unrecognized) {
 335   ucontext_t* uc = (ucontext_t*) ucVoid;
 336 
 337 #ifndef AMD64
 338   if (sig == SIGILL && info->si_addr == (caddr_t)sse_check) {
 339     // the SSE instruction faulted. supports_sse() need return false.
 340     uc->uc_mcontext.gregs[EIP] = (greg_t)sse_unavailable;
 341     return true;
 342   }
 343 #endif // !AMD64
 344 
 345   Thread* t = ThreadLocalStorage::get_thread_slow();  // slow & steady
 346 
 347   // Must do this before SignalHandlerMark, if crash protection installed we will longjmp away
 348   // (no destructors can be run)
 349   os::WatcherThreadCrashProtection::check_crash_protection(sig, t);
 350 
 351   SignalHandlerMark shm(t);
 352 
 353   if(sig == SIGPIPE || sig == SIGXFSZ) {
 354     if (os::Solaris::chained_handler(sig, info, ucVoid)) {
 355       return true;
 356     } else {
 357       if (PrintMiscellaneous && (WizardMode || Verbose)) {
 358         char buf[64];
 359         warning("Ignoring %s - see 4229104 or 6499219",
 360                 os::exception_name(sig, buf, sizeof(buf)));
 361 
 362       }
 363       return true;
 364     }
 365   }
 366 
 367   JavaThread* thread = NULL;
 368   VMThread* vmthread = NULL;
 369 
 370   if (os::Solaris::signal_handlers_are_installed) {
 371     if (t != NULL ){
 372       if(t->is_Java_thread()) {
 373         thread = (JavaThread*)t;
 374       }
 375       else if(t->is_VM_thread()){
 376         vmthread = (VMThread *)t;
 377       }
 378     }
 379   }
 380 
 381   guarantee(sig != os::Solaris::SIGinterrupt(), "Can not chain VM interrupt signal, try -XX:+UseAltSigs");
 382 
 383   if (sig == os::Solaris::SIGasync()) {
 384     if(thread || vmthread){
 385       OSThread::SR_handler(t, uc);
 386       return true;
 387     } else if (os::Solaris::chained_handler(sig, info, ucVoid)) {
 388       return true;
 389     } else {
 390       // If os::Solaris::SIGasync not chained, and this is a non-vm and
 391       // non-java thread
 392       return true;
 393     }
 394   }
 395 
 396   if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) {
 397     // can't decode this kind of signal
 398     info = NULL;
 399   } else {
 400     assert(sig == info->si_signo, "bad siginfo");
 401   }
 402 
 403   // decide if this trap can be handled by a stub
 404   address stub = NULL;
 405 
 406   address pc          = NULL;
 407 
 408   //%note os_trap_1
 409   if (info != NULL && uc != NULL && thread != NULL) {
 410     // factor me: getPCfromContext
 411     pc = (address) uc->uc_mcontext.gregs[REG_PC];
 412 
 413     if (StubRoutines::is_safefetch_fault(pc)) {
 414       uc->uc_mcontext.gregs[REG_PC] = intptr_t(StubRoutines::continuation_for_safefetch_fault(pc));
 415       return true;
 416     }
 417 
 418     // Handle ALL stack overflow variations here
 419     if (sig == SIGSEGV && info->si_code == SEGV_ACCERR) {
 420       address addr = (address) info->si_addr;
 421       if (thread->in_stack_yellow_zone(addr)) {
 422         thread->disable_stack_yellow_zone();
 423         if (thread->thread_state() == _thread_in_Java) {
 424           // Throw a stack overflow exception.  Guard pages will be reenabled
 425           // while unwinding the stack.
 426           stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
 427         } else {
 428           // Thread was in the vm or native code.  Return and try to finish.
 429           return true;
 430         }
 431       } else if (thread->in_stack_red_zone(addr)) {
 432         // Fatal red zone violation.  Disable the guard pages and fall through
 433         // to handle_unexpected_exception way down below.
 434         thread->disable_stack_red_zone();
 435         tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
 436       }
 437     }
 438 
 439     if ((sig == SIGSEGV) && VM_Version::is_cpuinfo_segv_addr(pc)) {
 440       // Verify that OS save/restore AVX registers.
 441       stub = VM_Version::cpuinfo_cont_addr();
 442     }
 443 
 444     if (thread->thread_state() == _thread_in_vm) {
 445       if (sig == SIGBUS && info->si_code == BUS_OBJERR && thread->doing_unsafe_access()) {
 446         stub = StubRoutines::handler_for_unsafe_access();
 447       }
 448     }
 449 
 450     if (thread->thread_state() == _thread_in_Java) {
 451       // Support Safepoint Polling
 452       if ( sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) {
 453         stub = SharedRuntime::get_poll_stub(pc);
 454       }
 455       else if (sig == SIGBUS && info->si_code == BUS_OBJERR) {
 456         // BugId 4454115: A read from a MappedByteBuffer can fault
 457         // here if the underlying file has been truncated.
 458         // Do not crash the VM in such a case.
 459         CodeBlob* cb = CodeCache::find_blob_unsafe(pc);
 460         if (cb != NULL) {
 461           nmethod* nm = cb->is_nmethod() ? (nmethod*)cb : NULL;
 462           if (nm != NULL && nm->has_unsafe_access()) {
 463             stub = StubRoutines::handler_for_unsafe_access();
 464           }
 465         }
 466       }
 467       else
 468       if (sig == SIGFPE && info->si_code == FPE_INTDIV) {
 469         // integer divide by zero
 470         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO);
 471       }
 472 #ifndef AMD64
 473       else if (sig == SIGFPE && info->si_code == FPE_FLTDIV) {
 474         // floating-point divide by zero
 475         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO);
 476       }
 477       else if (sig == SIGFPE && info->si_code == FPE_FLTINV) {
 478         // The encoding of D2I in i486.ad can cause an exception prior
 479         // to the fist instruction if there was an invalid operation
 480         // pending. We want to dismiss that exception. From the win_32
 481         // side it also seems that if it really was the fist causing
 482         // the exception that we do the d2i by hand with different
 483         // rounding. Seems kind of weird. QQQ TODO
 484         // Note that we take the exception at the NEXT floating point instruction.
 485         if (pc[0] == 0xDB) {
 486             assert(pc[0] == 0xDB, "not a FIST opcode");
 487             assert(pc[1] == 0x14, "not a FIST opcode");
 488             assert(pc[2] == 0x24, "not a FIST opcode");
 489             return true;
 490         } else {
 491             assert(pc[-3] == 0xDB, "not an flt invalid opcode");
 492             assert(pc[-2] == 0x14, "not an flt invalid opcode");
 493             assert(pc[-1] == 0x24, "not an flt invalid opcode");
 494         }
 495       }
 496       else if (sig == SIGFPE ) {
 497         tty->print_cr("caught SIGFPE, info 0x%x.", info->si_code);
 498       }
 499 #endif // !AMD64
 500 
 501         // QQQ It doesn't seem that we need to do this on x86 because we should be able
 502         // to return properly from the handler without this extra stuff on the back side.
 503 
 504       else if (sig == SIGSEGV && info->si_code > 0 && !MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) {
 505         // Determination of interpreter/vtable stub/compiled code null exception
 506         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
 507       }
 508     }
 509 
 510     // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
 511     // and the heap gets shrunk before the field access.
 512     if ((sig == SIGSEGV) || (sig == SIGBUS)) {
 513       address addr = JNI_FastGetField::find_slowcase_pc(pc);
 514       if (addr != (address)-1) {
 515         stub = addr;
 516       }
 517     }
 518 
 519     // Check to see if we caught the safepoint code in the
 520     // process of write protecting the memory serialization page.
 521     // It write enables the page immediately after protecting it
 522     // so we can just return to retry the write.
 523     if ((sig == SIGSEGV) &&
 524         os::is_memory_serialize_page(thread, (address)info->si_addr)) {
 525       // Block current thread until the memory serialize page permission restored.
 526       os::block_on_serialize_page_trap();
 527       return true;
 528     }
 529   }
 530 
 531   // Execution protection violation
 532   //
 533   // Preventative code for future versions of Solaris which may
 534   // enable execution protection when running the 32-bit VM on AMD64.
 535   //
 536   // This should be kept as the last step in the triage.  We don't
 537   // have a dedicated trap number for a no-execute fault, so be
 538   // conservative and allow other handlers the first shot.
 539   //
 540   // Note: We don't test that info->si_code == SEGV_ACCERR here.
 541   // this si_code is so generic that it is almost meaningless; and
 542   // the si_code for this condition may change in the future.
 543   // Furthermore, a false-positive should be harmless.
 544   if (UnguardOnExecutionViolation > 0 &&
 545       (sig == SIGSEGV || sig == SIGBUS) &&
 546       uc->uc_mcontext.gregs[TRAPNO] == T_PGFLT) {  // page fault
 547     int page_size = os::vm_page_size();
 548     address addr = (address) info->si_addr;
 549     address pc = (address) uc->uc_mcontext.gregs[REG_PC];
 550     // Make sure the pc and the faulting address are sane.
 551     //
 552     // If an instruction spans a page boundary, and the page containing
 553     // the beginning of the instruction is executable but the following
 554     // page is not, the pc and the faulting address might be slightly
 555     // different - we still want to unguard the 2nd page in this case.
 556     //
 557     // 15 bytes seems to be a (very) safe value for max instruction size.
 558     bool pc_is_near_addr =
 559       (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
 560     bool instr_spans_page_boundary =
 561       (align_size_down((intptr_t) pc ^ (intptr_t) addr,
 562                        (intptr_t) page_size) > 0);
 563 
 564     if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
 565       static volatile address last_addr =
 566         (address) os::non_memory_address_word();
 567 
 568       // In conservative mode, don't unguard unless the address is in the VM
 569       if (addr != last_addr &&
 570           (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
 571 
 572         // Make memory rwx and retry
 573         address page_start =
 574           (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
 575         bool res = os::protect_memory((char*) page_start, page_size,
 576                                       os::MEM_PROT_RWX);
 577 
 578         if (PrintMiscellaneous && Verbose) {
 579           char buf[256];
 580           jio_snprintf(buf, sizeof(buf), "Execution protection violation "
 581                        "at " INTPTR_FORMAT
 582                        ", unguarding " INTPTR_FORMAT ": %s, errno=%d", addr,
 583                        page_start, (res ? "success" : "failed"), errno);
 584           tty->print_raw_cr(buf);
 585         }
 586         stub = pc;
 587 
 588         // Set last_addr so if we fault again at the same address, we don't end
 589         // up in an endless loop.
 590         //
 591         // There are two potential complications here.  Two threads trapping at
 592         // the same address at the same time could cause one of the threads to
 593         // think it already unguarded, and abort the VM.  Likely very rare.
 594         //
 595         // The other race involves two threads alternately trapping at
 596         // different addresses and failing to unguard the page, resulting in
 597         // an endless loop.  This condition is probably even more unlikely than
 598         // the first.
 599         //
 600         // Although both cases could be avoided by using locks or thread local
 601         // last_addr, these solutions are unnecessary complication: this
 602         // handler is a best-effort safety net, not a complete solution.  It is
 603         // disabled by default and should only be used as a workaround in case
 604         // we missed any no-execute-unsafe VM code.
 605 
 606         last_addr = addr;
 607       }
 608     }
 609   }
 610 
 611   if (stub != NULL) {
 612     // save all thread context in case we need to restore it
 613 
 614     if (thread != NULL) thread->set_saved_exception_pc(pc);
 615     // 12/02/99: On Sparc it appears that the full context is also saved
 616     // but as yet, no one looks at or restores that saved context
 617     // factor me: setPC
 618     uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub;
 619     return true;
 620   }
 621 
 622   // signal-chaining
 623   if (os::Solaris::chained_handler(sig, info, ucVoid)) {
 624     return true;
 625   }
 626 
 627 #ifndef AMD64
 628   // Workaround (bug 4900493) for Solaris kernel bug 4966651.
 629   // Handle an undefined selector caused by an attempt to assign
 630   // fs in libthread getipriptr(). With the current libthread design every 512
 631   // thread creations the LDT for a private thread data structure is extended
 632   // and thre is a hazard that and another thread attempting a thread creation
 633   // will use a stale LDTR that doesn't reflect the structure's growth,
 634   // causing a GP fault.
 635   // Enforce the probable limit of passes through here to guard against an
 636   // infinite loop if some other move to fs caused the GP fault. Note that
 637   // this loop counter is ultimately a heuristic as it is possible for
 638   // more than one thread to generate this fault at a time in an MP system.
 639   // In the case of the loop count being exceeded or if the poll fails
 640   // just fall through to a fatal error.
 641   // If there is some other source of T_GPFLT traps and the text at EIP is
 642   // unreadable this code will loop infinitely until the stack is exausted.
 643   // The key to diagnosis in this case is to look for the bottom signal handler
 644   // frame.
 645 
 646   if(! IgnoreLibthreadGPFault) {
 647     if (sig == SIGSEGV && uc->uc_mcontext.gregs[TRAPNO] == T_GPFLT) {
 648       const unsigned char *p =
 649                         (unsigned const char *) uc->uc_mcontext.gregs[EIP];
 650 
 651       // Expected instruction?
 652 
 653       if(p[0] == movlfs[0] && p[1] == movlfs[1]) {
 654 
 655         Atomic::inc(&ldtr_refresh);
 656 
 657         // Infinite loop?
 658 
 659         if(ldtr_refresh < ((2 << 16) / PAGESIZE)) {
 660 
 661           // No, force scheduling to get a fresh view of the LDTR
 662 
 663           if(poll(NULL, 0, 10) == 0) {
 664 
 665             // Retry the move
 666 
 667             return false;
 668           }
 669         }
 670       }
 671     }
 672   }
 673 #endif // !AMD64
 674 
 675   if (!abort_if_unrecognized) {
 676     // caller wants another chance, so give it to him
 677     return false;
 678   }
 679 
 680   if (!os::Solaris::libjsig_is_loaded) {
 681     struct sigaction oldAct;
 682     sigaction(sig, (struct sigaction *)0, &oldAct);
 683     if (oldAct.sa_sigaction != signalHandler) {
 684       void* sighand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
 685                                           : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
 686       warning("Unexpected Signal %d occurred under user-defined signal handler %#lx", sig, (long)sighand);
 687     }
 688   }
 689 
 690   if (pc == NULL && uc != NULL) {
 691     pc = (address) uc->uc_mcontext.gregs[REG_PC];
 692   }
 693 
 694   // unmask current signal
 695   sigset_t newset;
 696   sigemptyset(&newset);
 697   sigaddset(&newset, sig);
 698   sigprocmask(SIG_UNBLOCK, &newset, NULL);
 699 
 700   // Determine which sort of error to throw.  Out of swap may signal
 701   // on the thread stack, which could get a mapping error when touched.
 702   address addr = (address) info->si_addr;
 703   if (sig == SIGBUS && info->si_code == BUS_OBJERR && info->si_errno == ENOMEM) {
 704     vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "Out of swap space to map in thread stack.");
 705   }
 706 
 707   VMError err(t, sig, pc, info, ucVoid);
 708   err.report_and_die();
 709 
 710   ShouldNotReachHere();
 711   return false;
 712 }
 713 
 714 void os::print_context(outputStream *st, void *context) {
 715   if (context == NULL) return;
 716 
 717   ucontext_t *uc = (ucontext_t*)context;
 718   st->print_cr("Registers:");
 719 #ifdef AMD64
 720   st->print(  "RAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RAX]);
 721   st->print(", RBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBX]);
 722   st->print(", RCX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RCX]);
 723   st->print(", RDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDX]);
 724   st->cr();
 725   st->print(  "RSP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSP]);
 726   st->print(", RBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RBP]);
 727   st->print(", RSI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RSI]);
 728   st->print(", RDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RDI]);
 729   st->cr();
 730   st->print(  "R8 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R8]);
 731   st->print(", R9 =" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R9]);
 732   st->print(", R10=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R10]);
 733   st->print(", R11=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R11]);
 734   st->cr();
 735   st->print(  "R12=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R12]);
 736   st->print(", R13=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R13]);
 737   st->print(", R14=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R14]);
 738   st->print(", R15=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_R15]);
 739   st->cr();
 740   st->print(  "RIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RIP]);
 741   st->print(", RFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[REG_RFL]);
 742 #else
 743   st->print(  "EAX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EAX]);
 744   st->print(", EBX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EBX]);
 745   st->print(", ECX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[ECX]);
 746   st->print(", EDX=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EDX]);
 747   st->cr();
 748   st->print(  "ESP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[UESP]);
 749   st->print(", EBP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EBP]);
 750   st->print(", ESI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[ESI]);
 751   st->print(", EDI=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EDI]);
 752   st->cr();
 753   st->print(  "EIP=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EIP]);
 754   st->print(", EFLAGS=" INTPTR_FORMAT, uc->uc_mcontext.gregs[EFL]);
 755 #endif // AMD64
 756   st->cr();
 757   st->cr();
 758 
 759   intptr_t *sp = (intptr_t *)os::Solaris::ucontext_get_sp(uc);
 760   st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp);
 761   print_hex_dump(st, (address)sp, (address)(sp + 8*sizeof(intptr_t)), sizeof(intptr_t));
 762   st->cr();
 763 
 764   // Note: it may be unsafe to inspect memory near pc. For example, pc may
 765   // point to garbage if entry point in an nmethod is corrupted. Leave
 766   // this at the end, and hope for the best.
 767   ExtendedPC epc = os::Solaris::ucontext_get_ExtendedPC(uc);
 768   address pc = epc.pc();
 769   st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc);
 770   print_hex_dump(st, pc - 32, pc + 32, sizeof(char));
 771 }
 772 
 773 void os::print_register_info(outputStream *st, void *context) {
 774   if (context == NULL) return;
 775 
 776   ucontext_t *uc = (ucontext_t*)context;
 777 
 778   st->print_cr("Register to memory mapping:");
 779   st->cr();
 780 
 781   // this is horrendously verbose but the layout of the registers in the
 782   // context does not match how we defined our abstract Register set, so
 783   // we can't just iterate through the gregs area
 784 
 785   // this is only for the "general purpose" registers
 786 
 787 #ifdef AMD64
 788   st->print("RAX="); print_location(st, uc->uc_mcontext.gregs[REG_RAX]);
 789   st->print("RBX="); print_location(st, uc->uc_mcontext.gregs[REG_RBX]);
 790   st->print("RCX="); print_location(st, uc->uc_mcontext.gregs[REG_RCX]);
 791   st->print("RDX="); print_location(st, uc->uc_mcontext.gregs[REG_RDX]);
 792   st->print("RSP="); print_location(st, uc->uc_mcontext.gregs[REG_RSP]);
 793   st->print("RBP="); print_location(st, uc->uc_mcontext.gregs[REG_RBP]);
 794   st->print("RSI="); print_location(st, uc->uc_mcontext.gregs[REG_RSI]);
 795   st->print("RDI="); print_location(st, uc->uc_mcontext.gregs[REG_RDI]);
 796   st->print("R8 ="); print_location(st, uc->uc_mcontext.gregs[REG_R8]);
 797   st->print("R9 ="); print_location(st, uc->uc_mcontext.gregs[REG_R9]);
 798   st->print("R10="); print_location(st, uc->uc_mcontext.gregs[REG_R10]);
 799   st->print("R11="); print_location(st, uc->uc_mcontext.gregs[REG_R11]);
 800   st->print("R12="); print_location(st, uc->uc_mcontext.gregs[REG_R12]);
 801   st->print("R13="); print_location(st, uc->uc_mcontext.gregs[REG_R13]);
 802   st->print("R14="); print_location(st, uc->uc_mcontext.gregs[REG_R14]);
 803   st->print("R15="); print_location(st, uc->uc_mcontext.gregs[REG_R15]);
 804 #else
 805   st->print("EAX="); print_location(st, uc->uc_mcontext.gregs[EAX]);
 806   st->print("EBX="); print_location(st, uc->uc_mcontext.gregs[EBX]);
 807   st->print("ECX="); print_location(st, uc->uc_mcontext.gregs[ECX]);
 808   st->print("EDX="); print_location(st, uc->uc_mcontext.gregs[EDX]);
 809   st->print("ESP="); print_location(st, uc->uc_mcontext.gregs[UESP]);
 810   st->print("EBP="); print_location(st, uc->uc_mcontext.gregs[EBP]);
 811   st->print("ESI="); print_location(st, uc->uc_mcontext.gregs[ESI]);
 812   st->print("EDI="); print_location(st, uc->uc_mcontext.gregs[EDI]);
 813 #endif
 814 
 815   st->cr();
 816 }
 817 
 818 
 819 #ifdef AMD64
 820 void os::Solaris::init_thread_fpu_state(void) {
 821   // Nothing to do
 822 }
 823 #else
 824 // From solaris_i486.s
 825 extern "C" void fixcw();
 826 
 827 void os::Solaris::init_thread_fpu_state(void) {
 828   // Set fpu to 53 bit precision. This happens too early to use a stub.
 829   fixcw();
 830 }
 831 
 832 // These routines are the initial value of atomic_xchg_entry(),
 833 // atomic_cmpxchg_entry(), atomic_inc_entry() and fence_entry()
 834 // until initialization is complete.
 835 // TODO - replace with .il implementation when compiler supports it.
 836 
 837 typedef jint  xchg_func_t        (jint,  volatile jint*);
 838 typedef jint  cmpxchg_func_t     (jint,  volatile jint*,  jint);
 839 typedef jlong cmpxchg_long_func_t(jlong, volatile jlong*, jlong);
 840 typedef jint  add_func_t         (jint,  volatile jint*);
 841 
 842 jint os::atomic_xchg_bootstrap(jint exchange_value, volatile jint* dest) {
 843   // try to use the stub:
 844   xchg_func_t* func = CAST_TO_FN_PTR(xchg_func_t*, StubRoutines::atomic_xchg_entry());
 845 
 846   if (func != NULL) {
 847     os::atomic_xchg_func = func;
 848     return (*func)(exchange_value, dest);
 849   }
 850   assert(Threads::number_of_threads() == 0, "for bootstrap only");
 851 
 852   jint old_value = *dest;
 853   *dest = exchange_value;
 854   return old_value;
 855 }
 856 
 857 jint os::atomic_cmpxchg_bootstrap(jint exchange_value, volatile jint* dest, jint compare_value) {
 858   // try to use the stub:
 859   cmpxchg_func_t* func = CAST_TO_FN_PTR(cmpxchg_func_t*, StubRoutines::atomic_cmpxchg_entry());
 860 
 861   if (func != NULL) {
 862     os::atomic_cmpxchg_func = func;
 863     return (*func)(exchange_value, dest, compare_value);
 864   }
 865   assert(Threads::number_of_threads() == 0, "for bootstrap only");
 866 
 867   jint old_value = *dest;
 868   if (old_value == compare_value)
 869     *dest = exchange_value;
 870   return old_value;
 871 }
 872 
 873 jlong os::atomic_cmpxchg_long_bootstrap(jlong exchange_value, volatile jlong* dest, jlong compare_value) {
 874   // try to use the stub:
 875   cmpxchg_long_func_t* func = CAST_TO_FN_PTR(cmpxchg_long_func_t*, StubRoutines::atomic_cmpxchg_long_entry());
 876 
 877   if (func != NULL) {
 878     os::atomic_cmpxchg_long_func = func;
 879     return (*func)(exchange_value, dest, compare_value);
 880   }
 881   assert(Threads::number_of_threads() == 0, "for bootstrap only");
 882 
 883   jlong old_value = *dest;
 884   if (old_value == compare_value)
 885     *dest = exchange_value;
 886   return old_value;
 887 }
 888 
 889 jint os::atomic_add_bootstrap(jint add_value, volatile jint* dest) {
 890   // try to use the stub:
 891   add_func_t* func = CAST_TO_FN_PTR(add_func_t*, StubRoutines::atomic_add_entry());
 892 
 893   if (func != NULL) {
 894     os::atomic_add_func = func;
 895     return (*func)(add_value, dest);
 896   }
 897   assert(Threads::number_of_threads() == 0, "for bootstrap only");
 898 
 899   return (*dest) += add_value;
 900 }
 901 
 902 xchg_func_t*         os::atomic_xchg_func         = os::atomic_xchg_bootstrap;
 903 cmpxchg_func_t*      os::atomic_cmpxchg_func      = os::atomic_cmpxchg_bootstrap;
 904 cmpxchg_long_func_t* os::atomic_cmpxchg_long_func = os::atomic_cmpxchg_long_bootstrap;
 905 add_func_t*          os::atomic_add_func          = os::atomic_add_bootstrap;
 906 
 907 extern "C" void _solaris_raw_setup_fpu(address ptr);
 908 void os::setup_fpu() {
 909   address fpu_cntrl = StubRoutines::addr_fpu_cntrl_wrd_std();
 910   _solaris_raw_setup_fpu(fpu_cntrl);
 911 }
 912 #endif // AMD64
 913 
 914 #ifndef PRODUCT
 915 void os::verify_stack_alignment() {
 916 #ifdef AMD64
 917   assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment");
 918 #endif
 919 }
 920 #endif
 921 
 922 int os::extra_bang_size_in_bytes() {
 923   // JDK-8050147 requires the full cache line bang for x86.
 924   return VM_Version::L1_line_size();
 925 }
--- EOF ---