/*

 * Copyright (c) 1999, 2017, 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.

 *

 */

#include "jvm.h"

#include "utilities/globalDefinitions.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/os.hpp"

#include "utilities/align.hpp"

#include "utilities/macros.hpp"

#include "utilities/vmError.hpp"

#ifndef __APPLE__

// POSIX unamed semaphores are not supported on OS X.

#include "semaphore_posix.hpp"

#endif

#include <dlfcn.h>

#include <pthread.h>

#include <semaphore.h>

#include <signal.h>

#include <sys/mman.h>

#include <sys/resource.h>

#include <sys/utsname.h>

#include <time.h>

#include <unistd.h>

// Todo: provide a os::get_max_process_id() or similar. Number of processes

// may have been configured, can be read more accurately from proc fs etc.

#ifndef MAX_PID

#define MAX_PID INT_MAX

#endif

#define IS_VALID_PID(p) (p > 0 && p < MAX_PID)

#ifndef MAP_ANONYMOUS

  #define MAP_ANONYMOUS MAP_ANON

#endif

#define check_with_errno(check_type, cond, msg)                             \

  do {                                                                      \

    int err = errno;                                                        \

    check_type(cond, "%s; error='%s' (errno=%s)", msg, os::strerror(err),   \

               os::errno_name(err));                                        \

} while (false)

#define assert_with_errno(cond, msg)    check_with_errno(assert, cond, msg)

#define guarantee_with_errno(cond, msg) check_with_errno(guarantee, cond, msg)

// Check core dump limit and report possible place where core can be found

void os::check_dump_limit(char* buffer, size_t bufferSize) {

  if (!FLAG_IS_DEFAULT(CreateCoredumpOnCrash) && !CreateCoredumpOnCrash) {

    jio_snprintf(buffer, bufferSize, "CreateCoredumpOnCrash is disabled from command line");

    VMError::record_coredump_status(buffer, false);

    return;

  }

  int n;

  struct rlimit rlim;

  bool success;

  char core_path[PATH_MAX];

  n = get_core_path(core_path, PATH_MAX);

  if (n <= 0) {

    jio_snprintf(buffer, bufferSize, "core.%d (may not exist)", current_process_id());

    success = true;

#ifdef LINUX

  } else if (core_path[0] == '"') { // redirect to user process

    jio_snprintf(buffer, bufferSize, "Core dumps may be processed with %s", core_path);

    success = true;

#endif

  } else if (getrlimit(RLIMIT_CORE, &rlim) != 0) {

    jio_snprintf(buffer, bufferSize, "%s (may not exist)", core_path);

    success = true;

  } else {

    switch(rlim.rlim_cur) {

      case RLIM_INFINITY:

        jio_snprintf(buffer, bufferSize, "%s", core_path);

        success = true;

        break;

      case 0:

        jio_snprintf(buffer, bufferSize, "Core dumps have been disabled. To enable core dumping, try \"ulimit -c unlimited\" before starting Java again");

        success = false;

        break;

      default:

        jio_snprintf(buffer, bufferSize, "%s (max size " UINT64_FORMAT " kB). To ensure a full core dump, try \"ulimit -c unlimited\" before starting Java again", core_path, uint64_t(rlim.rlim_cur) / 1024);

        success = true;

        break;

    }

  }

  VMError::record_coredump_status(buffer, success);

}

int os::get_native_stack(address* stack, int frames, int toSkip) {

  int frame_idx = 0;

  int num_of_frames;  // number of frames captured

  frame fr = os::current_frame();

  while (fr.pc() && frame_idx < frames) {

    if (toSkip > 0) {

      toSkip --;

    } else {

      stack[frame_idx ++] = fr.pc();

    }

    if (fr.fp() == NULL || fr.cb() != NULL ||

        fr.sender_pc() == NULL || os::is_first_C_frame(&fr)) break;

    if (fr.sender_pc() && !os::is_first_C_frame(&fr)) {

      fr = os::get_sender_for_C_frame(&fr);

    } else {

      break;

    }

  }

  num_of_frames = frame_idx;

  for (; frame_idx < frames; frame_idx ++) {

    stack[frame_idx] = NULL;

  }

  return num_of_frames;

}

