1 /*
   2  * Copyright (c) 1997, 2015, 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 "classfile/classLoader.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "classfile/vmSymbols.hpp"
  29 #include "code/icBuffer.hpp"
  30 #include "code/vtableStubs.hpp"
  31 #include "compiler/compileBroker.hpp"
  32 #include "compiler/disassembler.hpp"
  33 #include "interpreter/interpreter.hpp"
  34 #include "jvm_solaris.h"
  35 #include "memory/allocation.inline.hpp"
  36 #include "memory/filemap.hpp"
  37 #include "mutex_solaris.inline.hpp"
  38 #include "oops/oop.inline.hpp"
  39 #include "os_share_solaris.hpp"
  40 #include "os_solaris.inline.hpp"
  41 #include "prims/jniFastGetField.hpp"
  42 #include "prims/jvm.h"
  43 #include "prims/jvm_misc.hpp"
  44 #include "runtime/arguments.hpp"
  45 #include "runtime/atomic.inline.hpp"
  46 #include "runtime/extendedPC.hpp"
  47 #include "runtime/globals.hpp"
  48 #include "runtime/interfaceSupport.hpp"
  49 #include "runtime/java.hpp"
  50 #include "runtime/javaCalls.hpp"
  51 #include "runtime/mutexLocker.hpp"
  52 #include "runtime/objectMonitor.hpp"
  53 #include "runtime/orderAccess.inline.hpp"
  54 #include "runtime/osThread.hpp"
  55 #include "runtime/perfMemory.hpp"
  56 #include "runtime/sharedRuntime.hpp"
  57 #include "runtime/statSampler.hpp"
  58 #include "runtime/stubRoutines.hpp"
  59 #include "runtime/thread.inline.hpp"
  60 #include "runtime/threadCritical.hpp"
  61 #include "runtime/timer.hpp"
  62 #include "runtime/vm_version.hpp"
  63 #include "semaphore_posix.hpp"
  64 #include "services/attachListener.hpp"
  65 #include "services/memTracker.hpp"
  66 #include "services/runtimeService.hpp"
  67 #include "utilities/decoder.hpp"
  68 #include "utilities/defaultStream.hpp"
  69 #include "utilities/events.hpp"
  70 #include "utilities/growableArray.hpp"
  71 #include "utilities/vmError.hpp"
  72 
  73 // put OS-includes here
  74 # include <dlfcn.h>
  75 # include <errno.h>
  76 # include <exception>
  77 # include <link.h>
  78 # include <poll.h>
  79 # include <pthread.h>
  80 # include <pwd.h>
  81 # include <schedctl.h>
  82 # include <setjmp.h>
  83 # include <signal.h>
  84 # include <stdio.h>
  85 # include <alloca.h>
  86 # include <sys/filio.h>
  87 # include <sys/ipc.h>
  88 # include <sys/lwp.h>
  89 # include <sys/machelf.h>     // for elf Sym structure used by dladdr1
  90 # include <sys/mman.h>
  91 # include <sys/processor.h>
  92 # include <sys/procset.h>
  93 # include <sys/pset.h>
  94 # include <sys/resource.h>
  95 # include <sys/shm.h>
  96 # include <sys/socket.h>
  97 # include <sys/stat.h>
  98 # include <sys/systeminfo.h>
  99 # include <sys/time.h>
 100 # include <sys/times.h>
 101 # include <sys/types.h>
 102 # include <sys/wait.h>
 103 # include <sys/utsname.h>
 104 # include <thread.h>
 105 # include <unistd.h>
 106 # include <sys/priocntl.h>
 107 # include <sys/rtpriocntl.h>
 108 # include <sys/tspriocntl.h>
 109 # include <sys/iapriocntl.h>
 110 # include <sys/fxpriocntl.h>
 111 # include <sys/loadavg.h>
 112 # include <string.h>
 113 # include <stdio.h>
 114 
 115 # define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later
 116 # include <sys/procfs.h>     //  see comment in <sys/procfs.h>
 117 
 118 #define MAX_PATH (2 * K)
 119 
 120 // for timer info max values which include all bits
 121 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 122 
 123 
 124 // Here are some liblgrp types from sys/lgrp_user.h to be able to
 125 // compile on older systems without this header file.
 126 
 127 #ifndef MADV_ACCESS_LWP
 128   #define  MADV_ACCESS_LWP   7       /* next LWP to access heavily */
 129 #endif
 130 #ifndef MADV_ACCESS_MANY
 131   #define  MADV_ACCESS_MANY  8       /* many processes to access heavily */
 132 #endif
 133 
 134 #ifndef LGRP_RSRC_CPU
 135   #define LGRP_RSRC_CPU      0       /* CPU resources */
 136 #endif
 137 #ifndef LGRP_RSRC_MEM
 138   #define LGRP_RSRC_MEM      1       /* memory resources */
 139 #endif
 140 
 141 // see thr_setprio(3T) for the basis of these numbers
 142 #define MinimumPriority 0
 143 #define NormalPriority  64
 144 #define MaximumPriority 127
 145 
 146 // Values for ThreadPriorityPolicy == 1
 147 int prio_policy1[CriticalPriority+1] = {
 148   -99999,  0, 16,  32,  48,  64,
 149           80, 96, 112, 124, 127, 127 };
 150 
 151 // System parameters used internally
 152 static clock_t clock_tics_per_sec = 100;
 153 
 154 // Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)
 155 static bool enabled_extended_FILE_stdio = false;
 156 
 157 // For diagnostics to print a message once. see run_periodic_checks
 158 static bool check_addr0_done = false;
 159 static sigset_t check_signal_done;
 160 static bool check_signals = true;
 161 
 162 address os::Solaris::handler_start;  // start pc of thr_sighndlrinfo
 163 address os::Solaris::handler_end;    // end pc of thr_sighndlrinfo
 164 
 165 address os::Solaris::_main_stack_base = NULL;  // 4352906 workaround
 166 
 167 
 168 // "default" initializers for missing libc APIs
 169 extern "C" {
 170   static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
 171   static int lwp_mutex_destroy(mutex_t *mx)                 { return 0; }
 172 
 173   static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
 174   static int lwp_cond_destroy(cond_t *cv)                   { return 0; }
 175 }
 176 
 177 // "default" initializers for pthread-based synchronization
 178 extern "C" {
 179   static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
 180   static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
 181 }
 182 
 183 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);
 184 
 185 // Thread Local Storage
 186 // This is common to all Solaris platforms so it is defined here,
 187 // in this common file.
 188 // The declarations are in the os_cpu threadLS*.hpp files.
 189 //
 190 // Static member initialization for TLS
 191 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};
 192 
 193 #ifndef PRODUCT
 194   #define _PCT(n,d)       ((100.0*(double)(n))/(double)(d))
 195 
 196 int ThreadLocalStorage::_tcacheHit = 0;
 197 int ThreadLocalStorage::_tcacheMiss = 0;
 198 
 199 void ThreadLocalStorage::print_statistics() {
 200   int total = _tcacheMiss+_tcacheHit;
 201   tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",
 202                 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));
 203 }
 204   #undef _PCT
 205 #endif // PRODUCT
 206 
 207 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,
 208                                                         int index) {
 209   Thread *thread = get_thread_slow();
 210   if (thread != NULL) {
 211     address sp = os::current_stack_pointer();
 212     guarantee(thread->_stack_base == NULL ||
 213               (sp <= thread->_stack_base &&
 214               sp >= thread->_stack_base - thread->_stack_size) ||
 215               is_error_reported(),
 216               "sp must be inside of selected thread stack");
 217 
 218     thread->set_self_raw_id(raw_id);  // mark for quick retrieval
 219     _get_thread_cache[index] = thread;
 220   }
 221   return thread;
 222 }
 223 
 224 
 225 static const double all_zero[sizeof(Thread) / sizeof(double) + 1] = {0};
 226 #define NO_CACHED_THREAD ((Thread*)all_zero)
 227 
 228 void ThreadLocalStorage::pd_set_thread(Thread* thread) {
 229 
 230   // Store the new value before updating the cache to prevent a race
 231   // between get_thread_via_cache_slowly() and this store operation.
 232   os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);
 233 
 234   // Update thread cache with new thread if setting on thread create,
 235   // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.
 236   uintptr_t raw = pd_raw_thread_id();
 237   int ix = pd_cache_index(raw);
 238   _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;
 239 }
 240 
 241 void ThreadLocalStorage::pd_init() {
 242   for (int i = 0; i < _pd_cache_size; i++) {
 243     _get_thread_cache[i] = NO_CACHED_THREAD;
 244   }
 245 }
 246 
 247 // Invalidate all the caches (happens to be the same as pd_init).
 248 void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }
 249 
 250 #undef NO_CACHED_THREAD
 251 
 252 // END Thread Local Storage
 253 
 254 static inline size_t adjust_stack_size(address base, size_t size) {
 255   if ((ssize_t)size < 0) {
 256     // 4759953: Compensate for ridiculous stack size.
 257     size = max_intx;
 258   }
 259   if (size > (size_t)base) {
 260     // 4812466: Make sure size doesn't allow the stack to wrap the address space.
 261     size = (size_t)base;
 262   }
 263   return size;
 264 }
 265 
 266 static inline stack_t get_stack_info() {
 267   stack_t st;
 268   int retval = thr_stksegment(&st);
 269   st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);
 270   assert(retval == 0, "incorrect return value from thr_stksegment");
 271   assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
 272   assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
 273   return st;
 274 }
 275 
 276 address os::current_stack_base() {
 277   int r = thr_main();
 278   guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
 279   bool is_primordial_thread = r;
 280 
 281   // Workaround 4352906, avoid calls to thr_stksegment by
 282   // thr_main after the first one (it looks like we trash
 283   // some data, causing the value for ss_sp to be incorrect).
 284   if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {
 285     stack_t st = get_stack_info();
 286     if (is_primordial_thread) {
 287       // cache initial value of stack base
 288       os::Solaris::_main_stack_base = (address)st.ss_sp;
 289     }
 290     return (address)st.ss_sp;
 291   } else {
 292     guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");
 293     return os::Solaris::_main_stack_base;
 294   }
 295 }
 296 
 297 size_t os::current_stack_size() {
 298   size_t size;
 299 
 300   int r = thr_main();
 301   guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
 302   if (!r) {
 303     size = get_stack_info().ss_size;
 304   } else {
 305     struct rlimit limits;
 306     getrlimit(RLIMIT_STACK, &limits);
 307     size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);
 308   }
 309   // base may not be page aligned
 310   address base = current_stack_base();
 311   address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;
 312   return (size_t)(base - bottom);
 313 }
 314 
 315 struct tm* os::localtime_pd(const time_t* clock, struct tm*  res) {
 316   return localtime_r(clock, res);
 317 }
 318 
 319 void os::Solaris::try_enable_extended_io() {
 320   typedef int (*enable_extended_FILE_stdio_t)(int, int);
 321 
 322   if (!UseExtendedFileIO) {
 323     return;
 324   }
 325 
 326   enable_extended_FILE_stdio_t enabler =
 327     (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,
 328                                          "enable_extended_FILE_stdio");
 329   if (enabler) {
 330     enabler(-1, -1);
 331   }
 332 }
 333 
 334 static int _processors_online = 0;
 335 
 336 jint os::Solaris::_os_thread_limit = 0;
 337 volatile jint os::Solaris::_os_thread_count = 0;
 338 
 339 julong os::available_memory() {
 340   return Solaris::available_memory();
 341 }
 342 
 343 julong os::Solaris::available_memory() {
 344   return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();
 345 }
 346 
 347 julong os::Solaris::_physical_memory = 0;
 348 
 349 julong os::physical_memory() {
 350   return Solaris::physical_memory();
 351 }
 352 
 353 static hrtime_t first_hrtime = 0;
 354 static const hrtime_t hrtime_hz = 1000*1000*1000;
 355 static volatile hrtime_t max_hrtime = 0;
 356 
 357 
 358 void os::Solaris::initialize_system_info() {
 359   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
 360   _processors_online = sysconf(_SC_NPROCESSORS_ONLN);
 361   _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) *
 362                                      (julong)sysconf(_SC_PAGESIZE);
 363 }
 364 
 365 int os::active_processor_count() {
 366   int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 367   pid_t pid = getpid();
 368   psetid_t pset = PS_NONE;
 369   // Are we running in a processor set or is there any processor set around?
 370   if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
 371     uint_t pset_cpus;
 372     // Query the number of cpus available to us.
 373     if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
 374       assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
 375       _processors_online = pset_cpus;
 376       return pset_cpus;
 377     }
 378   }
 379   // Otherwise return number of online cpus
 380   return online_cpus;
 381 }
 382 
 383 static bool find_processors_in_pset(psetid_t        pset,
 384                                     processorid_t** id_array,
 385                                     uint_t*         id_length) {
 386   bool result = false;
 387   // Find the number of processors in the processor set.
 388   if (pset_info(pset, NULL, id_length, NULL) == 0) {
 389     // Make up an array to hold their ids.
 390     *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 391     // Fill in the array with their processor ids.
 392     if (pset_info(pset, NULL, id_length, *id_array) == 0) {
 393       result = true;
 394     }
 395   }
 396   return result;
 397 }
 398 
 399 // Callers of find_processors_online() must tolerate imprecise results --
 400 // the system configuration can change asynchronously because of DR
 401 // or explicit psradm operations.
 402 //
 403 // We also need to take care that the loop (below) terminates as the
 404 // number of processors online can change between the _SC_NPROCESSORS_ONLN
 405 // request and the loop that builds the list of processor ids.   Unfortunately
 406 // there's no reliable way to determine the maximum valid processor id,
 407 // so we use a manifest constant, MAX_PROCESSOR_ID, instead.  See p_online
 408 // man pages, which claim the processor id set is "sparse, but
 409 // not too sparse".  MAX_PROCESSOR_ID is used to ensure that we eventually
 410 // exit the loop.
 411 //
 412 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
 413 // not available on S8.0.
 414 
 415 static bool find_processors_online(processorid_t** id_array,
 416                                    uint*           id_length) {
 417   const processorid_t MAX_PROCESSOR_ID = 100000;
 418   // Find the number of processors online.
 419   *id_length = sysconf(_SC_NPROCESSORS_ONLN);
 420   // Make up an array to hold their ids.
 421   *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 422   // Processors need not be numbered consecutively.
 423   long found = 0;
 424   processorid_t next = 0;
 425   while (found < *id_length && next < MAX_PROCESSOR_ID) {
 426     processor_info_t info;
 427     if (processor_info(next, &info) == 0) {
 428       // NB, PI_NOINTR processors are effectively online ...
 429       if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {
 430         (*id_array)[found] = next;
 431         found += 1;
 432       }
 433     }
 434     next += 1;
 435   }
 436   if (found < *id_length) {
 437     // The loop above didn't identify the expected number of processors.
 438     // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)
 439     // and re-running the loop, above, but there's no guarantee of progress
 440     // if the system configuration is in flux.  Instead, we just return what
 441     // we've got.  Note that in the worst case find_processors_online() could
 442     // return an empty set.  (As a fall-back in the case of the empty set we
 443     // could just return the ID of the current processor).
 444     *id_length = found;
 445   }
 446 
 447   return true;
 448 }
 449 
 450 static bool assign_distribution(processorid_t* id_array,
 451                                 uint           id_length,
 452                                 uint*          distribution,
 453                                 uint           distribution_length) {
 454   // We assume we can assign processorid_t's to uint's.
 455   assert(sizeof(processorid_t) == sizeof(uint),
 456          "can't convert processorid_t to uint");
 457   // Quick check to see if we won't succeed.
 458   if (id_length < distribution_length) {
 459     return false;
 460   }
 461   // Assign processor ids to the distribution.
 462   // Try to shuffle processors to distribute work across boards,
 463   // assuming 4 processors per board.
 464   const uint processors_per_board = ProcessDistributionStride;
 465   // Find the maximum processor id.
 466   processorid_t max_id = 0;
 467   for (uint m = 0; m < id_length; m += 1) {
 468     max_id = MAX2(max_id, id_array[m]);
 469   }
 470   // The next id, to limit loops.
 471   const processorid_t limit_id = max_id + 1;
 472   // Make up markers for available processors.
 473   bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal);
 474   for (uint c = 0; c < limit_id; c += 1) {
 475     available_id[c] = false;
 476   }
 477   for (uint a = 0; a < id_length; a += 1) {
 478     available_id[id_array[a]] = true;
 479   }
 480   // Step by "boards", then by "slot", copying to "assigned".
 481   // NEEDS_CLEANUP: The assignment of processors should be stateful,
 482   //                remembering which processors have been assigned by
 483   //                previous calls, etc., so as to distribute several
 484   //                independent calls of this method.  What we'd like is
 485   //                It would be nice to have an API that let us ask
 486   //                how many processes are bound to a processor,
 487   //                but we don't have that, either.
 488   //                In the short term, "board" is static so that
 489   //                subsequent distributions don't all start at board 0.
 490   static uint board = 0;
 491   uint assigned = 0;
 492   // Until we've found enough processors ....
 493   while (assigned < distribution_length) {
 494     // ... find the next available processor in the board.
 495     for (uint slot = 0; slot < processors_per_board; slot += 1) {
 496       uint try_id = board * processors_per_board + slot;
 497       if ((try_id < limit_id) && (available_id[try_id] == true)) {
 498         distribution[assigned] = try_id;
 499         available_id[try_id] = false;
 500         assigned += 1;
 501         break;
 502       }
 503     }
 504     board += 1;
 505     if (board * processors_per_board + 0 >= limit_id) {
 506       board = 0;
 507     }
 508   }
 509   if (available_id != NULL) {
 510     FREE_C_HEAP_ARRAY(bool, available_id);
 511   }
 512   return true;
 513 }
 514 
 515 void os::set_native_thread_name(const char *name) {
 516   // Not yet implemented.
 517   return;
 518 }
 519 
 520 bool os::distribute_processes(uint length, uint* distribution) {
 521   bool result = false;
 522   // Find the processor id's of all the available CPUs.
 523   processorid_t* id_array  = NULL;
 524   uint           id_length = 0;
 525   // There are some races between querying information and using it,
 526   // since processor sets can change dynamically.
 527   psetid_t pset = PS_NONE;
 528   // Are we running in a processor set?
 529   if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {
 530     result = find_processors_in_pset(pset, &id_array, &id_length);
 531   } else {
 532     result = find_processors_online(&id_array, &id_length);
 533   }
 534   if (result == true) {
 535     if (id_length >= length) {
 536       result = assign_distribution(id_array, id_length, distribution, length);
 537     } else {
 538       result = false;
 539     }
 540   }
 541   if (id_array != NULL) {
 542     FREE_C_HEAP_ARRAY(processorid_t, id_array);
 543   }
 544   return result;
 545 }
 546 
 547 bool os::bind_to_processor(uint processor_id) {
 548   // We assume that a processorid_t can be stored in a uint.
 549   assert(sizeof(uint) == sizeof(processorid_t),
 550          "can't convert uint to processorid_t");
 551   int bind_result =
 552     processor_bind(P_LWPID,                       // bind LWP.
 553                    P_MYID,                        // bind current LWP.
 554                    (processorid_t) processor_id,  // id.
 555                    NULL);                         // don't return old binding.
 556   return (bind_result == 0);
 557 }
 558 
 559 // Return true if user is running as root.
 560 
 561 bool os::have_special_privileges() {
 562   static bool init = false;
 563   static bool privileges = false;
 564   if (!init) {
 565     privileges = (getuid() != geteuid()) || (getgid() != getegid());
 566     init = true;
 567   }
 568   return privileges;
 569 }
 570 
 571 
 572 void os::init_system_properties_values() {
 573   // The next steps are taken in the product version:
 574   //
 575   // Obtain the JAVA_HOME value from the location of libjvm.so.
 576   // This library should be located at:
 577   // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm.so.
 578   //
 579   // If "/jre/lib/" appears at the right place in the path, then we
 580   // assume libjvm.so is installed in a JDK and we use this path.
 581   //
 582   // Otherwise exit with message: "Could not create the Java virtual machine."
 583   //
 584   // The following extra steps are taken in the debugging version:
 585   //
 586   // If "/jre/lib/" does NOT appear at the right place in the path
 587   // instead of exit check for $JAVA_HOME environment variable.
 588   //
 589   // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,
 590   // then we append a fake suffix "hotspot/libjvm.so" to this path so
 591   // it looks like libjvm.so is installed there
 592   // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm.so.
 593   //
 594   // Otherwise exit.
 595   //
 596   // Important note: if the location of libjvm.so changes this
 597   // code needs to be changed accordingly.
 598 
 599 // Base path of extensions installed on the system.
 600 #define SYS_EXT_DIR     "/usr/jdk/packages"
 601 #define EXTENSIONS_DIR  "/lib/ext"
 602 
 603   char cpu_arch[12];
 604   // Buffer that fits several sprintfs.
 605   // Note that the space for the colon and the trailing null are provided
 606   // by the nulls included by the sizeof operator.
 607   const size_t bufsize =
 608     MAX3((size_t)MAXPATHLEN,  // For dll_dir & friends.
 609          sizeof(SYS_EXT_DIR) + sizeof("/lib/") + strlen(cpu_arch), // invariant ld_library_path
 610          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR) + sizeof(SYS_EXT_DIR) + sizeof(EXTENSIONS_DIR)); // extensions dir
 611   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
 612 
 613   // sysclasspath, java_home, dll_dir
 614   {
 615     char *pslash;
 616     os::jvm_path(buf, bufsize);
 617 
 618     // Found the full path to libjvm.so.
 619     // Now cut the path to <java_home>/jre if we can.
 620     *(strrchr(buf, '/')) = '\0'; // Get rid of /libjvm.so.
 621     pslash = strrchr(buf, '/');
 622     if (pslash != NULL) {
 623       *pslash = '\0';            // Get rid of /{client|server|hotspot}.
 624     }
 625     Arguments::set_dll_dir(buf);
 626 
 627     if (pslash != NULL) {
 628       pslash = strrchr(buf, '/');
 629       if (pslash != NULL) {
 630         *pslash = '\0';          // Get rid of /<arch>.
 631         pslash = strrchr(buf, '/');
 632         if (pslash != NULL) {
 633           *pslash = '\0';        // Get rid of /lib.
 634         }
 635       }
 636     }
 637     Arguments::set_java_home(buf);
 638     set_boot_path('/', ':');
 639   }
 640 
 641   // Where to look for native libraries.
 642   {
 643     // Use dlinfo() to determine the correct java.library.path.
 644     //
 645     // If we're launched by the Java launcher, and the user
 646     // does not set java.library.path explicitly on the commandline,
 647     // the Java launcher sets LD_LIBRARY_PATH for us and unsets
 648     // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64.  In this case
 649     // dlinfo returns LD_LIBRARY_PATH + crle settings (including
 650     // /usr/lib), which is exactly what we want.
 651     //
 652     // If the user does set java.library.path, it completely
 653     // overwrites this setting, and always has.
 654     //
 655     // If we're not launched by the Java launcher, we may
 656     // get here with any/all of the LD_LIBRARY_PATH[_32|64]
 657     // settings.  Again, dlinfo does exactly what we want.
 658 
 659     Dl_serinfo     info_sz, *info = &info_sz;
 660     Dl_serpath     *path;
 661     char           *library_path;
 662     char           *common_path = buf;
 663 
 664     // Determine search path count and required buffer size.
 665     if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {
 666       FREE_C_HEAP_ARRAY(char, buf);
 667       vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());
 668     }
 669 
 670     // Allocate new buffer and initialize.
 671     info = (Dl_serinfo*)NEW_C_HEAP_ARRAY(char, info_sz.dls_size, mtInternal);
 672     info->dls_size = info_sz.dls_size;
 673     info->dls_cnt = info_sz.dls_cnt;
 674 
 675     // Obtain search path information.
 676     if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {
 677       FREE_C_HEAP_ARRAY(char, buf);
 678       FREE_C_HEAP_ARRAY(char, info);
 679       vm_exit_during_initialization("dlinfo SERINFO request", dlerror());
 680     }
 681 
 682     path = &info->dls_serpath[0];
 683 
 684     // Note: Due to a legacy implementation, most of the library path
 685     // is set in the launcher. This was to accomodate linking restrictions
 686     // on legacy Solaris implementations (which are no longer supported).
 687     // Eventually, all the library path setting will be done here.
 688     //
 689     // However, to prevent the proliferation of improperly built native
 690     // libraries, the new path component /usr/jdk/packages is added here.
 691 
 692     // Determine the actual CPU architecture.
 693     sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
 694 #ifdef _LP64
 695     // If we are a 64-bit vm, perform the following translations:
 696     //   sparc   -> sparcv9
 697     //   i386    -> amd64
 698     if (strcmp(cpu_arch, "sparc") == 0) {
 699       strcat(cpu_arch, "v9");
 700     } else if (strcmp(cpu_arch, "i386") == 0) {
 701       strcpy(cpu_arch, "amd64");
 702     }
 703 #endif
 704 
 705     // Construct the invariant part of ld_library_path.
 706     sprintf(common_path, SYS_EXT_DIR "/lib/%s", cpu_arch);
 707 
 708     // Struct size is more than sufficient for the path components obtained
 709     // through the dlinfo() call, so only add additional space for the path
 710     // components explicitly added here.
 711     size_t library_path_size = info->dls_size + strlen(common_path);
 712     library_path = (char *)NEW_C_HEAP_ARRAY(char, library_path_size, mtInternal);
 713     library_path[0] = '\0';
 714 
 715     // Construct the desired Java library path from the linker's library
 716     // search path.
 717     //
 718     // For compatibility, it is optimal that we insert the additional path
 719     // components specific to the Java VM after those components specified
 720     // in LD_LIBRARY_PATH (if any) but before those added by the ld.so
 721     // infrastructure.
 722     if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it.
 723       strcpy(library_path, common_path);
 724     } else {
 725       int inserted = 0;
 726       int i;
 727       for (i = 0; i < info->dls_cnt; i++, path++) {
 728         uint_t flags = path->dls_flags & LA_SER_MASK;
 729         if (((flags & LA_SER_LIBPATH) == 0) && !inserted) {
 730           strcat(library_path, common_path);
 731           strcat(library_path, os::path_separator());
 732           inserted = 1;
 733         }
 734         strcat(library_path, path->dls_name);
 735         strcat(library_path, os::path_separator());
 736       }
 737       // Eliminate trailing path separator.
 738       library_path[strlen(library_path)-1] = '\0';
 739     }
 740 
 741     // happens before argument parsing - can't use a trace flag
 742     // tty->print_raw("init_system_properties_values: native lib path: ");
 743     // tty->print_raw_cr(library_path);
 744 
 745     // Callee copies into its own buffer.
 746     Arguments::set_library_path(library_path);
 747 
 748     FREE_C_HEAP_ARRAY(char, library_path);
 749     FREE_C_HEAP_ARRAY(char, info);
 750   }
 751 
 752   // Extensions directories.
 753   sprintf(buf, "%s" EXTENSIONS_DIR ":" SYS_EXT_DIR EXTENSIONS_DIR, Arguments::get_java_home());
 754   Arguments::set_ext_dirs(buf);
 755 
 756   FREE_C_HEAP_ARRAY(char, buf);
 757 
 758 #undef SYS_EXT_DIR
 759 #undef EXTENSIONS_DIR
 760 }
 761 
 762 void os::breakpoint() {
 763   BREAKPOINT;
 764 }
 765 
 766 bool os::obsolete_option(const JavaVMOption *option) {
 767   if (!strncmp(option->optionString, "-Xt", 3)) {
 768     return true;
 769   } else if (!strncmp(option->optionString, "-Xtm", 4)) {
 770     return true;
 771   } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {
 772     return true;
 773   } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) {
 774     return true;
 775   }
 776   return false;
 777 }
 778 
 779 bool os::Solaris::valid_stack_address(Thread* thread, address sp) {
 780   address  stackStart  = (address)thread->stack_base();
 781   address  stackEnd    = (address)(stackStart - (address)thread->stack_size());
 782   if (sp < stackStart && sp >= stackEnd) return true;
 783   return false;
 784 }
 785 
 786 extern "C" void breakpoint() {
 787   // use debugger to set breakpoint here
 788 }
 789 
 790 static thread_t main_thread;
 791 
 792 // Thread start routine for all new Java threads
 793 extern "C" void* java_start(void* thread_addr) {
 794   // Try to randomize the cache line index of hot stack frames.
 795   // This helps when threads of the same stack traces evict each other's
 796   // cache lines. The threads can be either from the same JVM instance, or
 797   // from different JVM instances. The benefit is especially true for
 798   // processors with hyperthreading technology.
 799   static int counter = 0;
 800   int pid = os::current_process_id();
 801   alloca(((pid ^ counter++) & 7) * 128);
 802 
 803   int prio;
 804   Thread* thread = (Thread*)thread_addr;
 805   OSThread* osthr = thread->osthread();
 806 
 807   osthr->set_lwp_id(_lwp_self());  // Store lwp in case we are bound
 808   thread->_schedctl = (void *) schedctl_init();
 809 
 810   if (UseNUMA) {
 811     int lgrp_id = os::numa_get_group_id();
 812     if (lgrp_id != -1) {
 813       thread->set_lgrp_id(lgrp_id);
 814     }
 815   }
 816 
 817   // If the creator called set priority before we started,
 818   // we need to call set_native_priority now that we have an lwp.
 819   // We used to get the priority from thr_getprio (we called
 820   // thr_setprio way back in create_thread) and pass it to
 821   // set_native_priority, but Solaris scales the priority
 822   // in java_to_os_priority, so when we read it back here,
 823   // we pass trash to set_native_priority instead of what's
 824   // in java_to_os_priority. So we save the native priority
 825   // in the osThread and recall it here.
 826 
 827   if (osthr->thread_id() != -1) {
 828     if (UseThreadPriorities) {
 829       int prio = osthr->native_priority();
 830       if (ThreadPriorityVerbose) {
 831         tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is "
 832                       INTPTR_FORMAT ", setting priority: %d\n",
 833                       osthr->thread_id(), osthr->lwp_id(), prio);
 834       }
 835       os::set_native_priority(thread, prio);
 836     }
 837   } else if (ThreadPriorityVerbose) {
 838     warning("Can't set priority in _start routine, thread id hasn't been set\n");
 839   }
 840 
 841   assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
 842 
 843   // initialize signal mask for this thread
 844   os::Solaris::hotspot_sigmask(thread);
 845 
 846   thread->run();
 847 
 848   // One less thread is executing
 849   // When the VMThread gets here, the main thread may have already exited
 850   // which frees the CodeHeap containing the Atomic::dec code
 851   if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
 852     Atomic::dec(&os::Solaris::_os_thread_count);
 853   }
 854 
 855   if (UseDetachedThreads) {
 856     thr_exit(NULL);
 857     ShouldNotReachHere();
 858   }
 859   return NULL;
 860 }
 861 
 862 static OSThread* create_os_thread(Thread* thread, thread_t thread_id) {
 863   // Allocate the OSThread object
 864   OSThread* osthread = new OSThread(NULL, NULL);
 865   if (osthread == NULL) return NULL;
 866 
 867   // Store info on the Solaris thread into the OSThread
 868   osthread->set_thread_id(thread_id);
 869   osthread->set_lwp_id(_lwp_self());
 870   thread->_schedctl = (void *) schedctl_init();
 871 
 872   if (UseNUMA) {
 873     int lgrp_id = os::numa_get_group_id();
 874     if (lgrp_id != -1) {
 875       thread->set_lgrp_id(lgrp_id);
 876     }
 877   }
 878 
 879   if (ThreadPriorityVerbose) {
 880     tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n",
 881                   osthread->thread_id(), osthread->lwp_id());
 882   }
 883 
 884   // Initial thread state is INITIALIZED, not SUSPENDED
 885   osthread->set_state(INITIALIZED);
 886 
 887   return osthread;
 888 }
 889 
 890 void os::Solaris::hotspot_sigmask(Thread* thread) {
 891   //Save caller's signal mask
 892   sigset_t sigmask;
 893   thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);
 894   OSThread *osthread = thread->osthread();
 895   osthread->set_caller_sigmask(sigmask);
 896 
 897   thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL);
 898   if (!ReduceSignalUsage) {
 899     if (thread->is_VM_thread()) {
 900       // Only the VM thread handles BREAK_SIGNAL ...
 901       thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL);
 902     } else {
 903       // ... all other threads block BREAK_SIGNAL
 904       assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked");
 905       thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL);
 906     }
 907   }
 908 }
 909 
 910 bool os::create_attached_thread(JavaThread* thread) {
 911 #ifdef ASSERT
 912   thread->verify_not_published();
 913 #endif
 914   OSThread* osthread = create_os_thread(thread, thr_self());
 915   if (osthread == NULL) {
 916     return false;
 917   }
 918 
 919   // Initial thread state is RUNNABLE
 920   osthread->set_state(RUNNABLE);
 921   thread->set_osthread(osthread);
 922 
 923   // initialize signal mask for this thread
 924   // and save the caller's signal mask
 925   os::Solaris::hotspot_sigmask(thread);
 926 
 927   return true;
 928 }
 929 
 930 bool os::create_main_thread(JavaThread* thread) {
 931 #ifdef ASSERT
 932   thread->verify_not_published();
 933 #endif
 934   if (_starting_thread == NULL) {
 935     _starting_thread = create_os_thread(thread, main_thread);
 936     if (_starting_thread == NULL) {
 937       return false;
 938     }
 939   }
 940 
 941   // The primodial thread is runnable from the start
 942   _starting_thread->set_state(RUNNABLE);
 943 
 944   thread->set_osthread(_starting_thread);
 945 
 946   // initialize signal mask for this thread
 947   // and save the caller's signal mask
 948   os::Solaris::hotspot_sigmask(thread);
 949 
 950   return true;
 951 }
 952 
 953 
 954 bool os::create_thread(Thread* thread, ThreadType thr_type,
 955                        size_t stack_size) {
 956   // Allocate the OSThread object
 957   OSThread* osthread = new OSThread(NULL, NULL);
 958   if (osthread == NULL) {
 959     return false;
 960   }
 961 
 962   if (ThreadPriorityVerbose) {
 963     char *thrtyp;
 964     switch (thr_type) {
 965     case vm_thread:
 966       thrtyp = (char *)"vm";
 967       break;
 968     case cgc_thread:
 969       thrtyp = (char *)"cgc";
 970       break;
 971     case pgc_thread:
 972       thrtyp = (char *)"pgc";
 973       break;
 974     case java_thread:
 975       thrtyp = (char *)"java";
 976       break;
 977     case compiler_thread:
 978       thrtyp = (char *)"compiler";
 979       break;
 980     case watcher_thread:
 981       thrtyp = (char *)"watcher";
 982       break;
 983     default:
 984       thrtyp = (char *)"unknown";
 985       break;
 986     }
 987     tty->print_cr("In create_thread, creating a %s thread\n", thrtyp);
 988   }
 989 
 990   // Calculate stack size if it's not specified by caller.
 991   if (stack_size == 0) {
 992     // The default stack size 1M (2M for LP64).
 993     stack_size = (BytesPerWord >> 2) * K * K;
 994 
 995     switch (thr_type) {
 996     case os::java_thread:
 997       // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
 998       if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();
 999       break;
1000     case os::compiler_thread:
1001       if (CompilerThreadStackSize > 0) {
1002         stack_size = (size_t)(CompilerThreadStackSize * K);
1003         break;
1004       } // else fall through:
1005         // use VMThreadStackSize if CompilerThreadStackSize is not defined
1006     case os::vm_thread:
1007     case os::pgc_thread:
1008     case os::cgc_thread:
1009     case os::watcher_thread:
1010       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
1011       break;
1012     }
1013   }
1014   stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed);
1015 
1016   // Initial state is ALLOCATED but not INITIALIZED
1017   osthread->set_state(ALLOCATED);
1018 
1019   if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) {
1020     // We got lots of threads. Check if we still have some address space left.
1021     // Need to be at least 5Mb of unreserved address space. We do check by
1022     // trying to reserve some.
1023     const size_t VirtualMemoryBangSize = 20*K*K;
1024     char* mem = os::reserve_memory(VirtualMemoryBangSize);
1025     if (mem == NULL) {
1026       delete osthread;
1027       return false;
1028     } else {
1029       // Release the memory again
1030       os::release_memory(mem, VirtualMemoryBangSize);
1031     }
1032   }
1033 
1034   // Setup osthread because the child thread may need it.
1035   thread->set_osthread(osthread);
1036 
1037   // Create the Solaris thread
1038   thread_t tid = 0;
1039   long     flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED;
1040   int      status;
1041 
1042   // Mark that we don't have an lwp or thread id yet.
1043   // In case we attempt to set the priority before the thread starts.
1044   osthread->set_lwp_id(-1);
1045   osthread->set_thread_id(-1);
1046 
1047   status = thr_create(NULL, stack_size, java_start, thread, flags, &tid);
1048   if (status != 0) {
1049     if (PrintMiscellaneous && (Verbose || WizardMode)) {
1050       perror("os::create_thread");
1051     }
1052     thread->set_osthread(NULL);
1053     // Need to clean up stuff we've allocated so far
1054     delete osthread;
1055     return false;
1056   }
1057 
1058   Atomic::inc(&os::Solaris::_os_thread_count);
1059 
1060   // Store info on the Solaris thread into the OSThread
1061   osthread->set_thread_id(tid);
1062 
1063   // Remember that we created this thread so we can set priority on it
1064   osthread->set_vm_created();
1065 
1066   // Initial thread state is INITIALIZED, not SUSPENDED
1067   osthread->set_state(INITIALIZED);
1068 
1069   // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
1070   return true;
1071 }
1072 
1073 // defined for >= Solaris 10. This allows builds on earlier versions
1074 // of Solaris to take advantage of the newly reserved Solaris JVM signals
1075 // With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
1076 // and -XX:+UseAltSigs does nothing since these should have no conflict
1077 //
1078 #if !defined(SIGJVM1)
1079   #define SIGJVM1 39
1080   #define SIGJVM2 40
1081 #endif
1082 
1083 debug_only(static bool signal_sets_initialized = false);
1084 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
1085 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;
1086 int os::Solaris::_SIGasync = ASYNC_SIGNAL;
1087 
1088 bool os::Solaris::is_sig_ignored(int sig) {
1089   struct sigaction oact;
1090   sigaction(sig, (struct sigaction*)NULL, &oact);
1091   void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)
1092                                  : CAST_FROM_FN_PTR(void*,  oact.sa_handler);
1093   if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
1094     return true;
1095   } else {
1096     return false;
1097   }
1098 }
1099 
1100 // Note: SIGRTMIN is a macro that calls sysconf() so it will
1101 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime
1102 static bool isJVM1available() {
1103   return SIGJVM1 < SIGRTMIN;
1104 }
1105 
1106 void os::Solaris::signal_sets_init() {
1107   // Should also have an assertion stating we are still single-threaded.
1108   assert(!signal_sets_initialized, "Already initialized");
1109   // Fill in signals that are necessarily unblocked for all threads in
1110   // the VM. Currently, we unblock the following signals:
1111   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
1112   //                         by -Xrs (=ReduceSignalUsage));
1113   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
1114   // other threads. The "ReduceSignalUsage" boolean tells us not to alter
1115   // the dispositions or masks wrt these signals.
1116   // Programs embedding the VM that want to use the above signals for their
1117   // own purposes must, at this time, use the "-Xrs" option to prevent
1118   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
1119   // (See bug 4345157, and other related bugs).
1120   // In reality, though, unblocking these signals is really a nop, since
1121   // these signals are not blocked by default.
1122   sigemptyset(&unblocked_sigs);
1123   sigemptyset(&allowdebug_blocked_sigs);
1124   sigaddset(&unblocked_sigs, SIGILL);
1125   sigaddset(&unblocked_sigs, SIGSEGV);
1126   sigaddset(&unblocked_sigs, SIGBUS);
1127   sigaddset(&unblocked_sigs, SIGFPE);
1128 
1129   if (isJVM1available) {
1130     os::Solaris::set_SIGinterrupt(SIGJVM1);
1131     os::Solaris::set_SIGasync(SIGJVM2);
1132   } else if (UseAltSigs) {
1133     os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);
1134     os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);
1135   } else {
1136     os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);
1137     os::Solaris::set_SIGasync(ASYNC_SIGNAL);
1138   }
1139 
1140   sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt());
1141   sigaddset(&unblocked_sigs, os::Solaris::SIGasync());
1142 
1143   if (!ReduceSignalUsage) {
1144     if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
1145       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
1146       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
1147     }
1148     if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
1149       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
1150       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
1151     }
1152     if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
1153       sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
1154       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
1155     }
1156   }
1157   // Fill in signals that are blocked by all but the VM thread.
1158   sigemptyset(&vm_sigs);
1159   if (!ReduceSignalUsage) {
1160     sigaddset(&vm_sigs, BREAK_SIGNAL);
1161   }
1162   debug_only(signal_sets_initialized = true);
1163 
1164   // For diagnostics only used in run_periodic_checks
1165   sigemptyset(&check_signal_done);
1166 }
1167 
1168 // These are signals that are unblocked while a thread is running Java.
1169 // (For some reason, they get blocked by default.)
1170 sigset_t* os::Solaris::unblocked_signals() {
1171   assert(signal_sets_initialized, "Not initialized");
1172   return &unblocked_sigs;
1173 }
1174 
1175 // These are the signals that are blocked while a (non-VM) thread is
1176 // running Java. Only the VM thread handles these signals.
1177 sigset_t* os::Solaris::vm_signals() {
1178   assert(signal_sets_initialized, "Not initialized");
1179   return &vm_sigs;
1180 }
1181 
1182 // These are signals that are blocked during cond_wait to allow debugger in
1183 sigset_t* os::Solaris::allowdebug_blocked_signals() {
1184   assert(signal_sets_initialized, "Not initialized");
1185   return &allowdebug_blocked_sigs;
1186 }
1187 
1188 
1189 void _handle_uncaught_cxx_exception() {
1190   VMError err("An uncaught C++ exception");
1191   err.report_and_die();
1192 }
1193 
1194 
1195 // First crack at OS-specific initialization, from inside the new thread.
1196 void os::initialize_thread(Thread* thr) {
1197   int r = thr_main();
1198   guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");
1199   if (r) {
1200     JavaThread* jt = (JavaThread *)thr;
1201     assert(jt != NULL, "Sanity check");
1202     size_t stack_size;
1203     address base = jt->stack_base();
1204     if (Arguments::created_by_java_launcher()) {
1205       // Use 2MB to allow for Solaris 7 64 bit mode.
1206       stack_size = JavaThread::stack_size_at_create() == 0
1207         ? 2048*K : JavaThread::stack_size_at_create();
1208 
1209       // There are rare cases when we may have already used more than
1210       // the basic stack size allotment before this method is invoked.
1211       // Attempt to allow for a normally sized java_stack.
1212       size_t current_stack_offset = (size_t)(base - (address)&stack_size);
1213       stack_size += ReservedSpace::page_align_size_down(current_stack_offset);
1214     } else {
1215       // 6269555: If we were not created by a Java launcher, i.e. if we are
1216       // running embedded in a native application, treat the primordial thread
1217       // as much like a native attached thread as possible.  This means using
1218       // the current stack size from thr_stksegment(), unless it is too large
1219       // to reliably setup guard pages.  A reasonable max size is 8MB.
1220       size_t current_size = current_stack_size();
1221       // This should never happen, but just in case....
1222       if (current_size == 0) current_size = 2 * K * K;
1223       stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size;
1224     }
1225     address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());;
1226     stack_size = (size_t)(base - bottom);
1227 
1228     assert(stack_size > 0, "Stack size calculation problem");
1229 
1230     if (stack_size > jt->stack_size()) {
1231 #ifndef PRODUCT
1232       struct rlimit limits;
1233       getrlimit(RLIMIT_STACK, &limits);
1234       size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);
1235       assert(size >= jt->stack_size(), "Stack size problem in main thread");
1236 #endif
1237       tty->print_cr("Stack size of %d Kb exceeds current limit of %d Kb.\n"
1238                     "(Stack sizes are rounded up to a multiple of the system page size.)\n"
1239                     "See limit(1) to increase the stack size limit.",
1240                     stack_size / K, jt->stack_size() / K);
1241       vm_exit(1);
1242     }
1243     assert(jt->stack_size() >= stack_size,
1244            "Attempt to map more stack than was allocated");
1245     jt->set_stack_size(stack_size);
1246   }
1247 
1248   // With the T2 libthread (T1 is no longer supported) threads are always bound
1249   // and we use stackbanging in all cases.
1250 
1251   os::Solaris::init_thread_fpu_state();
1252   std::set_terminate(_handle_uncaught_cxx_exception);
1253 }
1254 
1255 
1256 
1257 // Free Solaris resources related to the OSThread
1258 void os::free_thread(OSThread* osthread) {
1259   assert(osthread != NULL, "os::free_thread but osthread not set");
1260 
1261 
1262   // We are told to free resources of the argument thread,
1263   // but we can only really operate on the current thread.
1264   // The main thread must take the VMThread down synchronously
1265   // before the main thread exits and frees up CodeHeap
1266   guarantee((Thread::current()->osthread() == osthread
1267              || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread");
1268   if (Thread::current()->osthread() == osthread) {
1269     // Restore caller's signal mask
1270     sigset_t sigmask = osthread->caller_sigmask();
1271     thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
1272   }
1273   delete osthread;
1274 }
1275 
1276 void os::pd_start_thread(Thread* thread) {
1277   int status = thr_continue(thread->osthread()->thread_id());
1278   assert_status(status == 0, status, "thr_continue failed");
1279 }
1280 
1281 
1282 intx os::current_thread_id() {
1283   return (intx)thr_self();
1284 }
1285 
1286 static pid_t _initial_pid = 0;
1287 
1288 int os::current_process_id() {
1289   return (int)(_initial_pid ? _initial_pid : getpid());
1290 }
1291 
1292 int os::allocate_thread_local_storage() {
1293   // %%%       in Win32 this allocates a memory segment pointed to by a
1294   //           register.  Dan Stein can implement a similar feature in
1295   //           Solaris.  Alternatively, the VM can do the same thing
1296   //           explicitly: malloc some storage and keep the pointer in a
1297   //           register (which is part of the thread's context) (or keep it
1298   //           in TLS).
1299   // %%%       In current versions of Solaris, thr_self and TSD can
1300   //           be accessed via short sequences of displaced indirections.
1301   //           The value of thr_self is available as %g7(36).
1302   //           The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4),
1303   //           assuming that the current thread already has a value bound to k.
1304   //           It may be worth experimenting with such access patterns,
1305   //           and later having the parameters formally exported from a Solaris
1306   //           interface.  I think, however, that it will be faster to
1307   //           maintain the invariant that %g2 always contains the
1308   //           JavaThread in Java code, and have stubs simply
1309   //           treat %g2 as a caller-save register, preserving it in a %lN.
1310   thread_key_t tk;
1311   if (thr_keycreate(&tk, NULL)) {
1312     fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "
1313                   "(%s)", strerror(errno)));
1314   }
1315   return int(tk);
1316 }
1317 
1318 void os::free_thread_local_storage(int index) {
1319   // %%% don't think we need anything here
1320   // if (pthread_key_delete((pthread_key_t) tk)) {
1321   //   fatal("os::free_thread_local_storage: pthread_key_delete failed");
1322   // }
1323 }
1324 
1325 // libthread allocate for tsd_common is a version specific
1326 // small number - point is NO swap space available
1327 #define SMALLINT 32
1328 void os::thread_local_storage_at_put(int index, void* value) {
1329   // %%% this is used only in threadLocalStorage.cpp
1330   if (thr_setspecific((thread_key_t)index, value)) {
1331     if (errno == ENOMEM) {
1332       vm_exit_out_of_memory(SMALLINT, OOM_MALLOC_ERROR,
1333                             "thr_setspecific: out of swap space");
1334     } else {
1335       fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed "
1336                     "(%s)", strerror(errno)));
1337     }
1338   } else {
1339     ThreadLocalStorage::set_thread_in_slot((Thread *) value);
1340   }
1341 }
1342 
1343 // This function could be called before TLS is initialized, for example, when
1344 // VM receives an async signal or when VM causes a fatal error during
1345 // initialization. Return NULL if thr_getspecific() fails.
1346 void* os::thread_local_storage_at(int index) {
1347   // %%% this is used only in threadLocalStorage.cpp
1348   void* r = NULL;
1349   return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r;
1350 }
1351 
1352 
1353 // gethrtime() should be monotonic according to the documentation,
1354 // but some virtualized platforms are known to break this guarantee.
1355 // getTimeNanos() must be guaranteed not to move backwards, so we
1356 // are forced to add a check here.
1357 inline hrtime_t getTimeNanos() {
1358   const hrtime_t now = gethrtime();
1359   const hrtime_t prev = max_hrtime;
1360   if (now <= prev) {
1361     return prev;   // same or retrograde time;
1362   }
1363   const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev);
1364   assert(obsv >= prev, "invariant");   // Monotonicity
1365   // If the CAS succeeded then we're done and return "now".
1366   // If the CAS failed and the observed value "obsv" is >= now then
1367   // we should return "obsv".  If the CAS failed and now > obsv > prv then
1368   // some other thread raced this thread and installed a new value, in which case
1369   // we could either (a) retry the entire operation, (b) retry trying to install now
1370   // or (c) just return obsv.  We use (c).   No loop is required although in some cases
1371   // we might discard a higher "now" value in deference to a slightly lower but freshly
1372   // installed obsv value.   That's entirely benign -- it admits no new orderings compared
1373   // to (a) or (b) -- and greatly reduces coherence traffic.
1374   // We might also condition (c) on the magnitude of the delta between obsv and now.
1375   // Avoiding excessive CAS operations to hot RW locations is critical.
1376   // See https://blogs.oracle.com/dave/entry/cas_and_cache_trivia_invalidate
1377   return (prev == obsv) ? now : obsv;
1378 }
1379 
1380 // Time since start-up in seconds to a fine granularity.
1381 // Used by VMSelfDestructTimer and the MemProfiler.
1382 double os::elapsedTime() {
1383   return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz;
1384 }
1385 
1386 jlong os::elapsed_counter() {
1387   return (jlong)(getTimeNanos() - first_hrtime);
1388 }
1389 
1390 jlong os::elapsed_frequency() {
1391   return hrtime_hz;
1392 }
1393 
1394 // Return the real, user, and system times in seconds from an
1395 // arbitrary fixed point in the past.
1396 bool os::getTimesSecs(double* process_real_time,
1397                       double* process_user_time,
1398                       double* process_system_time) {
1399   struct tms ticks;
1400   clock_t real_ticks = times(&ticks);
1401 
1402   if (real_ticks == (clock_t) (-1)) {
1403     return false;
1404   } else {
1405     double ticks_per_second = (double) clock_tics_per_sec;
1406     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1407     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1408     // For consistency return the real time from getTimeNanos()
1409     // converted to seconds.
1410     *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS);
1411 
1412     return true;
1413   }
1414 }
1415 
1416 bool os::supports_vtime() { return true; }
1417 
1418 bool os::enable_vtime() {
1419   int fd = ::open("/proc/self/ctl", O_WRONLY);
1420   if (fd == -1) {
1421     return false;
1422   }
1423 
1424   long cmd[] = { PCSET, PR_MSACCT };
1425   int res = ::write(fd, cmd, sizeof(long) * 2);
1426   ::close(fd);
1427   if (res != sizeof(long) * 2) {
1428     return false;
1429   }
1430   return true;
1431 }
1432 
1433 bool os::vtime_enabled() {
1434   int fd = ::open("/proc/self/status", O_RDONLY);
1435   if (fd == -1) {
1436     return false;
1437   }
1438 
1439   pstatus_t status;
1440   int res = os::read(fd, (void*) &status, sizeof(pstatus_t));
1441   ::close(fd);
1442   if (res != sizeof(pstatus_t)) {
1443     return false;
1444   }
1445   return status.pr_flags & PR_MSACCT;
1446 }
1447 
1448 double os::elapsedVTime() {
1449   return (double)gethrvtime() / (double)hrtime_hz;
1450 }
1451 
1452 // Used internally for comparisons only
1453 // getTimeMillis guaranteed to not move backwards on Solaris
1454 jlong getTimeMillis() {
1455   jlong nanotime = getTimeNanos();
1456   return (jlong)(nanotime / NANOSECS_PER_MILLISEC);
1457 }
1458 
1459 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
1460 jlong os::javaTimeMillis() {
1461   timeval t;
1462   if (gettimeofday(&t, NULL) == -1) {
1463     fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));
1464   }
1465   return jlong(t.tv_sec) * 1000  +  jlong(t.tv_usec) / 1000;
1466 }
1467 
1468 void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
1469   timeval t;
1470   if (gettimeofday(&t, NULL) == -1) {
1471     fatal(err_msg("os::javaTimeSystemUTC: gettimeofday (%s)", strerror(errno)));
1472   }
1473   seconds = jlong(t.tv_sec);
1474   nanos = jlong(t.tv_usec) * 1000;
1475 }
1476 
1477 
1478 jlong os::javaTimeNanos() {
1479   return (jlong)getTimeNanos();
1480 }
1481 
1482 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1483   info_ptr->max_value = ALL_64_BITS;      // gethrtime() uses all 64 bits
1484   info_ptr->may_skip_backward = false;    // not subject to resetting or drifting
1485   info_ptr->may_skip_forward = false;     // not subject to resetting or drifting
1486   info_ptr->kind = JVMTI_TIMER_ELAPSED;   // elapsed not CPU time
1487 }
1488 
1489 char * os::local_time_string(char *buf, size_t buflen) {
1490   struct tm t;
1491   time_t long_time;
1492   time(&long_time);
1493   localtime_r(&long_time, &t);
1494   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1495                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1496                t.tm_hour, t.tm_min, t.tm_sec);
1497   return buf;
1498 }
1499 
1500 // Note: os::shutdown() might be called very early during initialization, or
1501 // called from signal handler. Before adding something to os::shutdown(), make
1502 // sure it is async-safe and can handle partially initialized VM.
1503 void os::shutdown() {
1504 
1505   // allow PerfMemory to attempt cleanup of any persistent resources
1506   perfMemory_exit();
1507 
1508   // needs to remove object in file system
1509   AttachListener::abort();
1510 
1511   // flush buffered output, finish log files
1512   ostream_abort();
1513 
1514   // Check for abort hook
1515   abort_hook_t abort_hook = Arguments::abort_hook();
1516   if (abort_hook != NULL) {
1517     abort_hook();
1518   }
1519 }
1520 
1521 // Note: os::abort() might be called very early during initialization, or
1522 // called from signal handler. Before adding something to os::abort(), make
1523 // sure it is async-safe and can handle partially initialized VM.
1524 void os::abort(bool dump_core, void* siginfo, void* context) {
1525   os::shutdown();
1526   if (dump_core) {
1527 #ifndef PRODUCT
1528     fdStream out(defaultStream::output_fd());
1529     out.print_raw("Current thread is ");
1530     char buf[16];
1531     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1532     out.print_raw_cr(buf);
1533     out.print_raw_cr("Dumping core ...");
1534 #endif
1535     ::abort(); // dump core (for debugging)
1536   }
1537 
1538   ::exit(1);
1539 }
1540 
1541 // Die immediately, no exit hook, no abort hook, no cleanup.
1542 void os::die() {
1543   ::abort(); // dump core (for debugging)
1544 }
1545 
1546 // DLL functions
1547 
1548 const char* os::dll_file_extension() { return ".so"; }
1549 
1550 // This must be hard coded because it's the system's temporary
1551 // directory not the java application's temp directory, ala java.io.tmpdir.
1552 const char* os::get_temp_directory() { return "/tmp"; }
1553 
1554 static bool file_exists(const char* filename) {
1555   struct stat statbuf;
1556   if (filename == NULL || strlen(filename) == 0) {
1557     return false;
1558   }
1559   return os::stat(filename, &statbuf) == 0;
1560 }
1561 
1562 bool os::dll_build_name(char* buffer, size_t buflen,
1563                         const char* pname, const char* fname) {
1564   bool retval = false;
1565   const size_t pnamelen = pname ? strlen(pname) : 0;
1566 
1567   // Return error on buffer overflow.
1568   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1569     return retval;
1570   }
1571 
1572   if (pnamelen == 0) {
1573     snprintf(buffer, buflen, "lib%s.so", fname);
1574     retval = true;
1575   } else if (strchr(pname, *os::path_separator()) != NULL) {
1576     int n;
1577     char** pelements = split_path(pname, &n);
1578     if (pelements == NULL) {
1579       return false;
1580     }
1581     for (int i = 0; i < n; i++) {
1582       // really shouldn't be NULL but what the heck, check can't hurt
1583       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1584         continue; // skip the empty path values
1585       }
1586       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1587       if (file_exists(buffer)) {
1588         retval = true;
1589         break;
1590       }
1591     }
1592     // release the storage
1593     for (int i = 0; i < n; i++) {
1594       if (pelements[i] != NULL) {
1595         FREE_C_HEAP_ARRAY(char, pelements[i]);
1596       }
1597     }
1598     if (pelements != NULL) {
1599       FREE_C_HEAP_ARRAY(char*, pelements);
1600     }
1601   } else {
1602     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1603     retval = true;
1604   }
1605   return retval;
1606 }
1607 
1608 // check if addr is inside libjvm.so
1609 bool os::address_is_in_vm(address addr) {
1610   static address libjvm_base_addr;
1611   Dl_info dlinfo;
1612 
1613   if (libjvm_base_addr == NULL) {
1614     if (dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo) != 0) {
1615       libjvm_base_addr = (address)dlinfo.dli_fbase;
1616     }
1617     assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
1618   }
1619 
1620   if (dladdr((void *)addr, &dlinfo) != 0) {
1621     if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
1622   }
1623 
1624   return false;
1625 }
1626 
1627 typedef int (*dladdr1_func_type)(void *, Dl_info *, void **, int);
1628 static dladdr1_func_type dladdr1_func = NULL;
1629 
1630 bool os::dll_address_to_function_name(address addr, char *buf,
1631                                       int buflen, int * offset,
1632                                       bool demangle) {
1633   // buf is not optional, but offset is optional
1634   assert(buf != NULL, "sanity check");
1635 
1636   Dl_info dlinfo;
1637 
1638   // dladdr1_func was initialized in os::init()
1639   if (dladdr1_func != NULL) {
1640     // yes, we have dladdr1
1641 
1642     // Support for dladdr1 is checked at runtime; it may be
1643     // available even if the vm is built on a machine that does
1644     // not have dladdr1 support.  Make sure there is a value for
1645     // RTLD_DL_SYMENT.
1646 #ifndef RTLD_DL_SYMENT
1647   #define RTLD_DL_SYMENT 1
1648 #endif
1649 #ifdef _LP64
1650     Elf64_Sym * info;
1651 #else
1652     Elf32_Sym * info;
1653 #endif
1654     if (dladdr1_func((void *)addr, &dlinfo, (void **)&info,
1655                      RTLD_DL_SYMENT) != 0) {
1656       // see if we have a matching symbol that covers our address
1657       if (dlinfo.dli_saddr != NULL &&
1658           (char *)dlinfo.dli_saddr + info->st_size > (char *)addr) {
1659         if (dlinfo.dli_sname != NULL) {
1660           if (!(demangle && Decoder::demangle(dlinfo.dli_sname, buf, buflen))) {
1661             jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
1662           }
1663           if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
1664           return true;
1665         }
1666       }
1667       // no matching symbol so try for just file info
1668       if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != NULL) {
1669         if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
1670                             buf, buflen, offset, dlinfo.dli_fname, demangle)) {
1671           return true;
1672         }
1673       }
1674     }
1675     buf[0] = '\0';
1676     if (offset != NULL) *offset  = -1;
1677     return false;
1678   }
1679 
1680   // no, only dladdr is available
1681   if (dladdr((void *)addr, &dlinfo) != 0) {
1682     // see if we have a matching symbol
1683     if (dlinfo.dli_saddr != NULL && dlinfo.dli_sname != NULL) {
1684       if (!(demangle && Decoder::demangle(dlinfo.dli_sname, buf, buflen))) {
1685         jio_snprintf(buf, buflen, dlinfo.dli_sname);
1686       }
1687       if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
1688       return true;
1689     }
1690     // no matching symbol so try for just file info
1691     if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != NULL) {
1692       if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
1693                           buf, buflen, offset, dlinfo.dli_fname, demangle)) {
1694         return true;
1695       }
1696     }
1697   }
1698   buf[0] = '\0';
1699   if (offset != NULL) *offset  = -1;
1700   return false;
1701 }
1702 
1703 bool os::dll_address_to_library_name(address addr, char* buf,
1704                                      int buflen, int* offset) {
1705   // buf is not optional, but offset is optional
1706   assert(buf != NULL, "sanity check");
1707 
1708   Dl_info dlinfo;
1709 
1710   if (dladdr((void*)addr, &dlinfo) != 0) {
1711     if (dlinfo.dli_fname != NULL) {
1712       jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
1713     }
1714     if (dlinfo.dli_fbase != NULL && offset != NULL) {
1715       *offset = addr - (address)dlinfo.dli_fbase;
1716     }
1717     return true;
1718   }
1719 
1720   buf[0] = '\0';
1721   if (offset) *offset = -1;
1722   return false;
1723 }
1724 
1725 int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
1726   Dl_info dli;
1727   // Sanity check?
1728   if (dladdr(CAST_FROM_FN_PTR(void *, os::get_loaded_modules_info), &dli) == 0 ||
1729       dli.dli_fname == NULL) {
1730     return 1;
1731   }
1732 
1733   void * handle = dlopen(dli.dli_fname, RTLD_LAZY);
1734   if (handle == NULL) {
1735     return 1;
1736   }
1737 
1738   Link_map *map;
1739   dlinfo(handle, RTLD_DI_LINKMAP, &map);
1740   if (map == NULL) {
1741     dlclose(handle);
1742     return 1;
1743   }
1744 
1745   while (map->l_prev != NULL) {
1746     map = map->l_prev;
1747   }
1748 
1749   while (map != NULL) {
1750     // Iterate through all map entries and call callback with fields of interest
1751     if(callback(map->l_name, (address)map->l_addr, (address)0, param)) {
1752       dlclose(handle);
1753       return 1;
1754     }
1755     map = map->l_next;
1756   }
1757 
1758   dlclose(handle);
1759   return 0;
1760 }
1761 
1762 int _print_dll_info_cb(const char * name, address base_address, address top_address, void * param) {
1763   outputStream * out = (outputStream *) param;
1764   out->print_cr(PTR_FORMAT " \t%s", base_address, name);
1765   return 0;
1766 }
1767 
1768 void os::print_dll_info(outputStream * st) {
1769   st->print_cr("Dynamic libraries:"); st->flush();
1770   if (get_loaded_modules_info(_print_dll_info_cb, (void *)st)) {
1771     st->print_cr("Error: Cannot print dynamic libraries.");
1772   }
1773 }
1774 
1775 // Loads .dll/.so and
1776 // in case of error it checks if .dll/.so was built for the
1777 // same architecture as Hotspot is running on
1778 
1779 void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
1780   void * result= ::dlopen(filename, RTLD_LAZY);
1781   if (result != NULL) {
1782     // Successful loading
1783     return result;
1784   }
1785 
1786   Elf32_Ehdr elf_head;
1787 
1788   // Read system error message into ebuf
1789   // It may or may not be overwritten below
1790   ::strncpy(ebuf, ::dlerror(), ebuflen-1);
1791   ebuf[ebuflen-1]='\0';
1792   int diag_msg_max_length=ebuflen-strlen(ebuf);
1793   char* diag_msg_buf=ebuf+strlen(ebuf);
1794 
1795   if (diag_msg_max_length==0) {
1796     // No more space in ebuf for additional diagnostics message
1797     return NULL;
1798   }
1799 
1800 
1801   int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
1802 
1803   if (file_descriptor < 0) {
1804     // Can't open library, report dlerror() message
1805     return NULL;
1806   }
1807 
1808   bool failed_to_read_elf_head=
1809     (sizeof(elf_head)!=
1810      (::read(file_descriptor, &elf_head,sizeof(elf_head))));
1811 
1812   ::close(file_descriptor);
1813   if (failed_to_read_elf_head) {
1814     // file i/o error - report dlerror() msg
1815     return NULL;
1816   }
1817 
1818   typedef struct {
1819     Elf32_Half  code;         // Actual value as defined in elf.h
1820     Elf32_Half  compat_class; // Compatibility of archs at VM's sense
1821     char        elf_class;    // 32 or 64 bit
1822     char        endianess;    // MSB or LSB
1823     char*       name;         // String representation
1824   } arch_t;
1825 
1826   static const arch_t arch_array[]={
1827     {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1828     {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1829     {EM_IA_64,       EM_IA_64,   ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
1830     {EM_X86_64,      EM_X86_64,  ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
1831     {EM_SPARC,       EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1832     {EM_SPARC32PLUS, EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1833     {EM_SPARCV9,     EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
1834     {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
1835     {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
1836     {EM_ARM,         EM_ARM,     ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"}
1837   };
1838 
1839 #if  (defined IA32)
1840   static  Elf32_Half running_arch_code=EM_386;
1841 #elif   (defined AMD64)
1842   static  Elf32_Half running_arch_code=EM_X86_64;
1843 #elif  (defined IA64)
1844   static  Elf32_Half running_arch_code=EM_IA_64;
1845 #elif  (defined __sparc) && (defined _LP64)
1846   static  Elf32_Half running_arch_code=EM_SPARCV9;
1847 #elif  (defined __sparc) && (!defined _LP64)
1848   static  Elf32_Half running_arch_code=EM_SPARC;
1849 #elif  (defined __powerpc64__)
1850   static  Elf32_Half running_arch_code=EM_PPC64;
1851 #elif  (defined __powerpc__)
1852   static  Elf32_Half running_arch_code=EM_PPC;
1853 #elif (defined ARM)
1854   static  Elf32_Half running_arch_code=EM_ARM;
1855 #else
1856   #error Method os::dll_load requires that one of following is defined:\
1857        IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM
1858 #endif
1859 
1860   // Identify compatability class for VM's architecture and library's architecture
1861   // Obtain string descriptions for architectures
1862 
1863   arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
1864   int running_arch_index=-1;
1865 
1866   for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
1867     if (running_arch_code == arch_array[i].code) {
1868       running_arch_index    = i;
1869     }
1870     if (lib_arch.code == arch_array[i].code) {
1871       lib_arch.compat_class = arch_array[i].compat_class;
1872       lib_arch.name         = arch_array[i].name;
1873     }
1874   }
1875 
1876   assert(running_arch_index != -1,
1877          "Didn't find running architecture code (running_arch_code) in arch_array");
1878   if (running_arch_index == -1) {
1879     // Even though running architecture detection failed
1880     // we may still continue with reporting dlerror() message
1881     return NULL;
1882   }
1883 
1884   if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
1885     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
1886     return NULL;
1887   }
1888 
1889   if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
1890     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
1891     return NULL;
1892   }
1893 
1894   if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
1895     if (lib_arch.name!=NULL) {
1896       ::snprintf(diag_msg_buf, diag_msg_max_length-1,
1897                  " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
1898                  lib_arch.name, arch_array[running_arch_index].name);
1899     } else {
1900       ::snprintf(diag_msg_buf, diag_msg_max_length-1,
1901                  " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
1902                  lib_arch.code,
1903                  arch_array[running_arch_index].name);
1904     }
1905   }
1906 
1907   return NULL;
1908 }
1909 
1910 void* os::dll_lookup(void* handle, const char* name) {
1911   return dlsym(handle, name);
1912 }
1913 
1914 void* os::get_default_process_handle() {
1915   return (void*)::dlopen(NULL, RTLD_LAZY);
1916 }
1917 
1918 int os::stat(const char *path, struct stat *sbuf) {
1919   char pathbuf[MAX_PATH];
1920   if (strlen(path) > MAX_PATH - 1) {
1921     errno = ENAMETOOLONG;
1922     return -1;
1923   }
1924   os::native_path(strcpy(pathbuf, path));
1925   return ::stat(pathbuf, sbuf);
1926 }
1927 
1928 static bool _print_ascii_file(const char* filename, outputStream* st) {
1929   int fd = ::open(filename, O_RDONLY);
1930   if (fd == -1) {
1931     return false;
1932   }
1933 
1934   char buf[32];
1935   int bytes;
1936   while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) {
1937     st->print_raw(buf, bytes);
1938   }
1939 
1940   ::close(fd);
1941 
1942   return true;
1943 }
1944 
1945 void os::print_os_info_brief(outputStream* st) {
1946   os::Solaris::print_distro_info(st);
1947 
1948   os::Posix::print_uname_info(st);
1949 
1950   os::Solaris::print_libversion_info(st);
1951 }
1952 
1953 void os::print_os_info(outputStream* st) {
1954   st->print("OS:");
1955 
1956   os::Solaris::print_distro_info(st);
1957 
1958   os::Posix::print_uname_info(st);
1959 
1960   os::Solaris::print_libversion_info(st);
1961 
1962   os::Posix::print_rlimit_info(st);
1963 
1964   os::Posix::print_load_average(st);
1965 }
1966 
1967 void os::Solaris::print_distro_info(outputStream* st) {
1968   if (!_print_ascii_file("/etc/release", st)) {
1969     st->print("Solaris");
1970   }
1971   st->cr();
1972 }
1973 
1974 void os::get_summary_os_info(char* buf, size_t buflen) {
1975   strncpy(buf, "Solaris", buflen);  // default to plain solaris
1976   FILE* fp = fopen("/etc/release", "r");
1977   if (fp != NULL) {
1978     char tmp[256];
1979     if (fgets(tmp, 256, fp)) {
1980       char* ptr = tmp;
1981       // skip past whitespace characters
1982       while (*ptr != '\0' && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')) ptr++;
1983       if (*ptr != '\0') {
1984         char* nl = strchr(ptr, '\n');
1985         if (nl != NULL) *nl = '\0';
1986         strncpy(buf, ptr, buflen);
1987       }
1988     }
1989     fclose(fp);
1990   }
1991 }
1992 
1993 void os::Solaris::print_libversion_info(outputStream* st) {
1994   st->print("  (T2 libthread)");
1995   st->cr();
1996 }
1997 
1998 static bool check_addr0(outputStream* st) {
1999   jboolean status = false;
2000   int fd = ::open("/proc/self/map",O_RDONLY);
2001   if (fd >= 0) {
2002     prmap_t p;
2003     while (::read(fd, &p, sizeof(p)) > 0) {
2004       if (p.pr_vaddr == 0x0) {
2005         st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
2006         st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
2007         st->print("Access:");
2008         st->print("%s",(p.pr_mflags & MA_READ)  ? "r" : "-");
2009         st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");
2010         st->print("%s",(p.pr_mflags & MA_EXEC)  ? "x" : "-");
2011         st->cr();
2012         status = true;
2013       }
2014     }
2015     ::close(fd);
2016   }
2017   return status;
2018 }
2019 
2020 void os::get_summary_cpu_info(char* buf, size_t buflen) {
2021   // Get MHz with system call. We don't seem to already have this.
2022   processor_info_t stats;
2023   processorid_t id = getcpuid();
2024   int clock = 0;
2025   if (processor_info(id, &stats) != -1) {
2026     clock = stats.pi_clock;  // pi_processor_type isn't more informative than below
2027   }
2028 #ifdef AMD64
2029   snprintf(buf, buflen, "x86 64 bit %d MHz", clock);
2030 #elif  (defined __sparc) && (defined _LP64)
2031   snprintf(buf, buflen, "Sparcv9 64 bit %d MHz", clock);
2032 #else
2033 #error "Invalid solaris configuration"
2034 #endif
2035 }
2036 
2037 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
2038   // Nothing to do for now.
2039 }
2040 
2041 void os::print_memory_info(outputStream* st) {
2042   st->print("Memory:");
2043   st->print(" %dk page", os::vm_page_size()>>10);
2044   st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);
2045   st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);
2046   st->cr();
2047   (void) check_addr0(st);
2048 }
2049 
2050 void os::print_siginfo(outputStream* st, void* siginfo) {
2051   const siginfo_t* si = (const siginfo_t*)siginfo;
2052 
2053   os::Posix::print_siginfo_brief(st, si);
2054 
2055   if (si && (si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
2056       UseSharedSpaces) {
2057     FileMapInfo* mapinfo = FileMapInfo::current_info();
2058     if (mapinfo->is_in_shared_space(si->si_addr)) {
2059       st->print("\n\nError accessing class data sharing archive."   \
2060                 " Mapped file inaccessible during execution, "      \
2061                 " possible disk/network problem.");
2062     }
2063   }
2064   st->cr();
2065 }
2066 
2067 // Moved from whole group, because we need them here for diagnostic
2068 // prints.
2069 #define OLDMAXSIGNUM 32
2070 static int Maxsignum = 0;
2071 static int *ourSigFlags = NULL;
2072 
2073 extern "C" void sigINTRHandler(int, siginfo_t*, void*);
2074 
2075 int os::Solaris::get_our_sigflags(int sig) {
2076   assert(ourSigFlags!=NULL, "signal data structure not initialized");
2077   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2078   return ourSigFlags[sig];
2079 }
2080 
2081 void os::Solaris::set_our_sigflags(int sig, int flags) {
2082   assert(ourSigFlags!=NULL, "signal data structure not initialized");
2083   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2084   ourSigFlags[sig] = flags;
2085 }
2086 
2087 
2088 static const char* get_signal_handler_name(address handler,
2089                                            char* buf, int buflen) {
2090   int offset;
2091   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
2092   if (found) {
2093     // skip directory names
2094     const char *p1, *p2;
2095     p1 = buf;
2096     size_t len = strlen(os::file_separator());
2097     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
2098     jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
2099   } else {
2100     jio_snprintf(buf, buflen, PTR_FORMAT, handler);
2101   }
2102   return buf;
2103 }
2104 
2105 static void print_signal_handler(outputStream* st, int sig,
2106                                  char* buf, size_t buflen) {
2107   struct sigaction sa;
2108 
2109   sigaction(sig, NULL, &sa);
2110 
2111   st->print("%s: ", os::exception_name(sig, buf, buflen));
2112 
2113   address handler = (sa.sa_flags & SA_SIGINFO)
2114                   ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
2115                   : CAST_FROM_FN_PTR(address, sa.sa_handler);
2116 
2117   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
2118     st->print("SIG_DFL");
2119   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
2120     st->print("SIG_IGN");
2121   } else {
2122     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
2123   }
2124 
2125   st->print(", sa_mask[0]=");
2126   os::Posix::print_signal_set_short(st, &sa.sa_mask);
2127 
2128   address rh = VMError::get_resetted_sighandler(sig);
2129   // May be, handler was resetted by VMError?
2130   if (rh != NULL) {
2131     handler = rh;
2132     sa.sa_flags = VMError::get_resetted_sigflags(sig);
2133   }
2134 
2135   st->print(", sa_flags=");
2136   os::Posix::print_sa_flags(st, sa.sa_flags);
2137 
2138   // Check: is it our handler?
2139   if (handler == CAST_FROM_FN_PTR(address, signalHandler) ||
2140       handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
2141     // It is our signal handler
2142     // check for flags
2143     if (sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
2144       st->print(
2145                 ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
2146                 os::Solaris::get_our_sigflags(sig));
2147     }
2148   }
2149   st->cr();
2150 }
2151 
2152 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2153   st->print_cr("Signal Handlers:");
2154   print_signal_handler(st, SIGSEGV, buf, buflen);
2155   print_signal_handler(st, SIGBUS , buf, buflen);
2156   print_signal_handler(st, SIGFPE , buf, buflen);
2157   print_signal_handler(st, SIGPIPE, buf, buflen);
2158   print_signal_handler(st, SIGXFSZ, buf, buflen);
2159   print_signal_handler(st, SIGILL , buf, buflen);
2160   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
2161   print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);
2162   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
2163   print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);
2164   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
2165   print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);
2166   print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);
2167   print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);
2168 }
2169 
2170 static char saved_jvm_path[MAXPATHLEN] = { 0 };
2171 
2172 // Find the full path to the current module, libjvm.so
2173 void os::jvm_path(char *buf, jint buflen) {
2174   // Error checking.
2175   if (buflen < MAXPATHLEN) {
2176     assert(false, "must use a large-enough buffer");
2177     buf[0] = '\0';
2178     return;
2179   }
2180   // Lazy resolve the path to current module.
2181   if (saved_jvm_path[0] != 0) {
2182     strcpy(buf, saved_jvm_path);
2183     return;
2184   }
2185 
2186   Dl_info dlinfo;
2187   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
2188   assert(ret != 0, "cannot locate libjvm");
2189   if (ret != 0 && dlinfo.dli_fname != NULL) {
2190     realpath((char *)dlinfo.dli_fname, buf);
2191   } else {
2192     buf[0] = '\0';
2193     return;
2194   }
2195 
2196   if (Arguments::sun_java_launcher_is_altjvm()) {
2197     // Support for the java launcher's '-XXaltjvm=<path>' option. Typical
2198     // value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".
2199     // If "/jre/lib/" appears at the right place in the string, then
2200     // assume we are installed in a JDK and we're done.  Otherwise, check
2201     // for a JAVA_HOME environment variable and fix up the path so it
2202     // looks like libjvm.so is installed there (append a fake suffix
2203     // hotspot/libjvm.so).
2204     const char *p = buf + strlen(buf) - 1;
2205     for (int count = 0; p > buf && count < 5; ++count) {
2206       for (--p; p > buf && *p != '/'; --p)
2207         /* empty */ ;
2208     }
2209 
2210     if (strncmp(p, "/jre/lib/", 9) != 0) {
2211       // Look for JAVA_HOME in the environment.
2212       char* java_home_var = ::getenv("JAVA_HOME");
2213       if (java_home_var != NULL && java_home_var[0] != 0) {
2214         char cpu_arch[12];
2215         char* jrelib_p;
2216         int   len;
2217         sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
2218 #ifdef _LP64
2219         // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.
2220         if (strcmp(cpu_arch, "sparc") == 0) {
2221           strcat(cpu_arch, "v9");
2222         } else if (strcmp(cpu_arch, "i386") == 0) {
2223           strcpy(cpu_arch, "amd64");
2224         }
2225 #endif
2226         // Check the current module name "libjvm.so".
2227         p = strrchr(buf, '/');
2228         assert(strstr(p, "/libjvm") == p, "invalid library name");
2229 
2230         realpath(java_home_var, buf);
2231         // determine if this is a legacy image or modules image
2232         // modules image doesn't have "jre" subdirectory
2233         len = strlen(buf);
2234         assert(len < buflen, "Ran out of buffer space");
2235         jrelib_p = buf + len;
2236         snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);
2237         if (0 != access(buf, F_OK)) {
2238           snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);
2239         }
2240 
2241         if (0 == access(buf, F_OK)) {
2242           // Use current module name "libjvm.so"
2243           len = strlen(buf);
2244           snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");
2245         } else {
2246           // Go back to path of .so
2247           realpath((char *)dlinfo.dli_fname, buf);
2248         }
2249       }
2250     }
2251   }
2252 
2253   strncpy(saved_jvm_path, buf, MAXPATHLEN);
2254   saved_jvm_path[MAXPATHLEN - 1] = '\0';
2255 }
2256 
2257 
2258 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
2259   // no prefix required, not even "_"
2260 }
2261 
2262 
2263 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2264   // no suffix required
2265 }
2266 
2267 // This method is a copy of JDK's sysGetLastErrorString
2268 // from src/solaris/hpi/src/system_md.c
2269 
2270 size_t os::lasterror(char *buf, size_t len) {
2271   if (errno == 0)  return 0;
2272 
2273   const char *s = ::strerror(errno);
2274   size_t n = ::strlen(s);
2275   if (n >= len) {
2276     n = len - 1;
2277   }
2278   ::strncpy(buf, s, n);
2279   buf[n] = '\0';
2280   return n;
2281 }
2282 
2283 
2284 // sun.misc.Signal
2285 
2286 extern "C" {
2287   static void UserHandler(int sig, void *siginfo, void *context) {
2288     // Ctrl-C is pressed during error reporting, likely because the error
2289     // handler fails to abort. Let VM die immediately.
2290     if (sig == SIGINT && is_error_reported()) {
2291       os::die();
2292     }
2293 
2294     os::signal_notify(sig);
2295     // We do not need to reinstate the signal handler each time...
2296   }
2297 }
2298 
2299 void* os::user_handler() {
2300   return CAST_FROM_FN_PTR(void*, UserHandler);
2301 }
2302 
2303 struct timespec PosixSemaphore::create_timespec(unsigned int sec, int nsec) {
2304   struct timespec ts;
2305   unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
2306 
2307   return ts;
2308 }
2309 
2310 extern "C" {
2311   typedef void (*sa_handler_t)(int);
2312   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
2313 }
2314 
2315 void* os::signal(int signal_number, void* handler) {
2316   struct sigaction sigAct, oldSigAct;
2317   sigfillset(&(sigAct.sa_mask));
2318   sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
2319   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
2320 
2321   if (sigaction(signal_number, &sigAct, &oldSigAct)) {
2322     // -1 means registration failed
2323     return (void *)-1;
2324   }
2325 
2326   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
2327 }
2328 
2329 void os::signal_raise(int signal_number) {
2330   raise(signal_number);
2331 }
2332 
2333 // The following code is moved from os.cpp for making this
2334 // code platform specific, which it is by its very nature.
2335 
2336 // a counter for each possible signal value
2337 static int Sigexit = 0;
2338 static int Maxlibjsigsigs;
2339 static jint *pending_signals = NULL;
2340 static int *preinstalled_sigs = NULL;
2341 static struct sigaction *chainedsigactions = NULL;
2342 static sema_t sig_sem;
2343 typedef int (*version_getting_t)();
2344 version_getting_t os::Solaris::get_libjsig_version = NULL;
2345 static int libjsigversion = NULL;
2346 
2347 int os::sigexitnum_pd() {
2348   assert(Sigexit > 0, "signal memory not yet initialized");
2349   return Sigexit;
2350 }
2351 
2352 void os::Solaris::init_signal_mem() {
2353   // Initialize signal structures
2354   Maxsignum = SIGRTMAX;
2355   Sigexit = Maxsignum+1;
2356   assert(Maxsignum >0, "Unable to obtain max signal number");
2357 
2358   Maxlibjsigsigs = Maxsignum;
2359 
2360   // pending_signals has one int per signal
2361   // The additional signal is for SIGEXIT - exit signal to signal_thread
2362   pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal);
2363   memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
2364 
2365   if (UseSignalChaining) {
2366     chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
2367                                                    * (Maxsignum + 1), mtInternal);
2368     memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
2369     preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
2370     memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
2371   }
2372   ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
2373   memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
2374 }
2375 
2376 void os::signal_init_pd() {
2377   int ret;
2378 
2379   ret = ::sema_init(&sig_sem, 0, NULL, NULL);
2380   assert(ret == 0, "sema_init() failed");
2381 }
2382 
2383 void os::signal_notify(int signal_number) {
2384   int ret;
2385 
2386   Atomic::inc(&pending_signals[signal_number]);
2387   ret = ::sema_post(&sig_sem);
2388   assert(ret == 0, "sema_post() failed");
2389 }
2390 
2391 static int check_pending_signals(bool wait_for_signal) {
2392   int ret;
2393   while (true) {
2394     for (int i = 0; i < Sigexit + 1; i++) {
2395       jint n = pending_signals[i];
2396       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2397         return i;
2398       }
2399     }
2400     if (!wait_for_signal) {
2401       return -1;
2402     }
2403     JavaThread *thread = JavaThread::current();
2404     ThreadBlockInVM tbivm(thread);
2405 
2406     bool threadIsSuspended;
2407     do {
2408       thread->set_suspend_equivalent();
2409       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2410       while ((ret = ::sema_wait(&sig_sem)) == EINTR)
2411         ;
2412       assert(ret == 0, "sema_wait() failed");
2413 
2414       // were we externally suspended while we were waiting?
2415       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2416       if (threadIsSuspended) {
2417         // The semaphore has been incremented, but while we were waiting
2418         // another thread suspended us. We don't want to continue running
2419         // while suspended because that would surprise the thread that
2420         // suspended us.
2421         ret = ::sema_post(&sig_sem);
2422         assert(ret == 0, "sema_post() failed");
2423 
2424         thread->java_suspend_self();
2425       }
2426     } while (threadIsSuspended);
2427   }
2428 }
2429 
2430 int os::signal_lookup() {
2431   return check_pending_signals(false);
2432 }
2433 
2434 int os::signal_wait() {
2435   return check_pending_signals(true);
2436 }
2437 
2438 ////////////////////////////////////////////////////////////////////////////////
2439 // Virtual Memory
2440 
2441 static int page_size = -1;
2442 
2443 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later.  init_2() will
2444 // clear this var if support is not available.
2445 static bool has_map_align = true;
2446 
2447 int os::vm_page_size() {
2448   assert(page_size != -1, "must call os::init");
2449   return page_size;
2450 }
2451 
2452 // Solaris allocates memory by pages.
2453 int os::vm_allocation_granularity() {
2454   assert(page_size != -1, "must call os::init");
2455   return page_size;
2456 }
2457 
2458 static bool recoverable_mmap_error(int err) {
2459   // See if the error is one we can let the caller handle. This
2460   // list of errno values comes from the Solaris mmap(2) man page.
2461   switch (err) {
2462   case EBADF:
2463   case EINVAL:
2464   case ENOTSUP:
2465     // let the caller deal with these errors
2466     return true;
2467 
2468   default:
2469     // Any remaining errors on this OS can cause our reserved mapping
2470     // to be lost. That can cause confusion where different data
2471     // structures think they have the same memory mapped. The worst
2472     // scenario is if both the VM and a library think they have the
2473     // same memory mapped.
2474     return false;
2475   }
2476 }
2477 
2478 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec,
2479                                     int err) {
2480   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2481           ", %d) failed; error='%s' (errno=%d)", addr, bytes, exec,
2482           strerror(err), err);
2483 }
2484 
2485 static void warn_fail_commit_memory(char* addr, size_t bytes,
2486                                     size_t alignment_hint, bool exec,
2487                                     int err) {
2488   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2489           ", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", addr, bytes,
2490           alignment_hint, exec, strerror(err), err);
2491 }
2492 
2493 int os::Solaris::commit_memory_impl(char* addr, size_t bytes, bool exec) {
2494   int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
2495   size_t size = bytes;
2496   char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
2497   if (res != NULL) {
2498     if (UseNUMAInterleaving) {
2499       numa_make_global(addr, bytes);
2500     }
2501     return 0;
2502   }
2503 
2504   int err = errno;  // save errno from mmap() call in mmap_chunk()
2505 
2506   if (!recoverable_mmap_error(err)) {
2507     warn_fail_commit_memory(addr, bytes, exec, err);
2508     vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, "committing reserved memory.");
2509   }
2510 
2511   return err;
2512 }
2513 
2514 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
2515   return Solaris::commit_memory_impl(addr, bytes, exec) == 0;
2516 }
2517 
2518 void os::pd_commit_memory_or_exit(char* addr, size_t bytes, bool exec,
2519                                   const char* mesg) {
2520   assert(mesg != NULL, "mesg must be specified");
2521   int err = os::Solaris::commit_memory_impl(addr, bytes, exec);
2522   if (err != 0) {
2523     // the caller wants all commit errors to exit with the specified mesg:
2524     warn_fail_commit_memory(addr, bytes, exec, err);
2525     vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
2526   }
2527 }
2528 
2529 size_t os::Solaris::page_size_for_alignment(size_t alignment) {
2530   assert(is_size_aligned(alignment, (size_t) vm_page_size()),
2531          err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT,
2532                  alignment, (size_t) vm_page_size()));
2533 
2534   for (int i = 0; _page_sizes[i] != 0; i++) {
2535     if (is_size_aligned(alignment, _page_sizes[i])) {
2536       return _page_sizes[i];
2537     }
2538   }
2539 
2540   return (size_t) vm_page_size();
2541 }
2542 
2543 int os::Solaris::commit_memory_impl(char* addr, size_t bytes,
2544                                     size_t alignment_hint, bool exec) {
2545   int err = Solaris::commit_memory_impl(addr, bytes, exec);
2546   if (err == 0 && UseLargePages && alignment_hint > 0) {
2547     assert(is_size_aligned(bytes, alignment_hint),
2548            err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, alignment_hint));
2549 
2550     // The syscall memcntl requires an exact page size (see man memcntl for details).
2551     size_t page_size = page_size_for_alignment(alignment_hint);
2552     if (page_size > (size_t) vm_page_size()) {
2553       (void)Solaris::setup_large_pages(addr, bytes, page_size);
2554     }
2555   }
2556   return err;
2557 }
2558 
2559 bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
2560                           bool exec) {
2561   return Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec) == 0;
2562 }
2563 
2564 void os::pd_commit_memory_or_exit(char* addr, size_t bytes,
2565                                   size_t alignment_hint, bool exec,
2566                                   const char* mesg) {
2567   assert(mesg != NULL, "mesg must be specified");
2568   int err = os::Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec);
2569   if (err != 0) {
2570     // the caller wants all commit errors to exit with the specified mesg:
2571     warn_fail_commit_memory(addr, bytes, alignment_hint, exec, err);
2572     vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
2573   }
2574 }
2575 
2576 // Uncommit the pages in a specified region.
2577 void os::pd_free_memory(char* addr, size_t bytes, size_t alignment_hint) {
2578   if (madvise(addr, bytes, MADV_FREE) < 0) {
2579     debug_only(warning("MADV_FREE failed."));
2580     return;
2581   }
2582 }
2583 
2584 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2585   return os::commit_memory(addr, size, !ExecMem);
2586 }
2587 
2588 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2589   return os::uncommit_memory(addr, size);
2590 }
2591 
2592 // Change the page size in a given range.
2593 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2594   assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
2595   assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
2596   if (UseLargePages) {
2597     size_t page_size = Solaris::page_size_for_alignment(alignment_hint);
2598     if (page_size > (size_t) vm_page_size()) {
2599       Solaris::setup_large_pages(addr, bytes, page_size);
2600     }
2601   }
2602 }
2603 
2604 // Tell the OS to make the range local to the first-touching LWP
2605 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2606   assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2607   if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) {
2608     debug_only(warning("MADV_ACCESS_LWP failed."));
2609   }
2610 }
2611 
2612 // Tell the OS that this range would be accessed from different LWPs.
2613 void os::numa_make_global(char *addr, size_t bytes) {
2614   assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2615   if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) {
2616     debug_only(warning("MADV_ACCESS_MANY failed."));
2617   }
2618 }
2619 
2620 // Get the number of the locality groups.
2621 size_t os::numa_get_groups_num() {
2622   size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie());
2623   return n != -1 ? n : 1;
2624 }
2625 
2626 // Get a list of leaf locality groups. A leaf lgroup is group that
2627 // doesn't have any children. Typical leaf group is a CPU or a CPU/memory
2628 // board. An LWP is assigned to one of these groups upon creation.
2629 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2630   if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) {
2631     ids[0] = 0;
2632     return 1;
2633   }
2634   int result_size = 0, top = 1, bottom = 0, cur = 0;
2635   for (int k = 0; k < size; k++) {
2636     int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur],
2637                                    (Solaris::lgrp_id_t*)&ids[top], size - top);
2638     if (r == -1) {
2639       ids[0] = 0;
2640       return 1;
2641     }
2642     if (!r) {
2643       // That's a leaf node.
2644       assert(bottom <= cur, "Sanity check");
2645       // Check if the node has memory
2646       if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
2647                                   NULL, 0, LGRP_RSRC_MEM) > 0) {
2648         ids[bottom++] = ids[cur];
2649       }
2650     }
2651     top += r;
2652     cur++;
2653   }
2654   if (bottom == 0) {
2655     // Handle a situation, when the OS reports no memory available.
2656     // Assume UMA architecture.
2657     ids[0] = 0;
2658     return 1;
2659   }
2660   return bottom;
2661 }
2662 
2663 // Detect the topology change. Typically happens during CPU plugging-unplugging.
2664 bool os::numa_topology_changed() {
2665   int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie());
2666   if (is_stale != -1 && is_stale) {
2667     Solaris::lgrp_fini(Solaris::lgrp_cookie());
2668     Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER);
2669     assert(c != 0, "Failure to initialize LGRP API");
2670     Solaris::set_lgrp_cookie(c);
2671     return true;
2672   }
2673   return false;
2674 }
2675 
2676 // Get the group id of the current LWP.
2677 int os::numa_get_group_id() {
2678   int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID);
2679   if (lgrp_id == -1) {
2680     return 0;
2681   }
2682   const int size = os::numa_get_groups_num();
2683   int *ids = (int*)alloca(size * sizeof(int));
2684 
2685   // Get the ids of all lgroups with memory; r is the count.
2686   int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id,
2687                                   (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM);
2688   if (r <= 0) {
2689     return 0;
2690   }
2691   return ids[os::random() % r];
2692 }
2693 
2694 // Request information about the page.
2695 bool os::get_page_info(char *start, page_info* info) {
2696   const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2697   uint64_t addr = (uintptr_t)start;
2698   uint64_t outdata[2];
2699   uint_t validity = 0;
2700 
2701   if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) {
2702     return false;
2703   }
2704 
2705   info->size = 0;
2706   info->lgrp_id = -1;
2707 
2708   if ((validity & 1) != 0) {
2709     if ((validity & 2) != 0) {
2710       info->lgrp_id = outdata[0];
2711     }
2712     if ((validity & 4) != 0) {
2713       info->size = outdata[1];
2714     }
2715     return true;
2716   }
2717   return false;
2718 }
2719 
2720 // Scan the pages from start to end until a page different than
2721 // the one described in the info parameter is encountered.
2722 char *os::scan_pages(char *start, char* end, page_info* page_expected,
2723                      page_info* page_found) {
2724   const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2725   const size_t types = sizeof(info_types) / sizeof(info_types[0]);
2726   uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT + 1];
2727   uint_t validity[MAX_MEMINFO_CNT];
2728 
2729   size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size);
2730   uint64_t p = (uint64_t)start;
2731   while (p < (uint64_t)end) {
2732     addrs[0] = p;
2733     size_t addrs_count = 1;
2734     while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] + page_size < (uint64_t)end) {
2735       addrs[addrs_count] = addrs[addrs_count - 1] + page_size;
2736       addrs_count++;
2737     }
2738 
2739     if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) {
2740       return NULL;
2741     }
2742 
2743     size_t i = 0;
2744     for (; i < addrs_count; i++) {
2745       if ((validity[i] & 1) != 0) {
2746         if ((validity[i] & 4) != 0) {
2747           if (outdata[types * i + 1] != page_expected->size) {
2748             break;
2749           }
2750         } else if (page_expected->size != 0) {
2751           break;
2752         }
2753 
2754         if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
2755           if (outdata[types * i] != page_expected->lgrp_id) {
2756             break;
2757           }
2758         }
2759       } else {
2760         return NULL;
2761       }
2762     }
2763 
2764     if (i < addrs_count) {
2765       if ((validity[i] & 2) != 0) {
2766         page_found->lgrp_id = outdata[types * i];
2767       } else {
2768         page_found->lgrp_id = -1;
2769       }
2770       if ((validity[i] & 4) != 0) {
2771         page_found->size = outdata[types * i + 1];
2772       } else {
2773         page_found->size = 0;
2774       }
2775       return (char*)addrs[i];
2776     }
2777 
2778     p = addrs[addrs_count - 1] + page_size;
2779   }
2780   return end;
2781 }
2782 
2783 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
2784   size_t size = bytes;
2785   // Map uncommitted pages PROT_NONE so we fail early if we touch an
2786   // uncommitted page. Otherwise, the read/write might succeed if we
2787   // have enough swap space to back the physical page.
2788   return
2789     NULL != Solaris::mmap_chunk(addr, size,
2790                                 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE,
2791                                 PROT_NONE);
2792 }
2793 
2794 char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) {
2795   char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0);
2796 
2797   if (b == MAP_FAILED) {
2798     return NULL;
2799   }
2800   return b;
2801 }
2802 
2803 char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes,
2804                              size_t alignment_hint, bool fixed) {
2805   char* addr = requested_addr;
2806   int flags = MAP_PRIVATE | MAP_NORESERVE;
2807 
2808   assert(!(fixed && (alignment_hint > 0)),
2809          "alignment hint meaningless with fixed mmap");
2810 
2811   if (fixed) {
2812     flags |= MAP_FIXED;
2813   } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
2814     flags |= MAP_ALIGN;
2815     addr = (char*) alignment_hint;
2816   }
2817 
2818   // Map uncommitted pages PROT_NONE so we fail early if we touch an
2819   // uncommitted page. Otherwise, the read/write might succeed if we
2820   // have enough swap space to back the physical page.
2821   return mmap_chunk(addr, bytes, flags, PROT_NONE);
2822 }
2823 
2824 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
2825                             size_t alignment_hint) {
2826   char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint,
2827                                   (requested_addr != NULL));
2828 
2829   guarantee(requested_addr == NULL || requested_addr == addr,
2830             "OS failed to return requested mmap address.");
2831   return addr;
2832 }
2833 
2834 // Reserve memory at an arbitrary address, only if that area is
2835 // available (and not reserved for something else).
2836 
2837 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2838   const int max_tries = 10;
2839   char* base[max_tries];
2840   size_t size[max_tries];
2841 
2842   // Solaris adds a gap between mmap'ed regions.  The size of the gap
2843   // is dependent on the requested size and the MMU.  Our initial gap
2844   // value here is just a guess and will be corrected later.
2845   bool had_top_overlap = false;
2846   bool have_adjusted_gap = false;
2847   size_t gap = 0x400000;
2848 
2849   // Assert only that the size is a multiple of the page size, since
2850   // that's all that mmap requires, and since that's all we really know
2851   // about at this low abstraction level.  If we need higher alignment,
2852   // we can either pass an alignment to this method or verify alignment
2853   // in one of the methods further up the call chain.  See bug 5044738.
2854   assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
2855 
2856   // Since snv_84, Solaris attempts to honor the address hint - see 5003415.
2857   // Give it a try, if the kernel honors the hint we can return immediately.
2858   char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false);
2859 
2860   volatile int err = errno;
2861   if (addr == requested_addr) {
2862     return addr;
2863   } else if (addr != NULL) {
2864     pd_unmap_memory(addr, bytes);
2865   }
2866 
2867   if (PrintMiscellaneous && Verbose) {
2868     char buf[256];
2869     buf[0] = '\0';
2870     if (addr == NULL) {
2871       jio_snprintf(buf, sizeof(buf), ": %s", strerror(err));
2872     }
2873     warning("attempt_reserve_memory_at: couldn't reserve " SIZE_FORMAT " bytes at "
2874             PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT
2875             "%s", bytes, requested_addr, addr, buf);
2876   }
2877 
2878   // Address hint method didn't work.  Fall back to the old method.
2879   // In theory, once SNV becomes our oldest supported platform, this
2880   // code will no longer be needed.
2881   //
2882   // Repeatedly allocate blocks until the block is allocated at the
2883   // right spot. Give up after max_tries.
2884   int i;
2885   for (i = 0; i < max_tries; ++i) {
2886     base[i] = reserve_memory(bytes);
2887 
2888     if (base[i] != NULL) {
2889       // Is this the block we wanted?
2890       if (base[i] == requested_addr) {
2891         size[i] = bytes;
2892         break;
2893       }
2894 
2895       // check that the gap value is right
2896       if (had_top_overlap && !have_adjusted_gap) {
2897         size_t actual_gap = base[i-1] - base[i] - bytes;
2898         if (gap != actual_gap) {
2899           // adjust the gap value and retry the last 2 allocations
2900           assert(i > 0, "gap adjustment code problem");
2901           have_adjusted_gap = true;  // adjust the gap only once, just in case
2902           gap = actual_gap;
2903           if (PrintMiscellaneous && Verbose) {
2904             warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap);
2905           }
2906           unmap_memory(base[i], bytes);
2907           unmap_memory(base[i-1], size[i-1]);
2908           i-=2;
2909           continue;
2910         }
2911       }
2912 
2913       // Does this overlap the block we wanted? Give back the overlapped
2914       // parts and try again.
2915       //
2916       // There is still a bug in this code: if top_overlap == bytes,
2917       // the overlap is offset from requested region by the value of gap.
2918       // In this case giving back the overlapped part will not work,
2919       // because we'll give back the entire block at base[i] and
2920       // therefore the subsequent allocation will not generate a new gap.
2921       // This could be fixed with a new algorithm that used larger
2922       // or variable size chunks to find the requested region -
2923       // but such a change would introduce additional complications.
2924       // It's rare enough that the planets align for this bug,
2925       // so we'll just wait for a fix for 6204603/5003415 which
2926       // will provide a mmap flag to allow us to avoid this business.
2927 
2928       size_t top_overlap = requested_addr + (bytes + gap) - base[i];
2929       if (top_overlap >= 0 && top_overlap < bytes) {
2930         had_top_overlap = true;
2931         unmap_memory(base[i], top_overlap);
2932         base[i] += top_overlap;
2933         size[i] = bytes - top_overlap;
2934       } else {
2935         size_t bottom_overlap = base[i] + bytes - requested_addr;
2936         if (bottom_overlap >= 0 && bottom_overlap < bytes) {
2937           if (PrintMiscellaneous && Verbose && bottom_overlap == 0) {
2938             warning("attempt_reserve_memory_at: possible alignment bug");
2939           }
2940           unmap_memory(requested_addr, bottom_overlap);
2941           size[i] = bytes - bottom_overlap;
2942         } else {
2943           size[i] = bytes;
2944         }
2945       }
2946     }
2947   }
2948 
2949   // Give back the unused reserved pieces.
2950 
2951   for (int j = 0; j < i; ++j) {
2952     if (base[j] != NULL) {
2953       unmap_memory(base[j], size[j]);
2954     }
2955   }
2956 
2957   return (i < max_tries) ? requested_addr : NULL;
2958 }
2959 
2960 bool os::pd_release_memory(char* addr, size_t bytes) {
2961   size_t size = bytes;
2962   return munmap(addr, size) == 0;
2963 }
2964 
2965 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
2966   assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()),
2967          "addr must be page aligned");
2968   int retVal = mprotect(addr, bytes, prot);
2969   return retVal == 0;
2970 }
2971 
2972 // Protect memory (Used to pass readonly pages through
2973 // JNI GetArray<type>Elements with empty arrays.)
2974 // Also, used for serialization page and for compressed oops null pointer
2975 // checking.
2976 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
2977                         bool is_committed) {
2978   unsigned int p = 0;
2979   switch (prot) {
2980   case MEM_PROT_NONE: p = PROT_NONE; break;
2981   case MEM_PROT_READ: p = PROT_READ; break;
2982   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
2983   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2984   default:
2985     ShouldNotReachHere();
2986   }
2987   // is_committed is unused.
2988   return solaris_mprotect(addr, bytes, p);
2989 }
2990 
2991 // guard_memory and unguard_memory only happens within stack guard pages.
2992 // Since ISM pertains only to the heap, guard and unguard memory should not
2993 /// happen with an ISM region.
2994 bool os::guard_memory(char* addr, size_t bytes) {
2995   return solaris_mprotect(addr, bytes, PROT_NONE);
2996 }
2997 
2998 bool os::unguard_memory(char* addr, size_t bytes) {
2999   return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE);
3000 }
3001 
3002 // Large page support
3003 static size_t _large_page_size = 0;
3004 
3005 // Insertion sort for small arrays (descending order).
3006 static void insertion_sort_descending(size_t* array, int len) {
3007   for (int i = 0; i < len; i++) {
3008     size_t val = array[i];
3009     for (size_t key = i; key > 0 && array[key - 1] < val; --key) {
3010       size_t tmp = array[key];
3011       array[key] = array[key - 1];
3012       array[key - 1] = tmp;
3013     }
3014   }
3015 }
3016 
3017 bool os::Solaris::mpss_sanity_check(bool warn, size_t* page_size) {
3018   const unsigned int usable_count = VM_Version::page_size_count();
3019   if (usable_count == 1) {
3020     return false;
3021   }
3022 
3023   // Find the right getpagesizes interface.  When solaris 11 is the minimum
3024   // build platform, getpagesizes() (without the '2') can be called directly.
3025   typedef int (*gps_t)(size_t[], int);
3026   gps_t gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes2"));
3027   if (gps_func == NULL) {
3028     gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes"));
3029     if (gps_func == NULL) {
3030       if (warn) {
3031         warning("MPSS is not supported by the operating system.");
3032       }
3033       return false;
3034     }
3035   }
3036 
3037   // Fill the array of page sizes.
3038   int n = (*gps_func)(_page_sizes, page_sizes_max);
3039   assert(n > 0, "Solaris bug?");
3040 
3041   if (n == page_sizes_max) {
3042     // Add a sentinel value (necessary only if the array was completely filled
3043     // since it is static (zeroed at initialization)).
3044     _page_sizes[--n] = 0;
3045     DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");)
3046   }
3047   assert(_page_sizes[n] == 0, "missing sentinel");
3048   trace_page_sizes("available page sizes", _page_sizes, n);
3049 
3050   if (n == 1) return false;     // Only one page size available.
3051 
3052   // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and
3053   // select up to usable_count elements.  First sort the array, find the first
3054   // acceptable value, then copy the usable sizes to the top of the array and
3055   // trim the rest.  Make sure to include the default page size :-).
3056   //
3057   // A better policy could get rid of the 4M limit by taking the sizes of the
3058   // important VM memory regions (java heap and possibly the code cache) into
3059   // account.
3060   insertion_sort_descending(_page_sizes, n);
3061   const size_t size_limit =
3062     FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
3063   int beg;
3064   for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */;
3065   const int end = MIN2((int)usable_count, n) - 1;
3066   for (int cur = 0; cur < end; ++cur, ++beg) {
3067     _page_sizes[cur] = _page_sizes[beg];
3068   }
3069   _page_sizes[end] = vm_page_size();
3070   _page_sizes[end + 1] = 0;
3071 
3072   if (_page_sizes[end] > _page_sizes[end - 1]) {
3073     // Default page size is not the smallest; sort again.
3074     insertion_sort_descending(_page_sizes, end + 1);
3075   }
3076   *page_size = _page_sizes[0];
3077 
3078   trace_page_sizes("usable page sizes", _page_sizes, end + 1);
3079   return true;
3080 }
3081 
3082 void os::large_page_init() {
3083   if (UseLargePages) {
3084     // print a warning if any large page related flag is specified on command line
3085     bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages)        ||
3086                            !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3087 
3088     UseLargePages = Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
3089   }
3090 }
3091 
3092 bool os::Solaris::is_valid_page_size(size_t bytes) {
3093   for (int i = 0; _page_sizes[i] != 0; i++) {
3094     if (_page_sizes[i] == bytes) {
3095       return true;
3096     }
3097   }
3098   return false;
3099 }
3100 
3101 bool os::Solaris::setup_large_pages(caddr_t start, size_t bytes, size_t align) {
3102   assert(is_valid_page_size(align), err_msg(SIZE_FORMAT " is not a valid page size", align));
3103   assert(is_ptr_aligned((void*) start, align),
3104          err_msg(PTR_FORMAT " is not aligned to " SIZE_FORMAT, p2i((void*) start), align));
3105   assert(is_size_aligned(bytes, align),
3106          err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, align));
3107 
3108   // Signal to OS that we want large pages for addresses
3109   // from addr, addr + bytes
3110   struct memcntl_mha mpss_struct;
3111   mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
3112   mpss_struct.mha_pagesize = align;
3113   mpss_struct.mha_flags = 0;
3114   // Upon successful completion, memcntl() returns 0
3115   if (memcntl(start, bytes, MC_HAT_ADVISE, (caddr_t) &mpss_struct, 0, 0)) {
3116     debug_only(warning("Attempt to use MPSS failed."));
3117     return false;
3118   }
3119   return true;
3120 }
3121 
3122 char* os::reserve_memory_special(size_t size, size_t alignment, char* addr, bool exec) {
3123   fatal("os::reserve_memory_special should not be called on Solaris.");
3124   return NULL;
3125 }
3126 
3127 bool os::release_memory_special(char* base, size_t bytes) {
3128   fatal("os::release_memory_special should not be called on Solaris.");
3129   return false;
3130 }
3131 
3132 size_t os::large_page_size() {
3133   return _large_page_size;
3134 }
3135 
3136 // MPSS allows application to commit large page memory on demand; with ISM
3137 // the entire memory region must be allocated as shared memory.
3138 bool os::can_commit_large_page_memory() {
3139   return true;
3140 }
3141 
3142 bool os::can_execute_large_page_memory() {
3143   return true;
3144 }
3145 
3146 // Read calls from inside the vm need to perform state transitions
3147 size_t os::read(int fd, void *buf, unsigned int nBytes) {
3148   size_t res;
3149   JavaThread* thread = (JavaThread*)Thread::current();
3150   assert(thread->thread_state() == _thread_in_vm, "Assumed _thread_in_vm");
3151   ThreadBlockInVM tbiv(thread);
3152   RESTARTABLE(::read(fd, buf, (size_t) nBytes), res);
3153   return res;
3154 }
3155 
3156 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
3157   size_t res;
3158   JavaThread* thread = (JavaThread*)Thread::current();
3159   assert(thread->thread_state() == _thread_in_vm, "Assumed _thread_in_vm");
3160   ThreadBlockInVM tbiv(thread);
3161   RESTARTABLE(::pread(fd, buf, (size_t) nBytes, offset), res);
3162   return res;
3163 }
3164 
3165 size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) {
3166   size_t res;
3167   assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
3168          "Assumed _thread_in_native");
3169   RESTARTABLE(::read(fd, buf, (size_t) nBytes), res);
3170   return res;
3171 }
3172 
3173 void os::naked_short_sleep(jlong ms) {
3174   assert(ms < 1000, "Un-interruptable sleep, short time use only");
3175 
3176   // usleep is deprecated and removed from POSIX, in favour of nanosleep, but
3177   // Solaris requires -lrt for this.
3178   usleep((ms * 1000));
3179 
3180   return;
3181 }
3182 
3183 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3184 void os::infinite_sleep() {
3185   while (true) {    // sleep forever ...
3186     ::sleep(100);   // ... 100 seconds at a time
3187   }
3188 }
3189 
3190 // Used to convert frequent JVM_Yield() to nops
3191 bool os::dont_yield() {
3192   if (DontYieldALot) {
3193     static hrtime_t last_time = 0;
3194     hrtime_t diff = getTimeNanos() - last_time;
3195 
3196     if (diff < DontYieldALotInterval * 1000000) {
3197       return true;
3198     }
3199 
3200     last_time += diff;
3201 
3202     return false;
3203   } else {
3204     return false;
3205   }
3206 }
3207 
3208 // Note that yield semantics are defined by the scheduling class to which
3209 // the thread currently belongs.  Typically, yield will _not yield to
3210 // other equal or higher priority threads that reside on the dispatch queues
3211 // of other CPUs.
3212 
3213 void os::naked_yield() {
3214   thr_yield();
3215 }
3216 
3217 // Interface for setting lwp priorities.  If we are using T2 libthread,
3218 // which forces the use of BoundThreads or we manually set UseBoundThreads,
3219 // all of our threads will be assigned to real lwp's.  Using the thr_setprio
3220 // function is meaningless in this mode so we must adjust the real lwp's priority
3221 // The routines below implement the getting and setting of lwp priorities.
3222 //
3223 // Note: T2 is now the only supported libthread. UseBoundThreads flag is
3224 //       being deprecated and all threads are now BoundThreads
3225 //
3226 // Note: There are three priority scales used on Solaris.  Java priotities
3227 //       which range from 1 to 10, libthread "thr_setprio" scale which range
3228 //       from 0 to 127, and the current scheduling class of the process we
3229 //       are running in.  This is typically from -60 to +60.
3230 //       The setting of the lwp priorities in done after a call to thr_setprio
3231 //       so Java priorities are mapped to libthread priorities and we map from
3232 //       the latter to lwp priorities.  We don't keep priorities stored in
3233 //       Java priorities since some of our worker threads want to set priorities
3234 //       higher than all Java threads.
3235 //
3236 // For related information:
3237 // (1)  man -s 2 priocntl
3238 // (2)  man -s 4 priocntl
3239 // (3)  man dispadmin
3240 // =    librt.so
3241 // =    libthread/common/rtsched.c - thrp_setlwpprio().
3242 // =    ps -cL <pid> ... to validate priority.
3243 // =    sched_get_priority_min and _max
3244 //              pthread_create
3245 //              sched_setparam
3246 //              pthread_setschedparam
3247 //
3248 // Assumptions:
3249 // +    We assume that all threads in the process belong to the same
3250 //              scheduling class.   IE. an homogenous process.
3251 // +    Must be root or in IA group to change change "interactive" attribute.
3252 //              Priocntl() will fail silently.  The only indication of failure is when
3253 //              we read-back the value and notice that it hasn't changed.
3254 // +    Interactive threads enter the runq at the head, non-interactive at the tail.
3255 // +    For RT, change timeslice as well.  Invariant:
3256 //              constant "priority integral"
3257 //              Konst == TimeSlice * (60-Priority)
3258 //              Given a priority, compute appropriate timeslice.
3259 // +    Higher numerical values have higher priority.
3260 
3261 // sched class attributes
3262 typedef struct {
3263   int   schedPolicy;              // classID
3264   int   maxPrio;
3265   int   minPrio;
3266 } SchedInfo;
3267 
3268 
3269 static SchedInfo tsLimits, iaLimits, rtLimits, fxLimits;
3270 
3271 #ifdef ASSERT
3272 static int  ReadBackValidate = 1;
3273 #endif
3274 static int  myClass     = 0;
3275 static int  myMin       = 0;
3276 static int  myMax       = 0;
3277 static int  myCur       = 0;
3278 static bool priocntl_enable = false;
3279 
3280 static const int criticalPrio = 60; // FX/60 is critical thread class/priority on T4
3281 static int java_MaxPriority_to_os_priority = 0; // Saved mapping
3282 
3283 
3284 // lwp_priocntl_init
3285 //
3286 // Try to determine the priority scale for our process.
3287 //
3288 // Return errno or 0 if OK.
3289 //
3290 static int lwp_priocntl_init() {
3291   int rslt;
3292   pcinfo_t ClassInfo;
3293   pcparms_t ParmInfo;
3294   int i;
3295 
3296   if (!UseThreadPriorities) return 0;
3297 
3298   // If ThreadPriorityPolicy is 1, switch tables
3299   if (ThreadPriorityPolicy == 1) {
3300     for (i = 0; i < CriticalPriority+1; i++)
3301       os::java_to_os_priority[i] = prio_policy1[i];
3302   }
3303   if (UseCriticalJavaThreadPriority) {
3304     // MaxPriority always maps to the FX scheduling class and criticalPrio.
3305     // See set_native_priority() and set_lwp_class_and_priority().
3306     // Save original MaxPriority mapping in case attempt to
3307     // use critical priority fails.
3308     java_MaxPriority_to_os_priority = os::java_to_os_priority[MaxPriority];
3309     // Set negative to distinguish from other priorities
3310     os::java_to_os_priority[MaxPriority] = -criticalPrio;
3311   }
3312 
3313   // Get IDs for a set of well-known scheduling classes.
3314   // TODO-FIXME: GETCLINFO returns the current # of classes in the
3315   // the system.  We should have a loop that iterates over the
3316   // classID values, which are known to be "small" integers.
3317 
3318   strcpy(ClassInfo.pc_clname, "TS");
3319   ClassInfo.pc_cid = -1;
3320   rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3321   if (rslt < 0) return errno;
3322   assert(ClassInfo.pc_cid != -1, "cid for TS class is -1");
3323   tsLimits.schedPolicy = ClassInfo.pc_cid;
3324   tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri;
3325   tsLimits.minPrio = -tsLimits.maxPrio;
3326 
3327   strcpy(ClassInfo.pc_clname, "IA");
3328   ClassInfo.pc_cid = -1;
3329   rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3330   if (rslt < 0) return errno;
3331   assert(ClassInfo.pc_cid != -1, "cid for IA class is -1");
3332   iaLimits.schedPolicy = ClassInfo.pc_cid;
3333   iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri;
3334   iaLimits.minPrio = -iaLimits.maxPrio;
3335 
3336   strcpy(ClassInfo.pc_clname, "RT");
3337   ClassInfo.pc_cid = -1;
3338   rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3339   if (rslt < 0) return errno;
3340   assert(ClassInfo.pc_cid != -1, "cid for RT class is -1");
3341   rtLimits.schedPolicy = ClassInfo.pc_cid;
3342   rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri;
3343   rtLimits.minPrio = 0;
3344 
3345   strcpy(ClassInfo.pc_clname, "FX");
3346   ClassInfo.pc_cid = -1;
3347   rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3348   if (rslt < 0) return errno;
3349   assert(ClassInfo.pc_cid != -1, "cid for FX class is -1");
3350   fxLimits.schedPolicy = ClassInfo.pc_cid;
3351   fxLimits.maxPrio = ((fxinfo_t*)ClassInfo.pc_clinfo)->fx_maxupri;
3352   fxLimits.minPrio = 0;
3353 
3354   // Query our "current" scheduling class.
3355   // This will normally be IA, TS or, rarely, FX or RT.
3356   memset(&ParmInfo, 0, sizeof(ParmInfo));
3357   ParmInfo.pc_cid = PC_CLNULL;
3358   rslt = priocntl(P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
3359   if (rslt < 0) return errno;
3360   myClass = ParmInfo.pc_cid;
3361 
3362   // We now know our scheduling classId, get specific information
3363   // about the class.
3364   ClassInfo.pc_cid = myClass;
3365   ClassInfo.pc_clname[0] = 0;
3366   rslt = priocntl((idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo);
3367   if (rslt < 0) return errno;
3368 
3369   if (ThreadPriorityVerbose) {
3370     tty->print_cr("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname);
3371   }
3372 
3373   memset(&ParmInfo, 0, sizeof(pcparms_t));
3374   ParmInfo.pc_cid = PC_CLNULL;
3375   rslt = priocntl(P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
3376   if (rslt < 0) return errno;
3377 
3378   if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3379     myMin = rtLimits.minPrio;
3380     myMax = rtLimits.maxPrio;
3381   } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3382     iaparms_t *iaInfo  = (iaparms_t*)ParmInfo.pc_clparms;
3383     myMin = iaLimits.minPrio;
3384     myMax = iaLimits.maxPrio;
3385     myMax = MIN2(myMax, (int)iaInfo->ia_uprilim);       // clamp - restrict
3386   } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3387     tsparms_t *tsInfo  = (tsparms_t*)ParmInfo.pc_clparms;
3388     myMin = tsLimits.minPrio;
3389     myMax = tsLimits.maxPrio;
3390     myMax = MIN2(myMax, (int)tsInfo->ts_uprilim);       // clamp - restrict
3391   } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) {
3392     fxparms_t *fxInfo = (fxparms_t*)ParmInfo.pc_clparms;
3393     myMin = fxLimits.minPrio;
3394     myMax = fxLimits.maxPrio;
3395     myMax = MIN2(myMax, (int)fxInfo->fx_uprilim);       // clamp - restrict
3396   } else {
3397     // No clue - punt
3398     if (ThreadPriorityVerbose) {
3399       tty->print_cr("Unknown scheduling class: %s ... \n",
3400                     ClassInfo.pc_clname);
3401     }
3402     return EINVAL;      // no clue, punt
3403   }
3404 
3405   if (ThreadPriorityVerbose) {
3406     tty->print_cr("Thread priority Range: [%d..%d]\n", myMin, myMax);
3407   }
3408 
3409   priocntl_enable = true;  // Enable changing priorities
3410   return 0;
3411 }
3412 
3413 #define IAPRI(x)        ((iaparms_t *)((x).pc_clparms))
3414 #define RTPRI(x)        ((rtparms_t *)((x).pc_clparms))
3415 #define TSPRI(x)        ((tsparms_t *)((x).pc_clparms))
3416 #define FXPRI(x)        ((fxparms_t *)((x).pc_clparms))
3417 
3418 
3419 // scale_to_lwp_priority
3420 //
3421 // Convert from the libthread "thr_setprio" scale to our current
3422 // lwp scheduling class scale.
3423 //
3424 static int scale_to_lwp_priority(int rMin, int rMax, int x) {
3425   int v;
3426 
3427   if (x == 127) return rMax;            // avoid round-down
3428   v = (((x*(rMax-rMin)))/128)+rMin;
3429   return v;
3430 }
3431 
3432 
3433 // set_lwp_class_and_priority
3434 int set_lwp_class_and_priority(int ThreadID, int lwpid,
3435                                int newPrio, int new_class, bool scale) {
3436   int rslt;
3437   int Actual, Expected, prv;
3438   pcparms_t ParmInfo;                   // for GET-SET
3439 #ifdef ASSERT
3440   pcparms_t ReadBack;                   // for readback
3441 #endif
3442 
3443   // Set priority via PC_GETPARMS, update, PC_SETPARMS
3444   // Query current values.
3445   // TODO: accelerate this by eliminating the PC_GETPARMS call.
3446   // Cache "pcparms_t" in global ParmCache.
3447   // TODO: elide set-to-same-value
3448 
3449   // If something went wrong on init, don't change priorities.
3450   if (!priocntl_enable) {
3451     if (ThreadPriorityVerbose) {
3452       tty->print_cr("Trying to set priority but init failed, ignoring");
3453     }
3454     return EINVAL;
3455   }
3456 
3457   // If lwp hasn't started yet, just return
3458   // the _start routine will call us again.
3459   if (lwpid <= 0) {
3460     if (ThreadPriorityVerbose) {
3461       tty->print_cr("deferring the set_lwp_class_and_priority of thread "
3462                     INTPTR_FORMAT " to %d, lwpid not set",
3463                     ThreadID, newPrio);
3464     }
3465     return 0;
3466   }
3467 
3468   if (ThreadPriorityVerbose) {
3469     tty->print_cr ("set_lwp_class_and_priority("
3470                    INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ",
3471                    ThreadID, lwpid, newPrio);
3472   }
3473 
3474   memset(&ParmInfo, 0, sizeof(pcparms_t));
3475   ParmInfo.pc_cid = PC_CLNULL;
3476   rslt = priocntl(P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo);
3477   if (rslt < 0) return errno;
3478 
3479   int cur_class = ParmInfo.pc_cid;
3480   ParmInfo.pc_cid = (id_t)new_class;
3481 
3482   if (new_class == rtLimits.schedPolicy) {
3483     rtparms_t *rtInfo  = (rtparms_t*)ParmInfo.pc_clparms;
3484     rtInfo->rt_pri     = scale ? scale_to_lwp_priority(rtLimits.minPrio,
3485                                                        rtLimits.maxPrio, newPrio)
3486                                : newPrio;
3487     rtInfo->rt_tqsecs  = RT_NOCHANGE;
3488     rtInfo->rt_tqnsecs = RT_NOCHANGE;
3489     if (ThreadPriorityVerbose) {
3490       tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri);
3491     }
3492   } else if (new_class == iaLimits.schedPolicy) {
3493     iaparms_t* iaInfo  = (iaparms_t*)ParmInfo.pc_clparms;
3494     int maxClamped     = MIN2(iaLimits.maxPrio,
3495                               cur_class == new_class
3496                               ? (int)iaInfo->ia_uprilim : iaLimits.maxPrio);
3497     iaInfo->ia_upri    = scale ? scale_to_lwp_priority(iaLimits.minPrio,
3498                                                        maxClamped, newPrio)
3499                                : newPrio;
3500     iaInfo->ia_uprilim = cur_class == new_class
3501                            ? IA_NOCHANGE : (pri_t)iaLimits.maxPrio;
3502     iaInfo->ia_mode    = IA_NOCHANGE;
3503     if (ThreadPriorityVerbose) {
3504       tty->print_cr("IA: [%d...%d] %d->%d\n",
3505                     iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri);
3506     }
3507   } else if (new_class == tsLimits.schedPolicy) {
3508     tsparms_t* tsInfo  = (tsparms_t*)ParmInfo.pc_clparms;
3509     int maxClamped     = MIN2(tsLimits.maxPrio,
3510                               cur_class == new_class
3511                               ? (int)tsInfo->ts_uprilim : tsLimits.maxPrio);
3512     tsInfo->ts_upri    = scale ? scale_to_lwp_priority(tsLimits.minPrio,
3513                                                        maxClamped, newPrio)
3514                                : newPrio;
3515     tsInfo->ts_uprilim = cur_class == new_class
3516                            ? TS_NOCHANGE : (pri_t)tsLimits.maxPrio;
3517     if (ThreadPriorityVerbose) {
3518       tty->print_cr("TS: [%d...%d] %d->%d\n",
3519                     tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri);
3520     }
3521   } else if (new_class == fxLimits.schedPolicy) {
3522     fxparms_t* fxInfo  = (fxparms_t*)ParmInfo.pc_clparms;
3523     int maxClamped     = MIN2(fxLimits.maxPrio,
3524                               cur_class == new_class
3525                               ? (int)fxInfo->fx_uprilim : fxLimits.maxPrio);
3526     fxInfo->fx_upri    = scale ? scale_to_lwp_priority(fxLimits.minPrio,
3527                                                        maxClamped, newPrio)
3528                                : newPrio;
3529     fxInfo->fx_uprilim = cur_class == new_class
3530                            ? FX_NOCHANGE : (pri_t)fxLimits.maxPrio;
3531     fxInfo->fx_tqsecs  = FX_NOCHANGE;
3532     fxInfo->fx_tqnsecs = FX_NOCHANGE;
3533     if (ThreadPriorityVerbose) {
3534       tty->print_cr("FX: [%d...%d] %d->%d\n",
3535                     fxLimits.minPrio, maxClamped, newPrio, fxInfo->fx_upri);
3536     }
3537   } else {
3538     if (ThreadPriorityVerbose) {
3539       tty->print_cr("Unknown new scheduling class %d\n", new_class);
3540     }
3541     return EINVAL;    // no clue, punt
3542   }
3543 
3544   rslt = priocntl(P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo);
3545   if (ThreadPriorityVerbose && rslt) {
3546     tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno);
3547   }
3548   if (rslt < 0) return errno;
3549 
3550 #ifdef ASSERT
3551   // Sanity check: read back what we just attempted to set.
3552   // In theory it could have changed in the interim ...
3553   //
3554   // The priocntl system call is tricky.
3555   // Sometimes it'll validate the priority value argument and
3556   // return EINVAL if unhappy.  At other times it fails silently.
3557   // Readbacks are prudent.
3558 
3559   if (!ReadBackValidate) return 0;
3560 
3561   memset(&ReadBack, 0, sizeof(pcparms_t));
3562   ReadBack.pc_cid = PC_CLNULL;
3563   rslt = priocntl(P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack);
3564   assert(rslt >= 0, "priocntl failed");
3565   Actual = Expected = 0xBAD;
3566   assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match");
3567   if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3568     Actual   = RTPRI(ReadBack)->rt_pri;
3569     Expected = RTPRI(ParmInfo)->rt_pri;
3570   } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3571     Actual   = IAPRI(ReadBack)->ia_upri;
3572     Expected = IAPRI(ParmInfo)->ia_upri;
3573   } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3574     Actual   = TSPRI(ReadBack)->ts_upri;
3575     Expected = TSPRI(ParmInfo)->ts_upri;
3576   } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) {
3577     Actual   = FXPRI(ReadBack)->fx_upri;
3578     Expected = FXPRI(ParmInfo)->fx_upri;
3579   } else {
3580     if (ThreadPriorityVerbose) {
3581       tty->print_cr("set_lwp_class_and_priority: unexpected class in readback: %d\n",
3582                     ParmInfo.pc_cid);
3583     }
3584   }
3585 
3586   if (Actual != Expected) {
3587     if (ThreadPriorityVerbose) {
3588       tty->print_cr ("set_lwp_class_and_priority(%d %d) Class=%d: actual=%d vs expected=%d\n",
3589                      lwpid, newPrio, ReadBack.pc_cid, Actual, Expected);
3590     }
3591   }
3592 #endif
3593 
3594   return 0;
3595 }
3596 
3597 // Solaris only gives access to 128 real priorities at a time,
3598 // so we expand Java's ten to fill this range.  This would be better
3599 // if we dynamically adjusted relative priorities.
3600 //
3601 // The ThreadPriorityPolicy option allows us to select 2 different
3602 // priority scales.
3603 //
3604 // ThreadPriorityPolicy=0
3605 // Since the Solaris' default priority is MaximumPriority, we do not
3606 // set a priority lower than Max unless a priority lower than
3607 // NormPriority is requested.
3608 //
3609 // ThreadPriorityPolicy=1
3610 // This mode causes the priority table to get filled with
3611 // linear values.  NormPriority get's mapped to 50% of the
3612 // Maximum priority an so on.  This will cause VM threads
3613 // to get unfair treatment against other Solaris processes
3614 // which do not explicitly alter their thread priorities.
3615 
3616 int os::java_to_os_priority[CriticalPriority + 1] = {
3617   -99999,         // 0 Entry should never be used
3618 
3619   0,              // 1 MinPriority
3620   32,             // 2
3621   64,             // 3
3622 
3623   96,             // 4
3624   127,            // 5 NormPriority
3625   127,            // 6
3626 
3627   127,            // 7
3628   127,            // 8
3629   127,            // 9 NearMaxPriority
3630 
3631   127,            // 10 MaxPriority
3632 
3633   -criticalPrio   // 11 CriticalPriority
3634 };
3635 
3636 OSReturn os::set_native_priority(Thread* thread, int newpri) {
3637   OSThread* osthread = thread->osthread();
3638 
3639   // Save requested priority in case the thread hasn't been started
3640   osthread->set_native_priority(newpri);
3641 
3642   // Check for critical priority request
3643   bool fxcritical = false;
3644   if (newpri == -criticalPrio) {
3645     fxcritical = true;
3646     newpri = criticalPrio;
3647   }
3648 
3649   assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping");
3650   if (!UseThreadPriorities) return OS_OK;
3651 
3652   int status = 0;
3653 
3654   if (!fxcritical) {
3655     // Use thr_setprio only if we have a priority that thr_setprio understands
3656     status = thr_setprio(thread->osthread()->thread_id(), newpri);
3657   }
3658 
3659   int lwp_status =
3660           set_lwp_class_and_priority(osthread->thread_id(),
3661                                      osthread->lwp_id(),
3662                                      newpri,
3663                                      fxcritical ? fxLimits.schedPolicy : myClass,
3664                                      !fxcritical);
3665   if (lwp_status != 0 && fxcritical) {
3666     // Try again, this time without changing the scheduling class
3667     newpri = java_MaxPriority_to_os_priority;
3668     lwp_status = set_lwp_class_and_priority(osthread->thread_id(),
3669                                             osthread->lwp_id(),
3670                                             newpri, myClass, false);
3671   }
3672   status |= lwp_status;
3673   return (status == 0) ? OS_OK : OS_ERR;
3674 }
3675 
3676 
3677 OSReturn os::get_native_priority(const Thread* const thread,
3678                                  int *priority_ptr) {
3679   int p;
3680   if (!UseThreadPriorities) {
3681     *priority_ptr = NormalPriority;
3682     return OS_OK;
3683   }
3684   int status = thr_getprio(thread->osthread()->thread_id(), &p);
3685   if (status != 0) {
3686     return OS_ERR;
3687   }
3688   *priority_ptr = p;
3689   return OS_OK;
3690 }
3691 
3692 
3693 // Hint to the underlying OS that a task switch would not be good.
3694 // Void return because it's a hint and can fail.
3695 void os::hint_no_preempt() {
3696   schedctl_start(schedctl_init());
3697 }
3698 
3699 static void resume_clear_context(OSThread *osthread) {
3700   osthread->set_ucontext(NULL);
3701 }
3702 
3703 static void suspend_save_context(OSThread *osthread, ucontext_t* context) {
3704   osthread->set_ucontext(context);
3705 }
3706 
3707 static PosixSemaphore sr_semaphore;
3708 
3709 void os::Solaris::SR_handler(Thread* thread, ucontext_t* uc) {
3710   // Save and restore errno to avoid confusing native code with EINTR
3711   // after sigsuspend.
3712   int old_errno = errno;
3713 
3714   OSThread* osthread = thread->osthread();
3715   assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
3716 
3717   os::SuspendResume::State current = osthread->sr.state();
3718   if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
3719     suspend_save_context(osthread, uc);
3720 
3721     // attempt to switch the state, we assume we had a SUSPEND_REQUEST
3722     os::SuspendResume::State state = osthread->sr.suspended();
3723     if (state == os::SuspendResume::SR_SUSPENDED) {
3724       sigset_t suspend_set;  // signals for sigsuspend()
3725 
3726       // get current set of blocked signals and unblock resume signal
3727       thr_sigsetmask(SIG_BLOCK, NULL, &suspend_set);
3728       sigdelset(&suspend_set, os::Solaris::SIGasync());
3729 
3730       sr_semaphore.signal();
3731       // wait here until we are resumed
3732       while (1) {
3733         sigsuspend(&suspend_set);
3734 
3735         os::SuspendResume::State result = osthread->sr.running();
3736         if (result == os::SuspendResume::SR_RUNNING) {
3737           sr_semaphore.signal();
3738           break;
3739         }
3740       }
3741 
3742     } else if (state == os::SuspendResume::SR_RUNNING) {
3743       // request was cancelled, continue
3744     } else {
3745       ShouldNotReachHere();
3746     }
3747 
3748     resume_clear_context(osthread);
3749   } else if (current == os::SuspendResume::SR_RUNNING) {
3750     // request was cancelled, continue
3751   } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
3752     // ignore
3753   } else {
3754     // ignore
3755   }
3756 
3757   errno = old_errno;
3758 }
3759 
3760 void os::print_statistics() {
3761 }
3762 
3763 int os::message_box(const char* title, const char* message) {
3764   int i;
3765   fdStream err(defaultStream::error_fd());
3766   for (i = 0; i < 78; i++) err.print_raw("=");
3767   err.cr();
3768   err.print_raw_cr(title);
3769   for (i = 0; i < 78; i++) err.print_raw("-");
3770   err.cr();
3771   err.print_raw_cr(message);
3772   for (i = 0; i < 78; i++) err.print_raw("=");
3773   err.cr();
3774 
3775   char buf[16];
3776   // Prevent process from exiting upon "read error" without consuming all CPU
3777   while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
3778 
3779   return buf[0] == 'y' || buf[0] == 'Y';
3780 }
3781 
3782 static int sr_notify(OSThread* osthread) {
3783   int status = thr_kill(osthread->thread_id(), os::Solaris::SIGasync());
3784   assert_status(status == 0, status, "thr_kill");
3785   return status;
3786 }
3787 
3788 // "Randomly" selected value for how long we want to spin
3789 // before bailing out on suspending a thread, also how often
3790 // we send a signal to a thread we want to resume
3791 static const int RANDOMLY_LARGE_INTEGER = 1000000;
3792 static const int RANDOMLY_LARGE_INTEGER2 = 100;
3793 
3794 static bool do_suspend(OSThread* osthread) {
3795   assert(osthread->sr.is_running(), "thread should be running");
3796   assert(!sr_semaphore.trywait(), "semaphore has invalid state");
3797 
3798   // mark as suspended and send signal
3799   if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
3800     // failed to switch, state wasn't running?
3801     ShouldNotReachHere();
3802     return false;
3803   }
3804 
3805   if (sr_notify(osthread) != 0) {
3806     ShouldNotReachHere();
3807   }
3808 
3809   // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
3810   while (true) {
3811     if (sr_semaphore.timedwait(0, 2000 * NANOSECS_PER_MILLISEC)) {
3812       break;
3813     } else {
3814       // timeout
3815       os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
3816       if (cancelled == os::SuspendResume::SR_RUNNING) {
3817         return false;
3818       } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
3819         // make sure that we consume the signal on the semaphore as well
3820         sr_semaphore.wait();
3821         break;
3822       } else {
3823         ShouldNotReachHere();
3824         return false;
3825       }
3826     }
3827   }
3828 
3829   guarantee(osthread->sr.is_suspended(), "Must be suspended");
3830   return true;
3831 }
3832 
3833 static void do_resume(OSThread* osthread) {
3834   assert(osthread->sr.is_suspended(), "thread should be suspended");
3835   assert(!sr_semaphore.trywait(), "invalid semaphore state");
3836 
3837   if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
3838     // failed to switch to WAKEUP_REQUEST
3839     ShouldNotReachHere();
3840     return;
3841   }
3842 
3843   while (true) {
3844     if (sr_notify(osthread) == 0) {
3845       if (sr_semaphore.timedwait(0, 2 * NANOSECS_PER_MILLISEC)) {
3846         if (osthread->sr.is_running()) {
3847           return;
3848         }
3849       }
3850     } else {
3851       ShouldNotReachHere();
3852     }
3853   }
3854 
3855   guarantee(osthread->sr.is_running(), "Must be running!");
3856 }
3857 
3858 void os::SuspendedThreadTask::internal_do_task() {
3859   if (do_suspend(_thread->osthread())) {
3860     SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
3861     do_task(context);
3862     do_resume(_thread->osthread());
3863   }
3864 }
3865 
3866 class PcFetcher : public os::SuspendedThreadTask {
3867  public:
3868   PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
3869   ExtendedPC result();
3870  protected:
3871   void do_task(const os::SuspendedThreadTaskContext& context);
3872  private:
3873   ExtendedPC _epc;
3874 };
3875 
3876 ExtendedPC PcFetcher::result() {
3877   guarantee(is_done(), "task is not done yet.");
3878   return _epc;
3879 }
3880 
3881 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
3882   Thread* thread = context.thread();
3883   OSThread* osthread = thread->osthread();
3884   if (osthread->ucontext() != NULL) {
3885     _epc = os::Solaris::ucontext_get_pc((ucontext_t *) context.ucontext());
3886   } else {
3887     // NULL context is unexpected, double-check this is the VMThread
3888     guarantee(thread->is_VM_thread(), "can only be called for VMThread");
3889   }
3890 }
3891 
3892 // A lightweight implementation that does not suspend the target thread and
3893 // thus returns only a hint. Used for profiling only!
3894 ExtendedPC os::get_thread_pc(Thread* thread) {
3895   // Make sure that it is called by the watcher and the Threads lock is owned.
3896   assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock");
3897   // For now, is only used to profile the VM Thread
3898   assert(thread->is_VM_thread(), "Can only be called for VMThread");
3899   PcFetcher fetcher(thread);
3900   fetcher.run();
3901   return fetcher.result();
3902 }
3903 
3904 
3905 // This does not do anything on Solaris. This is basically a hook for being
3906 // able to use structured exception handling (thread-local exception filters) on, e.g., Win32.
3907 void os::os_exception_wrapper(java_call_t f, JavaValue* value,
3908                               methodHandle* method, JavaCallArguments* args,
3909                               Thread* thread) {
3910   f(value, method, args, thread);
3911 }
3912 
3913 // This routine may be used by user applications as a "hook" to catch signals.
3914 // The user-defined signal handler must pass unrecognized signals to this
3915 // routine, and if it returns true (non-zero), then the signal handler must
3916 // return immediately.  If the flag "abort_if_unrecognized" is true, then this
3917 // routine will never retun false (zero), but instead will execute a VM panic
3918 // routine kill the process.
3919 //
3920 // If this routine returns false, it is OK to call it again.  This allows
3921 // the user-defined signal handler to perform checks either before or after
3922 // the VM performs its own checks.  Naturally, the user code would be making
3923 // a serious error if it tried to handle an exception (such as a null check
3924 // or breakpoint) that the VM was generating for its own correct operation.
3925 //
3926 // This routine may recognize any of the following kinds of signals:
3927 // SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ,
3928 // os::Solaris::SIGasync
3929 // It should be consulted by handlers for any of those signals.
3930 // It explicitly does not recognize os::Solaris::SIGinterrupt
3931 //
3932 // The caller of this routine must pass in the three arguments supplied
3933 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
3934 // field of the structure passed to sigaction().  This routine assumes that
3935 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
3936 //
3937 // Note that the VM will print warnings if it detects conflicting signal
3938 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
3939 //
3940 extern "C" JNIEXPORT int JVM_handle_solaris_signal(int signo,
3941                                                    siginfo_t* siginfo,
3942                                                    void* ucontext,
3943                                                    int abort_if_unrecognized);
3944 
3945 
3946 void signalHandler(int sig, siginfo_t* info, void* ucVoid) {
3947   int orig_errno = errno;  // Preserve errno value over signal handler.
3948   JVM_handle_solaris_signal(sig, info, ucVoid, true);
3949   errno = orig_errno;
3950 }
3951 
3952 // Do not delete - if guarantee is ever removed,  a signal handler (even empty)
3953 // is needed to provoke threads blocked on IO to return an EINTR
3954 // Note: this explicitly does NOT call JVM_handle_solaris_signal and
3955 // does NOT participate in signal chaining due to requirement for
3956 // NOT setting SA_RESTART to make EINTR work.
3957 extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) {
3958   if (UseSignalChaining) {
3959     struct sigaction *actp = os::Solaris::get_chained_signal_action(sig);
3960     if (actp && actp->sa_handler) {
3961       vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs");
3962     }
3963   }
3964 }
3965 
3966 // This boolean allows users to forward their own non-matching signals
3967 // to JVM_handle_solaris_signal, harmlessly.
3968 bool os::Solaris::signal_handlers_are_installed = false;
3969 
3970 // For signal-chaining
3971 bool os::Solaris::libjsig_is_loaded = false;
3972 typedef struct sigaction *(*get_signal_t)(int);
3973 get_signal_t os::Solaris::get_signal_action = NULL;
3974 
3975 struct sigaction* os::Solaris::get_chained_signal_action(int sig) {
3976   struct sigaction *actp = NULL;
3977 
3978   if ((libjsig_is_loaded)  && (sig <= Maxlibjsigsigs)) {
3979     // Retrieve the old signal handler from libjsig
3980     actp = (*get_signal_action)(sig);
3981   }
3982   if (actp == NULL) {
3983     // Retrieve the preinstalled signal handler from jvm
3984     actp = get_preinstalled_handler(sig);
3985   }
3986 
3987   return actp;
3988 }
3989 
3990 static bool call_chained_handler(struct sigaction *actp, int sig,
3991                                  siginfo_t *siginfo, void *context) {
3992   // Call the old signal handler
3993   if (actp->sa_handler == SIG_DFL) {
3994     // It's more reasonable to let jvm treat it as an unexpected exception
3995     // instead of taking the default action.
3996     return false;
3997   } else if (actp->sa_handler != SIG_IGN) {
3998     if ((actp->sa_flags & SA_NODEFER) == 0) {
3999       // automaticlly block the signal
4000       sigaddset(&(actp->sa_mask), sig);
4001     }
4002 
4003     sa_handler_t hand;
4004     sa_sigaction_t sa;
4005     bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
4006     // retrieve the chained handler
4007     if (siginfo_flag_set) {
4008       sa = actp->sa_sigaction;
4009     } else {
4010       hand = actp->sa_handler;
4011     }
4012 
4013     if ((actp->sa_flags & SA_RESETHAND) != 0) {
4014       actp->sa_handler = SIG_DFL;
4015     }
4016 
4017     // try to honor the signal mask
4018     sigset_t oset;
4019     thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset);
4020 
4021     // call into the chained handler
4022     if (siginfo_flag_set) {
4023       (*sa)(sig, siginfo, context);
4024     } else {
4025       (*hand)(sig);
4026     }
4027 
4028     // restore the signal mask
4029     thr_sigsetmask(SIG_SETMASK, &oset, 0);
4030   }
4031   // Tell jvm's signal handler the signal is taken care of.
4032   return true;
4033 }
4034 
4035 bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4036   bool chained = false;
4037   // signal-chaining
4038   if (UseSignalChaining) {
4039     struct sigaction *actp = get_chained_signal_action(sig);
4040     if (actp != NULL) {
4041       chained = call_chained_handler(actp, sig, siginfo, context);
4042     }
4043   }
4044   return chained;
4045 }
4046 
4047 struct sigaction* os::Solaris::get_preinstalled_handler(int sig) {
4048   assert((chainedsigactions != (struct sigaction *)NULL) &&
4049          (preinstalled_sigs != (int *)NULL), "signals not yet initialized");
4050   if (preinstalled_sigs[sig] != 0) {
4051     return &chainedsigactions[sig];
4052   }
4053   return NULL;
4054 }
4055 
4056 void os::Solaris::save_preinstalled_handler(int sig,
4057                                             struct sigaction& oldAct) {
4058   assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range");
4059   assert((chainedsigactions != (struct sigaction *)NULL) &&
4060          (preinstalled_sigs != (int *)NULL), "signals not yet initialized");
4061   chainedsigactions[sig] = oldAct;
4062   preinstalled_sigs[sig] = 1;
4063 }
4064 
4065 void os::Solaris::set_signal_handler(int sig, bool set_installed,
4066                                      bool oktochain) {
4067   // Check for overwrite.
4068   struct sigaction oldAct;
4069   sigaction(sig, (struct sigaction*)NULL, &oldAct);
4070   void* oldhand =
4071       oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
4072                           : CAST_FROM_FN_PTR(void*,  oldAct.sa_handler);
4073   if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
4074       oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
4075       oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) {
4076     if (AllowUserSignalHandlers || !set_installed) {
4077       // Do not overwrite; user takes responsibility to forward to us.
4078       return;
4079     } else if (UseSignalChaining) {
4080       if (oktochain) {
4081         // save the old handler in jvm
4082         save_preinstalled_handler(sig, oldAct);
4083       } else {
4084         vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs.");
4085       }
4086       // libjsig also interposes the sigaction() call below and saves the
4087       // old sigaction on it own.
4088     } else {
4089       fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
4090                     "%#lx for signal %d.", (long)oldhand, sig));
4091     }
4092   }
4093 
4094   struct sigaction sigAct;
4095   sigfillset(&(sigAct.sa_mask));
4096   sigAct.sa_handler = SIG_DFL;
4097 
4098   sigAct.sa_sigaction = signalHandler;
4099   // Handle SIGSEGV on alternate signal stack if
4100   // not using stack banging
4101   if (!UseStackBanging && sig == SIGSEGV) {
4102     sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
4103   } else if (sig == os::Solaris::SIGinterrupt()) {
4104     // Interruptible i/o requires SA_RESTART cleared so EINTR
4105     // is returned instead of restarting system calls
4106     sigemptyset(&sigAct.sa_mask);
4107     sigAct.sa_handler = NULL;
4108     sigAct.sa_flags = SA_SIGINFO;
4109     sigAct.sa_sigaction = sigINTRHandler;
4110   } else {
4111     sigAct.sa_flags = SA_SIGINFO | SA_RESTART;
4112   }
4113   os::Solaris::set_our_sigflags(sig, sigAct.sa_flags);
4114 
4115   sigaction(sig, &sigAct, &oldAct);
4116 
4117   void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4118                                        : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4119   assert(oldhand2 == oldhand, "no concurrent signal handler installation");
4120 }
4121 
4122 
4123 #define DO_SIGNAL_CHECK(sig)                      \
4124   do {                                            \
4125     if (!sigismember(&check_signal_done, sig)) {  \
4126       os::Solaris::check_signal_handler(sig);     \
4127     }                                             \
4128   } while (0)
4129 
4130 // This method is a periodic task to check for misbehaving JNI applications
4131 // under CheckJNI, we can add any periodic checks here
4132 
4133 void os::run_periodic_checks() {
4134   // A big source of grief is hijacking virt. addr 0x0 on Solaris,
4135   // thereby preventing a NULL checks.
4136   if (!check_addr0_done) check_addr0_done = check_addr0(tty);
4137 
4138   if (check_signals == false) return;
4139 
4140   // SEGV and BUS if overridden could potentially prevent
4141   // generation of hs*.log in the event of a crash, debugging
4142   // such a case can be very challenging, so we absolutely
4143   // check for the following for a good measure:
4144   DO_SIGNAL_CHECK(SIGSEGV);
4145   DO_SIGNAL_CHECK(SIGILL);
4146   DO_SIGNAL_CHECK(SIGFPE);
4147   DO_SIGNAL_CHECK(SIGBUS);
4148   DO_SIGNAL_CHECK(SIGPIPE);
4149   DO_SIGNAL_CHECK(SIGXFSZ);
4150 
4151   // ReduceSignalUsage allows the user to override these handlers
4152   // see comments at the very top and jvm_solaris.h
4153   if (!ReduceSignalUsage) {
4154     DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
4155     DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
4156     DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
4157     DO_SIGNAL_CHECK(BREAK_SIGNAL);
4158   }
4159 
4160   // See comments above for using JVM1/JVM2 and UseAltSigs
4161   DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt());
4162   DO_SIGNAL_CHECK(os::Solaris::SIGasync());
4163 
4164 }
4165 
4166 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
4167 
4168 static os_sigaction_t os_sigaction = NULL;
4169 
4170 void os::Solaris::check_signal_handler(int sig) {
4171   char buf[O_BUFLEN];
4172   address jvmHandler = NULL;
4173 
4174   struct sigaction act;
4175   if (os_sigaction == NULL) {
4176     // only trust the default sigaction, in case it has been interposed
4177     os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
4178     if (os_sigaction == NULL) return;
4179   }
4180 
4181   os_sigaction(sig, (struct sigaction*)NULL, &act);
4182 
4183   address thisHandler = (act.sa_flags & SA_SIGINFO)
4184     ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
4185     : CAST_FROM_FN_PTR(address, act.sa_handler);
4186 
4187 
4188   switch (sig) {
4189   case SIGSEGV:
4190   case SIGBUS:
4191   case SIGFPE:
4192   case SIGPIPE:
4193   case SIGXFSZ:
4194   case SIGILL:
4195     jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4196     break;
4197 
4198   case SHUTDOWN1_SIGNAL:
4199   case SHUTDOWN2_SIGNAL:
4200   case SHUTDOWN3_SIGNAL:
4201   case BREAK_SIGNAL:
4202     jvmHandler = (address)user_handler();
4203     break;
4204 
4205   default:
4206     int intrsig = os::Solaris::SIGinterrupt();
4207     int asynsig = os::Solaris::SIGasync();
4208 
4209     if (sig == intrsig) {
4210       jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler);
4211     } else if (sig == asynsig) {
4212       jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4213     } else {
4214       return;
4215     }
4216     break;
4217   }
4218 
4219 
4220   if (thisHandler != jvmHandler) {
4221     tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
4222     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
4223     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
4224     // No need to check this sig any longer
4225     sigaddset(&check_signal_done, sig);
4226     // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
4227     if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
4228       tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
4229                     exception_name(sig, buf, O_BUFLEN));
4230     }
4231   } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) {
4232     tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
4233     tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig));
4234     tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
4235     // No need to check this sig any longer
4236     sigaddset(&check_signal_done, sig);
4237   }
4238 
4239   // Print all the signal handler state
4240   if (sigismember(&check_signal_done, sig)) {
4241     print_signal_handlers(tty, buf, O_BUFLEN);
4242   }
4243 
4244 }
4245 
4246 void os::Solaris::install_signal_handlers() {
4247   bool libjsigdone = false;
4248   signal_handlers_are_installed = true;
4249 
4250   // signal-chaining
4251   typedef void (*signal_setting_t)();
4252   signal_setting_t begin_signal_setting = NULL;
4253   signal_setting_t end_signal_setting = NULL;
4254   begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4255                                         dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4256   if (begin_signal_setting != NULL) {
4257     end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4258                                         dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4259     get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4260                                        dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4261     get_libjsig_version = CAST_TO_FN_PTR(version_getting_t,
4262                                          dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version"));
4263     libjsig_is_loaded = true;
4264     if (os::Solaris::get_libjsig_version != NULL) {
4265       libjsigversion =  (*os::Solaris::get_libjsig_version)();
4266     }
4267     assert(UseSignalChaining, "should enable signal-chaining");
4268   }
4269   if (libjsig_is_loaded) {
4270     // Tell libjsig jvm is setting signal handlers
4271     (*begin_signal_setting)();
4272   }
4273 
4274   set_signal_handler(SIGSEGV, true, true);
4275   set_signal_handler(SIGPIPE, true, true);
4276   set_signal_handler(SIGXFSZ, true, true);
4277   set_signal_handler(SIGBUS, true, true);
4278   set_signal_handler(SIGILL, true, true);
4279   set_signal_handler(SIGFPE, true, true);
4280 
4281 
4282   if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) {
4283 
4284     // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so
4285     // can not register overridable signals which might be > 32
4286     if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) {
4287       // Tell libjsig jvm has finished setting signal handlers
4288       (*end_signal_setting)();
4289       libjsigdone = true;
4290     }
4291   }
4292 
4293   // Never ok to chain our SIGinterrupt
4294   set_signal_handler(os::Solaris::SIGinterrupt(), true, false);
4295   set_signal_handler(os::Solaris::SIGasync(), true, true);
4296 
4297   if (libjsig_is_loaded && !libjsigdone) {
4298     // Tell libjsig jvm finishes setting signal handlers
4299     (*end_signal_setting)();
4300   }
4301 
4302   // We don't activate signal checker if libjsig is in place, we trust ourselves
4303   // and if UserSignalHandler is installed all bets are off.
4304   // Log that signal checking is off only if -verbose:jni is specified.
4305   if (CheckJNICalls) {
4306     if (libjsig_is_loaded) {
4307       if (PrintJNIResolving) {
4308         tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
4309       }
4310       check_signals = false;
4311     }
4312     if (AllowUserSignalHandlers) {
4313       if (PrintJNIResolving) {
4314         tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
4315       }
4316       check_signals = false;
4317     }
4318   }
4319 }
4320 
4321 
4322 void report_error(const char* file_name, int line_no, const char* title,
4323                   const char* format, ...);
4324 
4325 const char * signames[] = {
4326   "SIG0",
4327   "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
4328   "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS",
4329   "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM",
4330   "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH",
4331   "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT",
4332   "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU",
4333   "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW",
4334   "SIGCANCEL", "SIGLOST"
4335 };
4336 
4337 const char* os::exception_name(int exception_code, char* buf, size_t size) {
4338   if (0 < exception_code && exception_code <= SIGRTMAX) {
4339     // signal
4340     if (exception_code < sizeof(signames)/sizeof(const char*)) {
4341       jio_snprintf(buf, size, "%s", signames[exception_code]);
4342     } else {
4343       jio_snprintf(buf, size, "SIG%d", exception_code);
4344     }
4345     return buf;
4346   } else {
4347     return NULL;
4348   }
4349 }
4350 
4351 // (Static) wrapper for getisax(2) call.
4352 os::Solaris::getisax_func_t os::Solaris::_getisax = 0;
4353 
4354 // (Static) wrappers for the liblgrp API
4355 os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home;
4356 os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init;
4357 os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini;
4358 os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root;
4359 os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children;
4360 os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources;
4361 os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps;
4362 os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale;
4363 os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0;
4364 
4365 // (Static) wrapper for meminfo() call.
4366 os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0;
4367 
4368 static address resolve_symbol_lazy(const char* name) {
4369   address addr = (address) dlsym(RTLD_DEFAULT, name);
4370   if (addr == NULL) {
4371     // RTLD_DEFAULT was not defined on some early versions of 2.5.1
4372     addr = (address) dlsym(RTLD_NEXT, name);
4373   }
4374   return addr;
4375 }
4376 
4377 static address resolve_symbol(const char* name) {
4378   address addr = resolve_symbol_lazy(name);
4379   if (addr == NULL) {
4380     fatal(dlerror());
4381   }
4382   return addr;
4383 }
4384 
4385 void os::Solaris::libthread_init() {
4386   address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators");
4387 
4388   lwp_priocntl_init();
4389 
4390   // RTLD_DEFAULT was not defined on some early versions of 5.5.1
4391   if (func == NULL) {
4392     func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators");
4393     // Guarantee that this VM is running on an new enough OS (5.6 or
4394     // later) that it will have a new enough libthread.so.
4395     guarantee(func != NULL, "libthread.so is too old.");
4396   }
4397 
4398   int size;
4399   void (*handler_info_func)(address *, int *);
4400   handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo"));
4401   handler_info_func(&handler_start, &size);
4402   handler_end = handler_start + size;
4403 }
4404 
4405 
4406 int_fnP_mutex_tP os::Solaris::_mutex_lock;
4407 int_fnP_mutex_tP os::Solaris::_mutex_trylock;
4408 int_fnP_mutex_tP os::Solaris::_mutex_unlock;
4409 int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init;
4410 int_fnP_mutex_tP os::Solaris::_mutex_destroy;
4411 int os::Solaris::_mutex_scope = USYNC_THREAD;
4412 
4413 int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait;
4414 int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait;
4415 int_fnP_cond_tP os::Solaris::_cond_signal;
4416 int_fnP_cond_tP os::Solaris::_cond_broadcast;
4417 int_fnP_cond_tP_i_vP os::Solaris::_cond_init;
4418 int_fnP_cond_tP os::Solaris::_cond_destroy;
4419 int os::Solaris::_cond_scope = USYNC_THREAD;
4420 
4421 void os::Solaris::synchronization_init() {
4422   if (UseLWPSynchronization) {
4423     os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock")));
4424     os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock")));
4425     os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock")));
4426     os::Solaris::set_mutex_init(lwp_mutex_init);
4427     os::Solaris::set_mutex_destroy(lwp_mutex_destroy);
4428     os::Solaris::set_mutex_scope(USYNC_THREAD);
4429 
4430     os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait")));
4431     os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait")));
4432     os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal")));
4433     os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast")));
4434     os::Solaris::set_cond_init(lwp_cond_init);
4435     os::Solaris::set_cond_destroy(lwp_cond_destroy);
4436     os::Solaris::set_cond_scope(USYNC_THREAD);
4437   } else {
4438     os::Solaris::set_mutex_scope(USYNC_THREAD);
4439     os::Solaris::set_cond_scope(USYNC_THREAD);
4440 
4441     if (UsePthreads) {
4442       os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
4443       os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock")));
4444       os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock")));
4445       os::Solaris::set_mutex_init(pthread_mutex_default_init);
4446       os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy")));
4447 
4448       os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait")));
4449       os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait")));
4450       os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal")));
4451       os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast")));
4452       os::Solaris::set_cond_init(pthread_cond_default_init);
4453       os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy")));
4454     } else {
4455       os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock")));
4456       os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock")));
4457       os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock")));
4458       os::Solaris::set_mutex_init(::mutex_init);
4459       os::Solaris::set_mutex_destroy(::mutex_destroy);
4460 
4461       os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait")));
4462       os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait")));
4463       os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal")));
4464       os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast")));
4465       os::Solaris::set_cond_init(::cond_init);
4466       os::Solaris::set_cond_destroy(::cond_destroy);
4467     }
4468   }
4469 }
4470 
4471 bool os::Solaris::liblgrp_init() {
4472   void *handle = dlopen("liblgrp.so.1", RTLD_LAZY);
4473   if (handle != NULL) {
4474     os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home")));
4475     os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init")));
4476     os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini")));
4477     os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root")));
4478     os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children")));
4479     os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources")));
4480     os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps")));
4481     os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t,
4482                                                       dlsym(handle, "lgrp_cookie_stale")));
4483 
4484     lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER);
4485     set_lgrp_cookie(c);
4486     return true;
4487   }
4488   return false;
4489 }
4490 
4491 void os::Solaris::misc_sym_init() {
4492   address func;
4493 
4494   // getisax
4495   func = resolve_symbol_lazy("getisax");
4496   if (func != NULL) {
4497     os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func);
4498   }
4499 
4500   // meminfo
4501   func = resolve_symbol_lazy("meminfo");
4502   if (func != NULL) {
4503     os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func));
4504   }
4505 }
4506 
4507 uint_t os::Solaris::getisax(uint32_t* array, uint_t n) {
4508   assert(_getisax != NULL, "_getisax not set");
4509   return _getisax(array, n);
4510 }
4511 
4512 // int pset_getloadavg(psetid_t pset, double loadavg[], int nelem);
4513 typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem);
4514 static pset_getloadavg_type pset_getloadavg_ptr = NULL;
4515 
4516 void init_pset_getloadavg_ptr(void) {
4517   pset_getloadavg_ptr =
4518     (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg");
4519   if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) {
4520     warning("pset_getloadavg function not found");
4521   }
4522 }
4523 
4524 int os::Solaris::_dev_zero_fd = -1;
4525 
4526 // this is called _before_ the global arguments have been parsed
4527 void os::init(void) {
4528   _initial_pid = getpid();
4529 
4530   max_hrtime = first_hrtime = gethrtime();
4531 
4532   init_random(1234567);
4533 
4534   page_size = sysconf(_SC_PAGESIZE);
4535   if (page_size == -1) {
4536     fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
4537                   strerror(errno)));
4538   }
4539   init_page_sizes((size_t) page_size);
4540 
4541   Solaris::initialize_system_info();
4542 
4543   // Initialize misc. symbols as soon as possible, so we can use them
4544   // if we need them.
4545   Solaris::misc_sym_init();
4546 
4547   int fd = ::open("/dev/zero", O_RDWR);
4548   if (fd < 0) {
4549     fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno)));
4550   } else {
4551     Solaris::set_dev_zero_fd(fd);
4552 
4553     // Close on exec, child won't inherit.
4554     fcntl(fd, F_SETFD, FD_CLOEXEC);
4555   }
4556 
4557   clock_tics_per_sec = CLK_TCK;
4558 
4559   // check if dladdr1() exists; dladdr1 can provide more information than
4560   // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9
4561   // and is available on linker patches for 5.7 and 5.8.
4562   // libdl.so must have been loaded, this call is just an entry lookup
4563   void * hdl = dlopen("libdl.so", RTLD_NOW);
4564   if (hdl) {
4565     dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1"));
4566   }
4567 
4568   // (Solaris only) this switches to calls that actually do locking.
4569   ThreadCritical::initialize();
4570 
4571   main_thread = thr_self();
4572 
4573   // Constant minimum stack size allowed. It must be at least
4574   // the minimum of what the OS supports (thr_min_stack()), and
4575   // enough to allow the thread to get to user bytecode execution.
4576   Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed);
4577   // If the pagesize of the VM is greater than 8K determine the appropriate
4578   // number of initial guard pages.  The user can change this with the
4579   // command line arguments, if needed.
4580   if (vm_page_size() > 8*K) {
4581     StackYellowPages = 1;
4582     StackRedPages = 1;
4583     StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size();
4584   }
4585 }
4586 
4587 // To install functions for atexit system call
4588 extern "C" {
4589   static void perfMemory_exit_helper() {
4590     perfMemory_exit();
4591   }
4592 }
4593 
4594 // this is called _after_ the global arguments have been parsed
4595 jint os::init_2(void) {
4596   // try to enable extended file IO ASAP, see 6431278
4597   os::Solaris::try_enable_extended_io();
4598 
4599   // Allocate a single page and mark it as readable for safepoint polling.  Also
4600   // use this first mmap call to check support for MAP_ALIGN.
4601   address polling_page = (address)Solaris::mmap_chunk((char*)page_size,
4602                                                       page_size,
4603                                                       MAP_PRIVATE | MAP_ALIGN,
4604                                                       PROT_READ);
4605   if (polling_page == NULL) {
4606     has_map_align = false;
4607     polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE,
4608                                                 PROT_READ);
4609   }
4610 
4611   os::set_polling_page(polling_page);
4612 
4613 #ifndef PRODUCT
4614   if (Verbose && PrintMiscellaneous) {
4615     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n",
4616                (intptr_t)polling_page);
4617   }
4618 #endif
4619 
4620   if (!UseMembar) {
4621     address mem_serialize_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE);
4622     guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
4623     os::set_memory_serialize_page(mem_serialize_page);
4624 
4625 #ifndef PRODUCT
4626     if (Verbose && PrintMiscellaneous) {
4627       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n",
4628                  (intptr_t)mem_serialize_page);
4629     }
4630 #endif
4631   }
4632 
4633   // Check minimum allowable stack size for thread creation and to initialize
4634   // the java system classes, including StackOverflowError - depends on page
4635   // size.  Add a page for compiler2 recursion in main thread.
4636   // Add in 2*BytesPerWord times page size to account for VM stack during
4637   // class initialization depending on 32 or 64 bit VM.
4638   os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
4639                                         (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4640                                         2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size);
4641 
4642   size_t threadStackSizeInBytes = ThreadStackSize * K;
4643   if (threadStackSizeInBytes != 0 &&
4644       threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
4645     tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
4646                   os::Solaris::min_stack_allowed/K);
4647     return JNI_ERR;
4648   }
4649 
4650   // For 64kbps there will be a 64kb page size, which makes
4651   // the usable default stack size quite a bit less.  Increase the
4652   // stack for 64kb (or any > than 8kb) pages, this increases
4653   // virtual memory fragmentation (since we're not creating the
4654   // stack on a power of 2 boundary.  The real fix for this
4655   // should be to fix the guard page mechanism.
4656 
4657   if (vm_page_size() > 8*K) {
4658     threadStackSizeInBytes = (threadStackSizeInBytes != 0)
4659        ? threadStackSizeInBytes +
4660          ((StackYellowPages + StackRedPages) * vm_page_size())
4661        : 0;
4662     ThreadStackSize = threadStackSizeInBytes/K;
4663   }
4664 
4665   // Make the stack size a multiple of the page size so that
4666   // the yellow/red zones can be guarded.
4667   JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
4668                                                 vm_page_size()));
4669 
4670   Solaris::libthread_init();
4671 
4672   if (UseNUMA) {
4673     if (!Solaris::liblgrp_init()) {
4674       UseNUMA = false;
4675     } else {
4676       size_t lgrp_limit = os::numa_get_groups_num();
4677       int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal);
4678       size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
4679       FREE_C_HEAP_ARRAY(int, lgrp_ids);
4680       if (lgrp_num < 2) {
4681         // There's only one locality group, disable NUMA.
4682         UseNUMA = false;
4683       }
4684     }
4685     if (!UseNUMA && ForceNUMA) {
4686       UseNUMA = true;
4687     }
4688   }
4689 
4690   Solaris::signal_sets_init();
4691   Solaris::init_signal_mem();
4692   Solaris::install_signal_handlers();
4693 
4694   if (libjsigversion < JSIG_VERSION_1_4_1) {
4695     Maxlibjsigsigs = OLDMAXSIGNUM;
4696   }
4697 
4698   // initialize synchronization primitives to use either thread or
4699   // lwp synchronization (controlled by UseLWPSynchronization)
4700   Solaris::synchronization_init();
4701 
4702   if (MaxFDLimit) {
4703     // set the number of file descriptors to max. print out error
4704     // if getrlimit/setrlimit fails but continue regardless.
4705     struct rlimit nbr_files;
4706     int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
4707     if (status != 0) {
4708       if (PrintMiscellaneous && (Verbose || WizardMode)) {
4709         perror("os::init_2 getrlimit failed");
4710       }
4711     } else {
4712       nbr_files.rlim_cur = nbr_files.rlim_max;
4713       status = setrlimit(RLIMIT_NOFILE, &nbr_files);
4714       if (status != 0) {
4715         if (PrintMiscellaneous && (Verbose || WizardMode)) {
4716           perror("os::init_2 setrlimit failed");
4717         }
4718       }
4719     }
4720   }
4721 
4722   // Calculate theoretical max. size of Threads to guard gainst
4723   // artifical out-of-memory situations, where all available address-
4724   // space has been reserved by thread stacks. Default stack size is 1Mb.
4725   size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ?
4726     JavaThread::stack_size_at_create() : (1*K*K);
4727   assert(pre_thread_stack_size != 0, "Must have a stack");
4728   // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when
4729   // we should start doing Virtual Memory banging. Currently when the threads will
4730   // have used all but 200Mb of space.
4731   size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K);
4732   Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size;
4733 
4734   // at-exit methods are called in the reverse order of their registration.
4735   // In Solaris 7 and earlier, atexit functions are called on return from
4736   // main or as a result of a call to exit(3C). There can be only 32 of
4737   // these functions registered and atexit() does not set errno. In Solaris
4738   // 8 and later, there is no limit to the number of functions registered
4739   // and atexit() sets errno. In addition, in Solaris 8 and later, atexit
4740   // functions are called upon dlclose(3DL) in addition to return from main
4741   // and exit(3C).
4742 
4743   if (PerfAllowAtExitRegistration) {
4744     // only register atexit functions if PerfAllowAtExitRegistration is set.
4745     // atexit functions can be delayed until process exit time, which
4746     // can be problematic for embedded VM situations. Embedded VMs should
4747     // call DestroyJavaVM() to assure that VM resources are released.
4748 
4749     // note: perfMemory_exit_helper atexit function may be removed in
4750     // the future if the appropriate cleanup code can be added to the
4751     // VM_Exit VMOperation's doit method.
4752     if (atexit(perfMemory_exit_helper) != 0) {
4753       warning("os::init2 atexit(perfMemory_exit_helper) failed");
4754     }
4755   }
4756 
4757   // Init pset_loadavg function pointer
4758   init_pset_getloadavg_ptr();
4759 
4760   return JNI_OK;
4761 }
4762 
4763 // Mark the polling page as unreadable
4764 void os::make_polling_page_unreadable(void) {
4765   if (mprotect((char *)_polling_page, page_size, PROT_NONE) != 0) {
4766     fatal("Could not disable polling page");
4767   }
4768 }
4769 
4770 // Mark the polling page as readable
4771 void os::make_polling_page_readable(void) {
4772   if (mprotect((char *)_polling_page, page_size, PROT_READ) != 0) {
4773     fatal("Could not enable polling page");
4774   }
4775 }
4776 
4777 // OS interface.
4778 
4779 bool os::check_heap(bool force) { return true; }
4780 
4781 // Is a (classpath) directory empty?
4782 bool os::dir_is_empty(const char* path) {
4783   DIR *dir = NULL;
4784   struct dirent *ptr;
4785 
4786   dir = opendir(path);
4787   if (dir == NULL) return true;
4788 
4789   // Scan the directory
4790   bool result = true;
4791   char buf[sizeof(struct dirent) + MAX_PATH];
4792   struct dirent *dbuf = (struct dirent *) buf;
4793   while (result && (ptr = readdir(dir, dbuf)) != NULL) {
4794     if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
4795       result = false;
4796     }
4797   }
4798   closedir(dir);
4799   return result;
4800 }
4801 
4802 // This code originates from JDK's sysOpen and open64_w
4803 // from src/solaris/hpi/src/system_md.c
4804 
4805 int os::open(const char *path, int oflag, int mode) {
4806   if (strlen(path) > MAX_PATH - 1) {
4807     errno = ENAMETOOLONG;
4808     return -1;
4809   }
4810   int fd;
4811 
4812   fd = ::open64(path, oflag, mode);
4813   if (fd == -1) return -1;
4814 
4815   // If the open succeeded, the file might still be a directory
4816   {
4817     struct stat64 buf64;
4818     int ret = ::fstat64(fd, &buf64);
4819     int st_mode = buf64.st_mode;
4820 
4821     if (ret != -1) {
4822       if ((st_mode & S_IFMT) == S_IFDIR) {
4823         errno = EISDIR;
4824         ::close(fd);
4825         return -1;
4826       }
4827     } else {
4828       ::close(fd);
4829       return -1;
4830     }
4831   }
4832 
4833   // 32-bit Solaris systems suffer from:
4834   //
4835   // - an historical default soft limit of 256 per-process file
4836   //   descriptors that is too low for many Java programs.
4837   //
4838   // - a design flaw where file descriptors created using stdio
4839   //   fopen must be less than 256, _even_ when the first limit above
4840   //   has been raised.  This can cause calls to fopen (but not calls to
4841   //   open, for example) to fail mysteriously, perhaps in 3rd party
4842   //   native code (although the JDK itself uses fopen).  One can hardly
4843   //   criticize them for using this most standard of all functions.
4844   //
4845   // We attempt to make everything work anyways by:
4846   //
4847   // - raising the soft limit on per-process file descriptors beyond
4848   //   256
4849   //
4850   // - As of Solaris 10u4, we can request that Solaris raise the 256
4851   //   stdio fopen limit by calling function enable_extended_FILE_stdio.
4852   //   This is done in init_2 and recorded in enabled_extended_FILE_stdio
4853   //
4854   // - If we are stuck on an old (pre 10u4) Solaris system, we can
4855   //   workaround the bug by remapping non-stdio file descriptors below
4856   //   256 to ones beyond 256, which is done below.
4857   //
4858   // See:
4859   // 1085341: 32-bit stdio routines should support file descriptors >255
4860   // 6533291: Work around 32-bit Solaris stdio limit of 256 open files
4861   // 6431278: Netbeans crash on 32 bit Solaris: need to call
4862   //          enable_extended_FILE_stdio() in VM initialisation
4863   // Giri Mandalika's blog
4864   // http://technopark02.blogspot.com/2005_05_01_archive.html
4865   //
4866 #ifndef  _LP64
4867   if ((!enabled_extended_FILE_stdio) && fd < 256) {
4868     int newfd = ::fcntl(fd, F_DUPFD, 256);
4869     if (newfd != -1) {
4870       ::close(fd);
4871       fd = newfd;
4872     }
4873   }
4874 #endif // 32-bit Solaris
4875 
4876   // All file descriptors that are opened in the JVM and not
4877   // specifically destined for a subprocess should have the
4878   // close-on-exec flag set.  If we don't set it, then careless 3rd
4879   // party native code might fork and exec without closing all
4880   // appropriate file descriptors (e.g. as we do in closeDescriptors in
4881   // UNIXProcess.c), and this in turn might:
4882   //
4883   // - cause end-of-file to fail to be detected on some file
4884   //   descriptors, resulting in mysterious hangs, or
4885   //
4886   // - might cause an fopen in the subprocess to fail on a system
4887   //   suffering from bug 1085341.
4888   //
4889   // (Yes, the default setting of the close-on-exec flag is a Unix
4890   // design flaw)
4891   //
4892   // See:
4893   // 1085341: 32-bit stdio routines should support file descriptors >255
4894   // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
4895   // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
4896   //
4897 #ifdef FD_CLOEXEC
4898   {
4899     int flags = ::fcntl(fd, F_GETFD);
4900     if (flags != -1) {
4901       ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
4902     }
4903   }
4904 #endif
4905 
4906   return fd;
4907 }
4908 
4909 // create binary file, rewriting existing file if required
4910 int os::create_binary_file(const char* path, bool rewrite_existing) {
4911   int oflags = O_WRONLY | O_CREAT;
4912   if (!rewrite_existing) {
4913     oflags |= O_EXCL;
4914   }
4915   return ::open64(path, oflags, S_IREAD | S_IWRITE);
4916 }
4917 
4918 // return current position of file pointer
4919 jlong os::current_file_offset(int fd) {
4920   return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
4921 }
4922 
4923 // move file pointer to the specified offset
4924 jlong os::seek_to_file_offset(int fd, jlong offset) {
4925   return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
4926 }
4927 
4928 jlong os::lseek(int fd, jlong offset, int whence) {
4929   return (jlong) ::lseek64(fd, offset, whence);
4930 }
4931 
4932 char * os::native_path(char *path) {
4933   return path;
4934 }
4935 
4936 int os::ftruncate(int fd, jlong length) {
4937   return ::ftruncate64(fd, length);
4938 }
4939 
4940 int os::fsync(int fd)  {
4941   RESTARTABLE_RETURN_INT(::fsync(fd));
4942 }
4943 
4944 int os::available(int fd, jlong *bytes) {
4945   assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
4946          "Assumed _thread_in_native");
4947   jlong cur, end;
4948   int mode;
4949   struct stat64 buf64;
4950 
4951   if (::fstat64(fd, &buf64) >= 0) {
4952     mode = buf64.st_mode;
4953     if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
4954       int n,ioctl_return;
4955 
4956       RESTARTABLE(::ioctl(fd, FIONREAD, &n), ioctl_return);
4957       if (ioctl_return>= 0) {
4958         *bytes = n;
4959         return 1;
4960       }
4961     }
4962   }
4963   if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
4964     return 0;
4965   } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
4966     return 0;
4967   } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
4968     return 0;
4969   }
4970   *bytes = end - cur;
4971   return 1;
4972 }
4973 
4974 // Map a block of memory.
4975 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4976                         char *addr, size_t bytes, bool read_only,
4977                         bool allow_exec) {
4978   int prot;
4979   int flags;
4980 
4981   if (read_only) {
4982     prot = PROT_READ;
4983     flags = MAP_SHARED;
4984   } else {
4985     prot = PROT_READ | PROT_WRITE;
4986     flags = MAP_PRIVATE;
4987   }
4988 
4989   if (allow_exec) {
4990     prot |= PROT_EXEC;
4991   }
4992 
4993   if (addr != NULL) {
4994     flags |= MAP_FIXED;
4995   }
4996 
4997   char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags,
4998                                      fd, file_offset);
4999   if (mapped_address == MAP_FAILED) {
5000     return NULL;
5001   }
5002   return mapped_address;
5003 }
5004 
5005 
5006 // Remap a block of memory.
5007 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
5008                           char *addr, size_t bytes, bool read_only,
5009                           bool allow_exec) {
5010   // same as map_memory() on this OS
5011   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
5012                         allow_exec);
5013 }
5014 
5015 
5016 // Unmap a block of memory.
5017 bool os::pd_unmap_memory(char* addr, size_t bytes) {
5018   return munmap(addr, bytes) == 0;
5019 }
5020 
5021 void os::pause() {
5022   char filename[MAX_PATH];
5023   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
5024     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
5025   } else {
5026     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
5027   }
5028 
5029   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
5030   if (fd != -1) {
5031     struct stat buf;
5032     ::close(fd);
5033     while (::stat(filename, &buf) == 0) {
5034       (void)::poll(NULL, 0, 100);
5035     }
5036   } else {
5037     jio_fprintf(stderr,
5038                 "Could not open pause file '%s', continuing immediately.\n", filename);
5039   }
5040 }
5041 
5042 #ifndef PRODUCT
5043 #ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5044 // Turn this on if you need to trace synch operations.
5045 // Set RECORD_SYNCH_LIMIT to a large-enough value,
5046 // and call record_synch_enable and record_synch_disable
5047 // around the computation of interest.
5048 
5049 void record_synch(char* name, bool returning);  // defined below
5050 
5051 class RecordSynch {
5052   char* _name;
5053  public:
5054   RecordSynch(char* name) :_name(name) { record_synch(_name, false); }
5055   ~RecordSynch()                       { record_synch(_name, true); }
5056 };
5057 
5058 #define CHECK_SYNCH_OP(ret, name, params, args, inner)          \
5059 extern "C" ret name params {                                    \
5060   typedef ret name##_t params;                                  \
5061   static name##_t* implem = NULL;                               \
5062   static int callcount = 0;                                     \
5063   if (implem == NULL) {                                         \
5064     implem = (name##_t*) dlsym(RTLD_NEXT, #name);               \
5065     if (implem == NULL)  fatal(dlerror());                      \
5066   }                                                             \
5067   ++callcount;                                                  \
5068   RecordSynch _rs(#name);                                       \
5069   inner;                                                        \
5070   return implem args;                                           \
5071 }
5072 // in dbx, examine callcounts this way:
5073 // for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done
5074 
5075 #define CHECK_POINTER_OK(p) \
5076   (!Universe::is_fully_initialized() || !Universe::is_reserved_heap((oop)(p)))
5077 #define CHECK_MU \
5078   if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only.");
5079 #define CHECK_CV \
5080   if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only.");
5081 #define CHECK_P(p) \
5082   if (!CHECK_POINTER_OK(p))  fatal(false,  "Pointer must be in C heap only.");
5083 
5084 #define CHECK_MUTEX(mutex_op) \
5085   CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU);
5086 
5087 CHECK_MUTEX(   mutex_lock)
5088 CHECK_MUTEX(  _mutex_lock)
5089 CHECK_MUTEX( mutex_unlock)
5090 CHECK_MUTEX(_mutex_unlock)
5091 CHECK_MUTEX( mutex_trylock)
5092 CHECK_MUTEX(_mutex_trylock)
5093 
5094 #define CHECK_COND(cond_op) \
5095   CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU; CHECK_CV);
5096 
5097 CHECK_COND( cond_wait);
5098 CHECK_COND(_cond_wait);
5099 CHECK_COND(_cond_wait_cancel);
5100 
5101 #define CHECK_COND2(cond_op) \
5102   CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU; CHECK_CV);
5103 
5104 CHECK_COND2( cond_timedwait);
5105 CHECK_COND2(_cond_timedwait);
5106 CHECK_COND2(_cond_timedwait_cancel);
5107 
5108 // do the _lwp_* versions too
5109 #define mutex_t lwp_mutex_t
5110 #define cond_t  lwp_cond_t
5111 CHECK_MUTEX(  _lwp_mutex_lock)
5112 CHECK_MUTEX(  _lwp_mutex_unlock)
5113 CHECK_MUTEX(  _lwp_mutex_trylock)
5114 CHECK_MUTEX( __lwp_mutex_lock)
5115 CHECK_MUTEX( __lwp_mutex_unlock)
5116 CHECK_MUTEX( __lwp_mutex_trylock)
5117 CHECK_MUTEX(___lwp_mutex_lock)
5118 CHECK_MUTEX(___lwp_mutex_unlock)
5119 
5120 CHECK_COND(  _lwp_cond_wait);
5121 CHECK_COND( __lwp_cond_wait);
5122 CHECK_COND(___lwp_cond_wait);
5123 
5124 CHECK_COND2(  _lwp_cond_timedwait);
5125 CHECK_COND2( __lwp_cond_timedwait);
5126 #undef mutex_t
5127 #undef cond_t
5128 
5129 CHECK_SYNCH_OP(int, _lwp_suspend2,       (int lwp, int *n), (lwp, n), 0);
5130 CHECK_SYNCH_OP(int,__lwp_suspend2,       (int lwp, int *n), (lwp, n), 0);
5131 CHECK_SYNCH_OP(int, _lwp_kill,           (int lwp, int n),  (lwp, n), 0);
5132 CHECK_SYNCH_OP(int,__lwp_kill,           (int lwp, int n),  (lwp, n), 0);
5133 CHECK_SYNCH_OP(int, _lwp_sema_wait,      (lwp_sema_t* p),   (p),  CHECK_P(p));
5134 CHECK_SYNCH_OP(int,__lwp_sema_wait,      (lwp_sema_t* p),   (p),  CHECK_P(p));
5135 CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv),  (cv), CHECK_CV);
5136 CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv),  (cv), CHECK_CV);
5137 
5138 
5139 // recording machinery:
5140 
5141 enum { RECORD_SYNCH_LIMIT = 200 };
5142 char* record_synch_name[RECORD_SYNCH_LIMIT];
5143 void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT];
5144 bool record_synch_returning[RECORD_SYNCH_LIMIT];
5145 thread_t record_synch_thread[RECORD_SYNCH_LIMIT];
5146 int record_synch_count = 0;
5147 bool record_synch_enabled = false;
5148 
5149 // in dbx, examine recorded data this way:
5150 // for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done
5151 
5152 void record_synch(char* name, bool returning) {
5153   if (record_synch_enabled) {
5154     if (record_synch_count < RECORD_SYNCH_LIMIT) {
5155       record_synch_name[record_synch_count] = name;
5156       record_synch_returning[record_synch_count] = returning;
5157       record_synch_thread[record_synch_count] = thr_self();
5158       record_synch_arg0ptr[record_synch_count] = &name;
5159       record_synch_count++;
5160     }
5161     // put more checking code here:
5162     // ...
5163   }
5164 }
5165 
5166 void record_synch_enable() {
5167   // start collecting trace data, if not already doing so
5168   if (!record_synch_enabled)  record_synch_count = 0;
5169   record_synch_enabled = true;
5170 }
5171 
5172 void record_synch_disable() {
5173   // stop collecting trace data
5174   record_synch_enabled = false;
5175 }
5176 
5177 #endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5178 #endif // PRODUCT
5179 
5180 const intptr_t thr_time_off  = (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5181 const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) -
5182                                (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5183 
5184 
5185 // JVMTI & JVM monitoring and management support
5186 // The thread_cpu_time() and current_thread_cpu_time() are only
5187 // supported if is_thread_cpu_time_supported() returns true.
5188 // They are not supported on Solaris T1.
5189 
5190 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
5191 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
5192 // of a thread.
5193 //
5194 // current_thread_cpu_time() and thread_cpu_time(Thread *)
5195 // returns the fast estimate available on the platform.
5196 
5197 // hrtime_t gethrvtime() return value includes
5198 // user time but does not include system time
5199 jlong os::current_thread_cpu_time() {
5200   return (jlong) gethrvtime();
5201 }
5202 
5203 jlong os::thread_cpu_time(Thread *thread) {
5204   // return user level CPU time only to be consistent with
5205   // what current_thread_cpu_time returns.
5206   // thread_cpu_time_info() must be changed if this changes
5207   return os::thread_cpu_time(thread, false /* user time only */);
5208 }
5209 
5210 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
5211   if (user_sys_cpu_time) {
5212     return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
5213   } else {
5214     return os::current_thread_cpu_time();
5215   }
5216 }
5217 
5218 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
5219   char proc_name[64];
5220   int count;
5221   prusage_t prusage;
5222   jlong lwp_time;
5223   int fd;
5224 
5225   sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage",
5226           getpid(),
5227           thread->osthread()->lwp_id());
5228   fd = ::open(proc_name, O_RDONLY);
5229   if (fd == -1) return -1;
5230 
5231   do {
5232     count = ::pread(fd,
5233                     (void *)&prusage.pr_utime,
5234                     thr_time_size,
5235                     thr_time_off);
5236   } while (count < 0 && errno == EINTR);
5237   ::close(fd);
5238   if (count < 0) return -1;
5239 
5240   if (user_sys_cpu_time) {
5241     // user + system CPU time
5242     lwp_time = (((jlong)prusage.pr_stime.tv_sec +
5243                  (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) +
5244                  (jlong)prusage.pr_stime.tv_nsec +
5245                  (jlong)prusage.pr_utime.tv_nsec;
5246   } else {
5247     // user level CPU time only
5248     lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) +
5249                 (jlong)prusage.pr_utime.tv_nsec;
5250   }
5251 
5252   return (lwp_time);
5253 }
5254 
5255 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5256   info_ptr->max_value = ALL_64_BITS;      // will not wrap in less than 64 bits
5257   info_ptr->may_skip_backward = false;    // elapsed time not wall time
5258   info_ptr->may_skip_forward = false;     // elapsed time not wall time
5259   info_ptr->kind = JVMTI_TIMER_USER_CPU;  // only user time is returned
5260 }
5261 
5262 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5263   info_ptr->max_value = ALL_64_BITS;      // will not wrap in less than 64 bits
5264   info_ptr->may_skip_backward = false;    // elapsed time not wall time
5265   info_ptr->may_skip_forward = false;     // elapsed time not wall time
5266   info_ptr->kind = JVMTI_TIMER_USER_CPU;  // only user time is returned
5267 }
5268 
5269 bool os::is_thread_cpu_time_supported() {
5270   return true;
5271 }
5272 
5273 // System loadavg support.  Returns -1 if load average cannot be obtained.
5274 // Return the load average for our processor set if the primitive exists
5275 // (Solaris 9 and later).  Otherwise just return system wide loadavg.
5276 int os::loadavg(double loadavg[], int nelem) {
5277   if (pset_getloadavg_ptr != NULL) {
5278     return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem);
5279   } else {
5280     return ::getloadavg(loadavg, nelem);
5281   }
5282 }
5283 
5284 //---------------------------------------------------------------------------------
5285 
5286 bool os::find(address addr, outputStream* st) {
5287   Dl_info dlinfo;
5288   memset(&dlinfo, 0, sizeof(dlinfo));
5289   if (dladdr(addr, &dlinfo) != 0) {
5290     st->print(PTR_FORMAT ": ", addr);
5291     if (dlinfo.dli_sname != NULL && dlinfo.dli_saddr != NULL) {
5292       st->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr);
5293     } else if (dlinfo.dli_fbase != NULL) {
5294       st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase);
5295     } else {
5296       st->print("<absolute address>");
5297     }
5298     if (dlinfo.dli_fname != NULL) {
5299       st->print(" in %s", dlinfo.dli_fname);
5300     }
5301     if (dlinfo.dli_fbase != NULL) {
5302       st->print(" at " PTR_FORMAT, dlinfo.dli_fbase);
5303     }
5304     st->cr();
5305 
5306     if (Verbose) {
5307       // decode some bytes around the PC
5308       address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size());
5309       address end   = clamp_address_in_page(addr+40, addr, os::vm_page_size());
5310       address       lowest = (address) dlinfo.dli_sname;
5311       if (!lowest)  lowest = (address) dlinfo.dli_fbase;
5312       if (begin < lowest)  begin = lowest;
5313       Dl_info dlinfo2;
5314       if (dladdr(end, &dlinfo2) != 0 && dlinfo2.dli_saddr != dlinfo.dli_saddr
5315           && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) {
5316         end = (address) dlinfo2.dli_saddr;
5317       }
5318       Disassembler::decode(begin, end, st);
5319     }
5320     return true;
5321   }
5322   return false;
5323 }
5324 
5325 // Following function has been added to support HotSparc's libjvm.so running
5326 // under Solaris production JDK 1.2.2 / 1.3.0.  These came from
5327 // src/solaris/hpi/native_threads in the EVM codebase.
5328 //
5329 // NOTE: This is no longer needed in the 1.3.1 and 1.4 production release
5330 // libraries and should thus be removed. We will leave it behind for a while
5331 // until we no longer want to able to run on top of 1.3.0 Solaris production
5332 // JDK. See 4341971.
5333 
5334 #define STACK_SLACK 0x800
5335 
5336 extern "C" {
5337   intptr_t sysThreadAvailableStackWithSlack() {
5338     stack_t st;
5339     intptr_t retval, stack_top;
5340     retval = thr_stksegment(&st);
5341     assert(retval == 0, "incorrect return value from thr_stksegment");
5342     assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
5343     assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
5344     stack_top=(intptr_t)st.ss_sp-st.ss_size;
5345     return ((intptr_t)&stack_top - stack_top - STACK_SLACK);
5346   }
5347 }
5348 
5349 // ObjectMonitor park-unpark infrastructure ...
5350 //
5351 // We implement Solaris and Linux PlatformEvents with the
5352 // obvious condvar-mutex-flag triple.
5353 // Another alternative that works quite well is pipes:
5354 // Each PlatformEvent consists of a pipe-pair.
5355 // The thread associated with the PlatformEvent
5356 // calls park(), which reads from the input end of the pipe.
5357 // Unpark() writes into the other end of the pipe.
5358 // The write-side of the pipe must be set NDELAY.
5359 // Unfortunately pipes consume a large # of handles.
5360 // Native solaris lwp_park() and lwp_unpark() work nicely, too.
5361 // Using pipes for the 1st few threads might be workable, however.
5362 //
5363 // park() is permitted to return spuriously.
5364 // Callers of park() should wrap the call to park() in
5365 // an appropriate loop.  A litmus test for the correct
5366 // usage of park is the following: if park() were modified
5367 // to immediately return 0 your code should still work,
5368 // albeit degenerating to a spin loop.
5369 //
5370 // In a sense, park()-unpark() just provides more polite spinning
5371 // and polling with the key difference over naive spinning being
5372 // that a parked thread needs to be explicitly unparked() in order
5373 // to wake up and to poll the underlying condition.
5374 //
5375 // Assumption:
5376 //    Only one parker can exist on an event, which is why we allocate
5377 //    them per-thread. Multiple unparkers can coexist.
5378 //
5379 // _Event transitions in park()
5380 //   -1 => -1 : illegal
5381 //    1 =>  0 : pass - return immediately
5382 //    0 => -1 : block; then set _Event to 0 before returning
5383 //
5384 // _Event transitions in unpark()
5385 //    0 => 1 : just return
5386 //    1 => 1 : just return
5387 //   -1 => either 0 or 1; must signal target thread
5388 //         That is, we can safely transition _Event from -1 to either
5389 //         0 or 1.
5390 //
5391 // _Event serves as a restricted-range semaphore.
5392 //   -1 : thread is blocked, i.e. there is a waiter
5393 //    0 : neutral: thread is running or ready,
5394 //        could have been signaled after a wait started
5395 //    1 : signaled - thread is running or ready
5396 //
5397 // Another possible encoding of _Event would be with
5398 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5399 //
5400 // TODO-FIXME: add DTRACE probes for:
5401 // 1.   Tx parks
5402 // 2.   Ty unparks Tx
5403 // 3.   Tx resumes from park
5404 
5405 
5406 // value determined through experimentation
5407 #define ROUNDINGFIX 11
5408 
5409 // utility to compute the abstime argument to timedwait.
5410 // TODO-FIXME: switch from compute_abstime() to unpackTime().
5411 
5412 static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) {
5413   // millis is the relative timeout time
5414   // abstime will be the absolute timeout time
5415   if (millis < 0)  millis = 0;
5416   struct timeval now;
5417   int status = gettimeofday(&now, NULL);
5418   assert(status == 0, "gettimeofday");
5419   jlong seconds = millis / 1000;
5420   jlong max_wait_period;
5421 
5422   if (UseLWPSynchronization) {
5423     // forward port of fix for 4275818 (not sleeping long enough)
5424     // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where
5425     // _lwp_cond_timedwait() used a round_down algorithm rather
5426     // than a round_up. For millis less than our roundfactor
5427     // it rounded down to 0 which doesn't meet the spec.
5428     // For millis > roundfactor we may return a bit sooner, but
5429     // since we can not accurately identify the patch level and
5430     // this has already been fixed in Solaris 9 and 8 we will
5431     // leave it alone rather than always rounding down.
5432 
5433     if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX;
5434     // It appears that when we go directly through Solaris _lwp_cond_timedwait()
5435     // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6
5436     max_wait_period = 21000000;
5437   } else {
5438     max_wait_period = 50000000;
5439   }
5440   millis %= 1000;
5441   if (seconds > max_wait_period) {      // see man cond_timedwait(3T)
5442     seconds = max_wait_period;
5443   }
5444   abstime->tv_sec = now.tv_sec  + seconds;
5445   long       usec = now.tv_usec + millis * 1000;
5446   if (usec >= 1000000) {
5447     abstime->tv_sec += 1;
5448     usec -= 1000000;
5449   }
5450   abstime->tv_nsec = usec * 1000;
5451   return abstime;
5452 }
5453 
5454 void os::PlatformEvent::park() {           // AKA: down()
5455   // Transitions for _Event:
5456   //   -1 => -1 : illegal
5457   //    1 =>  0 : pass - return immediately
5458   //    0 => -1 : block; then set _Event to 0 before returning
5459 
5460   // Invariant: Only the thread associated with the Event/PlatformEvent
5461   // may call park().
5462   assert(_nParked == 0, "invariant");
5463 
5464   int v;
5465   for (;;) {
5466     v = _Event;
5467     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5468   }
5469   guarantee(v >= 0, "invariant");
5470   if (v == 0) {
5471     // Do this the hard way by blocking ...
5472     // See http://monaco.sfbay/detail.jsf?cr=5094058.
5473     // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5474     // Only for SPARC >= V8PlusA
5475 #if defined(__sparc) && defined(COMPILER2)
5476     if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5477 #endif
5478     int status = os::Solaris::mutex_lock(_mutex);
5479     assert_status(status == 0, status, "mutex_lock");
5480     guarantee(_nParked == 0, "invariant");
5481     ++_nParked;
5482     while (_Event < 0) {
5483       // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
5484       // Treat this the same as if the wait was interrupted
5485       // With usr/lib/lwp going to kernel, always handle ETIME
5486       status = os::Solaris::cond_wait(_cond, _mutex);
5487       if (status == ETIME) status = EINTR;
5488       assert_status(status == 0 || status == EINTR, status, "cond_wait");
5489     }
5490     --_nParked;
5491     _Event = 0;
5492     status = os::Solaris::mutex_unlock(_mutex);
5493     assert_status(status == 0, status, "mutex_unlock");
5494     // Paranoia to ensure our locked and lock-free paths interact
5495     // correctly with each other.
5496     OrderAccess::fence();
5497   }
5498 }
5499 
5500 int os::PlatformEvent::park(jlong millis) {
5501   // Transitions for _Event:
5502   //   -1 => -1 : illegal
5503   //    1 =>  0 : pass - return immediately
5504   //    0 => -1 : block; then set _Event to 0 before returning
5505 
5506   guarantee(_nParked == 0, "invariant");
5507   int v;
5508   for (;;) {
5509     v = _Event;
5510     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5511   }
5512   guarantee(v >= 0, "invariant");
5513   if (v != 0) return OS_OK;
5514 
5515   int ret = OS_TIMEOUT;
5516   timestruc_t abst;
5517   compute_abstime(&abst, millis);
5518 
5519   // See http://monaco.sfbay/detail.jsf?cr=5094058.
5520   // For Solaris SPARC set fprs.FEF=0 prior to parking.
5521   // Only for SPARC >= V8PlusA
5522 #if defined(__sparc) && defined(COMPILER2)
5523   if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5524 #endif
5525   int status = os::Solaris::mutex_lock(_mutex);
5526   assert_status(status == 0, status, "mutex_lock");
5527   guarantee(_nParked == 0, "invariant");
5528   ++_nParked;
5529   while (_Event < 0) {
5530     int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst);
5531     assert_status(status == 0 || status == EINTR ||
5532                   status == ETIME || status == ETIMEDOUT,
5533                   status, "cond_timedwait");
5534     if (!FilterSpuriousWakeups) break;                // previous semantics
5535     if (status == ETIME || status == ETIMEDOUT) break;
5536     // We consume and ignore EINTR and spurious wakeups.
5537   }
5538   --_nParked;
5539   if (_Event >= 0) ret = OS_OK;
5540   _Event = 0;
5541   status = os::Solaris::mutex_unlock(_mutex);
5542   assert_status(status == 0, status, "mutex_unlock");
5543   // Paranoia to ensure our locked and lock-free paths interact
5544   // correctly with each other.
5545   OrderAccess::fence();
5546   return ret;
5547 }
5548 
5549 void os::PlatformEvent::unpark() {
5550   // Transitions for _Event:
5551   //    0 => 1 : just return
5552   //    1 => 1 : just return
5553   //   -1 => either 0 or 1; must signal target thread
5554   //         That is, we can safely transition _Event from -1 to either
5555   //         0 or 1.
5556   // See also: "Semaphores in Plan 9" by Mullender & Cox
5557   //
5558   // Note: Forcing a transition from "-1" to "1" on an unpark() means
5559   // that it will take two back-to-back park() calls for the owning
5560   // thread to block. This has the benefit of forcing a spurious return
5561   // from the first park() call after an unpark() call which will help
5562   // shake out uses of park() and unpark() without condition variables.
5563 
5564   if (Atomic::xchg(1, &_Event) >= 0) return;
5565 
5566   // If the thread associated with the event was parked, wake it.
5567   // Wait for the thread assoc with the PlatformEvent to vacate.
5568   int status = os::Solaris::mutex_lock(_mutex);
5569   assert_status(status == 0, status, "mutex_lock");
5570   int AnyWaiters = _nParked;
5571   status = os::Solaris::mutex_unlock(_mutex);
5572   assert_status(status == 0, status, "mutex_unlock");
5573   guarantee(AnyWaiters == 0 || AnyWaiters == 1, "invariant");
5574   if (AnyWaiters != 0) {
5575     // Note that we signal() *after* dropping the lock for "immortal" Events.
5576     // This is safe and avoids a common class of  futile wakeups.  In rare
5577     // circumstances this can cause a thread to return prematurely from
5578     // cond_{timed}wait() but the spurious wakeup is benign and the victim
5579     // will simply re-test the condition and re-park itself.
5580     // This provides particular benefit if the underlying platform does not
5581     // provide wait morphing.
5582     status = os::Solaris::cond_signal(_cond);
5583     assert_status(status == 0, status, "cond_signal");
5584   }
5585 }
5586 
5587 // JSR166
5588 // -------------------------------------------------------
5589 
5590 // The solaris and linux implementations of park/unpark are fairly
5591 // conservative for now, but can be improved. They currently use a
5592 // mutex/condvar pair, plus _counter.
5593 // Park decrements _counter if > 0, else does a condvar wait.  Unpark
5594 // sets count to 1 and signals condvar.  Only one thread ever waits
5595 // on the condvar. Contention seen when trying to park implies that someone
5596 // is unparking you, so don't wait. And spurious returns are fine, so there
5597 // is no need to track notifications.
5598 
5599 #define MAX_SECS 100000000
5600 
5601 // This code is common to linux and solaris and will be moved to a
5602 // common place in dolphin.
5603 //
5604 // The passed in time value is either a relative time in nanoseconds
5605 // or an absolute time in milliseconds. Either way it has to be unpacked
5606 // into suitable seconds and nanoseconds components and stored in the
5607 // given timespec structure.
5608 // Given time is a 64-bit value and the time_t used in the timespec is only
5609 // a signed-32-bit value (except on 64-bit Linux) we have to watch for
5610 // overflow if times way in the future are given. Further on Solaris versions
5611 // prior to 10 there is a restriction (see cond_timedwait) that the specified
5612 // number of seconds, in abstime, is less than current_time  + 100,000,000.
5613 // As it will be 28 years before "now + 100000000" will overflow we can
5614 // ignore overflow and just impose a hard-limit on seconds using the value
5615 // of "now + 100,000,000". This places a limit on the timeout of about 3.17
5616 // years from "now".
5617 //
5618 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
5619   assert(time > 0, "convertTime");
5620 
5621   struct timeval now;
5622   int status = gettimeofday(&now, NULL);
5623   assert(status == 0, "gettimeofday");
5624 
5625   time_t max_secs = now.tv_sec + MAX_SECS;
5626 
5627   if (isAbsolute) {
5628     jlong secs = time / 1000;
5629     if (secs > max_secs) {
5630       absTime->tv_sec = max_secs;
5631     } else {
5632       absTime->tv_sec = secs;
5633     }
5634     absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
5635   } else {
5636     jlong secs = time / NANOSECS_PER_SEC;
5637     if (secs >= MAX_SECS) {
5638       absTime->tv_sec = max_secs;
5639       absTime->tv_nsec = 0;
5640     } else {
5641       absTime->tv_sec = now.tv_sec + secs;
5642       absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
5643       if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
5644         absTime->tv_nsec -= NANOSECS_PER_SEC;
5645         ++absTime->tv_sec; // note: this must be <= max_secs
5646       }
5647     }
5648   }
5649   assert(absTime->tv_sec >= 0, "tv_sec < 0");
5650   assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
5651   assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
5652   assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
5653 }
5654 
5655 void Parker::park(bool isAbsolute, jlong time) {
5656   // Ideally we'd do something useful while spinning, such
5657   // as calling unpackTime().
5658 
5659   // Optional fast-path check:
5660   // Return immediately if a permit is available.
5661   // We depend on Atomic::xchg() having full barrier semantics
5662   // since we are doing a lock-free update to _counter.
5663   if (Atomic::xchg(0, &_counter) > 0) return;
5664 
5665   // Optional fast-exit: Check interrupt before trying to wait
5666   Thread* thread = Thread::current();
5667   assert(thread->is_Java_thread(), "Must be JavaThread");
5668   JavaThread *jt = (JavaThread *)thread;
5669   if (Thread::is_interrupted(thread, false)) {
5670     return;
5671   }
5672 
5673   // First, demultiplex/decode time arguments
5674   timespec absTime;
5675   if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
5676     return;
5677   }
5678   if (time > 0) {
5679     // Warning: this code might be exposed to the old Solaris time
5680     // round-down bugs.  Grep "roundingFix" for details.
5681     unpackTime(&absTime, isAbsolute, time);
5682   }
5683 
5684   // Enter safepoint region
5685   // Beware of deadlocks such as 6317397.
5686   // The per-thread Parker:: _mutex is a classic leaf-lock.
5687   // In particular a thread must never block on the Threads_lock while
5688   // holding the Parker:: mutex.  If safepoints are pending both the
5689   // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
5690   ThreadBlockInVM tbivm(jt);
5691 
5692   // Don't wait if cannot get lock since interference arises from
5693   // unblocking.  Also. check interrupt before trying wait
5694   if (Thread::is_interrupted(thread, false) ||
5695       os::Solaris::mutex_trylock(_mutex) != 0) {
5696     return;
5697   }
5698 
5699   int status;
5700 
5701   if (_counter > 0)  { // no wait needed
5702     _counter = 0;
5703     status = os::Solaris::mutex_unlock(_mutex);
5704     assert(status == 0, "invariant");
5705     // Paranoia to ensure our locked and lock-free paths interact
5706     // correctly with each other and Java-level accesses.
5707     OrderAccess::fence();
5708     return;
5709   }
5710 
5711 #ifdef ASSERT
5712   // Don't catch signals while blocked; let the running threads have the signals.
5713   // (This allows a debugger to break into the running thread.)
5714   sigset_t oldsigs;
5715   sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();
5716   thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
5717 #endif
5718 
5719   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5720   jt->set_suspend_equivalent();
5721   // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
5722 
5723   // Do this the hard way by blocking ...
5724   // See http://monaco.sfbay/detail.jsf?cr=5094058.
5725   // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5726   // Only for SPARC >= V8PlusA
5727 #if defined(__sparc) && defined(COMPILER2)
5728   if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5729 #endif
5730 
5731   if (time == 0) {
5732     status = os::Solaris::cond_wait(_cond, _mutex);
5733   } else {
5734     status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
5735   }
5736   // Note that an untimed cond_wait() can sometimes return ETIME on older
5737   // versions of the Solaris.
5738   assert_status(status == 0 || status == EINTR ||
5739                 status == ETIME || status == ETIMEDOUT,
5740                 status, "cond_timedwait");
5741 
5742 #ifdef ASSERT
5743   thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
5744 #endif
5745   _counter = 0;
5746   status = os::Solaris::mutex_unlock(_mutex);
5747   assert_status(status == 0, status, "mutex_unlock");
5748   // Paranoia to ensure our locked and lock-free paths interact
5749   // correctly with each other and Java-level accesses.
5750   OrderAccess::fence();
5751 
5752   // If externally suspended while waiting, re-suspend
5753   if (jt->handle_special_suspend_equivalent_condition()) {
5754     jt->java_suspend_self();
5755   }
5756 }
5757 
5758 void Parker::unpark() {
5759   int status = os::Solaris::mutex_lock(_mutex);
5760   assert(status == 0, "invariant");
5761   const int s = _counter;
5762   _counter = 1;
5763   status = os::Solaris::mutex_unlock(_mutex);
5764   assert(status == 0, "invariant");
5765 
5766   if (s < 1) {
5767     status = os::Solaris::cond_signal(_cond);
5768     assert(status == 0, "invariant");
5769   }
5770 }
5771 
5772 extern char** environ;
5773 
5774 // Run the specified command in a separate process. Return its exit value,
5775 // or -1 on failure (e.g. can't fork a new process).
5776 // Unlike system(), this function can be called from signal handler. It
5777 // doesn't block SIGINT et al.
5778 int os::fork_and_exec(char* cmd) {
5779   char * argv[4];
5780   argv[0] = (char *)"sh";
5781   argv[1] = (char *)"-c";
5782   argv[2] = cmd;
5783   argv[3] = NULL;
5784 
5785   // fork is async-safe, fork1 is not so can't use in signal handler
5786   pid_t pid;
5787   Thread* t = ThreadLocalStorage::get_thread_slow();
5788   if (t != NULL && t->is_inside_signal_handler()) {
5789     pid = fork();
5790   } else {
5791     pid = fork1();
5792   }
5793 
5794   if (pid < 0) {
5795     // fork failed
5796     warning("fork failed: %s", strerror(errno));
5797     return -1;
5798 
5799   } else if (pid == 0) {
5800     // child process
5801 
5802     // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris
5803     execve("/usr/bin/sh", argv, environ);
5804 
5805     // execve failed
5806     _exit(-1);
5807 
5808   } else  {
5809     // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
5810     // care about the actual exit code, for now.
5811 
5812     int status;
5813 
5814     // Wait for the child process to exit.  This returns immediately if
5815     // the child has already exited. */
5816     while (waitpid(pid, &status, 0) < 0) {
5817       switch (errno) {
5818       case ECHILD: return 0;
5819       case EINTR: break;
5820       default: return -1;
5821       }
5822     }
5823 
5824     if (WIFEXITED(status)) {
5825       // The child exited normally; get its exit code.
5826       return WEXITSTATUS(status);
5827     } else if (WIFSIGNALED(status)) {
5828       // The child exited because of a signal
5829       // The best value to return is 0x80 + signal number,
5830       // because that is what all Unix shells do, and because
5831       // it allows callers to distinguish between process exit and
5832       // process death by signal.
5833       return 0x80 + WTERMSIG(status);
5834     } else {
5835       // Unknown exit code; pass it through
5836       return status;
5837     }
5838   }
5839 }
5840 
5841 // is_headless_jre()
5842 //
5843 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
5844 // in order to report if we are running in a headless jre
5845 //
5846 // Since JDK8 xawt/libmawt.so was moved into the same directory
5847 // as libawt.so, and renamed libawt_xawt.so
5848 //
5849 bool os::is_headless_jre() {
5850   struct stat statbuf;
5851   char buf[MAXPATHLEN];
5852   char libmawtpath[MAXPATHLEN];
5853   const char *xawtstr  = "/xawt/libmawt.so";
5854   const char *new_xawtstr = "/libawt_xawt.so";
5855   char *p;
5856 
5857   // Get path to libjvm.so
5858   os::jvm_path(buf, sizeof(buf));
5859 
5860   // Get rid of libjvm.so
5861   p = strrchr(buf, '/');
5862   if (p == NULL) {
5863     return false;
5864   } else {
5865     *p = '\0';
5866   }
5867 
5868   // Get rid of client or server
5869   p = strrchr(buf, '/');
5870   if (p == NULL) {
5871     return false;
5872   } else {
5873     *p = '\0';
5874   }
5875 
5876   // check xawt/libmawt.so
5877   strcpy(libmawtpath, buf);
5878   strcat(libmawtpath, xawtstr);
5879   if (::stat(libmawtpath, &statbuf) == 0) return false;
5880 
5881   // check libawt_xawt.so
5882   strcpy(libmawtpath, buf);
5883   strcat(libmawtpath, new_xawtstr);
5884   if (::stat(libmawtpath, &statbuf) == 0) return false;
5885 
5886   return true;
5887 }
5888 
5889 size_t os::write(int fd, const void *buf, unsigned int nBytes) {
5890   size_t res;
5891   assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5892          "Assumed _thread_in_native");
5893   RESTARTABLE((size_t) ::write(fd, buf, (size_t) nBytes), res);
5894   return res;
5895 }
5896 
5897 int os::close(int fd) {
5898   return ::close(fd);
5899 }
5900 
5901 int os::socket_close(int fd) {
5902   return ::close(fd);
5903 }
5904 
5905 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5906   assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5907          "Assumed _thread_in_native");
5908   RESTARTABLE_RETURN_INT((int)::recv(fd, buf, nBytes, flags));
5909 }
5910 
5911 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5912   assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5913          "Assumed _thread_in_native");
5914   RESTARTABLE_RETURN_INT((int)::send(fd, buf, nBytes, flags));
5915 }
5916 
5917 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5918   RESTARTABLE_RETURN_INT((int)::send(fd, buf, nBytes, flags));
5919 }
5920 
5921 // As both poll and select can be interrupted by signals, we have to be
5922 // prepared to restart the system call after updating the timeout, unless
5923 // a poll() is done with timeout == -1, in which case we repeat with this
5924 // "wait forever" value.
5925 
5926 int os::connect(int fd, struct sockaddr *him, socklen_t len) {
5927   int _result;
5928   _result = ::connect(fd, him, len);
5929 
5930   // On Solaris, when a connect() call is interrupted, the connection
5931   // can be established asynchronously (see 6343810). Subsequent calls
5932   // to connect() must check the errno value which has the semantic
5933   // described below (copied from the connect() man page). Handling
5934   // of asynchronously established connections is required for both
5935   // blocking and non-blocking sockets.
5936   //     EINTR            The  connection  attempt  was   interrupted
5937   //                      before  any data arrived by the delivery of
5938   //                      a signal. The connection, however, will  be
5939   //                      established asynchronously.
5940   //
5941   //     EINPROGRESS      The socket is non-blocking, and the connec-
5942   //                      tion  cannot  be completed immediately.
5943   //
5944   //     EALREADY         The socket is non-blocking,  and a previous
5945   //                      connection  attempt  has  not yet been com-
5946   //                      pleted.
5947   //
5948   //     EISCONN          The socket is already connected.
5949   if (_result == OS_ERR && errno == EINTR) {
5950     // restarting a connect() changes its errno semantics
5951     RESTARTABLE(::connect(fd, him, len), _result);
5952     // undo these changes
5953     if (_result == OS_ERR) {
5954       if (errno == EALREADY) {
5955         errno = EINPROGRESS; // fall through
5956       } else if (errno == EISCONN) {
5957         errno = 0;
5958         return OS_OK;
5959       }
5960     }
5961   }
5962   return _result;
5963 }
5964 
5965 // Get the default path to the core file
5966 // Returns the length of the string
5967 int os::get_core_path(char* buffer, size_t bufferSize) {
5968   const char* p = get_current_directory(buffer, bufferSize);
5969 
5970   if (p == NULL) {
5971     assert(p != NULL, "failed to get current directory");
5972     return 0;
5973   }
5974 
5975   jio_snprintf(buffer, bufferSize, "%s/core or core.%d",
5976                                               p, current_process_id());
5977 
5978   return strlen(buffer);
5979 }
5980 
5981 #ifndef PRODUCT
5982 void TestReserveMemorySpecial_test() {
5983   // No tests available for this platform
5984 }
5985 #endif