/*

 * Copyright (c) 1997, 2018, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

// no precompiled headers

#include "jvm.h"

#include "classfile/classLoader.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/icBuffer.hpp"

#include "code/vtableStubs.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "oops/oop.inline.hpp"

#include "os_share_solaris.hpp"

#include "os_solaris.inline.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/extendedPC.hpp"

#include "runtime/globals.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/osThread.hpp"

#include "runtime/perfMemory.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "runtime/vm_version.hpp"

#include "semaphore_posix.hpp"

#include "services/attachListener.hpp"

#include "services/memTracker.hpp"

#include "services/runtimeService.hpp"

#include "utilities/align.hpp"

#include "utilities/decoder.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/events.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/macros.hpp"

#include "utilities/vmError.hpp"

// put OS-includes here

# include <dlfcn.h>

# include <errno.h>

# include <exception>

# include <link.h>

# include <poll.h>

# include <pthread.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/fxpriocntl.h>

# include <sys/loadavg.h>

# include <string.h>

# include <stdio.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)

// 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

#ifndef LGRP_RSRC_CPU

  #define LGRP_RSRC_CPU      0       /* CPU resources */

#endif

#ifndef LGRP_RSRC_MEM

  #define LGRP_RSRC_MEM      1       /* memory resources */

#endif

// Values for ThreadPriorityPolicy == 1

int prio_policy1[CriticalPriority+1] = {

  -99999,  0, 16,  32,  48,  64,

          80, 96, 112, 124, 127, 127 };

// System parameters used internally

static clock_t clock_tics_per_sec = 100;

// Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)

static bool enabled_extended_FILE_stdio = false;

// 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

os::Solaris::pthread_setname_np_func_t os::Solaris::_pthread_setname_np = NULL;

// "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; }

}

static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);

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;

}

bool os::is_primordial_thread(void) {

  int r = thr_main();

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

  return r == 1;

}

address os::current_stack_base() {

  bool _is_primordial_thread = is_primordial_thread();

  // 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;

  if (!is_primordial_thread()) {

    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 = align_up(base - size, os::vm_page_size());;

  return (size_t)(base - bottom);

}

struct tm* os::localtime_pd(const time_t* clock, struct tm*  res) {

  return localtime_r(clock, res);

}

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);

  }

}

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();

}

static hrtime_t first_hrtime = 0;

static const hrtime_t hrtime_hz = 1000*1000*1000;

static volatile hrtime_t max_hrtime = 0;

void os::Solaris::initialize_system_info() {

  set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

  _processors_online = sysconf(_SC_NPROCESSORS_ONLN);

  _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) *

                                     (julong)sysconf(_SC_PAGESIZE);

}

uint os::processor_id() {

  const processorid_t id = ::getcpuid();

  assert(id >= 0 && id < _processor_count, "Invalid processor id");

  return (uint)id;

}

int os::active_processor_count() {

  // User has overridden the number of active processors

  if (ActiveProcessorCount > 0) {

    log_trace(os)("active_processor_count: "

                  "active processor count set by user : %d",

                  ActiveProcessorCount);

    return ActiveProcessorCount;

  }

  int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);

  pid_t pid = getpid();

  psetid_t pset = PS_NONE;

  // Are we running in a processor set or is there any processor set around?

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

    uint_t pset_cpus;

    // Query the number of cpus available to us.

    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, mtInternal);

    // 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, mtInternal);

  // 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.

    // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)

    // and re-running the loop, above, but there's no guarantee of progress

    // if the system configuration is in flux.  Instead, we just return what

    // we've got.  Note that in the worst case find_processors_online() could

    // return an empty set.  (As a fall-back in the case of the empty set we

    // could just return the ID of the current processor).

    *id_length = found;

  }

  return true;

}