bool os::unsetenv(const char* name) {

  assert(name != NULL, "Null pointer");

  return (::unsetenv(name) == 0);

}

int os::get_last_error() {

  return errno;

}

bool os::is_debugger_attached() {

  // not implemented

  return false;

}

void os::wait_for_keypress_at_exit(void) {

  // don't do anything on posix platforms

  return;

}

int os::create_file_for_heap(const char* dir) {

  const char name_template[] = "/jvmheap.XXXXXX";

  char *fullname = (char*)os::malloc((strlen(dir) + strlen(name_template) + 1), mtInternal);

  if (fullname == NULL) {

    vm_exit_during_initialization(err_msg("Malloc failed during creation of backing file for heap (%s)", os::strerror(errno)));

    return -1;

  }

  (void)strncpy(fullname, dir, strlen(dir)+1);

  (void)strncat(fullname, name_template, strlen(name_template));

  os::native_path(fullname);

  sigset_t set, oldset;

  int ret = sigfillset(&set);

  assert_with_errno(ret == 0, "sigfillset returned error");

  // set the file creation mask.

  mode_t file_mode = S_IRUSR | S_IWUSR;

  // create a new file.

  int fd = mkstemp(fullname);

  if (fd < 0) {

    warning("Could not create file for heap with template %s", fullname);

    os::free(fullname);

    return -1;

  }

  // delete the name from the filesystem. When 'fd' is closed, the file (and space) will be deleted.

  ret = unlink(fullname);

  assert_with_errno(ret == 0, "unlink returned error");

  os::free(fullname);

  return fd;

}

static char* reserve_mmapped_memory(size_t bytes, char* requested_addr) {

  char * addr;

  if (requested_addr != NULL) {

    assert((uintptr_t)requested_addr % os::vm_page_size() == 0, "Requested address should be aligned to OS page size");

    flags |= MAP_FIXED;

  }

  // Map reserved/uncommitted pages PROT_NONE so we fail early if we

  // touch an uncommitted page. Otherwise, the read/write might

  // succeed if we have enough swap space to back the physical page.

  addr = (char*)::mmap(requested_addr, bytes, PROT_NONE,

                       flags, -1, 0);

  if (addr != MAP_FAILED) {

    MemTracker::record_virtual_memory_reserve((address)addr, bytes, CALLER_PC);

    return addr;

  }

  return NULL;

}

static int util_posix_fallocate(int fd, off_t offset, off_t len) {

#ifdef __APPLE__

  fstore_t store = { F_ALLOCATECONTIG, F_PEOFPOSMODE, 0, len };

  // First we try to get a continuous chunk of disk space

  int ret = fcntl(fd, F_PREALLOCATE, &store);

  if (ret == -1) {

    // Maybe we are too fragmented, try to allocate non-continuous range

    store.fst_flags = F_ALLOCATEALL;

    ret = fcntl(fd, F_PREALLOCATE, &store);

  }

  if(ret != -1) {

    return ftruncate(fd, len);

  }

  return -1;

#else

  return posix_fallocate(fd, offset, len);

#endif

}

// Map the given address range to the provided file descriptor.

char* os::map_memory_to_file(char* base, size_t size, int fd) {

  assert(fd != -1, "File descriptor is not valid");

  // allocate space for the file

  if (util_posix_fallocate(fd, 0, (off_t)size) != 0) {

    vm_exit_during_initialization(err_msg("Error in mapping Java heap at the given filesystem directory."));

    return NULL;

  }

  int prot = PROT_READ | PROT_WRITE;

  int flags = MAP_SHARED;

  if (base != NULL) {

    flags |= MAP_FIXED;

  }

  char* addr = (char*)mmap(base, size, prot, flags, fd, 0);

  if (addr == MAP_FAILED) {

    return NULL;

  }

  if (base != NULL && addr != base) {

    if (!os::release_memory(addr, size)) {

      warning("Could not release memory on unsuccessful file mapping");

     }

    return NULL;

  }

  return addr;

}

