/*

 * Copyright (c) 1997, 2019, 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.

 *

 */

// Must be at least Windows Vista or Server 2008 to use InitOnceExecuteOnce

#define _WIN32_WINNT 0x0600

// 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 "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "oops/oop.inline.hpp"

#include "os_share_windows.hpp"

#include "os_windows.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 "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"

#include "symbolengine.hpp"

#include "windbghelp.hpp"

#ifdef _DEBUG

#include <crtdbg.h>

#endif

#include <windows.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/timeb.h>

#include <objidl.h>

#include <shlobj.h>

#include <malloc.h>

#include <signal.h>

#include <direct.h>

#include <errno.h>

#include <fcntl.h>

#include <io.h>

#include <process.h>              // For _beginthreadex(), _endthreadex()

#include <imagehlp.h>             // For os::dll_address_to_function_name

// for enumerating dll libraries

#include <vdmdbg.h>

#include <psapi.h>

#include <mmsystem.h>

#include <winsock2.h>

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(-1)

// For DLL loading/load error detection

// Values of PE COFF

#define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c

#define IMAGE_FILE_SIGNATURE_LENGTH 4

static HANDLE main_process;

static HANDLE main_thread;

static int    main_thread_id;

static FILETIME process_creation_time;

static FILETIME process_exit_time;

static FILETIME process_user_time;

static FILETIME process_kernel_time;

#ifdef _M_AMD64

  #define __CPU__ amd64

#else

  #define __CPU__ i486

#endif

#if INCLUDE_AOT

PVOID  topLevelVectoredExceptionHandler = NULL;

LONG WINAPI topLevelVectoredExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);

#endif

// save DLL module handle, used by GetModuleFileName

HINSTANCE vm_lib_handle;

BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {

  switch (reason) {

  case DLL_PROCESS_ATTACH:

    vm_lib_handle = hinst;

    if (ForceTimeHighResolution) {

      timeBeginPeriod(1L);

    }

    WindowsDbgHelp::pre_initialize();

    SymbolEngine::pre_initialize();

    break;

  case DLL_PROCESS_DETACH:

    if (ForceTimeHighResolution) {

      timeEndPeriod(1L);

    }

#if INCLUDE_AOT

    if (topLevelVectoredExceptionHandler != NULL) {

      RemoveVectoredExceptionHandler(topLevelVectoredExceptionHandler);

      topLevelVectoredExceptionHandler = NULL;

    }

#endif

    break;

  default:

    break;

  }

  return true;

}

static inline double fileTimeAsDouble(FILETIME* time) {

  const double high  = (double) ((unsigned int) ~0);

  const double split = 10000000.0;

  double result = (time->dwLowDateTime / split) +

                   time->dwHighDateTime * (high/split);

  return result;

}

// Implementation of os

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

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

  return (SetEnvironmentVariable(name, NULL) == TRUE);

}

// No setuid programs under Windows.

bool os::have_special_privileges() {

  return false;

}

// This method is  a periodic task to check for misbehaving JNI applications

// under CheckJNI, we can add any periodic checks here.

// For Windows at the moment does nothing

void os::run_periodic_checks() {

  return;

}

// previous UnhandledExceptionFilter, if there is one

static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;

LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);

void os::init_system_properties_values() {

  // sysclasspath, java_home, dll_dir

  {

    char *home_path;

    char *dll_path;

    char *pslash;

    const char *bin = "\\bin";

    char home_dir[MAX_PATH + 1];

    char *alt_home_dir = ::getenv("_ALT_JAVA_HOME_DIR");

    if (alt_home_dir != NULL)  {

      strncpy(home_dir, alt_home_dir, MAX_PATH + 1);

      home_dir[MAX_PATH] = '\0';

    } else {

      os::jvm_path(home_dir, sizeof(home_dir));

      // Found the full path to jvm.dll.

      // Now cut the path to <java_home>/jre if we can.

      *(strrchr(home_dir, '\\')) = '\0';  // get rid of \jvm.dll

      pslash = strrchr(home_dir, '\\');

      if (pslash != NULL) {

        *pslash = '\0';                   // get rid of \{client|server}

        pslash = strrchr(home_dir, '\\');

        if (pslash != NULL) {

          *pslash = '\0';                 // get rid of \bin

        }

      }

    }

    home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal);

    strcpy(home_path, home_dir);

    Arguments::set_java_home(home_path);

    FREE_C_HEAP_ARRAY(char, home_path);

    dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1,

                                mtInternal);

    strcpy(dll_path, home_dir);

    strcat(dll_path, bin);

    Arguments::set_dll_dir(dll_path);

    FREE_C_HEAP_ARRAY(char, dll_path);

    if (!set_boot_path('\\', ';')) {

      vm_exit_during_initialization("Failed setting boot class path.", NULL);

    }

  }

