1 /*
   2  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // Must be at least Windows 2000 or XP to use VectoredExceptions and IsDebuggerPresent
  26 #define _WIN32_WINNT 0x500
  27 
  28 // no precompiled headers
  29 #include "classfile/classLoader.hpp"
  30 #include "classfile/systemDictionary.hpp"
  31 #include "classfile/vmSymbols.hpp"
  32 #include "code/icBuffer.hpp"
  33 #include "code/vtableStubs.hpp"
  34 #include "compiler/compileBroker.hpp"
  35 #include "interpreter/interpreter.hpp"
  36 #include "jvm_windows.h"
  37 #include "memory/allocation.inline.hpp"
  38 #include "memory/filemap.hpp"
  39 #include "mutex_windows.inline.hpp"
  40 #include "oops/oop.inline.hpp"
  41 #include "os_share_windows.hpp"
  42 #include "prims/jniFastGetField.hpp"
  43 #include "prims/jvm.h"
  44 #include "prims/jvm_misc.hpp"
  45 #include "runtime/arguments.hpp"
  46 #include "runtime/extendedPC.hpp"
  47 #include "runtime/globals.hpp"
  48 #include "runtime/interfaceSupport.hpp"
  49 #include "runtime/java.hpp"
  50 #include "runtime/javaCalls.hpp"
  51 #include "runtime/mutexLocker.hpp"
  52 #include "runtime/objectMonitor.hpp"
  53 #include "runtime/osThread.hpp"
  54 #include "runtime/perfMemory.hpp"
  55 #include "runtime/sharedRuntime.hpp"
  56 #include "runtime/statSampler.hpp"
  57 #include "runtime/stubRoutines.hpp"
  58 #include "runtime/threadCritical.hpp"
  59 #include "runtime/timer.hpp"
  60 #include "services/attachListener.hpp"
  61 #include "services/runtimeService.hpp"
  62 #include "thread_windows.inline.hpp"
  63 #include "utilities/decoder.hpp"
  64 #include "utilities/defaultStream.hpp"
  65 #include "utilities/events.hpp"
  66 #include "utilities/growableArray.hpp"
  67 #include "utilities/vmError.hpp"
  68 #ifdef TARGET_ARCH_x86
  69 # include "assembler_x86.inline.hpp"
  70 # include "nativeInst_x86.hpp"
  71 #endif
  72 
  73 #ifdef _DEBUG
  74 #include <crtdbg.h>
  75 #endif
  76 
  77 
  78 #include <windows.h>
  79 #include <sys/types.h>
  80 #include <sys/stat.h>
  81 #include <sys/timeb.h>
  82 #include <objidl.h>
  83 #include <shlobj.h>
  84 
  85 #include <malloc.h>
  86 #include <signal.h>
  87 #include <direct.h>
  88 #include <errno.h>
  89 #include <fcntl.h>
  90 #include <io.h>
  91 #include <process.h>              // For _beginthreadex(), _endthreadex()
  92 #include <imagehlp.h>             // For os::dll_address_to_function_name
  93 /* for enumerating dll libraries */
  94 #include <vdmdbg.h>
  95 
  96 // for timer info max values which include all bits
  97 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
  98 
  99 // For DLL loading/load error detection
 100 // Values of PE COFF
 101 #define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c
 102 #define IMAGE_FILE_SIGNATURE_LENGTH 4
 103 
 104 static HANDLE main_process;
 105 static HANDLE main_thread;
 106 static int    main_thread_id;
 107 
 108 static FILETIME process_creation_time;
 109 static FILETIME process_exit_time;
 110 static FILETIME process_user_time;
 111 static FILETIME process_kernel_time;
 112 
 113 #ifdef _WIN64
 114 PVOID  topLevelVectoredExceptionHandler = NULL;
 115 #endif
 116 
 117 #ifdef _M_IA64
 118 #define __CPU__ ia64
 119 #elif _M_AMD64
 120 #define __CPU__ amd64
 121 #else
 122 #define __CPU__ i486
 123 #endif
 124 
 125 // save DLL module handle, used by GetModuleFileName
 126 
 127 HINSTANCE vm_lib_handle;
 128 
 129 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
 130   switch (reason) {
 131     case DLL_PROCESS_ATTACH:
 132       vm_lib_handle = hinst;
 133       if(ForceTimeHighResolution)
 134         timeBeginPeriod(1L);
 135       break;
 136     case DLL_PROCESS_DETACH:
 137       if(ForceTimeHighResolution)
 138         timeEndPeriod(1L);
 139 #ifdef _WIN64
 140       if (topLevelVectoredExceptionHandler != NULL) {
 141         RemoveVectoredExceptionHandler(topLevelVectoredExceptionHandler);
 142         topLevelVectoredExceptionHandler = NULL;
 143       }
 144 #endif
 145       break;
 146     default:
 147       break;
 148   }
 149   return true;
 150 }
 151 
 152 static inline double fileTimeAsDouble(FILETIME* time) {
 153   const double high  = (double) ((unsigned int) ~0);
 154   const double split = 10000000.0;
 155   double result = (time->dwLowDateTime / split) +
 156                    time->dwHighDateTime * (high/split);
 157   return result;
 158 }
 159 
 160 // Implementation of os
 161 
 162 bool os::getenv(const char* name, char* buffer, int len) {
 163  int result = GetEnvironmentVariable(name, buffer, len);
 164  return result > 0 && result < len;
 165 }
 166 
 167 
 168 // No setuid programs under Windows.
 169 bool os::have_special_privileges() {
 170   return false;
 171 }
 172 
 173 
 174 // This method is  a periodic task to check for misbehaving JNI applications
 175 // under CheckJNI, we can add any periodic checks here.
 176 // For Windows at the moment does nothing
 177 void os::run_periodic_checks() {
 178   return;
 179 }
 180 
 181 #ifndef _WIN64
 182 // previous UnhandledExceptionFilter, if there is one
 183 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
 184 
 185 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
 186 #endif
 187 void os::init_system_properties_values() {
 188   /* sysclasspath, java_home, dll_dir */
 189   {
 190       char *home_path;
 191       char *dll_path;
 192       char *pslash;
 193       char *bin = "\\bin";
 194       char home_dir[MAX_PATH];
 195 
 196       if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) {
 197           os::jvm_path(home_dir, sizeof(home_dir));
 198           // Found the full path to jvm[_g].dll.
 199           // Now cut the path to <java_home>/jre if we can.
 200           *(strrchr(home_dir, '\\')) = '\0';  /* get rid of \jvm.dll */
 201           pslash = strrchr(home_dir, '\\');
 202           if (pslash != NULL) {
 203               *pslash = '\0';                 /* get rid of \{client|server} */
 204               pslash = strrchr(home_dir, '\\');
 205               if (pslash != NULL)
 206                   *pslash = '\0';             /* get rid of \bin */
 207           }
 208       }
 209 
 210       home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal);
 211       if (home_path == NULL)
 212           return;
 213       strcpy(home_path, home_dir);
 214       Arguments::set_java_home(home_path);
 215 
 216       dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1, mtInternal);
 217       if (dll_path == NULL)
 218           return;
 219       strcpy(dll_path, home_dir);
 220       strcat(dll_path, bin);
 221       Arguments::set_dll_dir(dll_path);
 222 
 223       if (!set_boot_path('\\', ';'))
 224           return;
 225   }
 226 
 227   /* library_path */
 228   #define EXT_DIR "\\lib\\ext"
 229   #define BIN_DIR "\\bin"
 230   #define PACKAGE_DIR "\\Sun\\Java"
 231   {
 232     /* Win32 library search order (See the documentation for LoadLibrary):
 233      *
 234      * 1. The directory from which application is loaded.
 235      * 2. The system wide Java Extensions directory (Java only)
 236      * 3. System directory (GetSystemDirectory)
 237      * 4. Windows directory (GetWindowsDirectory)
 238      * 5. The PATH environment variable
 239      * 6. The current directory
 240      */
 241 
 242     char *library_path;
 243     char tmp[MAX_PATH];
 244     char *path_str = ::getenv("PATH");
 245 
 246     library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) +
 247         sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10, mtInternal);
 248 
 249     library_path[0] = '\0';
 250 
 251     GetModuleFileName(NULL, tmp, sizeof(tmp));
 252     *(strrchr(tmp, '\\')) = '\0';
 253     strcat(library_path, tmp);
 254 
 255     GetWindowsDirectory(tmp, sizeof(tmp));
 256     strcat(library_path, ";");
 257     strcat(library_path, tmp);
 258     strcat(library_path, PACKAGE_DIR BIN_DIR);
 259 
 260     GetSystemDirectory(tmp, sizeof(tmp));
 261     strcat(library_path, ";");
 262     strcat(library_path, tmp);
 263 
 264     GetWindowsDirectory(tmp, sizeof(tmp));
 265     strcat(library_path, ";");
 266     strcat(library_path, tmp);
 267 
 268     if (path_str) {
 269         strcat(library_path, ";");
 270         strcat(library_path, path_str);
 271     }
 272 
 273     strcat(library_path, ";.");
 274 
 275     Arguments::set_library_path(library_path);
 276     FREE_C_HEAP_ARRAY(char, library_path, mtInternal);
 277   }
 278 
 279   /* Default extensions directory */
 280   {
 281     char path[MAX_PATH];
 282     char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1];
 283     GetWindowsDirectory(path, MAX_PATH);
 284     sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR,
 285         path, PACKAGE_DIR, EXT_DIR);
 286     Arguments::set_ext_dirs(buf);
 287   }
 288   #undef EXT_DIR
 289   #undef BIN_DIR
 290   #undef PACKAGE_DIR
 291 
 292   /* Default endorsed standards directory. */
 293   {
 294     #define ENDORSED_DIR "\\lib\\endorsed"
 295     size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR);
 296     char * buf = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 297     sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR);
 298     Arguments::set_endorsed_dirs(buf);
 299     #undef ENDORSED_DIR
 300   }
 301 
 302 #ifndef _WIN64
 303   // set our UnhandledExceptionFilter and save any previous one
 304   prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);
 305 #endif
 306 
 307   // Done
 308   return;
 309 }
 310 
 311 void os::breakpoint() {
 312   DebugBreak();
 313 }
 314 
 315 // Invoked from the BREAKPOINT Macro
 316 extern "C" void breakpoint() {
 317   os::breakpoint();
 318 }
 319 
 320 /*
 321  * RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.
 322  * So far, this method is only used by Native Memory Tracking, which is
 323  * only supported on Windows XP or later.
 324  */
 325 address os::get_caller_pc(int n) {
 326 #ifdef _NMT_NOINLINE_
 327   n ++;
 328 #endif
 329   address pc;
 330   if (os::Kernel32Dll::RtlCaptureStackBackTrace(n + 1, 1, (PVOID*)&pc, NULL) == 1) {
 331     return pc;
 332   }
 333   return NULL;
 334 }
 335 
 336 
 337 // os::current_stack_base()
 338 //
 339 //   Returns the base of the stack, which is the stack's
 340 //   starting address.  This function must be called
 341 //   while running on the stack of the thread being queried.
 342 
 343 address os::current_stack_base() {
 344   MEMORY_BASIC_INFORMATION minfo;
 345   address stack_bottom;
 346   size_t stack_size;
 347 
 348   VirtualQuery(&minfo, &minfo, sizeof(minfo));
 349   stack_bottom =  (address)minfo.AllocationBase;
 350   stack_size = minfo.RegionSize;
 351 
 352   // Add up the sizes of all the regions with the same
 353   // AllocationBase.
 354   while( 1 )
 355   {
 356     VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));
 357     if ( stack_bottom == (address)minfo.AllocationBase )
 358       stack_size += minfo.RegionSize;
 359     else
 360       break;
 361   }
 362 
 363 #ifdef _M_IA64
 364   // IA64 has memory and register stacks
 365   stack_size = stack_size / 2;
 366 #endif
 367   return stack_bottom + stack_size;
 368 }
 369 
 370 size_t os::current_stack_size() {
 371   size_t sz;
 372   MEMORY_BASIC_INFORMATION minfo;
 373   VirtualQuery(&minfo, &minfo, sizeof(minfo));
 374   sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase;
 375   return sz;
 376 }
 377 
 378 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
 379   const struct tm* time_struct_ptr = localtime(clock);
 380   if (time_struct_ptr != NULL) {
 381     *res = *time_struct_ptr;
 382     return res;
 383   }
 384   return NULL;
 385 }
 386 
 387 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
 388 
 389 // Thread start routine for all new Java threads
 390 static unsigned __stdcall java_start(Thread* thread) {
 391   // Try to randomize the cache line index of hot stack frames.
 392   // This helps when threads of the same stack traces evict each other's
 393   // cache lines. The threads can be either from the same JVM instance, or
 394   // from different JVM instances. The benefit is especially true for
 395   // processors with hyperthreading technology.
 396   static int counter = 0;
 397   int pid = os::current_process_id();
 398   _alloca(((pid ^ counter++) & 7) * 128);
 399 
 400   OSThread* osthr = thread->osthread();
 401   assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
 402 
 403   if (UseNUMA) {
 404     int lgrp_id = os::numa_get_group_id();
 405     if (lgrp_id != -1) {
 406       thread->set_lgrp_id(lgrp_id);
 407     }
 408   }
 409 
 410 
 411   if (UseVectoredExceptions) {
 412     // If we are using vectored exception we don't need to set a SEH
 413     thread->run();
 414   }
 415   else {
 416     // Install a win32 structured exception handler around every thread created
 417     // by VM, so VM can genrate error dump when an exception occurred in non-
 418     // Java thread (e.g. VM thread).
 419     __try {
 420        thread->run();
 421     } __except(topLevelExceptionFilter(
 422                (_EXCEPTION_POINTERS*)_exception_info())) {
 423         // Nothing to do.
 424     }
 425   }
 426 
 427   // One less thread is executing
 428   // When the VMThread gets here, the main thread may have already exited
 429   // which frees the CodeHeap containing the Atomic::add code
 430   if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
 431     Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count);
 432   }
 433 
 434   return 0;
 435 }
 436 
 437 static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, int thread_id) {
 438   // Allocate the OSThread object
 439   OSThread* osthread = new OSThread(NULL, NULL);
 440   if (osthread == NULL) return NULL;
 441 
 442   // Initialize support for Java interrupts
 443   HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
 444   if (interrupt_event == NULL) {
 445     delete osthread;
 446     return NULL;
 447   }
 448   osthread->set_interrupt_event(interrupt_event);
 449 
 450   // Store info on the Win32 thread into the OSThread
 451   osthread->set_thread_handle(thread_handle);
 452   osthread->set_thread_id(thread_id);
 453 
 454   if (UseNUMA) {
 455     int lgrp_id = os::numa_get_group_id();
 456     if (lgrp_id != -1) {
 457       thread->set_lgrp_id(lgrp_id);
 458     }
 459   }
 460 
 461   // Initial thread state is INITIALIZED, not SUSPENDED
 462   osthread->set_state(INITIALIZED);
 463 
 464   return osthread;
 465 }
 466 
 467 
 468 bool os::create_attached_thread(JavaThread* thread) {
 469 #ifdef ASSERT
 470   thread->verify_not_published();
 471 #endif
 472   HANDLE thread_h;
 473   if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(),
 474                        &thread_h, THREAD_ALL_ACCESS, false, 0)) {
 475     fatal("DuplicateHandle failed\n");
 476   }
 477   OSThread* osthread = create_os_thread(thread, thread_h,
 478                                         (int)current_thread_id());
 479   if (osthread == NULL) {
 480      return false;
 481   }
 482 
 483   // Initial thread state is RUNNABLE
 484   osthread->set_state(RUNNABLE);
 485 
 486   thread->set_osthread(osthread);
 487   return true;
 488 }
 489 
 490 bool os::create_main_thread(JavaThread* thread) {
 491 #ifdef ASSERT
 492   thread->verify_not_published();
 493 #endif
 494   if (_starting_thread == NULL) {
 495     _starting_thread = create_os_thread(thread, main_thread, main_thread_id);
 496      if (_starting_thread == NULL) {
 497         return false;
 498      }
 499   }
 500 
 501   // The primordial thread is runnable from the start)
 502   _starting_thread->set_state(RUNNABLE);
 503 
 504   thread->set_osthread(_starting_thread);
 505   return true;
 506 }
 507 
 508 // Allocate and initialize a new OSThread
 509 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
 510   unsigned thread_id;
 511 
 512   // Allocate the OSThread object
 513   OSThread* osthread = new OSThread(NULL, NULL);
 514   if (osthread == NULL) {
 515     return false;
 516   }
 517 
 518   // Initialize support for Java interrupts
 519   HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
 520   if (interrupt_event == NULL) {
 521     delete osthread;
 522     return NULL;
 523   }
 524   osthread->set_interrupt_event(interrupt_event);
 525   osthread->set_interrupted(false);
 526 
 527   thread->set_osthread(osthread);
 528 
 529   if (stack_size == 0) {
 530     switch (thr_type) {
 531     case os::java_thread:
 532       // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
 533       if (JavaThread::stack_size_at_create() > 0)
 534         stack_size = JavaThread::stack_size_at_create();
 535       break;
 536     case os::compiler_thread:
 537       if (CompilerThreadStackSize > 0) {
 538         stack_size = (size_t)(CompilerThreadStackSize * K);
 539         break;
 540       } // else fall through:
 541         // use VMThreadStackSize if CompilerThreadStackSize is not defined
 542     case os::vm_thread:
 543     case os::pgc_thread:
 544     case os::cgc_thread:
 545     case os::watcher_thread:
 546       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
 547       break;
 548     }
 549   }
 550 
 551   // Create the Win32 thread
 552   //
 553   // Contrary to what MSDN document says, "stack_size" in _beginthreadex()
 554   // does not specify stack size. Instead, it specifies the size of
 555   // initially committed space. The stack size is determined by
 556   // PE header in the executable. If the committed "stack_size" is larger
 557   // than default value in the PE header, the stack is rounded up to the
 558   // nearest multiple of 1MB. For example if the launcher has default
 559   // stack size of 320k, specifying any size less than 320k does not
 560   // affect the actual stack size at all, it only affects the initial
 561   // commitment. On the other hand, specifying 'stack_size' larger than
 562   // default value may cause significant increase in memory usage, because
 563   // not only the stack space will be rounded up to MB, but also the
 564   // entire space is committed upfront.
 565   //
 566   // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION'
 567   // for CreateThread() that can treat 'stack_size' as stack size. However we
 568   // are not supposed to call CreateThread() directly according to MSDN
 569   // document because JVM uses C runtime library. The good news is that the
 570   // flag appears to work with _beginthredex() as well.
 571 
 572 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
 573 #define STACK_SIZE_PARAM_IS_A_RESERVATION  (0x10000)
 574 #endif
 575 
 576   HANDLE thread_handle =
 577     (HANDLE)_beginthreadex(NULL,
 578                            (unsigned)stack_size,
 579                            (unsigned (__stdcall *)(void*)) java_start,
 580                            thread,
 581                            CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION,
 582                            &thread_id);
 583   if (thread_handle == NULL) {
 584     // perhaps STACK_SIZE_PARAM_IS_A_RESERVATION is not supported, try again
 585     // without the flag.
 586     thread_handle =
 587     (HANDLE)_beginthreadex(NULL,
 588                            (unsigned)stack_size,
 589                            (unsigned (__stdcall *)(void*)) java_start,
 590                            thread,
 591                            CREATE_SUSPENDED,
 592                            &thread_id);
 593   }
 594   if (thread_handle == NULL) {
 595     // Need to clean up stuff we've allocated so far
 596     CloseHandle(osthread->interrupt_event());
 597     thread->set_osthread(NULL);
 598     delete osthread;
 599     return NULL;
 600   }
 601 
 602   Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
 603 
 604   // Store info on the Win32 thread into the OSThread
 605   osthread->set_thread_handle(thread_handle);
 606   osthread->set_thread_id(thread_id);
 607 
 608   // Initial thread state is INITIALIZED, not SUSPENDED
 609   osthread->set_state(INITIALIZED);
 610 
 611   // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
 612   return true;
 613 }
 614 
 615 
 616 // Free Win32 resources related to the OSThread
 617 void os::free_thread(OSThread* osthread) {
 618   assert(osthread != NULL, "osthread not set");
 619   CloseHandle(osthread->thread_handle());
 620   CloseHandle(osthread->interrupt_event());
 621   delete osthread;
 622 }
 623 
 624 
 625 static int    has_performance_count = 0;
 626 static jlong first_filetime;
 627 static jlong initial_performance_count;
 628 static jlong performance_frequency;
 629 
 630 
 631 jlong as_long(LARGE_INTEGER x) {
 632   jlong result = 0; // initialization to avoid warning
 633   set_high(&result, x.HighPart);
 634   set_low(&result,  x.LowPart);
 635   return result;
 636 }
 637 
 638 
 639 jlong os::elapsed_counter() {
 640   LARGE_INTEGER count;
 641   if (has_performance_count) {
 642     QueryPerformanceCounter(&count);
 643     return as_long(count) - initial_performance_count;
 644   } else {
 645     FILETIME wt;
 646     GetSystemTimeAsFileTime(&wt);
 647     return (jlong_from(wt.dwHighDateTime, wt.dwLowDateTime) - first_filetime);
 648   }
 649 }
 650 
 651 
 652 jlong os::elapsed_frequency() {
 653   if (has_performance_count) {
 654     return performance_frequency;
 655   } else {
 656    // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601.
 657    return 10000000;
 658   }
 659 }
 660 
 661 
 662 julong os::available_memory() {
 663   return win32::available_memory();
 664 }
 665 
 666 julong os::win32::available_memory() {
 667   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
 668   // value if total memory is larger than 4GB
 669   MEMORYSTATUSEX ms;
 670   ms.dwLength = sizeof(ms);
 671   GlobalMemoryStatusEx(&ms);
 672 
 673   return (julong)ms.ullAvailPhys;
 674 }
 675 
 676 julong os::physical_memory() {
 677   return win32::physical_memory();
 678 }
 679 
 680 julong os::allocatable_physical_memory(julong size) {
 681 #ifdef _LP64
 682   return size;
 683 #else
 684   // Limit to 1400m because of the 2gb address space wall
 685   return MIN2(size, (julong)1400*M);
 686 #endif
 687 }
 688 
 689 // VC6 lacks DWORD_PTR
 690 #if _MSC_VER < 1300
 691 typedef UINT_PTR DWORD_PTR;
 692 #endif
 693 
 694 int os::active_processor_count() {
 695   DWORD_PTR lpProcessAffinityMask = 0;
 696   DWORD_PTR lpSystemAffinityMask = 0;
 697   int proc_count = processor_count();
 698   if (proc_count <= sizeof(UINT_PTR) * BitsPerByte &&
 699       GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) {
 700     // Nof active processors is number of bits in process affinity mask
 701     int bitcount = 0;
 702     while (lpProcessAffinityMask != 0) {
 703       lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1);
 704       bitcount++;
 705     }
 706     return bitcount;
 707   } else {
 708     return proc_count;
 709   }
 710 }
 711 
 712 void os::set_native_thread_name(const char *name) {
 713   // Not yet implemented.
 714   return;
 715 }
 716 
 717 bool os::distribute_processes(uint length, uint* distribution) {
 718   // Not yet implemented.
 719   return false;
 720 }
 721 
 722 bool os::bind_to_processor(uint processor_id) {
 723   // Not yet implemented.
 724   return false;
 725 }
 726 
 727 static void initialize_performance_counter() {
 728   LARGE_INTEGER count;
 729   if (QueryPerformanceFrequency(&count)) {
 730     has_performance_count = 1;
 731     performance_frequency = as_long(count);
 732     QueryPerformanceCounter(&count);
 733     initial_performance_count = as_long(count);
 734   } else {
 735     has_performance_count = 0;
 736     FILETIME wt;
 737     GetSystemTimeAsFileTime(&wt);
 738     first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
 739   }
 740 }
 741 
 742 
 743 double os::elapsedTime() {
 744   return (double) elapsed_counter() / (double) elapsed_frequency();
 745 }
 746 
 747 
 748 // Windows format:
 749 //   The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601.
 750 // Java format:
 751 //   Java standards require the number of milliseconds since 1/1/1970
 752 
 753 // Constant offset - calculated using offset()
 754 static jlong  _offset   = 116444736000000000;
 755 // Fake time counter for reproducible results when debugging
 756 static jlong  fake_time = 0;
 757 
 758 #ifdef ASSERT
 759 // Just to be safe, recalculate the offset in debug mode
 760 static jlong _calculated_offset = 0;
 761 static int   _has_calculated_offset = 0;
 762 
 763 jlong offset() {
 764   if (_has_calculated_offset) return _calculated_offset;
 765   SYSTEMTIME java_origin;
 766   java_origin.wYear          = 1970;
 767   java_origin.wMonth         = 1;
 768   java_origin.wDayOfWeek     = 0; // ignored
 769   java_origin.wDay           = 1;
 770   java_origin.wHour          = 0;
 771   java_origin.wMinute        = 0;
 772   java_origin.wSecond        = 0;
 773   java_origin.wMilliseconds  = 0;
 774   FILETIME jot;
 775   if (!SystemTimeToFileTime(&java_origin, &jot)) {
 776     fatal(err_msg("Error = %d\nWindows error", GetLastError()));
 777   }
 778   _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime);
 779   _has_calculated_offset = 1;
 780   assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal");
 781   return _calculated_offset;
 782 }
 783 #else
 784 jlong offset() {
 785   return _offset;
 786 }
 787 #endif
 788 
 789 jlong windows_to_java_time(FILETIME wt) {
 790   jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
 791   return (a - offset()) / 10000;
 792 }
 793 
 794 FILETIME java_to_windows_time(jlong l) {
 795   jlong a = (l * 10000) + offset();
 796   FILETIME result;
 797   result.dwHighDateTime = high(a);
 798   result.dwLowDateTime  = low(a);
 799   return result;
 800 }
 801 
 802 // For now, we say that Windows does not support vtime.  I have no idea
 803 // whether it can actually be made to (DLD, 9/13/05).
 804 
 805 bool os::supports_vtime() { return false; }
 806 bool os::enable_vtime() { return false; }
 807 bool os::vtime_enabled() { return false; }
 808 double os::elapsedVTime() {
 809   // better than nothing, but not much
 810   return elapsedTime();
 811 }
 812 
 813 jlong os::javaTimeMillis() {
 814   if (UseFakeTimers) {
 815     return fake_time++;
 816   } else {
 817     FILETIME wt;
 818     GetSystemTimeAsFileTime(&wt);
 819     return windows_to_java_time(wt);
 820   }
 821 }
 822 
 823 jlong os::javaTimeNanos() {
 824   if (!has_performance_count) {
 825     return javaTimeMillis() * NANOSECS_PER_MILLISEC; // the best we can do.
 826   } else {
 827     LARGE_INTEGER current_count;
 828     QueryPerformanceCounter(&current_count);
 829     double current = as_long(current_count);
 830     double freq = performance_frequency;
 831     jlong time = (jlong)((current/freq) * NANOSECS_PER_SEC);
 832     return time;
 833   }
 834 }
 835 
 836 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
 837   if (!has_performance_count) {
 838     // javaTimeMillis() doesn't have much percision,
 839     // but it is not going to wrap -- so all 64 bits
 840     info_ptr->max_value = ALL_64_BITS;
 841 
 842     // this is a wall clock timer, so may skip
 843     info_ptr->may_skip_backward = true;
 844     info_ptr->may_skip_forward = true;
 845   } else {
 846     jlong freq = performance_frequency;
 847     if (freq < NANOSECS_PER_SEC) {
 848       // the performance counter is 64 bits and we will
 849       // be multiplying it -- so no wrap in 64 bits
 850       info_ptr->max_value = ALL_64_BITS;
 851     } else if (freq > NANOSECS_PER_SEC) {
 852       // use the max value the counter can reach to
 853       // determine the max value which could be returned
 854       julong max_counter = (julong)ALL_64_BITS;
 855       info_ptr->max_value = (jlong)(max_counter / (freq / NANOSECS_PER_SEC));
 856     } else {
 857       // the performance counter is 64 bits and we will
 858       // be using it directly -- so no wrap in 64 bits
 859       info_ptr->max_value = ALL_64_BITS;
 860     }
 861 
 862     // using a counter, so no skipping
 863     info_ptr->may_skip_backward = false;
 864     info_ptr->may_skip_forward = false;
 865   }
 866   info_ptr->kind = JVMTI_TIMER_ELAPSED;                // elapsed not CPU time
 867 }
 868 
 869 char* os::local_time_string(char *buf, size_t buflen) {
 870   SYSTEMTIME st;
 871   GetLocalTime(&st);
 872   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
 873                st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
 874   return buf;
 875 }
 876 
 877 bool os::getTimesSecs(double* process_real_time,
 878                      double* process_user_time,
 879                      double* process_system_time) {
 880   HANDLE h_process = GetCurrentProcess();
 881   FILETIME create_time, exit_time, kernel_time, user_time;
 882   BOOL result = GetProcessTimes(h_process,
 883                                &create_time,
 884                                &exit_time,
 885                                &kernel_time,
 886                                &user_time);
 887   if (result != 0) {
 888     FILETIME wt;
 889     GetSystemTimeAsFileTime(&wt);
 890     jlong rtc_millis = windows_to_java_time(wt);
 891     jlong user_millis = windows_to_java_time(user_time);
 892     jlong system_millis = windows_to_java_time(kernel_time);
 893     *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS);
 894     *process_user_time = ((double) user_millis) / ((double) MILLIUNITS);
 895     *process_system_time = ((double) system_millis) / ((double) MILLIUNITS);
 896     return true;
 897   } else {
 898     return false;
 899   }
 900 }
 901 
 902 void os::shutdown() {
 903 
 904   // allow PerfMemory to attempt cleanup of any persistent resources
 905   perfMemory_exit();
 906 
 907   // flush buffered output, finish log files
 908   ostream_abort();
 909 
 910   // Check for abort hook
 911   abort_hook_t abort_hook = Arguments::abort_hook();
 912   if (abort_hook != NULL) {
 913     abort_hook();
 914   }
 915 }
 916 
 917 
 918 static BOOL  (WINAPI *_MiniDumpWriteDump)  ( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
 919                                             PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION);
 920 
 921 void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) {
 922   HINSTANCE dbghelp;
 923   EXCEPTION_POINTERS ep;
 924   MINIDUMP_EXCEPTION_INFORMATION mei;
 925   MINIDUMP_EXCEPTION_INFORMATION* pmei;
 926 
 927   HANDLE hProcess = GetCurrentProcess();
 928   DWORD processId = GetCurrentProcessId();
 929   HANDLE dumpFile;
 930   MINIDUMP_TYPE dumpType;
 931   static const char* cwd;
 932 
 933   // If running on a client version of Windows and user has not explicitly enabled dumping
 934   if (!os::win32::is_windows_server() && !CreateMinidumpOnCrash) {
 935     VMError::report_coredump_status("Minidumps are not enabled by default on client versions of Windows", false);
 936     return;
 937     // If running on a server version of Windows and user has explictly disabled dumping
 938   } else if (os::win32::is_windows_server() && !FLAG_IS_DEFAULT(CreateMinidumpOnCrash) && !CreateMinidumpOnCrash) {
 939     VMError::report_coredump_status("Minidump has been disabled from the command line", false);
 940     return;
 941   }
 942 
 943   dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0);
 944 
 945   if (dbghelp == NULL) {
 946     VMError::report_coredump_status("Failed to load dbghelp.dll", false);
 947     return;
 948   }
 949 
 950   _MiniDumpWriteDump = CAST_TO_FN_PTR(
 951     BOOL(WINAPI *)( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
 952     PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION),
 953     GetProcAddress(dbghelp, "MiniDumpWriteDump"));
 954 
 955   if (_MiniDumpWriteDump == NULL) {
 956     VMError::report_coredump_status("Failed to find MiniDumpWriteDump() in module dbghelp.dll", false);
 957     return;
 958   }
 959 
 960   dumpType = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | MiniDumpWithHandleData);
 961 
 962 // Older versions of dbghelp.h doesn't contain all the dumptypes we want, dbghelp.h with
 963 // API_VERSION_NUMBER 11 or higher contains the ones we want though
 964 #if API_VERSION_NUMBER >= 11
 965   dumpType = (MINIDUMP_TYPE)(dumpType | MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo |
 966     MiniDumpWithUnloadedModules);
 967 #endif
 968 
 969   cwd = get_current_directory(NULL, 0);
 970   jio_snprintf(buffer, bufferSize, "%s\\hs_err_pid%u.mdmp",cwd, current_process_id());
 971   dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 972 
 973   if (dumpFile == INVALID_HANDLE_VALUE) {
 974     VMError::report_coredump_status("Failed to create file for dumping", false);
 975     return;
 976   }
 977   if (exceptionRecord != NULL && contextRecord != NULL) {
 978     ep.ContextRecord = (PCONTEXT) contextRecord;
 979     ep.ExceptionRecord = (PEXCEPTION_RECORD) exceptionRecord;
 980 
 981     mei.ThreadId = GetCurrentThreadId();
 982     mei.ExceptionPointers = &ep;
 983     pmei = &mei;
 984   } else {
 985     pmei = NULL;
 986   }
 987 
 988 
 989   // Older versions of dbghelp.dll (the one shipped with Win2003 for example) may not support all
 990   // the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then.
 991   if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false &&
 992       _MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) {
 993     VMError::report_coredump_status("Call to MiniDumpWriteDump() failed", false);
 994   } else {
 995     VMError::report_coredump_status(buffer, true);
 996   }
 997 
 998   CloseHandle(dumpFile);
 999 }
