/*

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

 *

 */

#ifdef _WIN64

// Must be at least Windows 2000 or XP to use VectoredExceptions

#define _WIN32_WINNT 0x500

#endif

// no precompiled headers

#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 "interpreter/interpreter.hpp"

#include "jvm_windows.h"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "mutex_windows.inline.hpp"

#include "oops/oop.inline.hpp"

#include "os_share_windows.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm.h"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.hpp"

#include "runtime/extendedPC.hpp"

#include "runtime/globals.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/osThread.hpp"

#include "runtime/perfMemory.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "services/attachListener.hpp"

#include "services/runtimeService.hpp"

#include "thread_windows.inline.hpp"

#include "utilities/decoder.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/events.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/vmError.hpp"

#ifdef TARGET_ARCH_x86

# include "assembler_x86.inline.hpp"

# include "nativeInst_x86.hpp"

#endif

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

#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 <tlhelp32.h>

#include <vdmdbg.h>

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

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

PVOID  topLevelVectoredExceptionHandler = NULL;

#endif

#ifdef _M_IA64

#define __CPU__ ia64

#elif _M_AMD64

#define __CPU__ amd64

#else

#define __CPU__ i486

#endif

// save DLL module handle, used by GetModuleFileName

HINSTANCE vm_lib_handle;

static int getLastErrorString(char *buf, size_t len);

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

  switch (reason) {

    case DLL_PROCESS_ATTACH:

      vm_lib_handle = hinst;

      if(ForceTimeHighResolution)

        timeBeginPeriod(1L);

      break;

    case DLL_PROCESS_DETACH:

      if(ForceTimeHighResolution)

        timeEndPeriod(1L);

#ifdef _WIN64

      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::getenv(const char* name, char* buffer, int len) {

 int result = GetEnvironmentVariable(name, buffer, len);

 return result > 0 && result < len;

}

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

}

#ifndef _WIN64

// previous UnhandledExceptionFilter, if there is one

static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;

LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);

#endif

void os::init_system_properties_values() {

  /* sysclasspath, java_home, dll_dir */

  {

      char *home_path;

      char *dll_path;

      char *pslash;

      char *bin = "\\bin";

      char home_dir[MAX_PATH];

      if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) {

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

          // Found the full path to jvm[_g].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);

      if (home_path == NULL)

          return;

      strcpy(home_path, home_dir);

      Arguments::set_java_home(home_path);

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

      if (dll_path == NULL)

          return;

      strcpy(dll_path, home_dir);

      strcat(dll_path, bin);

      Arguments::set_dll_dir(dll_path);

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

          return;

  }

  /* 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 current directory

     * 3. The system wide Java Extensions directory (Java only)

     * 4. System directory (GetSystemDirectory)

     * 5. Windows directory (GetWindowsDirectory)

     * 6. The PATH environment variable

     */

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

    library_path[0] = '\0';

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

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

    strcat(library_path, tmp);

    strcat(library_path, ";.");

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

    }

    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

  /* Default endorsed standards directory. */

  {

    #define ENDORSED_DIR "\\lib\\endorsed"

    size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR);

    char * buf = NEW_C_HEAP_ARRAY(char, len);

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

    Arguments::set_endorsed_dirs(buf);

    #undef ENDORSED_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();

}

// Returns an estimate of the current stack pointer. Result must be guaranteed

// to point into the calling threads stack, and be no lower than the current

// stack pointer.

address os::current_stack_pointer() {

  int dummy;

  address sp = (address)&dummy;

  return sp;

}

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

  }

#ifdef _M_IA64

  // IA64 has memory and register stacks

  stack_size = stack_size / 2;

#endif

  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;

}

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;

}

LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);

// Thread start routine for all new Java threads

static unsigned __stdcall java_start(Thread* thread) {

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

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

    }

  }

  if (UseVectoredExceptions) {

    // If we are using vectored exception we don't need to set a SEH

    thread->run();

  }

  else {

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

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

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

    __try {

       thread->run();

    } __except(topLevelExceptionFilter(

               (_EXCEPTION_POINTERS*)_exception_info())) {

        // Nothing to do.

    }

  }

  // 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_ptr((intptr_t*)&os::win32::_os_thread_count);

  }

  return 0;

}

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 support for Java interrupts

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

  if (interrupt_event == NULL) {

    delete osthread;

    return NULL;

  }

  osthread->set_interrupt_event(interrupt_event);

  // Store info on the Win32 thread into the OSThread

  osthread->set_thread_handle(thread_handle);

  osthread->set_thread_id(thread_id);

  if (UseNUMA) {

    int lgrp_id = os::numa_get_group_id();

    if (lgrp_id != -1) {

      thread->set_lgrp_id(lgrp_id);

    }

  }

  // Initial thread state is INITIALIZED, not SUSPENDED

  osthread->set_state(INITIALIZED);

  return osthread;

}

bool os::create_attached_thread(JavaThread* thread) {

#ifdef ASSERT

  thread->verify_not_published();

#endif

  HANDLE thread_h;

  if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(),

                       &thread_h, THREAD_ALL_ACCESS, false, 0)) {

    fatal("DuplicateHandle failed\n");

  }

  OSThread* osthread = create_os_thread(thread, thread_h,

                                        (int)current_thread_id());

  if (osthread == NULL) {

     return false;

  }

  // Initial thread state is RUNNABLE

  osthread->set_state(RUNNABLE);

  thread->set_osthread(osthread);

  return true;

}

bool os::create_main_thread(JavaThread* thread) {

#ifdef ASSERT

  thread->verify_not_published();

#endif

  if (_starting_thread == NULL) {

    _starting_thread = create_os_thread(thread, main_thread, main_thread_id);

     if (_starting_thread == NULL) {

        return false;

     }

  }

  // The primordial thread is runnable from the start)

  _starting_thread->set_state(RUNNABLE);

  thread->set_osthread(_starting_thread);

  return true;

}

// Allocate and initialize a new OSThread

bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {

  unsigned thread_id;

  // Allocate the OSThread object

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

  if (osthread == NULL) {

    return false;

  }

  // Initialize support for Java interrupts

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