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