/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

// do not include  precompiled  header file

# include "incls/_os_solaris.cpp.incl"

// put OS-includes here

# include <dlfcn.h>

# include <errno.h>

# include <link.h>

# include <poll.h>

# include <pthread.h>

# include <pwd.h>

# include <schedctl.h>

# include <setjmp.h>

# include <signal.h>

# include <stdio.h>

# include <alloca.h>

# include <sys/filio.h>

# include <sys/ipc.h>

# include <sys/lwp.h>

# include <sys/machelf.h>     // for elf Sym structure used by dladdr1

# include <sys/mman.h>

# include <sys/processor.h>

# include <sys/procset.h>

# include <sys/pset.h>

# include <sys/resource.h>

# include <sys/shm.h>

# include <sys/socket.h>

# include <sys/stat.h>

# include <sys/systeminfo.h>

# include <sys/time.h>

# include <sys/times.h>

# include <sys/types.h>

# include <sys/wait.h>

# include <sys/utsname.h>

# include <thread.h>

# include <unistd.h>

# include <sys/priocntl.h>

# include <sys/rtpriocntl.h>

# include <sys/tspriocntl.h>

# include <sys/iapriocntl.h>

# include <sys/loadavg.h>

# include <string.h>

# define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later

# include <sys/procfs.h>     //  see comment in <sys/procfs.h>

#define MAX_PATH (2 * K)

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

#ifdef _GNU_SOURCE

// See bug #6514594

extern "C" int madvise(caddr_t, size_t, int);

extern "C"  int memcntl(caddr_t addr, size_t len, int cmd, caddr_t  arg,

     int attr, int mask);

#endif //_GNU_SOURCE

/*

  MPSS Changes Start.

  The JVM binary needs to be built and run on pre-Solaris 9

  systems, but the constants needed by MPSS are only in Solaris 9

  header files.  They are textually replicated here to allow

  building on earlier systems.  Once building on Solaris 8 is

  no longer a requirement, these #defines can be replaced by ordinary

  system .h inclusion.

  In earlier versions of the  JDK and Solaris, we used ISM for large pages.

  But ISM requires shared memory to achieve this and thus has many caveats.

  MPSS is a fully transparent and is a cleaner way to get large pages.

  Although we still require keeping ISM for backward compatiblitiy as well as

  giving the opportunity to use large pages on older systems it is

  recommended that MPSS be used for Solaris 9 and above.

*/

#ifndef MC_HAT_ADVISE

struct memcntl_mha {

  uint_t          mha_cmd;        /* command(s) */

  uint_t          mha_flags;

  size_t          mha_pagesize;

};

#define MC_HAT_ADVISE   7       /* advise hat map size */

#define MHA_MAPSIZE_VA  0x1     /* set preferred page size */

#define MAP_ALIGN       0x200   /* addr specifies alignment */

#endif

// MPSS Changes End.

// Here are some liblgrp types from sys/lgrp_user.h to be able to

// compile on older systems without this header file.

#ifndef MADV_ACCESS_LWP

# define  MADV_ACCESS_LWP         7       /* next LWP to access heavily */

#endif

#ifndef MADV_ACCESS_MANY

# define  MADV_ACCESS_MANY        8       /* many processes to access heavily */

#endif

// Some more macros from sys/mman.h that are not present in Solaris 8.

#ifndef MAX_MEMINFO_CNT

/*

 * info_req request type definitions for meminfo

 * request types starting with MEMINFO_V are used for Virtual addresses

 * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical

 * addresses

 */

# define MEMINFO_SHIFT           16

# define MEMINFO_MASK            (0xFF << MEMINFO_SHIFT)

# define MEMINFO_VPHYSICAL       (0x01 << MEMINFO_SHIFT) /* get physical addr */

# define MEMINFO_VLGRP           (0x02 << MEMINFO_SHIFT) /* get lgroup */

# define MEMINFO_VPAGESIZE       (0x03 << MEMINFO_SHIFT) /* size of phys page */

# define MEMINFO_VREPLCNT        (0x04 << MEMINFO_SHIFT) /* no. of replica */

# define MEMINFO_VREPL           (0x05 << MEMINFO_SHIFT) /* physical replica */

# define MEMINFO_VREPL_LGRP      (0x06 << MEMINFO_SHIFT) /* lgrp of replica */

# define MEMINFO_PLGRP           (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */

/* maximum number of addresses meminfo() can process at a time */

# define MAX_MEMINFO_CNT 256

/* maximum number of request types */

# define MAX_MEMINFO_REQ 31

#endif

// see thr_setprio(3T) for the basis of these numbers

#define MinimumPriority 0

#define NormalPriority  64

#define MaximumPriority 127

// Values for ThreadPriorityPolicy == 1

int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64,

                                        80, 96, 112, 124, 127 };

// System parameters used internally

static clock_t clock_tics_per_sec = 100;

// For diagnostics to print a message once. see run_periodic_checks

static bool check_addr0_done = false;

static sigset_t check_signal_done;

static bool check_signals = true;

address os::Solaris::handler_start;  // start pc of thr_sighndlrinfo