// library_path

#define EXT_DIR "\\lib\\ext"

#define BIN_DIR "\\bin"

#define PACKAGE_DIR "\\Sun\\Java"

  {

    // Win32 library search order (See the documentation for LoadLibrary):

    //

    // 1. The directory from which application is loaded.

    // 2. The system wide Java Extensions directory (Java only)

    // 3. System directory (GetSystemDirectory)

    // 4. Windows directory (GetWindowsDirectory)

    // 5. The PATH environment variable

    // 6. The current directory

    char *library_path;

    char tmp[MAX_PATH];

    char *path_str = ::getenv("PATH");

    library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) +

                                    sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10, mtInternal);

    library_path[0] = '\0';

    GetModuleFileName(NULL, tmp, sizeof(tmp));

    *(strrchr(tmp, '\\')) = '\0';

    strcat(library_path, tmp);

    GetWindowsDirectory(tmp, sizeof(tmp));

    strcat(library_path, ";");

    strcat(library_path, tmp);

    strcat(library_path, PACKAGE_DIR BIN_DIR);

    GetSystemDirectory(tmp, sizeof(tmp));

    strcat(library_path, ";");

    strcat(library_path, tmp);

    GetWindowsDirectory(tmp, sizeof(tmp));

    strcat(library_path, ";");

    strcat(library_path, tmp);

    if (path_str) {

      strcat(library_path, ";");

      strcat(library_path, path_str);

    }

    strcat(library_path, ";.");

    Arguments::set_library_path(library_path);

    FREE_C_HEAP_ARRAY(char, library_path);

  }

  // Default extensions directory

  {

    char path[MAX_PATH];

    char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1];

    GetWindowsDirectory(path, MAX_PATH);

    sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR,

            path, PACKAGE_DIR, EXT_DIR);

    Arguments::set_ext_dirs(buf);

  }

  #undef EXT_DIR

  #undef BIN_DIR

  #undef PACKAGE_DIR

#ifndef _WIN64

  // set our UnhandledExceptionFilter and save any previous one

  prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);

#endif

  // Done

  return;

}

void os::breakpoint() {

  DebugBreak();

}

// Invoked from the BREAKPOINT Macro

extern "C" void breakpoint() {

  os::breakpoint();

}

// RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.

// So far, this method is only used by Native Memory Tracking, which is

// only supported on Windows XP or later.

//

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

  int captured = RtlCaptureStackBackTrace(toSkip + 1, frames, (PVOID*)stack, NULL);

  for (int index = captured; index < frames; index ++) {

    stack[index] = NULL;

  }

  return captured;

}

// os::current_stack_base()

//

//   Returns the base of the stack, which is the stack's

//   starting address.  This function must be called

//   while running on the stack of the thread being queried.

address os::current_stack_base() {

  MEMORY_BASIC_INFORMATION minfo;

  address stack_bottom;

  size_t stack_size;

  VirtualQuery(&minfo, &minfo, sizeof(minfo));

  stack_bottom =  (address)minfo.AllocationBase;

  stack_size = minfo.RegionSize;

  // Add up the sizes of all the regions with the same

  // AllocationBase.

  while (1) {

    VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));

    if (stack_bottom == (address)minfo.AllocationBase) {

      stack_size += minfo.RegionSize;

    } else {

      break;

    }

  }

  return stack_bottom + stack_size;

}