static bool assign_distribution(processorid_t* id_array,

                                uint           id_length,

                                uint*          distribution,

                                uint           distribution_length) {

  // We assume we can assign processorid_t's to uint's.

  assert(sizeof(processorid_t) == sizeof(uint),

         "can't convert processorid_t to uint");

  // Quick check to see if we won't succeed.

  if (id_length < distribution_length) {

    return false;

  }

  // Assign processor ids to the distribution.

  // Try to shuffle processors to distribute work across boards,

  // assuming 4 processors per board.

  const uint processors_per_board = ProcessDistributionStride;

  // Find the maximum processor id.

  processorid_t max_id = 0;

  for (uint m = 0; m < id_length; m += 1) {

    max_id = MAX2(max_id, id_array[m]);

  }

  // The next id, to limit loops.

  const processorid_t limit_id = max_id + 1;

  // Make up markers for available processors.

  bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal);

  for (uint c = 0; c < limit_id; c += 1) {

    available_id[c] = false;

  }

  for (uint a = 0; a < id_length; a += 1) {

    available_id[id_array[a]] = true;

  }

  // Step by "boards", then by "slot", copying to "assigned".

  // NEEDS_CLEANUP: The assignment of processors should be stateful,

  //                remembering which processors have been assigned by

  //                previous calls, etc., so as to distribute several

  //                independent calls of this method.  What we'd like is

  //                It would be nice to have an API that let us ask

  //                how many processes are bound to a processor,

  //                but we don't have that, either.

  //                In the short term, "board" is static so that

  //                subsequent distributions don't all start at board 0.

  static uint board = 0;

  uint assigned = 0;

  // Until we've found enough processors ....

  while (assigned < distribution_length) {

    // ... find the next available processor in the board.

    for (uint slot = 0; slot < processors_per_board; slot += 1) {

      uint try_id = board * processors_per_board + slot;

      if ((try_id < limit_id) && (available_id[try_id] == true)) {

        distribution[assigned] = try_id;

        available_id[try_id] = false;

        assigned += 1;

        break;

      }

    }

    board += 1;

    if (board * processors_per_board + 0 >= limit_id) {

      board = 0;

    }

  }

  if (available_id != NULL) {

    FREE_C_HEAP_ARRAY(bool, available_id);

  }

  return true;

}

void os::set_native_thread_name(const char *name) {

  if (Solaris::_pthread_setname_np != NULL) {

    // Only the first 31 bytes of 'name' are processed by pthread_setname_np

    // but we explicitly copy into a size-limited buffer to avoid any

    // possible overflow.

    char buf[32];

    snprintf(buf, sizeof(buf), "%s", name);

    buf[sizeof(buf) - 1] = '\0';

    Solaris::_pthread_setname_np(pthread_self(), buf);

  }

}

bool os::distribute_processes(uint length, uint* distribution) {

  bool result = false;

  // Find the processor id's of all the available CPUs.

  processorid_t* id_array  = NULL;

  uint           id_length = 0;

  // There are some races between querying information and using it,

  // since processor sets can change dynamically.

  psetid_t pset = PS_NONE;

  // Are we running in a processor set?

  if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {

    result = find_processors_in_pset(pset, &id_array, &id_length);

  } else {

    result = find_processors_online(&id_array, &id_length);

  }

  if (result == true) {

    if (id_length >= length) {

      result = assign_distribution(id_array, id_length, distribution, length);

    } else {

      result = false;

    }

  }

  if (id_array != NULL) {

    FREE_C_HEAP_ARRAY(processorid_t, id_array);

  }

  return result;

}

bool os::bind_to_processor(uint processor_id) {

  // We assume that a processorid_t can be stored in a uint.

  assert(sizeof(uint) == sizeof(processorid_t),

         "can't convert uint to processorid_t");

  int bind_result =

    processor_bind(P_LWPID,                       // bind LWP.

                   P_MYID,                        // bind current LWP.

                   (processorid_t) processor_id,  // id.

                   NULL);                         // don't return old binding.

  return (bind_result == 0);

}

// Return true if user is running as root.

bool os::have_special_privileges() {

  static bool init = false;

  static bool privileges = false;