char* os::replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd) {

  assert(fd != -1, "File descriptor is not valid");

  assert(base != NULL, "Base cannot be NULL");

  return map_memory_to_file(base, size, fd);

}

// Multiple threads can race in this code, and can remap over each other with MAP_FIXED,

// so on posix, unmap the section at the start and at the end of the chunk that we mapped

// rather than unmapping and remapping the whole chunk to get requested alignment.

char* os::reserve_memory_aligned(size_t size, size_t alignment, int file_desc) {

  assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,

      "Alignment must be a multiple of allocation granularity (page size)");

  assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");

  size_t extra_size = size + alignment;

  assert(extra_size >= size, "overflow, size is too large to allow alignment");

  char* extra_base;

  if (file_desc != -1) {

    // For file mapping, we do not call os:reserve_memory(extra_size, NULL, alignment, file_desc) because

    // we need to deal with shrinking of the file space later when we release extra memory after alignment.

    // We also cannot called os:reserve_memory() with file_desc set to -1 because on aix we might get SHM memory.

    // So here to call a helper function while reserve memory for us. After we have a aligned base,

    // we will replace anonymous mapping with file mapping.

    extra_base = reserve_mmapped_memory(extra_size, NULL);

    if (extra_base != NULL) {

      MemTracker::record_virtual_memory_reserve((address)extra_base, extra_size, CALLER_PC);

    }

  } else {

    extra_base = os::reserve_memory(extra_size, NULL, alignment);

  }

  if (extra_base == NULL) {

    return NULL;

  }

  // Do manual alignment

  char* aligned_base = align_up(extra_base, alignment);

  // [  |                                       |  ]

  // ^ extra_base

  //    ^ extra_base + begin_offset == aligned_base

  //     extra_base + begin_offset + size       ^

  //                       extra_base + extra_size ^

  // |<>| == begin_offset

  //                              end_offset == |<>|

  size_t begin_offset = aligned_base - extra_base;

  size_t end_offset = (extra_base + extra_size) - (aligned_base + size);

  if (begin_offset > 0) {

      os::release_memory(extra_base, begin_offset);

  }

  if (end_offset > 0) {

      os::release_memory(extra_base + begin_offset + size, end_offset);

  }

  if (file_desc != -1) {

    // After we have an aligned address, we can replace anonymous mapping with file mapping

    if (replace_existing_mapping_with_file_mapping(aligned_base, size, file_desc) == NULL) {

      vm_exit_during_initialization(err_msg("Error in mapping Java heap at the given filesystem directory"));

    }

    MemTracker::record_virtual_memory_commit((address)aligned_base, size, CALLER_PC);

  }

  return aligned_base;

}

int os::log_vsnprintf(char* buf, size_t len, const char* fmt, va_list args) {

    return vsnprintf(buf, len, fmt, args);

}

int os::get_fileno(FILE* fp) {

  return NOT_AIX(::)fileno(fp);

}

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

  return gmtime_r(clock, res);

}

void os::Posix::print_load_average(outputStream* st) {

  st->print("load average:");

  double loadavg[3];

  os::loadavg(loadavg, 3);

  st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);

  st->cr();

}