size_t os::current_stack_size() {

  size_t sz;

  MEMORY_BASIC_INFORMATION minfo;

  VirtualQuery(&minfo, &minfo, sizeof(minfo));

  sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase;

  return sz;

}

bool os::committed_in_range(address start, size_t size, address& committed_start, size_t& committed_size) {

  MEMORY_BASIC_INFORMATION minfo;

  committed_start = NULL;

  committed_size = 0;

  address top = start + size;

  const address start_addr = start;

  while (start < top) {

    VirtualQuery(start, &minfo, sizeof(minfo));

    if ((minfo.State & MEM_COMMIT) == 0) {  // not committed

      if (committed_start != NULL) {

        break;

      }

    } else {  // committed

      if (committed_start == NULL) {

        committed_start = start;

      }

      size_t offset = start - (address)minfo.BaseAddress;

      committed_size += minfo.RegionSize - offset;

    }

    start = (address)minfo.BaseAddress + minfo.RegionSize;

  }

  if (committed_start == NULL) {

    assert(committed_size == 0, "Sanity");

    return false;

  } else {

    assert(committed_start >= start_addr && committed_start < top, "Out of range");

    // current region may go beyond the limit, trim to the limit

    committed_size = MIN2(committed_size, size_t(top - committed_start));

    return true;

  }

}

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

  const struct tm* time_struct_ptr = localtime(clock);

  if (time_struct_ptr != NULL) {

    *res = *time_struct_ptr;

    return res;

  }

  return NULL;

}

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

  const struct tm* time_struct_ptr = gmtime(clock);

  if (time_struct_ptr != NULL) {

    *res = *time_struct_ptr;

    return res;

  }

  return NULL;

}

LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);

// Thread start routine for all newly created threads

static unsigned __stdcall thread_native_entry(Thread* thread) {

  thread->record_stack_base_and_size();

  // Try to randomize the cache line index of hot stack frames.

  // This helps when threads of the same stack traces evict each other's

  // cache lines. The threads can be either from the same JVM instance, or

  // from different JVM instances. The benefit is especially true for

  // processors with hyperthreading technology.

  static int counter = 0;

  int pid = os::current_process_id();

  _alloca(((pid ^ counter++) & 7) * 128);

  thread->initialize_thread_current();

  OSThread* osthr = thread->osthread();

  assert(osthr->get_state() == RUNNABLE, "invalid os thread state");

  if (UseNUMA) {

    int lgrp_id = os::numa_get_group_id();

    if (lgrp_id != -1) {

      thread->set_lgrp_id(lgrp_id);

    }

  }

  // Diagnostic code to investigate JDK-6573254

  int res = 30115;  // non-java thread

  if (thread->is_Java_thread()) {

    res = 20115;    // java thread

  }

  log_info(os, thread)("Thread is alive (tid: " UINTX_FORMAT ").", os::current_thread_id());

  // Install a win32 structured exception handler around every thread created

  // by VM, so VM can generate error dump when an exception occurred in non-

  // Java thread (e.g. VM thread).

  __try {

    thread->call_run();

  } __except(topLevelExceptionFilter(

                                     (_EXCEPTION_POINTERS*)_exception_info())) {

    // Nothing to do.

  }

  // Note: at this point the thread object may already have deleted itself.

  // Do not dereference it from here on out.

  log_info(os, thread)("Thread finished (tid: " UINTX_FORMAT ").", os::current_thread_id());

  // One less thread is executing

  // When the VMThread gets here, the main thread may have already exited

  // which frees the CodeHeap containing the Atomic::add code

  if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {

    Atomic::dec(&os::win32::_os_thread_count);

  }

  // Thread must not return from exit_process_or_thread(), but if it does,

  // let it proceed to exit normally

  return (unsigned)os::win32::exit_process_or_thread(os::win32::EPT_THREAD, res);

}

static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle,

                                  int thread_id) {

  // Allocate the OSThread object

  OSThread* osthread = new OSThread(NULL, NULL);

  if (osthread == NULL) return NULL;

  // Initialize the JDK library's interrupt event.

  // This should really be done when OSThread is constructed,

  // but there is no way for a constructor to report failure to

  // allocate the event.

  HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);

  if (interrupt_event == NULL) {

    delete osthread;