rev 6280 : [mq]: osx-clock

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