void os::Posix::print_rlimit_info(outputStream* st) {

  st->print("rlimit:");

  struct rlimit rlim;

  st->print(" STACK ");

  getrlimit(RLIMIT_STACK, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT "k", uint64_t(rlim.rlim_cur) / 1024);

  st->print(", CORE ");

  getrlimit(RLIMIT_CORE, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT "k", uint64_t(rlim.rlim_cur) / 1024);

  // Isn't there on solaris

#if defined(AIX)

  st->print(", NPROC ");

  st->print("%d", sysconf(_SC_CHILD_MAX));

#elif !defined(SOLARIS)

  st->print(", NPROC ");

  getrlimit(RLIMIT_NPROC, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT, uint64_t(rlim.rlim_cur));

#endif

  st->print(", NOFILE ");

  getrlimit(RLIMIT_NOFILE, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT, uint64_t(rlim.rlim_cur));

  st->print(", AS ");

  getrlimit(RLIMIT_AS, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT "k", uint64_t(rlim.rlim_cur) / 1024);

  st->print(", DATA ");

  getrlimit(RLIMIT_DATA, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT "k", uint64_t(rlim.rlim_cur) / 1024);

  st->print(", FSIZE ");

  getrlimit(RLIMIT_FSIZE, &rlim);

  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

  else st->print(UINT64_FORMAT "k", uint64_t(rlim.rlim_cur) / 1024);

  st->cr();

}

void os::Posix::print_uname_info(outputStream* st) {

  // kernel

  st->print("uname:");

  struct utsname name;

  uname(&name);

  st->print("%s ", name.sysname);

#ifdef ASSERT

  st->print("%s ", name.nodename);

#endif

  st->print("%s ", name.release);

  st->print("%s ", name.version);

  st->print("%s", name.machine);

  st->cr();

}

bool os::get_host_name(char* buf, size_t buflen) {

  struct utsname name;

  uname(&name);

  jio_snprintf(buf, buflen, "%s", name.nodename);

  return true;

}

bool os::has_allocatable_memory_limit(julong* limit) {

  struct rlimit rlim;

  int getrlimit_res = getrlimit(RLIMIT_AS, &rlim);

  // if there was an error when calling getrlimit, assume that there is no limitation

  // on virtual memory.

  bool result;

  if ((getrlimit_res != 0) || (rlim.rlim_cur == RLIM_INFINITY)) {

    result = false;

  } else {

    *limit = (julong)rlim.rlim_cur;

    result = true;

  }

#ifdef _LP64

  return result;

#else

  // arbitrary virtual space limit for 32 bit Unices found by testing. If

  // getrlimit above returned a limit, bound it with this limit. Otherwise

  // directly use it.

  const julong max_virtual_limit = (julong)3800*M;

  if (result) {

    *limit = MIN2(*limit, max_virtual_limit);

  } else {

    *limit = max_virtual_limit;

  }

  // bound by actually allocatable memory. The algorithm uses two bounds, an

  // upper and a lower limit. The upper limit is the current highest amount of

  // memory that could not be allocated, the lower limit is the current highest

  // amount of memory that could be allocated.

  // The algorithm iteratively refines the result by halving the difference

  // between these limits, updating either the upper limit (if that value could

  // not be allocated) or the lower limit (if the that value could be allocated)

  // until the difference between these limits is "small".

  // the minimum amount of memory we care about allocating.

  const julong min_allocation_size = M;

  julong upper_limit = *limit;

  // first check a few trivial cases

  if (is_allocatable(upper_limit) || (upper_limit <= min_allocation_size)) {

    *limit = upper_limit;

  } else if (!is_allocatable(min_allocation_size)) {

    // we found that not even min_allocation_size is allocatable. Return it

    // anyway. There is no point to search for a better value any more.

    *limit = min_allocation_size;

  } else {

    // perform the binary search.

    julong lower_limit = min_allocation_size;

    while ((upper_limit - lower_limit) > min_allocation_size) {

      julong temp_limit = ((upper_limit - lower_limit) / 2) + lower_limit;

      temp_limit = align_down(temp_limit, min_allocation_size);

      if (is_allocatable(temp_limit)) {

        lower_limit = temp_limit;

      } else {

        upper_limit = temp_limit;

      }

    }

    *limit = lower_limit;

  }

  return true;

#endif

}