address os::Solaris::handler_end;    // end pc of thr_sighndlrinfo

address os::Solaris::_main_stack_base = NULL;  // 4352906 workaround

// "default" initializers for missing libc APIs

extern "C" {

  static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

  static int lwp_mutex_destroy(mutex_t *mx)                 { return 0; }

  static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

  static int lwp_cond_destroy(cond_t *cv)                   { return 0; }

}

// "default" initializers for pthread-based synchronization

extern "C" {

  static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

  static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

}

// Thread Local Storage

// This is common to all Solaris platforms so it is defined here,

// in this common file.

// The declarations are in the os_cpu threadLS*.hpp files.

//

// Static member initialization for TLS

Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};

#ifndef PRODUCT

#define _PCT(n,d)       ((100.0*(double)(n))/(double)(d))

int ThreadLocalStorage::_tcacheHit = 0;

int ThreadLocalStorage::_tcacheMiss = 0;

void ThreadLocalStorage::print_statistics() {

  int total = _tcacheMiss+_tcacheHit;

  tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",

                _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));

}

#undef _PCT

#endif // PRODUCT

Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,

                                                        int index) {

  Thread *thread = get_thread_slow();

  if (thread != NULL) {

    address sp = os::current_stack_pointer();

    guarantee(thread->_stack_base == NULL ||

              (sp <= thread->_stack_base &&

                 sp >= thread->_stack_base - thread->_stack_size) ||

               is_error_reported(),

              "sp must be inside of selected thread stack");

    thread->_self_raw_id = raw_id;  // mark for quick retrieval

    _get_thread_cache[ index ] = thread;

  }

  return thread;

}

static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};

#define NO_CACHED_THREAD ((Thread*)all_zero)

void ThreadLocalStorage::pd_set_thread(Thread* thread) {

  // Store the new value before updating the cache to prevent a race

  // between get_thread_via_cache_slowly() and this store operation.

  os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);

  // Update thread cache with new thread if setting on thread create,

  // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.

  uintptr_t raw = pd_raw_thread_id();

  int ix = pd_cache_index(raw);

  _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;

}

void ThreadLocalStorage::pd_init() {

  for (int i = 0; i < _pd_cache_size; i++) {

    _get_thread_cache[i] = NO_CACHED_THREAD;

  }

}

// Invalidate all the caches (happens to be the same as pd_init).

void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }

#undef NO_CACHED_THREAD

// END Thread Local Storage

static inline size_t adjust_stack_size(address base, size_t size) {

  if ((ssize_t)size < 0) {

    // 4759953: Compensate for ridiculous stack size.

    size = max_intx;

  }

  if (size > (size_t)base) {

    // 4812466: Make sure size doesn't allow the stack to wrap the address space.

    size = (size_t)base;

  }

  return size;

}

static inline stack_t get_stack_info() {

  stack_t st;

  int retval = thr_stksegment(&st);

  st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);

  assert(retval == 0, "incorrect return value from thr_stksegment");

  assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");

  assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");

  return st;

}

address os::current_stack_base() {

  int r = thr_main() ;

  guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;

  bool is_primordial_thread = r;

  // Workaround 4352906, avoid calls to thr_stksegment by

  // thr_main after the first one (it looks like we trash

  // some data, causing the value for ss_sp to be incorrect).

  if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {

    stack_t st = get_stack_info();

    if (is_primordial_thread) {

      // cache initial value of stack base

      os::Solaris::_main_stack_base = (address)st.ss_sp;

    }

    return (address)st.ss_sp;

  } else {

    guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");

    return os::Solaris::_main_stack_base;

  }

}

size_t os::current_stack_size() {

  size_t size;

  int r = thr_main() ;

  guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;

  if(!r) {

    size = get_stack_info().ss_size;

  } else {

    struct rlimit limits;

    getrlimit(RLIMIT_STACK, &limits);

    size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);

  }

  // base may not be page aligned

  address base = current_stack_base();

  address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;

  return (size_t)(base - bottom);

}

// interruptible infrastructure

// setup_interruptible saves the thread state before going into an

// interruptible system call.

// The saved state is used to restore the thread to

// its former state whether or not an interrupt is received.

// Used by classloader os::read

// hpi calls skip this layer and stay in _thread_in_native

void os::Solaris::setup_interruptible(JavaThread* thread) {

  JavaThreadState thread_state = thread->thread_state();

  assert(thread_state != _thread_blocked, "Coming from the wrong thread");

  assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible");

  OSThread* osthread = thread->osthread();

  osthread->set_saved_interrupt_thread_state(thread_state);

  thread->frame_anchor()->make_walkable(thread);

  ThreadStateTransition::transition(thread, thread_state, _thread_blocked);

}

// Version of setup_interruptible() for threads that are already in

// _thread_blocked. Used by os_sleep().

void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) {

  thread->frame_anchor()->make_walkable(thread);

}

JavaThread* os::Solaris::setup_interruptible() {

  JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();

  setup_interruptible(thread);

  return thread;

}

