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