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