1000 
1001 
1002 
1003 void os::abort(bool dump_core)
1004 {
1005   os::shutdown();
1006   // no core dump on Windows
1007   ::exit(1);
1008 }
1009 
1010 // Die immediately, no exit hook, no abort hook, no cleanup.
1011 void os::die() {
1012   _exit(-1);
1013 }
1014 
1015 // Directory routines copied from src/win32/native/java/io/dirent_md.c
1016 //  * dirent_md.c       1.15 00/02/02
1017 //
1018 // The declarations for DIR and struct dirent are in jvm_win32.h.
1019 
1020 /* Caller must have already run dirname through JVM_NativePath, which removes
1021    duplicate slashes and converts all instances of '/' into '\\'. */
1022 
1023 DIR *
1024 os::opendir(const char *dirname)
1025 {
1026     assert(dirname != NULL, "just checking");   // hotspot change
1027     DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal);
1028     DWORD fattr;                                // hotspot change
1029     char alt_dirname[4] = { 0, 0, 0, 0 };
1030 
1031     if (dirp == 0) {
1032         errno = ENOMEM;
1033         return 0;
1034     }
1035 
1036     /*
1037      * Win32 accepts "\" in its POSIX stat(), but refuses to treat it
1038      * as a directory in FindFirstFile().  We detect this case here and
1039      * prepend the current drive name.
1040      */
1041     if (dirname[1] == '\0' && dirname[0] == '\\') {
1042         alt_dirname[0] = _getdrive() + 'A' - 1;
1043         alt_dirname[1] = ':';
1044         alt_dirname[2] = '\\';
1045         alt_dirname[3] = '\0';
1046         dirname = alt_dirname;
1047     }
1048 
1049     dirp->path = (char *)malloc(strlen(dirname) + 5, mtInternal);
1050     if (dirp->path == 0) {
1051         free(dirp, mtInternal);
1052         errno = ENOMEM;
1053         return 0;
1054     }
1055     strcpy(dirp->path, dirname);
1056 
1057     fattr = GetFileAttributes(dirp->path);
1058     if (fattr == 0xffffffff) {
1059         free(dirp->path, mtInternal);
1060         free(dirp, mtInternal);
1061         errno = ENOENT;
1062         return 0;
1063     } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
1064         free(dirp->path, mtInternal);
1065         free(dirp, mtInternal);
1066         errno = ENOTDIR;
1067         return 0;
1068     }
1069 
1070     /* Append "*.*", or possibly "\\*.*", to path */
1071     if (dirp->path[1] == ':'
1072         && (dirp->path[2] == '\0'
1073             || (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
1074         /* No '\\' needed for cases like "Z:" or "Z:\" */
1075         strcat(dirp->path, "*.*");
1076     } else {
1077         strcat(dirp->path, "\\*.*");
1078     }
1079 
1080     dirp->handle = FindFirstFile(dirp->path, &dirp->find_data);
1081     if (dirp->handle == INVALID_HANDLE_VALUE) {
1082         if (GetLastError() != ERROR_FILE_NOT_FOUND) {
1083             free(dirp->path, mtInternal);
1084             free(dirp, mtInternal);
1085             errno = EACCES;
1086             return 0;
1087         }
1088     }
1089     return dirp;
1090 }
1091 
1092 /* parameter dbuf unused on Windows */
1093 
1094 struct dirent *
1095 os::readdir(DIR *dirp, dirent *dbuf)
1096 {
1097     assert(dirp != NULL, "just checking");      // hotspot change
1098     if (dirp->handle == INVALID_HANDLE_VALUE) {
1099         return 0;
1100     }
1101 
1102     strcpy(dirp->dirent.d_name, dirp->find_data.cFileName);
1103 
1104     if (!FindNextFile(dirp->handle, &dirp->find_data)) {
1105         if (GetLastError() == ERROR_INVALID_HANDLE) {
1106             errno = EBADF;
1107             return 0;
1108         }
1109         FindClose(dirp->handle);
1110         dirp->handle = INVALID_HANDLE_VALUE;
1111     }
1112 
1113     return &dirp->dirent;
1114 }
1115 
1116 int
1117 os::closedir(DIR *dirp)
1118 {
1119     assert(dirp != NULL, "just checking");      // hotspot change
1120     if (dirp->handle != INVALID_HANDLE_VALUE) {
1121         if (!FindClose(dirp->handle)) {
1122             errno = EBADF;
1123             return -1;
1124         }
1125         dirp->handle = INVALID_HANDLE_VALUE;
1126     }
1127     free(dirp->path, mtInternal);
1128     free(dirp, mtInternal);
1129     return 0;
1130 }
1131 
1132 // This must be hard coded because it's the system's temporary
1133 // directory not the java application's temp directory, ala java.io.tmpdir.
1134 const char* os::get_temp_directory() {
1135   static char path_buf[MAX_PATH];
1136   if (GetTempPath(MAX_PATH, path_buf)>0)
1137     return path_buf;
1138   else{
1139     path_buf[0]='\0';
1140     return path_buf;
1141   }
1142 }
1143 
1144 static bool file_exists(const char* filename) {
1145   if (filename == NULL || strlen(filename) == 0) {
1146     return false;
1147   }
1148   return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
1149 }
1150 
1151 void os::dll_build_name(char *buffer, size_t buflen,
1152                         const char* pname, const char* fname) {
1153   const size_t pnamelen = pname ? strlen(pname) : 0;
1154   const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
1155 
1156   // Quietly truncates on buffer overflow. Should be an error.
1157   if (pnamelen + strlen(fname) + 10 > buflen) {
1158     *buffer = '\0';
1159     return;
1160   }
1161 
1162   if (pnamelen == 0) {
1163     jio_snprintf(buffer, buflen, "%s.dll", fname);
1164   } else if (c == ':' || c == '\\') {
1165     jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname);
1166   } else if (strchr(pname, *os::path_separator()) != NULL) {
1167     int n;
1168     char** pelements = split_path(pname, &n);
1169     for (int i = 0 ; i < n ; i++) {
1170       char* path = pelements[i];
1171       // Really shouldn't be NULL, but check can't hurt
1172       size_t plen = (path == NULL) ? 0 : strlen(path);
1173       if (plen == 0) {
1174         continue; // skip the empty path values
1175       }
1176       const char lastchar = path[plen - 1];
1177       if (lastchar == ':' || lastchar == '\\') {
1178         jio_snprintf(buffer, buflen, "%s%s.dll", path, fname);
1179       } else {
1180         jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname);
1181       }
1182       if (file_exists(buffer)) {
1183         break;
1184       }
1185     }
1186     // release the storage
1187     for (int i = 0 ; i < n ; i++) {
1188       if (pelements[i] != NULL) {
1189         FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
1190       }
1191     }
1192     if (pelements != NULL) {
1193       FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
1194     }
1195   } else {
1196     jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname);
1197   }
1198 }
1199 
1200 // Needs to be in os specific directory because windows requires another
1201 // header file <direct.h>
1202 const char* os::get_current_directory(char *buf, int buflen) {
1203   return _getcwd(buf, buflen);
1204 }
1205 
1206 //-----------------------------------------------------------
1207 // Helper functions for fatal error handler
1208 #ifdef _WIN64
1209 // Helper routine which returns true if address in
1210 // within the NTDLL address space.
1211 //
1212 static bool _addr_in_ntdll( address addr )
1213 {
1214   HMODULE hmod;
1215   MODULEINFO minfo;
1216 
1217   hmod = GetModuleHandle("NTDLL.DLL");
1218   if ( hmod == NULL ) return false;
1219   if ( !os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
1220                                &minfo, sizeof(MODULEINFO)) )
1221     return false;
1222 
1223   if ( (addr >= minfo.lpBaseOfDll) &&
1224        (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
1225     return true;
1226   else
1227     return false;
1228 }
1229 #endif
1230 
1231 
1232 // Enumerate all modules for a given process ID
1233 //
1234 // Notice that Windows 95/98/Me and Windows NT/2000/XP have
1235 // different API for doing this. We use PSAPI.DLL on NT based
1236 // Windows and ToolHelp on 95/98/Me.
1237 
1238 // Callback function that is called by enumerate_modules() on
1239 // every DLL module.
1240 // Input parameters:
1241 //    int       pid,
1242 //    char*     module_file_name,
1243 //    address   module_base_addr,
1244 //    unsigned  module_size,
1245 //    void*     param
1246 typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
1247 
1248 // enumerate_modules for Windows NT, using PSAPI
1249 static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
1250 {
1251   HANDLE   hProcess ;
1252 
1253 # define MAX_NUM_MODULES 128
1254   HMODULE     modules[MAX_NUM_MODULES];
1255   static char filename[ MAX_PATH ];
1256   int         result = 0;
1257 
1258   if (!os::PSApiDll::PSApiAvailable()) {
1259     return 0;
1260   }
1261 
1262   hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1263                          FALSE, pid ) ;
1264   if (hProcess == NULL) return 0;
1265 
1266   DWORD size_needed;
1267   if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
1268                            sizeof(modules), &size_needed)) {
1269       CloseHandle( hProcess );
1270       return 0;
1271   }
1272 
1273   // number of modules that are currently loaded
1274   int num_modules = size_needed / sizeof(HMODULE);
1275 
1276   for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1277     // Get Full pathname:
1278     if(!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
1279                              filename, sizeof(filename))) {
1280         filename[0] = '\0';
1281     }
1282 
1283     MODULEINFO modinfo;
1284     if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i],
1285                                &modinfo, sizeof(modinfo))) {
1286         modinfo.lpBaseOfDll = NULL;
1287         modinfo.SizeOfImage = 0;
1288     }
1289 
1290     // Invoke callback function
1291     result = func(pid, filename, (address)modinfo.lpBaseOfDll,
1292                   modinfo.SizeOfImage, param);
1293     if (result) break;
1294   }
1295 
1296   CloseHandle( hProcess ) ;
1297   return result;
1298 }
1299 
1300 
1301 // enumerate_modules for Windows 95/98/ME, using TOOLHELP
1302 static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
1303 {
1304   HANDLE                hSnapShot ;
1305   static MODULEENTRY32  modentry ;
1306   int                   result = 0;
1307 
1308   if (!os::Kernel32Dll::HelpToolsAvailable()) {
1309     return 0;
1310   }
1311 
1312   // Get a handle to a Toolhelp snapshot of the system
1313   hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ;
1314   if( hSnapShot == INVALID_HANDLE_VALUE ) {
1315       return FALSE ;
1316   }
1317 
1318   // iterate through all modules
1319   modentry.dwSize = sizeof(MODULEENTRY32) ;
1320   bool not_done = os::Kernel32Dll::Module32First( hSnapShot, &modentry ) != 0;
1321 
1322   while( not_done ) {
1323     // invoke the callback
1324     result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
1325                 modentry.modBaseSize, param);
1326     if (result) break;
1327 
1328     modentry.dwSize = sizeof(MODULEENTRY32) ;
1329     not_done = os::Kernel32Dll::Module32Next( hSnapShot, &modentry ) != 0;
1330   }
1331 
1332   CloseHandle(hSnapShot);
1333   return result;
1334 }
1335 
1336 int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param )
1337 {
1338   // Get current process ID if caller doesn't provide it.
1339   if (!pid) pid = os::current_process_id();
1340 
1341   if (os::win32::is_nt()) return _enumerate_modules_winnt  (pid, func, param);
1342   else                    return _enumerate_modules_windows(pid, func, param);
1343 }
1344 
1345 struct _modinfo {
1346    address addr;
1347    char*   full_path;   // point to a char buffer
1348    int     buflen;      // size of the buffer
1349    address base_addr;
1350 };
1351 
1352 static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr,
1353                                   unsigned size, void * param) {
1354    struct _modinfo *pmod = (struct _modinfo *)param;
1355    if (!pmod) return -1;
1356 
1357    if (base_addr     <= pmod->addr &&
1358        base_addr+size > pmod->addr) {
1359      // if a buffer is provided, copy path name to the buffer
1360      if (pmod->full_path) {
1361        jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
1362      }
1363      pmod->base_addr = base_addr;
1364      return 1;
1365    }
1366    return 0;
1367 }
1368 
1369 bool os::dll_address_to_library_name(address addr, char* buf,
1370                                      int buflen, int* offset) {
1371 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
1372 //       return the full path to the DLL file, sometimes it returns path
1373 //       to the corresponding PDB file (debug info); sometimes it only
1374 //       returns partial path, which makes life painful.
1375 
1376    struct _modinfo mi;
1377    mi.addr      = addr;
1378    mi.full_path = buf;
1379    mi.buflen    = buflen;
1380    int pid = os::current_process_id();
1381    if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
1382       // buf already contains path name
1383       if (offset) *offset = addr - mi.base_addr;
1384       return true;
1385    } else {
1386       if (buf) buf[0] = '\0';
1387       if (offset) *offset = -1;
1388       return false;
1389    }
1390 }
1391 
1392 bool os::dll_address_to_function_name(address addr, char *buf,
1393                                       int buflen, int *offset) {
1394   if (Decoder::decode(addr, buf, buflen, offset)) {
1395     return true;
1396   }
1397   if (offset != NULL)  *offset  = -1;
1398   if (buf != NULL) buf[0] = '\0';
1399   return false;
1400 }
1401 
1402 // save the start and end address of jvm.dll into param[0] and param[1]
1403 static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
1404                     unsigned size, void * param) {
1405    if (!param) return -1;
1406 
1407    if (base_addr     <= (address)_locate_jvm_dll &&
1408        base_addr+size > (address)_locate_jvm_dll) {
1409          ((address*)param)[0] = base_addr;
1410          ((address*)param)[1] = base_addr + size;
1411          return 1;
1412    }
1413    return 0;
1414 }
1415 
1416 address vm_lib_location[2];    // start and end address of jvm.dll
1417 
1418 // check if addr is inside jvm.dll
1419 bool os::address_is_in_vm(address addr) {
1420   if (!vm_lib_location[0] || !vm_lib_location[1]) {
1421     int pid = os::current_process_id();
1422     if (!enumerate_modules(pid, _locate_jvm_dll, (void *)vm_lib_location)) {
1423       assert(false, "Can't find jvm module.");
1424       return false;
1425     }
1426   }
1427 
1428   return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]);
1429 }
1430 
1431 // print module info; param is outputStream*
1432 static int _print_module(int pid, char* fname, address base,
1433                          unsigned size, void* param) {
1434    if (!param) return -1;
1435 
1436    outputStream* st = (outputStream*)param;
1437 
1438    address end_addr = base + size;
1439    st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname);
1440    return 0;
1441 }
1442 
1443 // Loads .dll/.so and
1444 // in case of error it checks if .dll/.so was built for the
1445 // same architecture as Hotspot is running on
1446 void * os::dll_load(const char *name, char *ebuf, int ebuflen)
1447 {
1448   void * result = LoadLibrary(name);
1449   if (result != NULL)
1450   {
1451     return result;
1452   }
1453 
1454   DWORD errcode = GetLastError();
1455   if (errcode == ERROR_MOD_NOT_FOUND) {
1456     strncpy(ebuf, "Can't find dependent libraries", ebuflen-1);
1457     ebuf[ebuflen-1]='\0';
1458     return NULL;
1459   }
1460 
1461   // Parsing dll below
1462   // If we can read dll-info and find that dll was built
1463   // for an architecture other than Hotspot is running in
1464   // - then print to buffer "DLL was built for a different architecture"
1465   // else call os::lasterror to obtain system error message
1466 
1467   // Read system error message into ebuf
1468   // It may or may not be overwritten below (in the for loop and just above)
1469   lasterror(ebuf, (size_t) ebuflen);
1470   ebuf[ebuflen-1]='\0';
1471   int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0);
1472   if (file_descriptor<0)
1473   {
1474     return NULL;
1475   }
1476 
1477   uint32_t signature_offset;
1478   uint16_t lib_arch=0;
1479   bool failed_to_get_lib_arch=
1480   (
1481     //Go to position 3c in the dll
1482     (os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0)
1483     ||
1484     // Read loacation of signature
1485     (sizeof(signature_offset)!=
1486       (os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset))))
1487     ||
1488     //Go to COFF File Header in dll
1489     //that is located after"signature" (4 bytes long)
1490     (os::seek_to_file_offset(file_descriptor,
1491       signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0)
1492     ||
1493     //Read field that contains code of architecture
1494     // that dll was build for
1495     (sizeof(lib_arch)!=
1496       (os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch))))
1497   );
1498 
1499   ::close(file_descriptor);
1500   if (failed_to_get_lib_arch)
1501   {
1502     // file i/o error - report os::lasterror(...) msg
1503     return NULL;
1504   }
1505 
1506   typedef struct
1507   {
1508     uint16_t arch_code;
1509     char* arch_name;
1510   } arch_t;
1511 
1512   static const arch_t arch_array[]={
1513     {IMAGE_FILE_MACHINE_I386,      (char*)"IA 32"},
1514     {IMAGE_FILE_MACHINE_AMD64,     (char*)"AMD 64"},
1515     {IMAGE_FILE_MACHINE_IA64,      (char*)"IA 64"}
1516   };
1517   #if   (defined _M_IA64)
1518     static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64;
1519   #elif (defined _M_AMD64)
1520     static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64;
1521   #elif (defined _M_IX86)
1522     static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386;
1523   #else
1524     #error Method os::dll_load requires that one of following \
1525            is defined :_M_IA64,_M_AMD64 or _M_IX86
1526   #endif
1527 
1528 
1529   // Obtain a string for printf operation
1530   // lib_arch_str shall contain string what platform this .dll was built for
1531   // running_arch_str shall string contain what platform Hotspot was built for
1532   char *running_arch_str=NULL,*lib_arch_str=NULL;
1533   for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++)
1534   {
1535     if (lib_arch==arch_array[i].arch_code)
1536       lib_arch_str=arch_array[i].arch_name;
1537     if (running_arch==arch_array[i].arch_code)
1538       running_arch_str=arch_array[i].arch_name;
1539   }
1540 
1541   assert(running_arch_str,
1542     "Didn't find runing architecture code in arch_array");
1543 
1544   // If the architure is right
1545   // but some other error took place - report os::lasterror(...) msg
1546   if (lib_arch == running_arch)
1547   {
1548     return NULL;
1549   }
1550 
1551   if (lib_arch_str!=NULL)
1552   {
1553     ::_snprintf(ebuf, ebuflen-1,
1554       "Can't load %s-bit .dll on a %s-bit platform",
1555       lib_arch_str,running_arch_str);
1556   }
1557   else
1558   {
1559     // don't know what architecture this dll was build for
1560     ::_snprintf(ebuf, ebuflen-1,
1561       "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
1562       lib_arch,running_arch_str);
1563   }
1564 
1565   return NULL;
1566 }
1567 
1568 
1569 void os::print_dll_info(outputStream *st) {
1570    int pid = os::current_process_id();
1571    st->print_cr("Dynamic libraries:");
1572    enumerate_modules(pid, _print_module, (void *)st);
1573 }
1574 
1575 void os::print_os_info_brief(outputStream* st) {
1576   os::print_os_info(st);
1577 }
1578 
1579 void os::print_os_info(outputStream* st) {
1580   st->print("OS:");
1581 
1582   os::win32::print_windows_version(st);
1583 }
1584 
1585 void os::win32::print_windows_version(outputStream* st) {
1586   OSVERSIONINFOEX osvi;
1587   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1588   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1589 
1590   if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1591     st->print_cr("N/A");
1592     return;
1593   }
1594 
1595   int os_vers = osvi.dwMajorVersion * 1000 + osvi.dwMinorVersion;
1596   if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1597     switch (os_vers) {
1598     case 3051: st->print(" Windows NT 3.51"); break;
1599     case 4000: st->print(" Windows NT 4.0"); break;
1600     case 5000: st->print(" Windows 2000"); break;
1601     case 5001: st->print(" Windows XP"); break;
1602     case 5002:
1603     case 6000:
1604     case 6001:
1605     case 6002: {
1606       // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1607       // find out whether we are running on 64 bit processor or not.
1608       SYSTEM_INFO si;
1609       ZeroMemory(&si, sizeof(SYSTEM_INFO));
1610         if (!os::Kernel32Dll::GetNativeSystemInfoAvailable()){
1611           GetSystemInfo(&si);
1612       } else {
1613         os::Kernel32Dll::GetNativeSystemInfo(&si);
1614       }
1615       if (os_vers == 5002) {
1616         if (osvi.wProductType == VER_NT_WORKSTATION &&
1617             si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1618           st->print(" Windows XP x64 Edition");
1619         else
1620             st->print(" Windows Server 2003 family");
1621       } else if (os_vers == 6000) {
1622         if (osvi.wProductType == VER_NT_WORKSTATION)
1623             st->print(" Windows Vista");
1624         else
1625             st->print(" Windows Server 2008");
1626         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1627             st->print(" , 64 bit");
1628       } else if (os_vers == 6001) {
1629         if (osvi.wProductType == VER_NT_WORKSTATION) {
1630             st->print(" Windows 7");
1631         } else {
1632             // Unrecognized windows, print out its major and minor versions
1633             st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1634         }
1635         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1636             st->print(" , 64 bit");
1637       } else if (os_vers == 6002) {
1638         if (osvi.wProductType == VER_NT_WORKSTATION) {
1639             st->print(" Windows 8");
1640         } else {
1641             st->print(" Windows Server 2012");
1642         }
1643         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1644             st->print(" , 64 bit");
1645       } else { // future os
1646         // Unrecognized windows, print out its major and minor versions
1647         st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1648         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1649             st->print(" , 64 bit");
1650       }
1651       break;
1652     }
1653     default: // future windows, print out its major and minor versions
1654       st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1655     }
1656   } else {
1657     switch (os_vers) {
1658     case 4000: st->print(" Windows 95"); break;
1659     case 4010: st->print(" Windows 98"); break;
1660     case 4090: st->print(" Windows Me"); break;
1661     default: // future windows, print out its major and minor versions
1662       st->print(" Windows %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1663     }
1664   }
1665   st->print(" Build %d", osvi.dwBuildNumber);
1666   st->print(" %s", osvi.szCSDVersion);           // service pack
1667   st->cr();
1668 }
1669 
1670 void os::pd_print_cpu_info(outputStream* st) {
1671   // Nothing to do for now.
1672 }
1673 
1674 void os::print_memory_info(outputStream* st) {
1675   st->print("Memory:");
1676   st->print(" %dk page", os::vm_page_size()>>10);
1677 
1678   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1679   // value if total memory is larger than 4GB
1680   MEMORYSTATUSEX ms;
1681   ms.dwLength = sizeof(ms);
1682   GlobalMemoryStatusEx(&ms);
1683 
1684   st->print(", physical %uk", os::physical_memory() >> 10);
1685   st->print("(%uk free)", os::available_memory() >> 10);
1686 
1687   st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1688   st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1689   st->cr();
1690 }
1691 
1692 void os::print_siginfo(outputStream *st, void *siginfo) {
1693   EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo;
1694   st->print("siginfo:");
1695   st->print(" ExceptionCode=0x%x", er->ExceptionCode);
1696 
1697   if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1698       er->NumberParameters >= 2) {
1699       switch (er->ExceptionInformation[0]) {
1700       case 0: st->print(", reading address"); break;
1701       case 1: st->print(", writing address"); break;
1702       default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1703                             er->ExceptionInformation[0]);
1704       }
1705       st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1706   } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
1707              er->NumberParameters >= 2 && UseSharedSpaces) {
1708     FileMapInfo* mapinfo = FileMapInfo::current_info();
1709     if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) {
1710       st->print("\n\nError accessing class data sharing archive."       \
1711                 " Mapped file inaccessible during execution, "          \
1712                 " possible disk/network problem.");
1713     }
1714   } else {
1715     int num = er->NumberParameters;
1716     if (num > 0) {
1717       st->print(", ExceptionInformation=");
1718       for (int i = 0; i < num; i++) {
1719         st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1720       }
1721     }
1722   }
1723   st->cr();
1724 }
1725 
1726 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1727   // do nothing
1728 }
1729 
1730 static char saved_jvm_path[MAX_PATH] = {0};
1731 
1732 // Find the full path to the current module, jvm.dll or jvm_g.dll
1733 void os::jvm_path(char *buf, jint buflen) {
1734   // Error checking.
1735   if (buflen < MAX_PATH) {
1736     assert(false, "must use a large-enough buffer");
1737     buf[0] = '\0';
1738     return;
1739   }
1740   // Lazy resolve the path to current module.
1741   if (saved_jvm_path[0] != 0) {
1742     strcpy(buf, saved_jvm_path);
1743     return;
1744   }
1745 
1746   buf[0] = '\0';
1747   if (Arguments::created_by_gamma_launcher()) {
1748      // Support for the gamma launcher. Check for an
1749      // JAVA_HOME environment variable
1750      // and fix up the path so it looks like
1751      // libjvm.so is installed there (append a fake suffix
1752      // hotspot/libjvm.so).
1753      char* java_home_var = ::getenv("JAVA_HOME");
1754      if (java_home_var != NULL && java_home_var[0] != 0) {
1755 
1756         strncpy(buf, java_home_var, buflen);
1757 
1758         // determine if this is a legacy image or modules image
1759         // modules image doesn't have "jre" subdirectory
1760         size_t len = strlen(buf);
1761         char* jrebin_p = buf + len;
1762         jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1763         if (0 != _access(buf, 0)) {
1764           jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1765         }
1766         len = strlen(buf);
1767         jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1768      }
1769   }
1770 
1771   if(buf[0] == '\0') {
1772   GetModuleFileName(vm_lib_handle, buf, buflen);
1773   }
1774   strcpy(saved_jvm_path, buf);
1775 }
1776 
1777 
1778 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1779 #ifndef _WIN64
1780   st->print("_");
1781 #endif
1782 }
1783 
1784 
1785 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1786 #ifndef _WIN64
1787   st->print("@%d", args_size  * sizeof(int));
1788 #endif
1789 }
1790 
1791 // This method is a copy of JDK's sysGetLastErrorString
1792 // from src/windows/hpi/src/system_md.c
1793 
1794 size_t os::lasterror(char* buf, size_t len) {
1795   DWORD errval;
1796 
1797   if ((errval = GetLastError()) != 0) {
1798     // DOS error
1799     size_t n = (size_t)FormatMessage(
1800           FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1801           NULL,
1802           errval,
1803           0,
1804           buf,
1805           (DWORD)len,
1806           NULL);
1807     if (n > 3) {
1808       // Drop final '.', CR, LF
1809       if (buf[n - 1] == '\n') n--;
1810       if (buf[n - 1] == '\r') n--;
1811       if (buf[n - 1] == '.') n--;
1812       buf[n] = '\0';
1813     }
1814     return n;
1815   }
1816 
1817   if (errno != 0) {
1818     // C runtime error that has no corresponding DOS error code
1819     const char* s = strerror(errno);
1820     size_t n = strlen(s);
1821     if (n >= len) n = len - 1;
1822     strncpy(buf, s, n);
1823     buf[n] = '\0';
1824     return n;
1825   }
1826 
1827   return 0;
1828 }
1829 
1830 int os::get_last_error() {
1831   DWORD error = GetLastError();
1832   if (error == 0)
1833     error = errno;
1834   return (int)error;
1835 }
1836 
1837 // sun.misc.Signal
1838 // NOTE that this is a workaround for an apparent kernel bug where if
1839 // a signal handler for SIGBREAK is installed then that signal handler
1840 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1841 // See bug 4416763.
1842 static void (*sigbreakHandler)(int) = NULL;
1843 
1844 static void UserHandler(int sig, void *siginfo, void *context) {
1845   os::signal_notify(sig);
1846   // We need to reinstate the signal handler each time...
1847   os::signal(sig, (void*)UserHandler);
1848 }
1849 
1850 void* os::user_handler() {
1851   return (void*) UserHandler;
1852 }
1853 
1854 void* os::signal(int signal_number, void* handler) {
1855   if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1856     void (*oldHandler)(int) = sigbreakHandler;
1857     sigbreakHandler = (void (*)(int)) handler;
1858     return (void*) oldHandler;
1859   } else {
1860     return (void*)::signal(signal_number, (void (*)(int))handler);
1861   }
1862 }
1863 
1864 void os::signal_raise(int signal_number) {
1865   raise(signal_number);
1866 }
1867 
1868 // The Win32 C runtime library maps all console control events other than ^C
1869 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1870 // logoff, and shutdown events.  We therefore install our own console handler
1871 // that raises SIGTERM for the latter cases.
1872 //
1873 static BOOL WINAPI consoleHandler(DWORD event) {
1874   switch(event) {
1875     case CTRL_C_EVENT:
1876       if (is_error_reported()) {
1877         // Ctrl-C is pressed during error reporting, likely because the error
1878         // handler fails to abort. Let VM die immediately.
1879         os::die();
1880       }
1881 
1882       os::signal_raise(SIGINT);
1883       return TRUE;
1884       break;
1885     case CTRL_BREAK_EVENT:
1886       if (sigbreakHandler != NULL) {
1887         (*sigbreakHandler)(SIGBREAK);
1888       }
1889       return TRUE;
1890       break;
1891     case CTRL_CLOSE_EVENT:
1892     case CTRL_LOGOFF_EVENT:
1893     case CTRL_SHUTDOWN_EVENT:
1894       os::signal_raise(SIGTERM);
1895       return TRUE;
1896       break;
1897     default:
1898       break;
1899   }
1900   return FALSE;
1901 }
1902 
1903 /*
1904  * The following code is moved from os.cpp for making this
1905  * code platform specific, which it is by its very nature.
1906  */
1907 
1908 // Return maximum OS signal used + 1 for internal use only
1909 // Used as exit signal for signal_thread
1910 int os::sigexitnum_pd(){
1911   return NSIG;
1912 }
1913 
1914 // a counter for each possible signal value, including signal_thread exit signal
1915 static volatile jint pending_signals[NSIG+1] = { 0 };
1916 static HANDLE sig_sem;
1917 
1918 void os::signal_init_pd() {
1919   // Initialize signal structures
1920   memset((void*)pending_signals, 0, sizeof(pending_signals));
1921 
1922   sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
1923 
1924   // Programs embedding the VM do not want it to attempt to receive
1925   // events like CTRL_LOGOFF_EVENT, which are used to implement the
1926   // shutdown hooks mechanism introduced in 1.3.  For example, when
1927   // the VM is run as part of a Windows NT service (i.e., a servlet
1928   // engine in a web server), the correct behavior is for any console
1929   // control handler to return FALSE, not TRUE, because the OS's
1930   // "final" handler for such events allows the process to continue if
1931   // it is a service (while terminating it if it is not a service).
1932   // To make this behavior uniform and the mechanism simpler, we
1933   // completely disable the VM's usage of these console events if -Xrs
1934   // (=ReduceSignalUsage) is specified.  This means, for example, that
1935   // the CTRL-BREAK thread dump mechanism is also disabled in this
1936   // case.  See bugs 4323062, 4345157, and related bugs.
1937 
1938   if (!ReduceSignalUsage) {
1939     // Add a CTRL-C handler
1940     SetConsoleCtrlHandler(consoleHandler, TRUE);
1941   }
1942 }
1943 
1944 void os::signal_notify(int signal_number) {
1945   BOOL ret;
1946 
1947   Atomic::inc(&pending_signals[signal_number]);
1948   ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1949   assert(ret != 0, "ReleaseSemaphore() failed");
1950 }
1951 
1952 static int check_pending_signals(bool wait_for_signal) {
1953   DWORD ret;
1954   while (true) {
1955     for (int i = 0; i < NSIG + 1; i++) {
1956       jint n = pending_signals[i];
1957       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1958         return i;
1959       }
1960     }
1961     if (!wait_for_signal) {
1962       return -1;
1963     }
1964 
1965     JavaThread *thread = JavaThread::current();
1966 
1967     ThreadBlockInVM tbivm(thread);
1968 
1969     bool threadIsSuspended;
1970     do {
1971       thread->set_suspend_equivalent();
1972       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1973       ret = ::WaitForSingleObject(sig_sem, INFINITE);
1974       assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
1975 
1976       // were we externally suspended while we were waiting?
1977       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1978       if (threadIsSuspended) {
1979         //
1980         // The semaphore has been incremented, but while we were waiting
1981         // another thread suspended us. We don't want to continue running
1982         // while suspended because that would surprise the thread that
1983         // suspended us.
1984         //
1985         ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1986         assert(ret != 0, "ReleaseSemaphore() failed");
1987 
1988         thread->java_suspend_self();
1989       }
1990     } while (threadIsSuspended);
1991   }
1992 }
1993 
1994 int os::signal_lookup() {
1995   return check_pending_signals(false);
1996 }
1997 
1998 int os::signal_wait() {
1999   return check_pending_signals(true);
2000 }
2001 
2002 // Implicit OS exception handling
2003 
2004 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
2005   JavaThread* thread = JavaThread::current();
2006   // Save pc in thread
2007 #ifdef _M_IA64
2008   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
2009   // Set pc to handler
2010   exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
2011 #elif _M_AMD64
2012   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
2013   // Set pc to handler
2014   exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
2015 #else
2016   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
2017   // Set pc to handler
2018   exceptionInfo->ContextRecord->Eip = (LONG)handler;
2019 #endif
2020 
2021   // Continue the execution
2022   return EXCEPTION_CONTINUE_EXECUTION;
2023 }
2024 
2025 
2026 // Used for PostMortemDump
2027 extern "C" void safepoints();
2028 extern "C" void find(int x);
2029 extern "C" void events();
2030 
2031 // According to Windows API documentation, an illegal instruction sequence should generate
2032 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2033 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2034 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2035 
2036 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2037 
2038 // From "Execution Protection in the Windows Operating System" draft 0.35
2039 // Once a system header becomes available, the "real" define should be
2040 // included or copied here.
2041 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2042 
2043 #define def_excpt(val) #val, val
2044 
2045 struct siglabel {
2046   char *name;
2047   int   number;
2048 };
2049 
2050 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2051 // C++ compiler contain this error code. Because this is a compiler-generated
2052 // error, the code is not listed in the Win32 API header files.
2053 // The code is actually a cryptic mnemonic device, with the initial "E"
2054 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2055 // ASCII values of "msc".
2056 
2057 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION    0xE06D7363
2058 
2059 
2060 struct siglabel exceptlabels[] = {
2061     def_excpt(EXCEPTION_ACCESS_VIOLATION),
2062     def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2063     def_excpt(EXCEPTION_BREAKPOINT),
2064     def_excpt(EXCEPTION_SINGLE_STEP),
2065     def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2066     def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2067     def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2068     def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2069     def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2070     def_excpt(EXCEPTION_FLT_OVERFLOW),
2071     def_excpt(EXCEPTION_FLT_STACK_CHECK),
2072     def_excpt(EXCEPTION_FLT_UNDERFLOW),
2073     def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2074     def_excpt(EXCEPTION_INT_OVERFLOW),
2075     def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2076     def_excpt(EXCEPTION_IN_PAGE_ERROR),
2077     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2078     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2079     def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2080     def_excpt(EXCEPTION_STACK_OVERFLOW),
2081     def_excpt(EXCEPTION_INVALID_DISPOSITION),
2082     def_excpt(EXCEPTION_GUARD_PAGE),
2083     def_excpt(EXCEPTION_INVALID_HANDLE),
2084     def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2085     NULL, 0
2086 };
2087 
2088 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2089   for (int i = 0; exceptlabels[i].name != NULL; i++) {
2090     if (exceptlabels[i].number == exception_code) {
2091        jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2092        return buf;
2093     }
2094   }
2095 
2096   return NULL;
2097 }
2098 
2099 //-----------------------------------------------------------------------------
2100 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2101   // handle exception caused by idiv; should only happen for -MinInt/-1
2102   // (division by zero is handled explicitly)
2103 #ifdef _M_IA64
2104   assert(0, "Fix Handle_IDiv_Exception");
2105 #elif _M_AMD64
2106   PCONTEXT ctx = exceptionInfo->ContextRecord;
2107   address pc = (address)ctx->Rip;
2108   assert(pc[0] == 0xF7, "not an idiv opcode");
2109   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2110   assert(ctx->Rax == min_jint, "unexpected idiv exception");
2111   // set correct result values and continue after idiv instruction
2112   ctx->Rip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2113   ctx->Rax = (DWORD)min_jint;      // result
2114   ctx->Rdx = (DWORD)0;             // remainder
2115   // Continue the execution
2116 #else
2117   PCONTEXT ctx = exceptionInfo->ContextRecord;
2118   address pc = (address)ctx->Eip;
2119   assert(pc[0] == 0xF7, "not an idiv opcode");
2120   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2121   assert(ctx->Eax == min_jint, "unexpected idiv exception");
2122   // set correct result values and continue after idiv instruction
2123   ctx->Eip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2124   ctx->Eax = (DWORD)min_jint;      // result
2125   ctx->Edx = (DWORD)0;             // remainder
2126   // Continue the execution
2127 #endif
2128   return EXCEPTION_CONTINUE_EXECUTION;
2129 }
2130 
2131 #ifndef  _WIN64
2132 //-----------------------------------------------------------------------------
2133 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2134   // handle exception caused by native method modifying control word
2135   PCONTEXT ctx = exceptionInfo->ContextRecord;
2136   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2137 
2138   switch (exception_code) {
2139     case EXCEPTION_FLT_DENORMAL_OPERAND:
2140     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2141     case EXCEPTION_FLT_INEXACT_RESULT:
2142     case EXCEPTION_FLT_INVALID_OPERATION:
2143     case EXCEPTION_FLT_OVERFLOW:
2144     case EXCEPTION_FLT_STACK_CHECK:
2145     case EXCEPTION_FLT_UNDERFLOW:
2146       jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2147       if (fp_control_word != ctx->FloatSave.ControlWord) {
2148         // Restore FPCW and mask out FLT exceptions
2149         ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2150         // Mask out pending FLT exceptions
2151         ctx->FloatSave.StatusWord &=  0xffffff00;
2152         return EXCEPTION_CONTINUE_EXECUTION;
2153       }
2154   }
2155 
2156   if (prev_uef_handler != NULL) {
2157     // We didn't handle this exception so pass it to the previous
2158     // UnhandledExceptionFilter.
2159     return (prev_uef_handler)(exceptionInfo);
2160   }
2161 
2162   return EXCEPTION_CONTINUE_SEARCH;
2163 }
2164 #else //_WIN64
2165 /*
2166   On Windows, the mxcsr control bits are non-volatile across calls
2167   See also CR 6192333
2168   If EXCEPTION_FLT_* happened after some native method modified
2169   mxcsr - it is not a jvm fault.
2170   However should we decide to restore of mxcsr after a faulty
2171   native method we can uncomment following code
2172       jint MxCsr = INITIAL_MXCSR;
2173         // we can't use StubRoutines::addr_mxcsr_std()
2174         // because in Win64 mxcsr is not saved there
2175       if (MxCsr != ctx->MxCsr) {
2176         ctx->MxCsr = MxCsr;
2177         return EXCEPTION_CONTINUE_EXECUTION;
2178       }
2179 
2180 */
2181 #endif //_WIN64
2182 
2183 
2184 // Fatal error reporting is single threaded so we can make this a
2185 // static and preallocated.  If it's more than MAX_PATH silently ignore
2186 // it.
2187 static char saved_error_file[MAX_PATH] = {0};
2188 
2189 void os::set_error_file(const char *logfile) {
2190   if (strlen(logfile) <= MAX_PATH) {
2191     strncpy(saved_error_file, logfile, MAX_PATH);
2192   }
2193 }
2194 
2195 static inline void report_error(Thread* t, DWORD exception_code,
2196                                 address addr, void* siginfo, void* context) {
2197   VMError err(t, exception_code, addr, siginfo, context);
2198   err.report_and_die();
2199 
2200   // If UseOsErrorReporting, this will return here and save the error file
2201   // somewhere where we can find it in the minidump.
2202 }
2203 
2204 //-----------------------------------------------------------------------------
2205 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2206   if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2207   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2208 #ifdef _M_IA64
2209   address pc = (address) exceptionInfo->ContextRecord->StIIP;
2210 #elif _M_AMD64
2211   address pc = (address) exceptionInfo->ContextRecord->Rip;
2212 #else
2213   address pc = (address) exceptionInfo->ContextRecord->Eip;
2214 #endif
2215   Thread* t = ThreadLocalStorage::get_thread_slow();          // slow & steady
2216 
2217 #ifndef _WIN64
2218   // Execution protection violation - win32 running on AMD64 only
2219   // Handled first to avoid misdiagnosis as a "normal" access violation;
2220   // This is safe to do because we have a new/unique ExceptionInformation
2221   // code for this condition.
2222   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2223     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2224     int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2225     address addr = (address) exceptionRecord->ExceptionInformation[1];
2226 
2227     if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2228       int page_size = os::vm_page_size();
2229 
2230       // Make sure the pc and the faulting address are sane.
2231       //
2232       // If an instruction spans a page boundary, and the page containing
2233       // the beginning of the instruction is executable but the following
2234       // page is not, the pc and the faulting address might be slightly
2235       // different - we still want to unguard the 2nd page in this case.
2236       //
2237       // 15 bytes seems to be a (very) safe value for max instruction size.
2238       bool pc_is_near_addr =
2239         (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2240       bool instr_spans_page_boundary =
2241         (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2242                          (intptr_t) page_size) > 0);
2243 
2244       if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2245         static volatile address last_addr =
2246           (address) os::non_memory_address_word();
2247 
2248         // In conservative mode, don't unguard unless the address is in the VM
2249         if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2250             (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2251 
2252           // Set memory to RWX and retry
2253           address page_start =
2254             (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2255           bool res = os::protect_memory((char*) page_start, page_size,
2256                                         os::MEM_PROT_RWX);
2257 
2258           if (PrintMiscellaneous && Verbose) {
2259             char buf[256];
2260             jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2261                          "at " INTPTR_FORMAT
2262                          ", unguarding " INTPTR_FORMAT ": %s", addr,
2263                          page_start, (res ? "success" : strerror(errno)));
2264             tty->print_raw_cr(buf);
2265           }
2266 
2267           // Set last_addr so if we fault again at the same address, we don't
2268           // end up in an endless loop.
2269           //
2270           // There are two potential complications here.  Two threads trapping
2271           // at the same address at the same time could cause one of the
2272           // threads to think it already unguarded, and abort the VM.  Likely
2273           // very rare.
2274           //
2275           // The other race involves two threads alternately trapping at
2276           // different addresses and failing to unguard the page, resulting in
2277           // an endless loop.  This condition is probably even more unlikely
2278           // than the first.
2279           //
2280           // Although both cases could be avoided by using locks or thread
2281           // local last_addr, these solutions are unnecessary complication:
2282           // this handler is a best-effort safety net, not a complete solution.
2283           // It is disabled by default and should only be used as a workaround
2284           // in case we missed any no-execute-unsafe VM code.
2285 
2286           last_addr = addr;
2287 
2288           return EXCEPTION_CONTINUE_EXECUTION;
2289         }
2290       }
2291 
2292       // Last unguard failed or not unguarding
2293       tty->print_raw_cr("Execution protection violation");
2294       report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2295                    exceptionInfo->ContextRecord);
2296       return EXCEPTION_CONTINUE_SEARCH;
2297     }
2298   }
2299 #endif // _WIN64
2300 
2301   // Check to see if we caught the safepoint code in the
2302   // process of write protecting the memory serialization page.
2303   // It write enables the page immediately after protecting it
2304   // so just return.
2305   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2306     JavaThread* thread = (JavaThread*) t;
2307     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2308     address addr = (address) exceptionRecord->ExceptionInformation[1];
2309     if ( os::is_memory_serialize_page(thread, addr) ) {
2310       // Block current thread until the memory serialize page permission restored.
2311       os::block_on_serialize_page_trap();
2312       return EXCEPTION_CONTINUE_EXECUTION;
2313     }
2314   }
2315 
2316   if (t != NULL && t->is_Java_thread()) {
2317     JavaThread* thread = (JavaThread*) t;
2318     bool in_java = thread->thread_state() == _thread_in_Java;
2319 
2320     // Handle potential stack overflows up front.
2321     if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2322       if (os::uses_stack_guard_pages()) {
2323 #ifdef _M_IA64
2324         //
2325         // If it's a legal stack address continue, Windows will map it in.
2326         //
2327         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2328         address addr = (address) exceptionRecord->ExceptionInformation[1];
2329         if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2330           return EXCEPTION_CONTINUE_EXECUTION;
2331 
2332         // The register save area is the same size as the memory stack
2333         // and starts at the page just above the start of the memory stack.
2334         // If we get a fault in this area, we've run out of register
2335         // stack.  If we are in java, try throwing a stack overflow exception.
2336         if (addr > thread->stack_base() &&
2337                       addr <= (thread->stack_base()+thread->stack_size()) ) {
2338           char buf[256];
2339           jio_snprintf(buf, sizeof(buf),
2340                        "Register stack overflow, addr:%p, stack_base:%p\n",
2341                        addr, thread->stack_base() );
2342           tty->print_raw_cr(buf);
2343           // If not in java code, return and hope for the best.
2344           return in_java ? Handle_Exception(exceptionInfo,
2345             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2346             :  EXCEPTION_CONTINUE_EXECUTION;
2347         }
2348 #endif
2349         if (thread->stack_yellow_zone_enabled()) {
2350           // Yellow zone violation.  The o/s has unprotected the first yellow
2351           // zone page for us.  Note:  must call disable_stack_yellow_zone to
2352           // update the enabled status, even if the zone contains only one page.
2353           thread->disable_stack_yellow_zone();
2354           // If not in java code, return and hope for the best.
2355           return in_java ? Handle_Exception(exceptionInfo,
2356             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2357             :  EXCEPTION_CONTINUE_EXECUTION;
2358         } else {
2359           // Fatal red zone violation.
2360           thread->disable_stack_red_zone();
2361           tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2362           report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2363                        exceptionInfo->ContextRecord);
2364           return EXCEPTION_CONTINUE_SEARCH;
2365         }
2366       } else if (in_java) {
2367         // JVM-managed guard pages cannot be used on win95/98.  The o/s provides
2368         // a one-time-only guard page, which it has released to us.  The next
2369         // stack overflow on this thread will result in an ACCESS_VIOLATION.
2370         return Handle_Exception(exceptionInfo,
2371           SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2372       } else {
2373         // Can only return and hope for the best.  Further stack growth will
2374         // result in an ACCESS_VIOLATION.
2375         return EXCEPTION_CONTINUE_EXECUTION;
2376       }
2377     } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2378       // Either stack overflow or null pointer exception.
2379       if (in_java) {
2380         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2381         address addr = (address) exceptionRecord->ExceptionInformation[1];
2382         address stack_end = thread->stack_base() - thread->stack_size();
2383         if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2384           // Stack overflow.
2385           assert(!os::uses_stack_guard_pages(),
2386             "should be caught by red zone code above.");
2387           return Handle_Exception(exceptionInfo,
2388             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2389         }
2390         //
2391         // Check for safepoint polling and implicit null
2392         // We only expect null pointers in the stubs (vtable)
2393         // the rest are checked explicitly now.
2394         //
2395         CodeBlob* cb = CodeCache::find_blob(pc);
2396         if (cb != NULL) {
2397           if (os::is_poll_address(addr)) {
2398             address stub = SharedRuntime::get_poll_stub(pc);
2399             return Handle_Exception(exceptionInfo, stub);
2400           }
2401         }
2402         {
2403 #ifdef _WIN64
2404           //
2405           // If it's a legal stack address map the entire region in
2406           //
2407           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2408           address addr = (address) exceptionRecord->ExceptionInformation[1];
2409           if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2410                   addr = (address)((uintptr_t)addr &
2411                          (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2412                   os::commit_memory((char *)addr, thread->stack_base() - addr,
2413                                     false );
2414                   return EXCEPTION_CONTINUE_EXECUTION;
2415           }
2416           else
2417 #endif
2418           {
2419             // Null pointer exception.
2420 #ifdef _M_IA64
2421             // We catch register stack overflows in compiled code by doing
2422             // an explicit compare and executing a st8(G0, G0) if the
2423             // BSP enters into our guard area.  We test for the overflow
2424             // condition and fall into the normal null pointer exception
2425             // code if BSP hasn't overflowed.
2426             if ( in_java ) {
2427               if(thread->register_stack_overflow()) {
2428                 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2429                                 thread->register_stack_limit(),
2430                                "GR7 doesn't contain register_stack_limit");
2431                 // Disable the yellow zone which sets the state that
2432                 // we've got a stack overflow problem.
2433                 if (thread->stack_yellow_zone_enabled()) {
2434                   thread->disable_stack_yellow_zone();
2435                 }
2436                 // Give us some room to process the exception
2437                 thread->disable_register_stack_guard();
2438                 // Update GR7 with the new limit so we can continue running
2439                 // compiled code.
2440                 exceptionInfo->ContextRecord->IntS3 =
2441                                (ULONGLONG)thread->register_stack_limit();
2442                 return Handle_Exception(exceptionInfo,
2443                        SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2444               } else {
2445                 //
2446                 // Check for implicit null
2447                 // We only expect null pointers in the stubs (vtable)
2448                 // the rest are checked explicitly now.
2449                 //
2450                 if (((uintptr_t)addr) < os::vm_page_size() ) {
2451                   // an access to the first page of VM--assume it is a null pointer
2452                   address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2453                   if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2454                 }
2455               }
2456             } // in_java
2457 
2458             // IA64 doesn't use implicit null checking yet. So we shouldn't
2459             // get here.
2460             tty->print_raw_cr("Access violation, possible null pointer exception");
2461             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2462                          exceptionInfo->ContextRecord);
2463             return EXCEPTION_CONTINUE_SEARCH;
2464 #else /* !IA64 */
2465 
2466             // Windows 98 reports faulting addresses incorrectly
2467             if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2468                 !os::win32::is_nt()) {
2469               address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2470               if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2471             }
2472             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2473                          exceptionInfo->ContextRecord);
2474             return EXCEPTION_CONTINUE_SEARCH;
2475 #endif
2476           }
2477         }
2478       }
2479 
2480 #ifdef _WIN64
2481       // Special care for fast JNI field accessors.
2482       // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2483       // in and the heap gets shrunk before the field access.
2484       if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2485         address addr = JNI_FastGetField::find_slowcase_pc(pc);
2486         if (addr != (address)-1) {
2487           return Handle_Exception(exceptionInfo, addr);
2488         }
2489       }
2490 #endif
2491 
2492 #ifdef _WIN64
2493       // Windows will sometimes generate an access violation
2494       // when we call malloc.  Since we use VectoredExceptions
2495       // on 64 bit platforms, we see this exception.  We must
2496       // pass this exception on so Windows can recover.
2497       // We check to see if the pc of the fault is in NTDLL.DLL
2498       // if so, we pass control on to Windows for handling.
2499       if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2500 #endif
2501 
2502       // Stack overflow or null pointer exception in native code.
2503       report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2504                    exceptionInfo->ContextRecord);
2505       return EXCEPTION_CONTINUE_SEARCH;
2506     }
2507 
2508     if (in_java) {
2509       switch (exception_code) {
2510       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2511         return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2512 
2513       case EXCEPTION_INT_OVERFLOW:
2514         return Handle_IDiv_Exception(exceptionInfo);
2515 
2516       } // switch
2517     }
2518 #ifndef _WIN64
2519     if (((thread->thread_state() == _thread_in_Java) ||
2520         (thread->thread_state() == _thread_in_native)) &&
2521         exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2522     {
2523       LONG result=Handle_FLT_Exception(exceptionInfo);
2524       if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2525     }
2526 #endif //_WIN64
2527   }
2528 
2529   if (exception_code != EXCEPTION_BREAKPOINT) {
2530 #ifndef _WIN64
2531     report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2532                  exceptionInfo->ContextRecord);
2533 #else
2534     // Itanium Windows uses a VectoredExceptionHandler
2535     // Which means that C++ programatic exception handlers (try/except)
2536     // will get here.  Continue the search for the right except block if
2537     // the exception code is not a fatal code.
2538     switch ( exception_code ) {
2539       case EXCEPTION_ACCESS_VIOLATION:
2540       case EXCEPTION_STACK_OVERFLOW:
2541       case EXCEPTION_ILLEGAL_INSTRUCTION:
2542       case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2543       case EXCEPTION_INT_OVERFLOW:
2544       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2545       case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
2546       {  report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2547                        exceptionInfo->ContextRecord);
2548       }
2549         break;
2550       default:
2551         break;
2552     }
2553 #endif
2554   }
2555   return EXCEPTION_CONTINUE_SEARCH;
2556 }
2557 
2558 #ifndef _WIN64
2559 // Special care for fast JNI accessors.
2560 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2561 // the heap gets shrunk before the field access.
2562 // Need to install our own structured exception handler since native code may
2563 // install its own.
2564 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2565   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2566   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2567     address pc = (address) exceptionInfo->ContextRecord->Eip;
2568     address addr = JNI_FastGetField::find_slowcase_pc(pc);
2569     if (addr != (address)-1) {
2570       return Handle_Exception(exceptionInfo, addr);
2571     }
2572   }
2573   return EXCEPTION_CONTINUE_SEARCH;
2574 }
2575 
2576 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2577 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2578   __try { \
2579     return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2580   } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2581   } \
2582   return 0; \
2583 }
2584 
2585 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2586 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2587 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2588 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2589 DEFINE_FAST_GETFIELD(jint,     int,    Int)
2590 DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2591 DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2592 DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2593 
2594 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2595   switch (type) {
2596     case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2597     case T_BYTE:    return (address)jni_fast_GetByteField_wrapper;
2598     case T_CHAR:    return (address)jni_fast_GetCharField_wrapper;
2599     case T_SHORT:   return (address)jni_fast_GetShortField_wrapper;
2600     case T_INT:     return (address)jni_fast_GetIntField_wrapper;
2601     case T_LONG:    return (address)jni_fast_GetLongField_wrapper;
2602     case T_FLOAT:   return (address)jni_fast_GetFloatField_wrapper;
2603     case T_DOUBLE:  return (address)jni_fast_GetDoubleField_wrapper;
2604     default:        ShouldNotReachHere();
2605   }
2606   return (address)-1;
2607 }
2608 #endif
2609 
2610 // Virtual Memory
2611 
2612 int os::vm_page_size() { return os::win32::vm_page_size(); }
2613 int os::vm_allocation_granularity() {
2614   return os::win32::vm_allocation_granularity();
2615 }
2616 
2617 // Windows large page support is available on Windows 2003. In order to use
2618 // large page memory, the administrator must first assign additional privilege
2619 // to the user:
2620 //   + select Control Panel -> Administrative Tools -> Local Security Policy
2621 //   + select Local Policies -> User Rights Assignment
2622 //   + double click "Lock pages in memory", add users and/or groups
2623 //   + reboot
2624 // Note the above steps are needed for administrator as well, as administrators
2625 // by default do not have the privilege to lock pages in memory.
2626 //
2627 // Note about Windows 2003: although the API supports committing large page
2628 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2629 // scenario, I found through experiment it only uses large page if the entire
2630 // memory region is reserved and committed in a single VirtualAlloc() call.
2631 // This makes Windows large page support more or less like Solaris ISM, in
2632 // that the entire heap must be committed upfront. This probably will change
2633 // in the future, if so the code below needs to be revisited.
2634 
2635 #ifndef MEM_LARGE_PAGES
2636 #define MEM_LARGE_PAGES 0x20000000
2637 #endif
2638 
2639 static HANDLE    _hProcess;
2640 static HANDLE    _hToken;
2641 
2642 // Container for NUMA node list info
2643 class NUMANodeListHolder {
2644 private:
2645   int *_numa_used_node_list;  // allocated below
2646   int _numa_used_node_count;
2647 
2648   void free_node_list() {
2649     if (_numa_used_node_list != NULL) {
2650       FREE_C_HEAP_ARRAY(int, _numa_used_node_list, mtInternal);
2651     }
2652   }
2653 
2654 public:
2655   NUMANodeListHolder() {
2656     _numa_used_node_count = 0;
2657     _numa_used_node_list = NULL;
2658     // do rest of initialization in build routine (after function pointers are set up)
2659   }
2660 
2661   ~NUMANodeListHolder() {
2662     free_node_list();
2663   }
2664 
2665   bool build() {
2666     DWORD_PTR proc_aff_mask;
2667     DWORD_PTR sys_aff_mask;
2668     if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2669     ULONG highest_node_number;
2670     if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false;
2671     free_node_list();
2672     _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal);
2673     for (unsigned int i = 0; i <= highest_node_number; i++) {
2674       ULONGLONG proc_mask_numa_node;
2675       if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2676       if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2677         _numa_used_node_list[_numa_used_node_count++] = i;
2678       }
2679     }
2680     return (_numa_used_node_count > 1);
2681   }
2682 
2683   int get_count() {return _numa_used_node_count;}
2684   int get_node_list_entry(int n) {
2685     // for indexes out of range, returns -1
2686     return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2687   }
2688 
2689 } numa_node_list_holder;
2690 
2691 
2692 
2693 static size_t _large_page_size = 0;
2694 
2695 static bool resolve_functions_for_large_page_init() {
2696   return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2697     os::Advapi32Dll::AdvapiAvailable();
2698 }
2699 
2700 static bool request_lock_memory_privilege() {
2701   _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2702                                 os::current_process_id());
2703 
2704   LUID luid;
2705   if (_hProcess != NULL &&
2706       os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2707       os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2708 
2709     TOKEN_PRIVILEGES tp;
2710     tp.PrivilegeCount = 1;
2711     tp.Privileges[0].Luid = luid;
2712     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2713 
2714     // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2715     // privilege. Check GetLastError() too. See MSDN document.
2716     if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2717         (GetLastError() == ERROR_SUCCESS)) {
2718       return true;
2719     }
2720   }
2721 
2722   return false;
2723 }
2724 
2725 static void cleanup_after_large_page_init() {
2726   if (_hProcess) CloseHandle(_hProcess);
2727   _hProcess = NULL;
2728   if (_hToken) CloseHandle(_hToken);
2729   _hToken = NULL;
2730 }
2731 
2732 static bool numa_interleaving_init() {
2733   bool success = false;
2734   bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2735 
2736   // print a warning if UseNUMAInterleaving flag is specified on command line
2737   bool warn_on_failure = use_numa_interleaving_specified;
2738 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2739 
2740   // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2741   size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2742   NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
2743 
2744   if (os::Kernel32Dll::NumaCallsAvailable()) {
2745     if (numa_node_list_holder.build()) {
2746       if (PrintMiscellaneous && Verbose) {
2747         tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
2748         for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
2749           tty->print("%d ", numa_node_list_holder.get_node_list_entry(i));
2750         }
2751         tty->print("\n");
2752       }
2753       success = true;
2754     } else {
2755       WARN("Process does not cover multiple NUMA nodes.");
2756     }
2757   } else {
2758     WARN("NUMA Interleaving is not supported by the operating system.");
2759   }
2760   if (!success) {
2761     if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2762   }
2763   return success;
2764 #undef WARN
2765 }
2766 
2767 // this routine is used whenever we need to reserve a contiguous VA range
2768 // but we need to make separate VirtualAlloc calls for each piece of the range
2769 // Reasons for doing this:
2770 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2771 //  * UseNUMAInterleaving requires a separate node for each piece
2772 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
2773                                          bool should_inject_error=false) {
2774   char * p_buf;
2775   // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2776   size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2777   size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2778 
2779   // first reserve enough address space in advance since we want to be
2780   // able to break a single contiguous virtual address range into multiple
2781   // large page commits but WS2003 does not allow reserving large page space
2782   // so we just use 4K pages for reserve, this gives us a legal contiguous
2783   // address space. then we will deallocate that reservation, and re alloc
2784   // using large pages
2785   const size_t size_of_reserve = bytes + chunk_size;
2786   if (bytes > size_of_reserve) {
2787     // Overflowed.
2788     return NULL;
2789   }
2790   p_buf = (char *) VirtualAlloc(addr,
2791                                 size_of_reserve,  // size of Reserve
2792                                 MEM_RESERVE,
2793                                 PAGE_READWRITE);
2794   // If reservation failed, return NULL
2795   if (p_buf == NULL) return NULL;
2796 
2797   os::release_memory(p_buf, bytes + chunk_size);
2798 
2799   // we still need to round up to a page boundary (in case we are using large pages)
2800   // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
2801   // instead we handle this in the bytes_to_rq computation below
2802   p_buf = (char *) align_size_up((size_t)p_buf, page_size);
2803 
2804   // now go through and allocate one chunk at a time until all bytes are
2805   // allocated
2806   size_t  bytes_remaining = bytes;
2807   // An overflow of align_size_up() would have been caught above
2808   // in the calculation of size_of_reserve.
2809   char * next_alloc_addr = p_buf;
2810   HANDLE hProc = GetCurrentProcess();
2811 
2812 #ifdef ASSERT
2813   // Variable for the failure injection
2814   long ran_num = os::random();
2815   size_t fail_after = ran_num % bytes;
2816 #endif
2817 
2818   int count=0;
2819   while (bytes_remaining) {
2820     // select bytes_to_rq to get to the next chunk_size boundary
2821 
2822     size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
2823     // Note allocate and commit
2824     char * p_new;
2825 
2826 #ifdef ASSERT
2827     bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
2828 #else
2829     const bool inject_error_now = false;
2830 #endif
2831 
2832     if (inject_error_now) {
2833       p_new = NULL;
2834     } else {
2835       if (!UseNUMAInterleaving) {
2836         p_new = (char *) VirtualAlloc(next_alloc_addr,
2837                                       bytes_to_rq,
2838                                       flags,
2839                                       prot);
2840       } else {
2841         // get the next node to use from the used_node_list
2842         assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
2843         DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
2844         p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc,
2845                                                             next_alloc_addr,
2846                                                             bytes_to_rq,
2847                                                             flags,
2848                                                             prot,
2849                                                             node);
2850       }
2851     }
2852 
2853     if (p_new == NULL) {
2854       // Free any allocated pages
2855       if (next_alloc_addr > p_buf) {
2856         // Some memory was committed so release it.
2857         size_t bytes_to_release = bytes - bytes_remaining;
2858         os::release_memory(p_buf, bytes_to_release);
2859       }
2860 #ifdef ASSERT
2861       if (should_inject_error) {
2862         if (TracePageSizes && Verbose) {
2863           tty->print_cr("Reserving pages individually failed.");
2864         }
2865       }
2866 #endif
2867       return NULL;
2868     }
2869     bytes_remaining -= bytes_to_rq;
2870     next_alloc_addr += bytes_to_rq;
2871     count++;
2872   }
2873   // made it this far, success
2874   return p_buf;
2875 }
2876 
2877 
2878 
2879 void os::large_page_init() {
2880   if (!UseLargePages) return;
2881 
2882   // print a warning if any large page related flag is specified on command line
2883   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2884                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2885   bool success = false;
2886 
2887 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2888   if (resolve_functions_for_large_page_init()) {
2889     if (request_lock_memory_privilege()) {
2890       size_t s = os::Kernel32Dll::GetLargePageMinimum();
2891       if (s) {
2892 #if defined(IA32) || defined(AMD64)
2893         if (s > 4*M || LargePageSizeInBytes > 4*M) {
2894           WARN("JVM cannot use large pages bigger than 4mb.");
2895         } else {
2896 #endif
2897           if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2898             _large_page_size = LargePageSizeInBytes;
2899           } else {
2900             _large_page_size = s;
2901           }
2902           success = true;
2903 #if defined(IA32) || defined(AMD64)
2904         }
2905 #endif
2906       } else {
2907         WARN("Large page is not supported by the processor.");
2908       }
2909     } else {
2910       WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2911     }
2912   } else {
2913     WARN("Large page is not supported by the operating system.");
2914   }
2915 #undef WARN
2916 
2917   const size_t default_page_size = (size_t) vm_page_size();
2918   if (success && _large_page_size > default_page_size) {
2919     _page_sizes[0] = _large_page_size;
2920     _page_sizes[1] = default_page_size;
2921     _page_sizes[2] = 0;
2922   }
2923 
2924   cleanup_after_large_page_init();
2925   UseLargePages = success;
2926 }
2927 
2928 // On win32, one cannot release just a part of reserved memory, it's an
2929 // all or nothing deal.  When we split a reservation, we must break the
2930 // reservation into two reservations.
2931 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
2932                               bool realloc) {
2933   if (size > 0) {
2934     release_memory(base, size);
2935     if (realloc) {
2936       reserve_memory(split, base);
2937     }
2938     if (size != split) {
2939       reserve_memory(size - split, base + split);
2940     }
2941   }
2942 }
2943 
2944 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2945   assert((size_t)addr % os::vm_allocation_granularity() == 0,
2946          "reserve alignment");
2947   assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2948   char* res;
2949   // note that if UseLargePages is on, all the areas that require interleaving
2950   // will go thru reserve_memory_special rather than thru here.
2951   bool use_individual = (UseNUMAInterleaving && !UseLargePages);
2952   if (!use_individual) {
2953     res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2954   } else {
2955     elapsedTimer reserveTimer;
2956     if( Verbose && PrintMiscellaneous ) reserveTimer.start();
2957     // in numa interleaving, we have to allocate pages individually
2958     // (well really chunks of NUMAInterleaveGranularity size)
2959     res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
2960     if (res == NULL) {
2961       warning("NUMA page allocation failed");
2962     }
2963     if( Verbose && PrintMiscellaneous ) {
2964       reserveTimer.stop();
2965       tty->print_cr("reserve_memory of %Ix bytes took %ld ms (%ld ticks)", bytes,
2966                     reserveTimer.milliseconds(), reserveTimer.ticks());
2967     }
2968   }
2969   assert(res == NULL || addr == NULL || addr == res,
2970          "Unexpected address from reserve.");
2971 
2972   return res;
2973 }
2974 
2975 // Reserve memory at an arbitrary address, only if that area is
2976 // available (and not reserved for something else).
2977 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2978   // Windows os::reserve_memory() fails of the requested address range is
2979   // not avilable.
2980   return reserve_memory(bytes, requested_addr);
2981 }
2982 
2983 size_t os::large_page_size() {
2984   return _large_page_size;
2985 }
2986 
2987 bool os::can_commit_large_page_memory() {
2988   // Windows only uses large page memory when the entire region is reserved
2989   // and committed in a single VirtualAlloc() call. This may change in the
2990   // future, but with Windows 2003 it's not possible to commit on demand.
2991   return false;
2992 }
2993 
2994 bool os::can_execute_large_page_memory() {
2995   return true;
2996 }
2997 
2998 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2999 
3000   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3001   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3002 
3003   // with large pages, there are two cases where we need to use Individual Allocation
3004   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3005   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3006   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3007     if (TracePageSizes && Verbose) {
3008        tty->print_cr("Reserving large pages individually.");
3009     }
3010     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3011     if (p_buf == NULL) {
3012       // give an appropriate warning message
3013       if (UseNUMAInterleaving) {
3014         warning("NUMA large page allocation failed, UseLargePages flag ignored");
3015       }
3016       if (UseLargePagesIndividualAllocation) {
3017         warning("Individually allocated large pages failed, "
3018                 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3019       }
3020       return NULL;
3021     }
3022 
3023     return p_buf;
3024 
3025   } else {
3026     // normal policy just allocate it all at once
3027     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3028     char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
3029     return res;
3030   }
3031 }
3032 
3033 bool os::release_memory_special(char* base, size_t bytes) {
3034   return release_memory(base, bytes);
3035 }
3036 
3037 void os::print_statistics() {
3038 }
3039 
3040 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
3041   if (bytes == 0) {
3042     // Don't bother the OS with noops.
3043     return true;
3044   }
3045   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3046   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3047   // Don't attempt to print anything if the OS call fails. We're
3048   // probably low on resources, so the print itself may cause crashes.
3049 
3050   // unless we have NUMAInterleaving enabled, the range of a commit
3051   // is always within a reserve covered by a single VirtualAlloc
3052   // in that case we can just do a single commit for the requested size
3053   if (!UseNUMAInterleaving) {
3054     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
3055     if (exec) {
3056       DWORD oldprot;
3057       // Windows doc says to use VirtualProtect to get execute permissions
3058       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
3059     }
3060     return true;
3061   } else {
3062 
3063     // when NUMAInterleaving is enabled, the commit might cover a range that
3064     // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3065     // VirtualQuery can help us determine that.  The RegionSize that VirtualQuery
3066     // returns represents the number of bytes that can be committed in one step.
3067     size_t bytes_remaining = bytes;
3068     char * next_alloc_addr = addr;
3069     while (bytes_remaining > 0) {
3070       MEMORY_BASIC_INFORMATION alloc_info;
3071       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3072       size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3073       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL)
3074         return false;
3075       if (exec) {
3076         DWORD oldprot;
3077         if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot))
3078           return false;
3079       }
3080       bytes_remaining -= bytes_to_rq;
3081       next_alloc_addr += bytes_to_rq;
3082     }
3083   }
3084   // if we made it this far, return true
3085   return true;
3086 }
3087 
3088 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
3089                        bool exec) {
3090   return commit_memory(addr, size, exec);
3091 }
3092 
3093 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
3094   if (bytes == 0) {
3095     // Don't bother the OS with noops.
3096     return true;
3097   }
3098   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3099   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3100   return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0);
3101 }
3102 
3103 bool os::pd_release_memory(char* addr, size_t bytes) {
3104   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3105 }
3106 
3107 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3108   return os::commit_memory(addr, size);
3109 }
3110 
3111 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3112   return os::uncommit_memory(addr, size);
3113 }
3114 
3115 // Set protections specified
3116 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3117                         bool is_committed) {
3118   unsigned int p = 0;
3119   switch (prot) {
3120   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3121   case MEM_PROT_READ: p = PAGE_READONLY; break;
3122   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3123   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3124   default:
3125     ShouldNotReachHere();
3126   }
3127 
3128   DWORD old_status;
3129 
3130   // Strange enough, but on Win32 one can change protection only for committed
3131   // memory, not a big deal anyway, as bytes less or equal than 64K
3132   if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
3133     fatal("cannot commit protection page");
3134   }
3135   // One cannot use os::guard_memory() here, as on Win32 guard page
3136   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3137   //
3138   // Pages in the region become guard pages. Any attempt to access a guard page
3139   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3140   // the guard page status. Guard pages thus act as a one-time access alarm.
3141   return VirtualProtect(addr, bytes, p, &old_status) != 0;
3142 }
3143 
3144 bool os::guard_memory(char* addr, size_t bytes) {
3145   DWORD old_status;
3146   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3147 }
3148 
3149 bool os::unguard_memory(char* addr, size_t bytes) {
3150   DWORD old_status;
3151   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3152 }
3153 
3154 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3155 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3156 void os::numa_make_global(char *addr, size_t bytes)    { }
3157 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3158 bool os::numa_topology_changed()                       { return false; }
3159 size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3160 int os::numa_get_group_id()                            { return 0; }
3161 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3162   if (numa_node_list_holder.get_count() == 0 && size > 0) {
3163     // Provide an answer for UMA systems
3164     ids[0] = 0;
3165     return 1;
3166   } else {
3167     // check for size bigger than actual groups_num
3168     size = MIN2(size, numa_get_groups_num());
3169     for (int i = 0; i < (int)size; i++) {
3170       ids[i] = numa_node_list_holder.get_node_list_entry(i);
3171     }
3172     return size;
3173   }
3174 }
3175 
3176 bool os::get_page_info(char *start, page_info* info) {
3177   return false;
3178 }
3179 
3180 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3181   return end;
3182 }
3183 
3184 char* os::non_memory_address_word() {
3185   // Must never look like an address returned by reserve_memory,
3186   // even in its subfields (as defined by the CPU immediate fields,
3187   // if the CPU splits constants across multiple instructions).
3188   return (char*)-1;
3189 }
3190 
3191 #define MAX_ERROR_COUNT 100
3192 #define SYS_THREAD_ERROR 0xffffffffUL
3193 
3194 void os::pd_start_thread(Thread* thread) {
3195   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3196   // Returns previous suspend state:
3197   // 0:  Thread was not suspended
3198   // 1:  Thread is running now
3199   // >1: Thread is still suspended.
3200   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3201 }
3202 
3203 class HighResolutionInterval {
3204   // The default timer resolution seems to be 10 milliseconds.
3205   // (Where is this written down?)
3206   // If someone wants to sleep for only a fraction of the default,
3207   // then we set the timer resolution down to 1 millisecond for
3208   // the duration of their interval.
3209   // We carefully set the resolution back, since otherwise we
3210   // seem to incur an overhead (3%?) that we don't need.
3211   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3212   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3213   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3214   // timeBeginPeriod() if the relative error exceeded some threshold.
3215   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3216   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3217   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3218   // resolution timers running.
3219 private:
3220     jlong resolution;
3221 public:
3222   HighResolutionInterval(jlong ms) {
3223     resolution = ms % 10L;
3224     if (resolution != 0) {
3225       MMRESULT result = timeBeginPeriod(1L);
3226     }
3227   }
3228   ~HighResolutionInterval() {
3229     if (resolution != 0) {
3230       MMRESULT result = timeEndPeriod(1L);
3231     }
3232     resolution = 0L;
3233   }
3234 };
3235 
3236 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3237   jlong limit = (jlong) MAXDWORD;
3238 
3239   while(ms > limit) {
3240     int res;
3241     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3242       return res;
3243     ms -= limit;
3244   }
3245 
3246   assert(thread == Thread::current(),  "thread consistency check");
3247   OSThread* osthread = thread->osthread();
3248   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3249   int result;
3250   if (interruptable) {
3251     assert(thread->is_Java_thread(), "must be java thread");
3252     JavaThread *jt = (JavaThread *) thread;
3253     ThreadBlockInVM tbivm(jt);
3254 
3255     jt->set_suspend_equivalent();
3256     // cleared by handle_special_suspend_equivalent_condition() or
3257     // java_suspend_self() via check_and_wait_while_suspended()
3258 
3259     HANDLE events[1];
3260     events[0] = osthread->interrupt_event();
3261     HighResolutionInterval *phri=NULL;
3262     if(!ForceTimeHighResolution)
3263       phri = new HighResolutionInterval( ms );
3264     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3265       result = OS_TIMEOUT;
3266     } else {
3267       ResetEvent(osthread->interrupt_event());
3268       osthread->set_interrupted(false);
3269       result = OS_INTRPT;
3270     }
3271     delete phri; //if it is NULL, harmless
3272 
3273     // were we externally suspended while we were waiting?
3274     jt->check_and_wait_while_suspended();
3275   } else {
3276     assert(!thread->is_Java_thread(), "must not be java thread");
3277     Sleep((long) ms);
3278     result = OS_TIMEOUT;
3279   }
3280   return result;
3281 }
3282 
3283 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3284 void os::infinite_sleep() {
3285   while (true) {    // sleep forever ...
3286     Sleep(100000);  // ... 100 seconds at a time
3287   }
3288 }
3289 
3290 typedef BOOL (WINAPI * STTSignature)(void) ;
3291 
3292 os::YieldResult os::NakedYield() {
3293   // Use either SwitchToThread() or Sleep(0)
3294   // Consider passing back the return value from SwitchToThread().
3295   if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3296     return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3297   } else {
3298     Sleep(0);
3299   }
3300   return os::YIELD_UNKNOWN ;
3301 }
3302 
3303 void os::yield() {  os::NakedYield(); }
3304 
3305 void os::yield_all(int attempts) {
3306   // Yields to all threads, including threads with lower priorities
3307   Sleep(1);
3308 }
3309 
3310 // Win32 only gives you access to seven real priorities at a time,
3311 // so we compress Java's ten down to seven.  It would be better
3312 // if we dynamically adjusted relative priorities.
3313 
3314 int os::java_to_os_priority[CriticalPriority + 1] = {
3315   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3316   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3317   THREAD_PRIORITY_LOWEST,                       // 2
3318   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3319   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3320   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3321   THREAD_PRIORITY_NORMAL,                       // 6
3322   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3323   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3324   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3325   THREAD_PRIORITY_HIGHEST,                      // 10 MaxPriority
3326   THREAD_PRIORITY_HIGHEST                       // 11 CriticalPriority
3327 };
3328 
3329 int prio_policy1[CriticalPriority + 1] = {
3330   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3331   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3332   THREAD_PRIORITY_LOWEST,                       // 2
3333   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3334   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3335   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3336   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3337   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3338   THREAD_PRIORITY_HIGHEST,                      // 8
3339   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3340   THREAD_PRIORITY_TIME_CRITICAL,                // 10 MaxPriority
3341   THREAD_PRIORITY_TIME_CRITICAL                 // 11 CriticalPriority
3342 };
3343 
3344 static int prio_init() {
3345   // If ThreadPriorityPolicy is 1, switch tables
3346   if (ThreadPriorityPolicy == 1) {
3347     int i;
3348     for (i = 0; i < CriticalPriority + 1; i++) {
3349       os::java_to_os_priority[i] = prio_policy1[i];
3350     }
3351   }
3352   if (UseCriticalJavaThreadPriority) {
3353     os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority] ;
3354   }
3355   return 0;
3356 }
3357 
3358 OSReturn os::set_native_priority(Thread* thread, int priority) {
3359   if (!UseThreadPriorities) return OS_OK;
3360   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3361   return ret ? OS_OK : OS_ERR;
3362 }
3363 
3364 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3365   if ( !UseThreadPriorities ) {
3366     *priority_ptr = java_to_os_priority[NormPriority];
3367     return OS_OK;
3368   }
3369   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3370   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3371     assert(false, "GetThreadPriority failed");
3372     return OS_ERR;
3373   }
3374   *priority_ptr = os_prio;
3375   return OS_OK;
3376 }
3377 
3378 
3379 // Hint to the underlying OS that a task switch would not be good.
3380 // Void return because it's a hint and can fail.
3381 void os::hint_no_preempt() {}
3382 
3383 void os::interrupt(Thread* thread) {
3384   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3385          "possibility of dangling Thread pointer");
3386 
3387   OSThread* osthread = thread->osthread();
3388   osthread->set_interrupted(true);
3389   // More than one thread can get here with the same value of osthread,
3390   // resulting in multiple notifications.  We do, however, want the store
3391   // to interrupted() to be visible to other threads before we post
3392   // the interrupt event.
3393   OrderAccess::release();
3394   SetEvent(osthread->interrupt_event());
3395   // For JSR166:  unpark after setting status
3396   if (thread->is_Java_thread())
3397     ((JavaThread*)thread)->parker()->unpark();
3398 
3399   ParkEvent * ev = thread->_ParkEvent ;
3400   if (ev != NULL) ev->unpark() ;
3401 
3402 }
3403 
3404 
3405 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3406   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3407          "possibility of dangling Thread pointer");
3408 
3409   OSThread* osthread = thread->osthread();
3410   bool interrupted = osthread->interrupted();
3411   // There is no synchronization between the setting of the interrupt
3412   // and it being cleared here. It is critical - see 6535709 - that
3413   // we only clear the interrupt state, and reset the interrupt event,
3414   // if we are going to report that we were indeed interrupted - else
3415   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3416   // depending on the timing
3417   if (interrupted && clear_interrupted) {
3418     osthread->set_interrupted(false);
3419     ResetEvent(osthread->interrupt_event());
3420   } // Otherwise leave the interrupted state alone
3421 
3422   return interrupted;
3423 }
3424 
3425 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3426 ExtendedPC os::get_thread_pc(Thread* thread) {
3427   CONTEXT context;
3428   context.ContextFlags = CONTEXT_CONTROL;
3429   HANDLE handle = thread->osthread()->thread_handle();
3430 #ifdef _M_IA64
3431   assert(0, "Fix get_thread_pc");
3432   return ExtendedPC(NULL);
3433 #else
3434   if (GetThreadContext(handle, &context)) {
3435 #ifdef _M_AMD64
3436     return ExtendedPC((address) context.Rip);
3437 #else
3438     return ExtendedPC((address) context.Eip);
3439 #endif
3440   } else {
3441     return ExtendedPC(NULL);
3442   }
3443 #endif
3444 }
3445 
3446 // GetCurrentThreadId() returns DWORD
3447 intx os::current_thread_id()          { return GetCurrentThreadId(); }
3448 
3449 static int _initial_pid = 0;
3450 
3451 int os::current_process_id()
3452 {
3453   return (_initial_pid ? _initial_pid : _getpid());
3454 }
3455 
3456 int    os::win32::_vm_page_size       = 0;
3457 int    os::win32::_vm_allocation_granularity = 0;
3458 int    os::win32::_processor_type     = 0;
3459 // Processor level is not available on non-NT systems, use vm_version instead
3460 int    os::win32::_processor_level    = 0;
3461 julong os::win32::_physical_memory    = 0;
3462 size_t os::win32::_default_stack_size = 0;
3463 
3464          intx os::win32::_os_thread_limit    = 0;
3465 volatile intx os::win32::_os_thread_count    = 0;
3466 
3467 bool   os::win32::_is_nt              = false;
3468 bool   os::win32::_is_windows_2003    = false;
3469 bool   os::win32::_is_windows_server  = false;
3470 
3471 void os::win32::initialize_system_info() {
3472   SYSTEM_INFO si;
3473   GetSystemInfo(&si);
3474   _vm_page_size    = si.dwPageSize;
3475   _vm_allocation_granularity = si.dwAllocationGranularity;
3476   _processor_type  = si.dwProcessorType;
3477   _processor_level = si.wProcessorLevel;
3478   set_processor_count(si.dwNumberOfProcessors);
3479 
3480   MEMORYSTATUSEX ms;
3481   ms.dwLength = sizeof(ms);
3482 
3483   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3484   // dwMemoryLoad (% of memory in use)
3485   GlobalMemoryStatusEx(&ms);
3486   _physical_memory = ms.ullTotalPhys;
3487 
3488   OSVERSIONINFOEX oi;
3489   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3490   GetVersionEx((OSVERSIONINFO*)&oi);
3491   switch(oi.dwPlatformId) {
3492     case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3493     case VER_PLATFORM_WIN32_NT:
3494       _is_nt = true;
3495       {
3496         int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3497         if (os_vers == 5002) {
3498           _is_windows_2003 = true;
3499         }
3500         if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3501           oi.wProductType == VER_NT_SERVER) {
3502             _is_windows_server = true;
3503         }
3504       }
3505       break;
3506     default: fatal("Unknown platform");
3507   }
3508 
3509   _default_stack_size = os::current_stack_size();
3510   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3511   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3512     "stack size not a multiple of page size");
3513 
3514   initialize_performance_counter();
3515 
3516   // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3517   // known to deadlock the system, if the VM issues to thread operations with
3518   // a too high frequency, e.g., such as changing the priorities.
3519   // The 6000 seems to work well - no deadlocks has been notices on the test
3520   // programs that we have seen experience this problem.
3521   if (!os::win32::is_nt()) {
3522     StarvationMonitorInterval = 6000;
3523   }
3524 }
3525 
3526 
3527 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3528   char path[MAX_PATH];
3529   DWORD size;
3530   DWORD pathLen = (DWORD)sizeof(path);
3531   HINSTANCE result = NULL;
3532 
3533   // only allow library name without path component
3534   assert(strchr(name, '\\') == NULL, "path not allowed");
3535   assert(strchr(name, ':') == NULL, "path not allowed");
3536   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3537     jio_snprintf(ebuf, ebuflen,
3538       "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3539     return NULL;
3540   }
3541 
3542   // search system directory
3543   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3544     strcat(path, "\\");
3545     strcat(path, name);
3546     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3547       return result;
3548     }
3549   }
3550 
3551   // try Windows directory
3552   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3553     strcat(path, "\\");
3554     strcat(path, name);
3555     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3556       return result;
3557     }
3558   }
3559 
3560   jio_snprintf(ebuf, ebuflen,
3561     "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3562   return NULL;
3563 }
3564 
3565 void os::win32::setmode_streams() {
3566   _setmode(_fileno(stdin), _O_BINARY);
3567   _setmode(_fileno(stdout), _O_BINARY);
3568   _setmode(_fileno(stderr), _O_BINARY);
3569 }
3570 
3571 
3572 bool os::is_debugger_attached() {
3573   return IsDebuggerPresent() ? true : false;
3574 }
3575 
3576 
3577 void os::wait_for_keypress_at_exit(void) {
3578   if (PauseAtExit) {
3579     fprintf(stderr, "Press any key to continue...\n");
3580     fgetc(stdin);
3581   }
3582 }
3583 
3584 
3585 int os::message_box(const char* title, const char* message) {
3586   int result = MessageBox(NULL, message, title,
3587                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3588   return result == IDYES;
3589 }
3590 
3591 int os::allocate_thread_local_storage() {
3592   return TlsAlloc();
3593 }
3594 
3595 
3596 void os::free_thread_local_storage(int index) {
3597   TlsFree(index);
3598 }
3599 
3600 
3601 void os::thread_local_storage_at_put(int index, void* value) {
3602   TlsSetValue(index, value);
3603   assert(thread_local_storage_at(index) == value, "Just checking");
3604 }
3605 
3606 
3607 void* os::thread_local_storage_at(int index) {
3608   return TlsGetValue(index);
3609 }
3610 
3611 
3612 #ifndef PRODUCT
3613 #ifndef _WIN64
3614 // Helpers to check whether NX protection is enabled
3615 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3616   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3617       pex->ExceptionRecord->NumberParameters > 0 &&
3618       pex->ExceptionRecord->ExceptionInformation[0] ==
3619       EXCEPTION_INFO_EXEC_VIOLATION) {
3620     return EXCEPTION_EXECUTE_HANDLER;
3621   }
3622   return EXCEPTION_CONTINUE_SEARCH;
3623 }
3624 
3625 void nx_check_protection() {
3626   // If NX is enabled we'll get an exception calling into code on the stack
3627   char code[] = { (char)0xC3 }; // ret
3628   void *code_ptr = (void *)code;
3629   __try {
3630     __asm call code_ptr
3631   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3632     tty->print_raw_cr("NX protection detected.");
3633   }
3634 }
3635 #endif // _WIN64
3636 #endif // PRODUCT
3637 
3638 // this is called _before_ the global arguments have been parsed
3639 void os::init(void) {
3640   _initial_pid = _getpid();
3641 
3642   init_random(1234567);
3643 
3644   win32::initialize_system_info();
3645   win32::setmode_streams();
3646   init_page_sizes((size_t) win32::vm_page_size());
3647 
3648   // For better scalability on MP systems (must be called after initialize_system_info)
3649 #ifndef PRODUCT
3650   if (is_MP()) {
3651     NoYieldsInMicrolock = true;
3652   }
3653 #endif
3654   // This may be overridden later when argument processing is done.
3655   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3656     os::win32::is_windows_2003());
3657 
3658   // Initialize main_process and main_thread
3659   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
3660  if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3661                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3662     fatal("DuplicateHandle failed\n");
3663   }
3664   main_thread_id = (int) GetCurrentThreadId();
3665 }
3666 
3667 // To install functions for atexit processing
3668 extern "C" {
3669   static void perfMemory_exit_helper() {
3670     perfMemory_exit();
3671   }
3672 }
3673 
3674 // this is called _after_ the global arguments have been parsed
3675 jint os::init_2(void) {
3676   // Allocate a single page and mark it as readable for safepoint polling
3677   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3678   guarantee( polling_page != NULL, "Reserve Failed for polling page");
3679 
3680   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3681   guarantee( return_page != NULL, "Commit Failed for polling page");
3682 
3683   os::set_polling_page( polling_page );
3684 
3685 #ifndef PRODUCT
3686   if( Verbose && PrintMiscellaneous )
3687     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3688 #endif
3689 
3690   if (!UseMembar) {
3691     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3692     guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3693 
3694     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3695     guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3696 
3697     os::set_memory_serialize_page( mem_serialize_page );
3698 
3699 #ifndef PRODUCT
3700     if(Verbose && PrintMiscellaneous)
3701       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3702 #endif
3703   }
3704 
3705   os::large_page_init();
3706 
3707   // Setup Windows Exceptions
3708 
3709   // On Itanium systems, Structured Exception Handling does not
3710   // work since stack frames must be walkable by the OS.  Since
3711   // much of our code is dynamically generated, and we do not have
3712   // proper unwind .xdata sections, the system simply exits
3713   // rather than delivering the exception.  To work around
3714   // this we use VectorExceptions instead.
3715 #ifdef _WIN64
3716   if (UseVectoredExceptions) {
3717     topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3718   }
3719 #endif
3720 
3721   // for debugging float code generation bugs
3722   if (ForceFloatExceptions) {
3723 #ifndef  _WIN64
3724     static long fp_control_word = 0;
3725     __asm { fstcw fp_control_word }
3726     // see Intel PPro Manual, Vol. 2, p 7-16
3727     const long precision = 0x20;
3728     const long underflow = 0x10;
3729     const long overflow  = 0x08;
3730     const long zero_div  = 0x04;
3731     const long denorm    = 0x02;
3732     const long invalid   = 0x01;
3733     fp_control_word |= invalid;
3734     __asm { fldcw fp_control_word }
3735 #endif
3736   }
3737 
3738   // If stack_commit_size is 0, windows will reserve the default size,
3739   // but only commit a small portion of it.
3740   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3741   size_t default_reserve_size = os::win32::default_stack_size();
3742   size_t actual_reserve_size = stack_commit_size;
3743   if (stack_commit_size < default_reserve_size) {
3744     // If stack_commit_size == 0, we want this too
3745     actual_reserve_size = default_reserve_size;
3746   }
3747 
3748   // Check minimum allowable stack size for thread creation and to initialize
3749   // the java system classes, including StackOverflowError - depends on page
3750   // size.  Add a page for compiler2 recursion in main thread.
3751   // Add in 2*BytesPerWord times page size to account for VM stack during
3752   // class initialization depending on 32 or 64 bit VM.
3753   size_t min_stack_allowed =
3754             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3755             2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3756   if (actual_reserve_size < min_stack_allowed) {
3757     tty->print_cr("\nThe stack size specified is too small, "
3758                   "Specify at least %dk",
3759                   min_stack_allowed / K);
3760     return JNI_ERR;
3761   }
3762 
3763   JavaThread::set_stack_size_at_create(stack_commit_size);
3764 
3765   // Calculate theoretical max. size of Threads to guard gainst artifical
3766   // out-of-memory situations, where all available address-space has been
3767   // reserved by thread stacks.
3768   assert(actual_reserve_size != 0, "Must have a stack");
3769 
3770   // Calculate the thread limit when we should start doing Virtual Memory
3771   // banging. Currently when the threads will have used all but 200Mb of space.
3772   //
3773   // TODO: consider performing a similar calculation for commit size instead
3774   // as reserve size, since on a 64-bit platform we'll run into that more
3775   // often than running out of virtual memory space.  We can use the
3776   // lower value of the two calculations as the os_thread_limit.
3777   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3778   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3779 
3780   // at exit methods are called in the reverse order of their registration.
3781   // there is no limit to the number of functions registered. atexit does
3782   // not set errno.
3783 
3784   if (PerfAllowAtExitRegistration) {
3785     // only register atexit functions if PerfAllowAtExitRegistration is set.
3786     // atexit functions can be delayed until process exit time, which
3787     // can be problematic for embedded VM situations. Embedded VMs should
3788     // call DestroyJavaVM() to assure that VM resources are released.
3789 
3790     // note: perfMemory_exit_helper atexit function may be removed in
3791     // the future if the appropriate cleanup code can be added to the
3792     // VM_Exit VMOperation's doit method.
3793     if (atexit(perfMemory_exit_helper) != 0) {
3794       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3795     }
3796   }
3797 
3798 #ifndef _WIN64
3799   // Print something if NX is enabled (win32 on AMD64)
3800   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3801 #endif
3802 
3803   // initialize thread priority policy
3804   prio_init();
3805 
3806   if (UseNUMA && !ForceNUMA) {
3807     UseNUMA = false; // We don't fully support this yet
3808   }
3809 
3810   if (UseNUMAInterleaving) {
3811     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
3812     bool success = numa_interleaving_init();
3813     if (!success) UseNUMAInterleaving = false;
3814   }
3815 
3816   return JNI_OK;
3817 }
3818 
3819 void os::init_3(void) {
3820   return;
3821 }
3822 
3823 // Mark the polling page as unreadable
3824 void os::make_polling_page_unreadable(void) {
3825   DWORD old_status;
3826   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3827     fatal("Could not disable polling page");
3828 };
3829 
3830 // Mark the polling page as readable
3831 void os::make_polling_page_readable(void) {
3832   DWORD old_status;
3833   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3834     fatal("Could not enable polling page");
3835 };
3836 
3837 
3838 int os::stat(const char *path, struct stat *sbuf) {
3839   char pathbuf[MAX_PATH];
3840   if (strlen(path) > MAX_PATH - 1) {
3841     errno = ENAMETOOLONG;
3842     return -1;
3843   }
3844   os::native_path(strcpy(pathbuf, path));
3845   int ret = ::stat(pathbuf, sbuf);
3846   if (sbuf != NULL && UseUTCFileTimestamp) {
3847     // Fix for 6539723.  st_mtime returned from stat() is dependent on
3848     // the system timezone and so can return different values for the
3849     // same file if/when daylight savings time changes.  This adjustment
3850     // makes sure the same timestamp is returned regardless of the TZ.
3851     //
3852     // See:
3853     // http://msdn.microsoft.com/library/
3854     //   default.asp?url=/library/en-us/sysinfo/base/
3855     //   time_zone_information_str.asp
3856     // and
3857     // http://msdn.microsoft.com/library/default.asp?url=
3858     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
3859     //
3860     // NOTE: there is a insidious bug here:  If the timezone is changed
3861     // after the call to stat() but before 'GetTimeZoneInformation()', then
3862     // the adjustment we do here will be wrong and we'll return the wrong
3863     // value (which will likely end up creating an invalid class data
3864     // archive).  Absent a better API for this, or some time zone locking
3865     // mechanism, we'll have to live with this risk.
3866     TIME_ZONE_INFORMATION tz;
3867     DWORD tzid = GetTimeZoneInformation(&tz);
3868     int daylightBias =
3869       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
3870     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3871   }
3872   return ret;
3873 }
3874 
3875 
3876 #define FT2INT64(ft) \
3877   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3878 
3879 
3880 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3881 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3882 // of a thread.
3883 //
3884 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3885 // the fast estimate available on the platform.
3886 
3887 // current_thread_cpu_time() is not optimized for Windows yet
3888 jlong os::current_thread_cpu_time() {
3889   // return user + sys since the cost is the same
3890   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3891 }
3892 
3893 jlong os::thread_cpu_time(Thread* thread) {
3894   // consistent with what current_thread_cpu_time() returns.
3895   return os::thread_cpu_time(thread, true /* user+sys */);
3896 }
3897 
3898 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3899   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3900 }
3901 
3902 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3903   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3904   // If this function changes, os::is_thread_cpu_time_supported() should too
3905   if (os::win32::is_nt()) {
3906     FILETIME CreationTime;
3907     FILETIME ExitTime;
3908     FILETIME KernelTime;
3909     FILETIME UserTime;
3910 
3911     if ( GetThreadTimes(thread->osthread()->thread_handle(),
3912                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3913       return -1;
3914     else
3915       if (user_sys_cpu_time) {
3916         return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3917       } else {
3918         return FT2INT64(UserTime) * 100;
3919       }
3920   } else {
3921     return (jlong) timeGetTime() * 1000000;
3922   }
3923 }
3924 
3925 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3926   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3927   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3928   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3929   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3930 }
3931 
3932 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3933   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3934   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3935   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3936   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3937 }
3938 
3939 bool os::is_thread_cpu_time_supported() {
3940   // see os::thread_cpu_time
3941   if (os::win32::is_nt()) {
3942     FILETIME CreationTime;
3943     FILETIME ExitTime;
3944     FILETIME KernelTime;
3945     FILETIME UserTime;
3946 
3947     if ( GetThreadTimes(GetCurrentThread(),
3948                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3949       return false;
3950     else
3951       return true;
3952   } else {
3953     return false;
3954   }
3955 }
3956 
3957 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3958 // It does have primitives (PDH API) to get CPU usage and run queue length.
3959 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3960 // If we wanted to implement loadavg on Windows, we have a few options:
3961 //
3962 // a) Query CPU usage and run queue length and "fake" an answer by
3963 //    returning the CPU usage if it's under 100%, and the run queue
3964 //    length otherwise.  It turns out that querying is pretty slow
3965 //    on Windows, on the order of 200 microseconds on a fast machine.
3966 //    Note that on the Windows the CPU usage value is the % usage
3967 //    since the last time the API was called (and the first call
3968 //    returns 100%), so we'd have to deal with that as well.
3969 //
3970 // b) Sample the "fake" answer using a sampling thread and store
3971 //    the answer in a global variable.  The call to loadavg would
3972 //    just return the value of the global, avoiding the slow query.
3973 //
3974 // c) Sample a better answer using exponential decay to smooth the
3975 //    value.  This is basically the algorithm used by UNIX kernels.
3976 //
3977 // Note that sampling thread starvation could affect both (b) and (c).
3978 int os::loadavg(double loadavg[], int nelem) {
3979   return -1;
3980 }
3981 
3982 
3983 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3984 bool os::dont_yield() {
3985   return DontYieldALot;
3986 }
3987 
3988 // This method is a slightly reworked copy of JDK's sysOpen
3989 // from src/windows/hpi/src/sys_api_md.c
3990 
3991 int os::open(const char *path, int oflag, int mode) {
3992   char pathbuf[MAX_PATH];
3993 
3994   if (strlen(path) > MAX_PATH - 1) {
3995     errno = ENAMETOOLONG;
3996           return -1;
3997   }
3998   os::native_path(strcpy(pathbuf, path));
3999   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4000 }
4001 
4002 // Is a (classpath) directory empty?
4003 bool os::dir_is_empty(const char* path) {
4004   WIN32_FIND_DATA fd;
4005   HANDLE f = FindFirstFile(path, &fd);
4006   if (f == INVALID_HANDLE_VALUE) {
4007     return true;
4008   }
4009   FindClose(f);
4010   return false;
4011 }
4012 
4013 // create binary file, rewriting existing file if required
4014 int os::create_binary_file(const char* path, bool rewrite_existing) {
4015   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4016   if (!rewrite_existing) {
4017     oflags |= _O_EXCL;
4018   }
4019   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4020 }
4021 
4022 // return current position of file pointer
4023 jlong os::current_file_offset(int fd) {
4024   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4025 }
4026 
4027 // move file pointer to the specified offset
4028 jlong os::seek_to_file_offset(int fd, jlong offset) {
4029   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4030 }
4031 
4032 
4033 jlong os::lseek(int fd, jlong offset, int whence) {
4034   return (jlong) ::_lseeki64(fd, offset, whence);
4035 }
4036 
4037 // This method is a slightly reworked copy of JDK's sysNativePath
4038 // from src/windows/hpi/src/path_md.c
4039 
4040 /* Convert a pathname to native format.  On win32, this involves forcing all
4041    separators to be '\\' rather than '/' (both are legal inputs, but Win95
4042    sometimes rejects '/') and removing redundant separators.  The input path is
4043    assumed to have been converted into the character encoding used by the local
4044    system.  Because this might be a double-byte encoding, care is taken to
4045    treat double-byte lead characters correctly.
4046 
4047    This procedure modifies the given path in place, as the result is never
4048    longer than the original.  There is no error return; this operation always
4049    succeeds. */
4050 char * os::native_path(char *path) {
4051   char *src = path, *dst = path, *end = path;
4052   char *colon = NULL;           /* If a drive specifier is found, this will
4053                                         point to the colon following the drive
4054                                         letter */
4055 
4056   /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4057   assert(((!::IsDBCSLeadByte('/'))
4058     && (!::IsDBCSLeadByte('\\'))
4059     && (!::IsDBCSLeadByte(':'))),
4060     "Illegal lead byte");
4061 
4062   /* Check for leading separators */
4063 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4064   while (isfilesep(*src)) {
4065     src++;
4066   }
4067 
4068   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4069     /* Remove leading separators if followed by drive specifier.  This
4070       hack is necessary to support file URLs containing drive
4071       specifiers (e.g., "file://c:/path").  As a side effect,
4072       "/c:/path" can be used as an alternative to "c:/path". */
4073     *dst++ = *src++;
4074     colon = dst;
4075     *dst++ = ':';
4076     src++;
4077   } else {
4078     src = path;
4079     if (isfilesep(src[0]) && isfilesep(src[1])) {
4080       /* UNC pathname: Retain first separator; leave src pointed at
4081          second separator so that further separators will be collapsed
4082          into the second separator.  The result will be a pathname
4083          beginning with "\\\\" followed (most likely) by a host name. */
4084       src = dst = path + 1;
4085       path[0] = '\\';     /* Force first separator to '\\' */
4086     }
4087   }
4088 
4089   end = dst;
4090 
4091   /* Remove redundant separators from remainder of path, forcing all
4092       separators to be '\\' rather than '/'. Also, single byte space
4093       characters are removed from the end of the path because those
4094       are not legal ending characters on this operating system.
4095   */
4096   while (*src != '\0') {
4097     if (isfilesep(*src)) {
4098       *dst++ = '\\'; src++;
4099       while (isfilesep(*src)) src++;
4100       if (*src == '\0') {
4101         /* Check for trailing separator */
4102         end = dst;
4103         if (colon == dst - 2) break;                      /* "z:\\" */
4104         if (dst == path + 1) break;                       /* "\\" */
4105         if (dst == path + 2 && isfilesep(path[0])) {
4106           /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4107             beginning of a UNC pathname.  Even though it is not, by
4108             itself, a valid UNC pathname, we leave it as is in order
4109             to be consistent with the path canonicalizer as well
4110             as the win32 APIs, which treat this case as an invalid
4111             UNC pathname rather than as an alias for the root
4112             directory of the current drive. */
4113           break;
4114         }
4115         end = --dst;  /* Path does not denote a root directory, so
4116                                     remove trailing separator */
4117         break;
4118       }
4119       end = dst;
4120     } else {
4121       if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4122         *dst++ = *src++;
4123         if (*src) *dst++ = *src++;
4124         end = dst;
4125       } else {         /* Copy a single-byte character */
4126         char c = *src++;
4127         *dst++ = c;
4128         /* Space is not a legal ending character */
4129         if (c != ' ') end = dst;
4130       }
4131     }
4132   }
4133 
4134   *end = '\0';
4135 
4136   /* For "z:", add "." to work around a bug in the C runtime library */
4137   if (colon == dst - 1) {
4138           path[2] = '.';
4139           path[3] = '\0';
4140   }
4141 
4142   #ifdef DEBUG
4143     jio_fprintf(stderr, "sysNativePath: %s\n", path);
4144   #endif DEBUG
4145   return path;
4146 }
4147 
4148 // This code is a copy of JDK's sysSetLength
4149 // from src/windows/hpi/src/sys_api_md.c
4150 
4151 int os::ftruncate(int fd, jlong length) {
4152   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4153   long high = (long)(length >> 32);
4154   DWORD ret;
4155 
4156   if (h == (HANDLE)(-1)) {
4157     return -1;
4158   }
4159 
4160   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4161   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4162       return -1;
4163   }
4164 
4165   if (::SetEndOfFile(h) == FALSE) {
4166     return -1;
4167   }
4168 
4169   return 0;
4170 }
4171 
4172 
4173 // This code is a copy of JDK's sysSync
4174 // from src/windows/hpi/src/sys_api_md.c
4175 // except for the legacy workaround for a bug in Win 98
4176 
4177 int os::fsync(int fd) {
4178   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4179 
4180   if ( (!::FlushFileBuffers(handle)) &&
4181          (GetLastError() != ERROR_ACCESS_DENIED) ) {
4182     /* from winerror.h */
4183     return -1;
4184   }
4185   return 0;
4186 }
4187 
4188 static int nonSeekAvailable(int, long *);
4189 static int stdinAvailable(int, long *);
4190 
4191 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4192 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4193 
4194 // This code is a copy of JDK's sysAvailable
4195 // from src/windows/hpi/src/sys_api_md.c
4196 
4197 int os::available(int fd, jlong *bytes) {
4198   jlong cur, end;
4199   struct _stati64 stbuf64;
4200 
4201   if (::_fstati64(fd, &stbuf64) >= 0) {
4202     int mode = stbuf64.st_mode;
4203     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4204       int ret;
4205       long lpbytes;
4206       if (fd == 0) {
4207         ret = stdinAvailable(fd, &lpbytes);
4208       } else {
4209         ret = nonSeekAvailable(fd, &lpbytes);
4210       }
4211       (*bytes) = (jlong)(lpbytes);
4212       return ret;
4213     }
4214     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4215       return FALSE;
4216     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4217       return FALSE;
4218     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4219       return FALSE;
4220     }
4221     *bytes = end - cur;
4222     return TRUE;
4223   } else {
4224     return FALSE;
4225   }
4226 }
4227 
4228 // This code is a copy of JDK's nonSeekAvailable
4229 // from src/windows/hpi/src/sys_api_md.c
4230 
4231 static int nonSeekAvailable(int fd, long *pbytes) {
4232   /* This is used for available on non-seekable devices
4233     * (like both named and anonymous pipes, such as pipes
4234     *  connected to an exec'd process).
4235     * Standard Input is a special case.
4236     *
4237     */
4238   HANDLE han;
4239 
4240   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4241     return FALSE;
4242   }
4243 
4244   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4245         /* PeekNamedPipe fails when at EOF.  In that case we
4246          * simply make *pbytes = 0 which is consistent with the
4247          * behavior we get on Solaris when an fd is at EOF.
4248          * The only alternative is to raise an Exception,
4249          * which isn't really warranted.
4250          */
4251     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4252       return FALSE;
4253     }
4254     *pbytes = 0;
4255   }
4256   return TRUE;
4257 }
4258 
4259 #define MAX_INPUT_EVENTS 2000
4260 
4261 // This code is a copy of JDK's stdinAvailable
4262 // from src/windows/hpi/src/sys_api_md.c
4263 
4264 static int stdinAvailable(int fd, long *pbytes) {
4265   HANDLE han;
4266   DWORD numEventsRead = 0;      /* Number of events read from buffer */
4267   DWORD numEvents = 0;  /* Number of events in buffer */
4268   DWORD i = 0;          /* Loop index */
4269   DWORD curLength = 0;  /* Position marker */
4270   DWORD actualLength = 0;       /* Number of bytes readable */
4271   BOOL error = FALSE;         /* Error holder */
4272   INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
4273 
4274   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4275         return FALSE;
4276   }
4277 
4278   /* Construct an array of input records in the console buffer */
4279   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4280   if (error == 0) {
4281     return nonSeekAvailable(fd, pbytes);
4282   }
4283 
4284   /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4285   if (numEvents > MAX_INPUT_EVENTS) {
4286     numEvents = MAX_INPUT_EVENTS;
4287   }
4288 
4289   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4290   if (lpBuffer == NULL) {
4291     return FALSE;
4292   }
4293 
4294   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4295   if (error == 0) {
4296     os::free(lpBuffer, mtInternal);
4297     return FALSE;
4298   }
4299 
4300   /* Examine input records for the number of bytes available */
4301   for(i=0; i<numEvents; i++) {
4302     if (lpBuffer[i].EventType == KEY_EVENT) {
4303 
4304       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4305                                       &(lpBuffer[i].Event);
4306       if (keyRecord->bKeyDown == TRUE) {
4307         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4308         curLength++;
4309         if (*keyPressed == '\r') {
4310           actualLength = curLength;
4311         }
4312       }
4313     }
4314   }
4315 
4316   if(lpBuffer != NULL) {
4317     os::free(lpBuffer, mtInternal);
4318   }
4319 
4320   *pbytes = (long) actualLength;
4321   return TRUE;
4322 }
4323 
4324 // Map a block of memory.
4325 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4326                      char *addr, size_t bytes, bool read_only,
4327                      bool allow_exec) {
4328   HANDLE hFile;
4329   char* base;
4330 
4331   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4332                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4333   if (hFile == NULL) {
4334     if (PrintMiscellaneous && Verbose) {
4335       DWORD err = GetLastError();
4336       tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4337     }
4338     return NULL;
4339   }
4340 
4341   if (allow_exec) {
4342     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4343     // unless it comes from a PE image (which the shared archive is not.)
4344     // Even VirtualProtect refuses to give execute access to mapped memory
4345     // that was not previously executable.
4346     //
4347     // Instead, stick the executable region in anonymous memory.  Yuck.
4348     // Penalty is that ~4 pages will not be shareable - in the future
4349     // we might consider DLLizing the shared archive with a proper PE
4350     // header so that mapping executable + sharing is possible.
4351 
4352     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4353                                 PAGE_READWRITE);
4354     if (base == NULL) {
4355       if (PrintMiscellaneous && Verbose) {
4356         DWORD err = GetLastError();
4357         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4358       }
4359       CloseHandle(hFile);
4360       return NULL;
4361     }
4362 
4363     DWORD bytes_read;
4364     OVERLAPPED overlapped;
4365     overlapped.Offset = (DWORD)file_offset;
4366     overlapped.OffsetHigh = 0;
4367     overlapped.hEvent = NULL;
4368     // ReadFile guarantees that if the return value is true, the requested
4369     // number of bytes were read before returning.
4370     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4371     if (!res) {
4372       if (PrintMiscellaneous && Verbose) {
4373         DWORD err = GetLastError();
4374         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4375       }
4376       release_memory(base, bytes);
4377       CloseHandle(hFile);
4378       return NULL;
4379     }
4380   } else {
4381     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4382                                     NULL /*file_name*/);
4383     if (hMap == NULL) {
4384       if (PrintMiscellaneous && Verbose) {
4385         DWORD err = GetLastError();
4386         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4387       }
4388       CloseHandle(hFile);
4389       return NULL;
4390     }
4391 
4392     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4393     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4394                                   (DWORD)bytes, addr);
4395     if (base == NULL) {
4396       if (PrintMiscellaneous && Verbose) {
4397         DWORD err = GetLastError();
4398         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4399       }
4400       CloseHandle(hMap);
4401       CloseHandle(hFile);
4402       return NULL;
4403     }
4404 
4405     if (CloseHandle(hMap) == 0) {
4406       if (PrintMiscellaneous && Verbose) {
4407         DWORD err = GetLastError();
4408         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4409       }
4410       CloseHandle(hFile);
4411       return base;
4412     }
4413   }
4414 
4415   if (allow_exec) {
4416     DWORD old_protect;
4417     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4418     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4419 
4420     if (!res) {
4421       if (PrintMiscellaneous && Verbose) {
4422         DWORD err = GetLastError();
4423         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4424       }
4425       // Don't consider this a hard error, on IA32 even if the
4426       // VirtualProtect fails, we should still be able to execute
4427       CloseHandle(hFile);
4428       return base;
4429     }
4430   }
4431 
4432   if (CloseHandle(hFile) == 0) {
4433     if (PrintMiscellaneous && Verbose) {
4434       DWORD err = GetLastError();
4435       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4436     }
4437     return base;
4438   }
4439 
4440   return base;
4441 }
4442 
4443 
4444 // Remap a block of memory.
4445 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4446                        char *addr, size_t bytes, bool read_only,
4447                        bool allow_exec) {
4448   // This OS does not allow existing memory maps to be remapped so we
4449   // have to unmap the memory before we remap it.
4450   if (!os::unmap_memory(addr, bytes)) {
4451     return NULL;
4452   }
4453 
4454   // There is a very small theoretical window between the unmap_memory()
4455   // call above and the map_memory() call below where a thread in native
4456   // code may be able to access an address that is no longer mapped.
4457 
4458   return os::map_memory(fd, file_name, file_offset, addr, bytes,
4459            read_only, allow_exec);
4460 }
4461 
4462 
4463 // Unmap a block of memory.
4464 // Returns true=success, otherwise false.
4465 
4466 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4467   BOOL result = UnmapViewOfFile(addr);
4468   if (result == 0) {
4469     if (PrintMiscellaneous && Verbose) {
4470       DWORD err = GetLastError();
4471       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4472     }
4473     return false;
4474   }
4475   return true;
4476 }
4477 
4478 void os::pause() {
4479   char filename[MAX_PATH];
4480   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4481     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4482   } else {
4483     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4484   }
4485 
4486   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4487   if (fd != -1) {
4488     struct stat buf;
4489     ::close(fd);
4490     while (::stat(filename, &buf) == 0) {
4491       Sleep(100);
4492     }
4493   } else {
4494     jio_fprintf(stderr,
4495       "Could not open pause file '%s', continuing immediately.\n", filename);
4496   }
4497 }
4498 
4499 // An Event wraps a win32 "CreateEvent" kernel handle.
4500 //
4501 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4502 //
4503 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4504 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
4505 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4506 //     In addition, an unpark() operation might fetch the handle field, but the
4507 //     event could recycle between the fetch and the SetEvent() operation.
4508 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
4509 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
4510 //     on an stale but recycled handle would be harmless, but in practice this might
4511 //     confuse other non-Sun code, so it's not a viable approach.
4512 //
4513 // 2:  Once a win32 event handle is associated with an Event, it remains associated
4514 //     with the Event.  The event handle is never closed.  This could be construed
4515 //     as handle leakage, but only up to the maximum # of threads that have been extant
4516 //     at any one time.  This shouldn't be an issue, as windows platforms typically
4517 //     permit a process to have hundreds of thousands of open handles.
4518 //
4519 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4520 //     and release unused handles.
4521 //
4522 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4523 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
4524 //
4525 // 5.  Use an RCU-like mechanism (Read-Copy Update).
4526 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
4527 //
4528 // We use (2).
4529 //
4530 // TODO-FIXME:
4531 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4532 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4533 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
4534 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4535 //     into a single win32 CreateEvent() handle.
4536 //
4537 // _Event transitions in park()
4538 //   -1 => -1 : illegal
4539 //    1 =>  0 : pass - return immediately
4540 //    0 => -1 : block
4541 //
4542 // _Event serves as a restricted-range semaphore :
4543 //    -1 : thread is blocked
4544 //     0 : neutral  - thread is running or ready
4545 //     1 : signaled - thread is running or ready
4546 //
4547 // Another possible encoding of _Event would be
4548 // with explicit "PARKED" and "SIGNALED" bits.
4549 
4550 int os::PlatformEvent::park (jlong Millis) {
4551     guarantee (_ParkHandle != NULL , "Invariant") ;
4552     guarantee (Millis > 0          , "Invariant") ;
4553     int v ;
4554 
4555     // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4556     // the initial park() operation.
4557 
4558     for (;;) {
4559         v = _Event ;
4560         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4561     }
4562     guarantee ((v == 0) || (v == 1), "invariant") ;
4563     if (v != 0) return OS_OK ;
4564 
4565     // Do this the hard way by blocking ...
4566     // TODO: consider a brief spin here, gated on the success of recent
4567     // spin attempts by this thread.
4568     //
4569     // We decompose long timeouts into series of shorter timed waits.
4570     // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4571     // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
4572     // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4573     // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
4574     // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4575     // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
4576     // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4577     // for the already waited time.  This policy does not admit any new outcomes.
4578     // In the future, however, we might want to track the accumulated wait time and
4579     // adjust Millis accordingly if we encounter a spurious wakeup.
4580 
4581     const int MAXTIMEOUT = 0x10000000 ;
4582     DWORD rv = WAIT_TIMEOUT ;
4583     while (_Event < 0 && Millis > 0) {
4584        DWORD prd = Millis ;     // set prd = MAX (Millis, MAXTIMEOUT)
4585        if (Millis > MAXTIMEOUT) {
4586           prd = MAXTIMEOUT ;
4587        }
4588        rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4589        assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4590        if (rv == WAIT_TIMEOUT) {
4591            Millis -= prd ;
4592        }
4593     }
4594     v = _Event ;
4595     _Event = 0 ;
4596     OrderAccess::fence() ;
4597     // If we encounter a nearly simultanous timeout expiry and unpark()
4598     // we return OS_OK indicating we awoke via unpark().
4599     // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4600     return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4601 }
4602 
4603 void os::PlatformEvent::park () {
4604     guarantee (_ParkHandle != NULL, "Invariant") ;
4605     // Invariant: Only the thread associated with the Event/PlatformEvent
4606     // may call park().
4607     int v ;
4608     for (;;) {
4609         v = _Event ;
4610         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4611     }
4612     guarantee ((v == 0) || (v == 1), "invariant") ;
4613     if (v != 0) return ;
4614 
4615     // Do this the hard way by blocking ...
4616     // TODO: consider a brief spin here, gated on the success of recent
4617     // spin attempts by this thread.
4618     while (_Event < 0) {
4619        DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4620        assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4621     }
4622 
4623     // Usually we'll find _Event == 0 at this point, but as
4624     // an optional optimization we clear it, just in case can
4625     // multiple unpark() operations drove _Event up to 1.
4626     _Event = 0 ;
4627     OrderAccess::fence() ;
4628     guarantee (_Event >= 0, "invariant") ;
4629 }
4630 
4631 void os::PlatformEvent::unpark() {
4632   guarantee (_ParkHandle != NULL, "Invariant") ;
4633   int v ;
4634   for (;;) {
4635       v = _Event ;      // Increment _Event if it's < 1.
4636       if (v > 0) {
4637          // If it's already signaled just return.
4638          // The LD of _Event could have reordered or be satisfied
4639          // by a read-aside from this processor's write buffer.
4640          // To avoid problems execute a barrier and then
4641          // ratify the value.  A degenerate CAS() would also work.
4642          // Viz., CAS (v+0, &_Event, v) == v).
4643          OrderAccess::fence() ;
4644          if (_Event == v) return ;
4645          continue ;
4646       }
4647       if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4648   }
4649   if (v < 0) {
4650      ::SetEvent (_ParkHandle) ;
4651   }
4652 }
4653 
4654 
4655 // JSR166
4656 // -------------------------------------------------------
4657 
4658 /*
4659  * The Windows implementation of Park is very straightforward: Basic
4660  * operations on Win32 Events turn out to have the right semantics to
4661  * use them directly. We opportunistically resuse the event inherited
4662  * from Monitor.
4663  */
4664 
4665 
4666 void Parker::park(bool isAbsolute, jlong time) {
4667   guarantee (_ParkEvent != NULL, "invariant") ;
4668   // First, demultiplex/decode time arguments
4669   if (time < 0) { // don't wait
4670     return;
4671   }
4672   else if (time == 0 && !isAbsolute) {
4673     time = INFINITE;
4674   }
4675   else if  (isAbsolute) {
4676     time -= os::javaTimeMillis(); // convert to relative time
4677     if (time <= 0) // already elapsed
4678       return;
4679   }
4680   else { // relative
4681     time /= 1000000; // Must coarsen from nanos to millis
4682     if (time == 0)   // Wait for the minimal time unit if zero
4683       time = 1;
4684   }
4685 
4686   JavaThread* thread = (JavaThread*)(Thread::current());
4687   assert(thread->is_Java_thread(), "Must be JavaThread");
4688   JavaThread *jt = (JavaThread *)thread;
4689 
4690   // Don't wait if interrupted or already triggered
4691   if (Thread::is_interrupted(thread, false) ||
4692     WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4693     ResetEvent(_ParkEvent);
4694     return;
4695   }
4696   else {
4697     ThreadBlockInVM tbivm(jt);
4698     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4699     jt->set_suspend_equivalent();
4700 
4701     WaitForSingleObject(_ParkEvent,  time);
4702     ResetEvent(_ParkEvent);
4703 
4704     // If externally suspended while waiting, re-suspend
4705     if (jt->handle_special_suspend_equivalent_condition()) {
4706       jt->java_suspend_self();
4707     }
4708   }
4709 }
4710 
4711 void Parker::unpark() {
4712   guarantee (_ParkEvent != NULL, "invariant") ;
4713   SetEvent(_ParkEvent);
4714 }
4715 
4716 // Run the specified command in a separate process. Return its exit value,
4717 // or -1 on failure (e.g. can't create a new process).
4718 int os::fork_and_exec(char* cmd) {
4719   STARTUPINFO si;
4720   PROCESS_INFORMATION pi;
4721 
4722   memset(&si, 0, sizeof(si));
4723   si.cb = sizeof(si);
4724   memset(&pi, 0, sizeof(pi));
4725   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
4726                             cmd,    // command line
4727                             NULL,   // process security attribute
4728                             NULL,   // thread security attribute
4729                             TRUE,   // inherits system handles
4730                             0,      // no creation flags
4731                             NULL,   // use parent's environment block
4732                             NULL,   // use parent's starting directory
4733                             &si,    // (in) startup information
4734                             &pi);   // (out) process information
4735 
4736   if (rslt) {
4737     // Wait until child process exits.
4738     WaitForSingleObject(pi.hProcess, INFINITE);
4739 
4740     DWORD exit_code;
4741     GetExitCodeProcess(pi.hProcess, &exit_code);
4742 
4743     // Close process and thread handles.
4744     CloseHandle(pi.hProcess);
4745     CloseHandle(pi.hThread);
4746 
4747     return (int)exit_code;
4748   } else {
4749     return -1;
4750   }
4751 }
4752 
4753 //--------------------------------------------------------------------------------------------------
4754 // Non-product code
4755 
4756 static int mallocDebugIntervalCounter = 0;
4757 static int mallocDebugCounter = 0;
4758 bool os::check_heap(bool force) {
4759   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4760   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4761     // Note: HeapValidate executes two hardware breakpoints when it finds something
4762     // wrong; at these points, eax contains the address of the offending block (I think).
4763     // To get to the exlicit error message(s) below, just continue twice.
4764     HANDLE heap = GetProcessHeap();
4765     { HeapLock(heap);
4766       PROCESS_HEAP_ENTRY phe;
4767       phe.lpData = NULL;
4768       while (HeapWalk(heap, &phe) != 0) {
4769         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4770             !HeapValidate(heap, 0, phe.lpData)) {
4771           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4772           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4773           fatal("corrupted C heap");
4774         }
4775       }
4776       DWORD err = GetLastError();
4777       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4778         fatal(err_msg("heap walk aborted with error %d", err));
4779       }
4780       HeapUnlock(heap);
4781     }
4782     mallocDebugIntervalCounter = 0;
4783   }
4784   return true;
4785 }
4786 
4787 
4788 bool os::find(address addr, outputStream* st) {
4789   // Nothing yet
4790   return false;
4791 }
4792 
4793 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4794   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4795 
4796   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4797     JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4798     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4799     address addr = (address) exceptionRecord->ExceptionInformation[1];
4800 
4801     if (os::is_memory_serialize_page(thread, addr))
4802       return EXCEPTION_CONTINUE_EXECUTION;
4803   }
4804 
4805   return EXCEPTION_CONTINUE_SEARCH;
4806 }
4807 
4808 // We don't build a headless jre for Windows
4809 bool os::is_headless_jre() { return false; }
4810 
4811 
4812 typedef CRITICAL_SECTION mutex_t;
4813 #define mutexInit(m)    InitializeCriticalSection(m)
4814 #define mutexDestroy(m) DeleteCriticalSection(m)
4815 #define mutexLock(m)    EnterCriticalSection(m)
4816 #define mutexUnlock(m)  LeaveCriticalSection(m)
4817 
4818 static bool sock_initialized = FALSE;
4819 static mutex_t sockFnTableMutex;
4820 
4821 static void initSock() {
4822   WSADATA wsadata;
4823 
4824   if (!os::WinSock2Dll::WinSock2Available()) {
4825     jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4826       ::GetLastError());
4827     return;
4828   }
4829   if (sock_initialized == TRUE) return;
4830 
4831   ::mutexInit(&sockFnTableMutex);
4832   ::mutexLock(&sockFnTableMutex);
4833   if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) {
4834       jio_fprintf(stderr, "Could not initialize Winsock\n");
4835   }
4836   sock_initialized = TRUE;
4837   ::mutexUnlock(&sockFnTableMutex);
4838 }
4839 
4840 struct hostent* os::get_host_by_name(char* name) {
4841   if (!sock_initialized) {
4842     initSock();
4843   }
4844   if (!os::WinSock2Dll::WinSock2Available()) {
4845     return NULL;
4846   }
4847   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
4848 }
4849 
4850 int os::socket_close(int fd) {
4851   return ::closesocket(fd);
4852 }
4853 
4854 int os::socket_available(int fd, jint *pbytes) {
4855   int ret = ::ioctlsocket(fd, FIONREAD, (u_long*)pbytes);
4856   return (ret < 0) ? 0 : 1;
4857 }
4858 
4859 int os::socket(int domain, int type, int protocol) {
4860   return ::socket(domain, type, protocol);
4861 }
4862 
4863 int os::listen(int fd, int count) {
4864   return ::listen(fd, count);
4865 }
4866 
4867 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
4868   return ::connect(fd, him, len);
4869 }
4870 
4871 int os::accept(int fd, struct sockaddr* him, socklen_t* len) {
4872   return ::accept(fd, him, len);
4873 }
4874 
4875 int os::sendto(int fd, char* buf, size_t len, uint flags,
4876                struct sockaddr* to, socklen_t tolen) {
4877 
4878   return ::sendto(fd, buf, (int)len, flags, to, tolen);
4879 }
4880 
4881 int os::recvfrom(int fd, char *buf, size_t nBytes, uint flags,
4882                  sockaddr* from, socklen_t* fromlen) {
4883 
4884   return ::recvfrom(fd, buf, (int)nBytes, flags, from, fromlen);
4885 }
4886 
4887 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
4888   return ::recv(fd, buf, (int)nBytes, flags);
4889 }
4890 
4891 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
4892   return ::send(fd, buf, (int)nBytes, flags);
4893 }
4894 
4895 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
4896   return ::send(fd, buf, (int)nBytes, flags);
4897 }
4898 
4899 int os::timeout(int fd, long timeout) {
4900   fd_set tbl;
4901   struct timeval t;
4902 
4903   t.tv_sec  = timeout / 1000;
4904   t.tv_usec = (timeout % 1000) * 1000;
4905 
4906   tbl.fd_count    = 1;
4907   tbl.fd_array[0] = fd;
4908 
4909   return ::select(1, &tbl, 0, 0, &t);
4910 }
4911 
4912 int os::get_host_name(char* name, int namelen) {
4913   return ::gethostname(name, namelen);
4914 }
4915 
4916 int os::socket_shutdown(int fd, int howto) {
4917   return ::shutdown(fd, howto);
4918 }
4919 
4920 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
4921   return ::bind(fd, him, len);
4922 }
4923 
4924 int os::get_sock_name(int fd, struct sockaddr* him, socklen_t* len) {
4925   return ::getsockname(fd, him, len);
4926 }
4927 
4928 int os::get_sock_opt(int fd, int level, int optname,
4929                      char* optval, socklen_t* optlen) {
4930   return ::getsockopt(fd, level, optname, optval, optlen);
4931 }
4932 
4933 int os::set_sock_opt(int fd, int level, int optname,
4934                      const char* optval, socklen_t optlen) {
4935   return ::setsockopt(fd, level, optname, optval, optlen);
4936 }
4937 
4938 
4939 // Kernel32 API
4940 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
4941 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
4942 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
4943 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
4944 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
4945 
4946 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
4947 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
4948 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
4949 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
4950 RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL;
4951 
4952 
4953 BOOL                        os::Kernel32Dll::initialized = FALSE;
4954 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
4955   assert(initialized && _GetLargePageMinimum != NULL,
4956     "GetLargePageMinimumAvailable() not yet called");
4957   return _GetLargePageMinimum();
4958 }
4959 
4960 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
4961   if (!initialized) {
4962     initialize();
4963   }
4964   return _GetLargePageMinimum != NULL;
4965 }
4966 
4967 BOOL os::Kernel32Dll::NumaCallsAvailable() {
4968   if (!initialized) {
4969     initialize();
4970   }
4971   return _VirtualAllocExNuma != NULL;
4972 }
4973 
4974 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
4975   assert(initialized && _VirtualAllocExNuma != NULL,
4976     "NUMACallsAvailable() not yet called");
4977 
4978   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
4979 }
4980 
4981 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
4982   assert(initialized && _GetNumaHighestNodeNumber != NULL,
4983     "NUMACallsAvailable() not yet called");
4984 
4985   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
4986 }
4987 
4988 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
4989   assert(initialized && _GetNumaNodeProcessorMask != NULL,
4990     "NUMACallsAvailable() not yet called");
4991 
4992   return _GetNumaNodeProcessorMask(node, proc_mask);
4993 }
4994 
4995 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
4996   ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) {
4997     if (!initialized) {
4998       initialize();
4999     }
5000 
5001     if (_RtlCaptureStackBackTrace != NULL) {
5002       return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture,
5003         BackTrace, BackTraceHash);
5004     } else {
5005       return 0;
5006     }
5007 }
5008 
5009 void os::Kernel32Dll::initializeCommon() {
5010   if (!initialized) {
5011     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5012     assert(handle != NULL, "Just check");
5013     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
5014     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
5015     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
5016     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
5017     _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace");
5018     initialized = TRUE;
5019   }
5020 }
5021 
5022 
5023 
5024 #ifndef JDK6_OR_EARLIER
5025 
5026 void os::Kernel32Dll::initialize() {
5027   initializeCommon();
5028 }
5029 
5030 
5031 // Kernel32 API
5032 inline BOOL os::Kernel32Dll::SwitchToThread() {
5033   return ::SwitchToThread();
5034 }
5035 
5036 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5037   return true;
5038 }
5039 
5040   // Help tools
5041 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5042   return true;
5043 }
5044 
5045 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5046   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5047 }
5048 
5049 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5050   return ::Module32First(hSnapshot, lpme);
5051 }
5052 
5053 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5054   return ::Module32Next(hSnapshot, lpme);
5055 }
5056 
5057 
5058 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5059   return true;
5060 }
5061 
5062 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5063   ::GetNativeSystemInfo(lpSystemInfo);
5064 }
5065 
5066 // PSAPI API
5067 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5068   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5069 }
5070 
5071 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5072   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5073 }
5074 
5075 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5076   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5077 }
5078 
5079 inline BOOL os::PSApiDll::PSApiAvailable() {
5080   return true;
5081 }
5082 
5083 
5084 // WinSock2 API
5085 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5086   return ::WSAStartup(wVersionRequested, lpWSAData);
5087 }
5088 
5089 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5090   return ::gethostbyname(name);
5091 }
5092 
5093 inline BOOL os::WinSock2Dll::WinSock2Available() {
5094   return true;
5095 }
5096 
5097 // Advapi API
5098 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5099    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5100    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5101      return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5102        BufferLength, PreviousState, ReturnLength);
5103 }
5104 
5105 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5106   PHANDLE TokenHandle) {
5107     return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5108 }
5109 
5110 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5111   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5112 }
5113 
5114 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5115   return true;
5116 }
5117 
5118 #else
5119 // Kernel32 API
5120 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5121 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5122 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5123 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5124 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5125 
5126 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
5127 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5128 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
5129 Module32Next_Fn             os::Kernel32Dll::_Module32Next = NULL;
5130 GetNativeSystemInfo_Fn      os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5131 
5132 void os::Kernel32Dll::initialize() {
5133   if (!initialized) {
5134     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5135     assert(handle != NULL, "Just check");
5136 
5137     _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5138     _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5139       ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5140     _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5141     _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5142     _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5143     initializeCommon();  // resolve the functions that always need resolving
5144 
5145     initialized = TRUE;
5146   }
5147 }
5148 
5149 BOOL os::Kernel32Dll::SwitchToThread() {
5150   assert(initialized && _SwitchToThread != NULL,
5151     "SwitchToThreadAvailable() not yet called");
5152   return _SwitchToThread();
5153 }
5154 
5155 
5156 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5157   if (!initialized) {
5158     initialize();
5159   }
5160   return _SwitchToThread != NULL;
5161 }
5162 
5163 // Help tools
5164 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5165   if (!initialized) {
5166     initialize();
5167   }
5168   return _CreateToolhelp32Snapshot != NULL &&
5169          _Module32First != NULL &&
5170          _Module32Next != NULL;
5171 }
5172 
5173 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5174   assert(initialized && _CreateToolhelp32Snapshot != NULL,
5175     "HelpToolsAvailable() not yet called");
5176 
5177   return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5178 }
5179 
5180 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5181   assert(initialized && _Module32First != NULL,
5182     "HelpToolsAvailable() not yet called");
5183 
5184   return _Module32First(hSnapshot, lpme);
5185 }
5186 
5187 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5188   assert(initialized && _Module32Next != NULL,
5189     "HelpToolsAvailable() not yet called");
5190 
5191   return _Module32Next(hSnapshot, lpme);
5192 }
5193 
5194 
5195 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5196   if (!initialized) {
5197     initialize();
5198   }
5199   return _GetNativeSystemInfo != NULL;
5200 }
5201 
5202 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5203   assert(initialized && _GetNativeSystemInfo != NULL,
5204     "GetNativeSystemInfoAvailable() not yet called");
5205 
5206   _GetNativeSystemInfo(lpSystemInfo);
5207 }
5208 
5209 // PSAPI API
5210 
5211 
5212 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5213 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5214 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5215 
5216 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
5217 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
5218 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5219 BOOL                    os::PSApiDll::initialized = FALSE;
5220 
5221 void os::PSApiDll::initialize() {
5222   if (!initialized) {
5223     HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5224     if (handle != NULL) {
5225       _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5226         "EnumProcessModules");
5227       _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5228         "GetModuleFileNameExA");
5229       _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5230         "GetModuleInformation");
5231     }
5232     initialized = TRUE;
5233   }
5234 }
5235 
5236 
5237 
5238 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5239   assert(initialized && _EnumProcessModules != NULL,
5240     "PSApiAvailable() not yet called");
5241   return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5242 }
5243 
5244 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5245   assert(initialized && _GetModuleFileNameEx != NULL,
5246     "PSApiAvailable() not yet called");
5247   return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5248 }
5249 
5250 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5251   assert(initialized && _GetModuleInformation != NULL,
5252     "PSApiAvailable() not yet called");
5253   return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5254 }
5255 
5256 BOOL os::PSApiDll::PSApiAvailable() {
5257   if (!initialized) {
5258     initialize();
5259   }
5260   return _EnumProcessModules != NULL &&
5261     _GetModuleFileNameEx != NULL &&
5262     _GetModuleInformation != NULL;
5263 }
5264 
5265 
5266 // WinSock2 API
5267 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5268 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5269 
5270 WSAStartup_Fn    os::WinSock2Dll::_WSAStartup = NULL;
5271 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5272 BOOL             os::WinSock2Dll::initialized = FALSE;
5273 
5274 void os::WinSock2Dll::initialize() {
5275   if (!initialized) {
5276     HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5277     if (handle != NULL) {
5278       _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5279       _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5280     }
5281     initialized = TRUE;
5282   }
5283 }
5284 
5285 
5286 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5287   assert(initialized && _WSAStartup != NULL,
5288     "WinSock2Available() not yet called");
5289   return _WSAStartup(wVersionRequested, lpWSAData);
5290 }
5291 
5292 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5293   assert(initialized && _gethostbyname != NULL,
5294     "WinSock2Available() not yet called");
5295   return _gethostbyname(name);
5296 }
5297 
5298 BOOL os::WinSock2Dll::WinSock2Available() {
5299   if (!initialized) {
5300     initialize();
5301   }
5302   return _WSAStartup != NULL &&
5303     _gethostbyname != NULL;
5304 }
5305 
5306 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5307 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5308 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5309 
5310 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5311 OpenProcessToken_Fn      os::Advapi32Dll::_OpenProcessToken = NULL;
5312 LookupPrivilegeValue_Fn  os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5313 BOOL                     os::Advapi32Dll::initialized = FALSE;
5314 
5315 void os::Advapi32Dll::initialize() {
5316   if (!initialized) {
5317     HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5318     if (handle != NULL) {
5319       _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5320         "AdjustTokenPrivileges");
5321       _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5322         "OpenProcessToken");
5323       _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5324         "LookupPrivilegeValueA");
5325     }
5326     initialized = TRUE;
5327   }
5328 }
5329 
5330 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5331    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5332    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5333    assert(initialized && _AdjustTokenPrivileges != NULL,
5334      "AdvapiAvailable() not yet called");
5335    return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5336        BufferLength, PreviousState, ReturnLength);
5337 }
5338 
5339 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5340   PHANDLE TokenHandle) {
5341    assert(initialized && _OpenProcessToken != NULL,
5342      "AdvapiAvailable() not yet called");
5343     return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5344 }
5345 
5346 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5347    assert(initialized && _LookupPrivilegeValue != NULL,
5348      "AdvapiAvailable() not yet called");
5349   return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5350 }
5351 
5352 BOOL os::Advapi32Dll::AdvapiAvailable() {
5353   if (!initialized) {
5354     initialize();
5355   }
5356   return _AdjustTokenPrivileges != NULL &&
5357     _OpenProcessToken != NULL &&
5358     _LookupPrivilegeValue != NULL;
5359 }
5360 
5361 #endif