void os::Solaris::try_enable_extended_io() {

  typedef int (*enable_extended_FILE_stdio_t)(int, int);

  if (!UseExtendedFileIO) {

    return;

  }

  enable_extended_FILE_stdio_t enabler =

    (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,

                                         "enable_extended_FILE_stdio");

  if (enabler) {

    enabler(-1, -1);

  }

}

#ifdef ASSERT

JavaThread* os::Solaris::setup_interruptible_native() {

  JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();

  JavaThreadState thread_state = thread->thread_state();

  assert(thread_state == _thread_in_native, "Assumed thread_in_native");

  return thread;

}

void os::Solaris::cleanup_interruptible_native(JavaThread* thread) {

  JavaThreadState thread_state = thread->thread_state();

  assert(thread_state == _thread_in_native, "Assumed thread_in_native");

}

#endif

// cleanup_interruptible reverses the effects of setup_interruptible

// setup_interruptible_already_blocked() does not need any cleanup.

void os::Solaris::cleanup_interruptible(JavaThread* thread) {

  OSThread* osthread = thread->osthread();

  ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state());

}

// I/O interruption related counters called in _INTERRUPTIBLE

void os::Solaris::bump_interrupted_before_count() {

  RuntimeService::record_interrupted_before_count();

}

void os::Solaris::bump_interrupted_during_count() {

  RuntimeService::record_interrupted_during_count();

}

static int _processors_online = 0;

         jint os::Solaris::_os_thread_limit = 0;

volatile jint os::Solaris::_os_thread_count = 0;

julong os::available_memory() {

  return Solaris::available_memory();

}

julong os::Solaris::available_memory() {

  return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();

}

julong os::Solaris::_physical_memory = 0;

julong os::physical_memory() {

   return Solaris::physical_memory();

}

julong os::allocatable_physical_memory(julong size) {

#ifdef _LP64

   return size;

#else

   julong result = MIN2(size, (julong)3835*M);

   if (!is_allocatable(result)) {

     // Memory allocations will be aligned but the alignment

     // is not known at this point.  Alignments will

     // be at most to LargePageSizeInBytes.  Protect

     // allocations from alignments up to illegal

     // values. If at this point 2G is illegal.

     julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes;

     result =  MIN2(size, reasonable_size);

   }

   return result;

#endif

}

static hrtime_t first_hrtime = 0;

static const hrtime_t hrtime_hz = 1000*1000*1000;

const int LOCK_BUSY = 1;

const int LOCK_FREE = 0;

const int LOCK_INVALID = -1;

static volatile hrtime_t max_hrtime = 0;

static volatile int max_hrtime_lock = LOCK_FREE;     // Update counter with LSB as lock-in-progress

void os::Solaris::initialize_system_info() {

  _processor_count = sysconf(_SC_NPROCESSORS_CONF);

  _processors_online = sysconf (_SC_NPROCESSORS_ONLN);

  _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);

}

int os::active_processor_count() {

  int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);

  pid_t pid = getpid();

  psetid_t pset = PS_NONE;

  // Are we running in a processor set?

  if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {

    if (pset != PS_NONE) {

      uint_t pset_cpus;

      // Query number of cpus in processor set

      if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {

        assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");

        _processors_online = pset_cpus;

        return pset_cpus;

      }

    }

  }

  // Otherwise return number of online cpus

  return online_cpus;

}

static bool find_processors_in_pset(psetid_t        pset,

                                    processorid_t** id_array,

                                    uint_t*         id_length) {

  bool result = false;

  // Find the number of processors in the processor set.

  if (pset_info(pset, NULL, id_length, NULL) == 0) {

    // Make up an array to hold their ids.

    *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);

    // Fill in the array with their processor ids.

    if (pset_info(pset, NULL, id_length, *id_array) == 0) {

      result = true;

    }

  }

  return result;

}

// Callers of find_processors_online() must tolerate imprecise results --

// the system configuration can change asynchronously because of DR

// or explicit psradm operations.

//

// We also need to take care that the loop (below) terminates as the

// number of processors online can change between the _SC_NPROCESSORS_ONLN

// request and the loop that builds the list of processor ids.   Unfortunately

// there's no reliable way to determine the maximum valid processor id,

// so we use a manifest constant, MAX_PROCESSOR_ID, instead.  See p_online

// man pages, which claim the processor id set is "sparse, but

// not too sparse".  MAX_PROCESSOR_ID is used to ensure that we eventually

// exit the loop.

//

// In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's

// not available on S8.0.

static bool find_processors_online(processorid_t** id_array,

                                   uint*           id_length) {

  const processorid_t MAX_PROCESSOR_ID = 100000 ;

  // Find the number of processors online.

  *id_length = sysconf(_SC_NPROCESSORS_ONLN);

  // Make up an array to hold their ids.

  *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);

  // Processors need not be numbered consecutively.

  long found = 0;

  processorid_t next = 0;

  while (found < *id_length && next < MAX_PROCESSOR_ID) {

    processor_info_t info;

    if (processor_info(next, &info) == 0) {

      // NB, PI_NOINTR processors are effectively online ...

      if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {

        (*id_array)[found] = next;

        found += 1;

      }

    }

    next += 1;

  }

  if (found < *id_length) {

      // The loop above didn't identify the expected number of processors.