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 
1968 int os::signal_lookup() {
1969   return check_pending_signals(false);
1970 }
1971 
1972 int os::signal_wait() {
1973   return check_pending_signals(true);
1974 }
1975 
1976 // Implicit OS exception handling
1977 
1978 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
1979   JavaThread* thread = JavaThread::current();
1980   // Save pc in thread
1981 #ifdef _M_IA64
1982   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
1983   // Set pc to handler
1984   exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
1985 #elif _M_AMD64
1986   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
1987   // Set pc to handler
1988   exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
1989 #else
1990   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
1991   // Set pc to handler
1992   exceptionInfo->ContextRecord->Eip = (LONG)handler;
1993 #endif
1994 
1995   // Continue the execution
1996   return EXCEPTION_CONTINUE_EXECUTION;
1997 }
1998 
1999 
2000 // Used for PostMortemDump
2001 extern "C" void safepoints();
2002 extern "C" void find(int x);
2003 extern "C" void events();
2004 
2005 // According to Windows API documentation, an illegal instruction sequence should generate
2006 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2007 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2008 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2009 
2010 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2011 
2012 // From "Execution Protection in the Windows Operating System" draft 0.35
2013 // Once a system header becomes available, the "real" define should be
2014 // included or copied here.
2015 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2016 
2017 #define def_excpt(val) #val, val
2018 
2019 struct siglabel {
2020   char *name;
2021   int   number;
2022 };
2023 
2024 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2025 // C++ compiler contain this error code. Because this is a compiler-generated
2026 // error, the code is not listed in the Win32 API header files.
2027 // The code is actually a cryptic mnemonic device, with the initial "E"
2028 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2029 // ASCII values of "msc".
2030 
2031 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION    0xE06D7363
2032 
2033 
2034 struct siglabel exceptlabels[] = {
2035     def_excpt(EXCEPTION_ACCESS_VIOLATION),
2036     def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2037     def_excpt(EXCEPTION_BREAKPOINT),
2038     def_excpt(EXCEPTION_SINGLE_STEP),
2039     def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2040     def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2041     def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2042     def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2043     def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2044     def_excpt(EXCEPTION_FLT_OVERFLOW),
2045     def_excpt(EXCEPTION_FLT_STACK_CHECK),
2046     def_excpt(EXCEPTION_FLT_UNDERFLOW),
2047     def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2048     def_excpt(EXCEPTION_INT_OVERFLOW),
2049     def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2050     def_excpt(EXCEPTION_IN_PAGE_ERROR),
2051     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2052     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2053     def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2054     def_excpt(EXCEPTION_STACK_OVERFLOW),
2055     def_excpt(EXCEPTION_INVALID_DISPOSITION),
2056     def_excpt(EXCEPTION_GUARD_PAGE),
2057     def_excpt(EXCEPTION_INVALID_HANDLE),
2058     def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2059     NULL, 0
2060 };
2061 
2062 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2063   for (int i = 0; exceptlabels[i].name != NULL; i++) {
2064     if (exceptlabels[i].number == exception_code) {
2065        jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2066        return buf;
2067     }
2068   }
2069 
2070   return NULL;
2071 }
2072 
2073 //-----------------------------------------------------------------------------
2074 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2075   // handle exception caused by idiv; should only happen for -MinInt/-1
2076   // (division by zero is handled explicitly)
2077 #ifdef _M_IA64
2078   assert(0, "Fix Handle_IDiv_Exception");
2079 #elif _M_AMD64
2080   PCONTEXT ctx = exceptionInfo->ContextRecord;
2081   address pc = (address)ctx->Rip;
2082   NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2083   assert(pc[0] == 0xF7, "not an idiv opcode");
2084   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2085   assert(ctx->Rax == min_jint, "unexpected idiv exception");
2086   // set correct result values and continue after idiv instruction
2087   ctx->Rip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2088   ctx->Rax = (DWORD)min_jint;      // result
2089   ctx->Rdx = (DWORD)0;             // remainder
2090   // Continue the execution
2091 #else
2092   PCONTEXT ctx = exceptionInfo->ContextRecord;
2093   address pc = (address)ctx->Eip;
2094   NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2095   assert(pc[0] == 0xF7, "not an idiv opcode");
2096   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2097   assert(ctx->Eax == min_jint, "unexpected idiv exception");
2098   // set correct result values and continue after idiv instruction
2099   ctx->Eip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2100   ctx->Eax = (DWORD)min_jint;      // result
2101   ctx->Edx = (DWORD)0;             // remainder
2102   // Continue the execution
2103 #endif
2104   return EXCEPTION_CONTINUE_EXECUTION;
2105 }
2106 
2107 #ifndef  _WIN64
2108 //-----------------------------------------------------------------------------
2109 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2110   // handle exception caused by native method modifying control word
2111   PCONTEXT ctx = exceptionInfo->ContextRecord;
2112   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2113 
2114   switch (exception_code) {
2115     case EXCEPTION_FLT_DENORMAL_OPERAND:
2116     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2117     case EXCEPTION_FLT_INEXACT_RESULT:
2118     case EXCEPTION_FLT_INVALID_OPERATION:
2119     case EXCEPTION_FLT_OVERFLOW:
2120     case EXCEPTION_FLT_STACK_CHECK:
2121     case EXCEPTION_FLT_UNDERFLOW:
2122       jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2123       if (fp_control_word != ctx->FloatSave.ControlWord) {
2124         // Restore FPCW and mask out FLT exceptions
2125         ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2126         // Mask out pending FLT exceptions
2127         ctx->FloatSave.StatusWord &=  0xffffff00;
2128         return EXCEPTION_CONTINUE_EXECUTION;
2129       }
2130   }
2131 
2132   if (prev_uef_handler != NULL) {
2133     // We didn't handle this exception so pass it to the previous
2134     // UnhandledExceptionFilter.
2135     return (prev_uef_handler)(exceptionInfo);
2136   }
2137 
2138   return EXCEPTION_CONTINUE_SEARCH;
2139 }
2140 #else //_WIN64
2141 /*
2142   On Windows, the mxcsr control bits are non-volatile across calls
2143   See also CR 6192333
2144   If EXCEPTION_FLT_* happened after some native method modified
2145   mxcsr - it is not a jvm fault.
2146   However should we decide to restore of mxcsr after a faulty
2147   native method we can uncomment following code
2148       jint MxCsr = INITIAL_MXCSR;
2149         // we can't use StubRoutines::addr_mxcsr_std()
2150         // because in Win64 mxcsr is not saved there
2151       if (MxCsr != ctx->MxCsr) {
2152         ctx->MxCsr = MxCsr;
2153         return EXCEPTION_CONTINUE_EXECUTION;
2154       }
2155 
2156 */
2157 #endif //_WIN64
2158 
2159 
2160 // Fatal error reporting is single threaded so we can make this a
2161 // static and preallocated.  If it's more than MAX_PATH silently ignore
2162 // it.
2163 static char saved_error_file[MAX_PATH] = {0};
2164 
2165 void os::set_error_file(const char *logfile) {
2166   if (strlen(logfile) <= MAX_PATH) {
2167     strncpy(saved_error_file, logfile, MAX_PATH);
2168   }
2169 }
2170 
2171 static inline void report_error(Thread* t, DWORD exception_code,
2172                                 address addr, void* siginfo, void* context) {
2173   VMError err(t, exception_code, addr, siginfo, context);
2174   err.report_and_die();
2175 
2176   // If UseOsErrorReporting, this will return here and save the error file
2177   // somewhere where we can find it in the minidump.
2178 }
2179 
2180 //-----------------------------------------------------------------------------
2181 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2182   if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2183   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2184 #ifdef _M_IA64
2185   address pc = (address) exceptionInfo->ContextRecord->StIIP;
2186 #elif _M_AMD64
2187   address pc = (address) exceptionInfo->ContextRecord->Rip;
2188 #else
2189   address pc = (address) exceptionInfo->ContextRecord->Eip;
2190 #endif
2191   Thread* t = ThreadLocalStorage::get_thread_slow();          // slow & steady
2192 
2193 #ifndef _WIN64
2194   // Execution protection violation - win32 running on AMD64 only
2195   // Handled first to avoid misdiagnosis as a "normal" access violation;
2196   // This is safe to do because we have a new/unique ExceptionInformation
2197   // code for this condition.
2198   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2199     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2200     int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2201     address addr = (address) exceptionRecord->ExceptionInformation[1];
2202 
2203     if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2204       int page_size = os::vm_page_size();
2205 
2206       // Make sure the pc and the faulting address are sane.
2207       //
2208       // If an instruction spans a page boundary, and the page containing
2209       // the beginning of the instruction is executable but the following
2210       // page is not, the pc and the faulting address might be slightly
2211       // different - we still want to unguard the 2nd page in this case.
2212       //
2213       // 15 bytes seems to be a (very) safe value for max instruction size.
2214       bool pc_is_near_addr =
2215         (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2216       bool instr_spans_page_boundary =
2217         (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2218                          (intptr_t) page_size) > 0);
2219 
2220       if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2221         static volatile address last_addr =
2222           (address) os::non_memory_address_word();
2223 
2224         // In conservative mode, don't unguard unless the address is in the VM
2225         if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2226             (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2227 
2228           // Set memory to RWX and retry
2229           address page_start =
2230             (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2231           bool res = os::protect_memory((char*) page_start, page_size,
2232                                         os::MEM_PROT_RWX);
2233 
2234           if (PrintMiscellaneous && Verbose) {
2235             char buf[256];
2236             jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2237                          "at " INTPTR_FORMAT
2238                          ", unguarding " INTPTR_FORMAT ": %s", addr,
2239                          page_start, (res ? "success" : strerror(errno)));
2240             tty->print_raw_cr(buf);
2241           }
2242 
2243           // Set last_addr so if we fault again at the same address, we don't
2244           // end up in an endless loop.
2245           //
2246           // There are two potential complications here.  Two threads trapping
2247           // at the same address at the same time could cause one of the
2248           // threads to think it already unguarded, and abort the VM.  Likely
2249           // very rare.
2250           //
2251           // The other race involves two threads alternately trapping at
2252           // different addresses and failing to unguard the page, resulting in
2253           // an endless loop.  This condition is probably even more unlikely
2254           // than the first.
2255           //
2256           // Although both cases could be avoided by using locks or thread
2257           // local last_addr, these solutions are unnecessary complication:
2258           // this handler is a best-effort safety net, not a complete solution.
2259           // It is disabled by default and should only be used as a workaround
2260           // in case we missed any no-execute-unsafe VM code.
2261 
2262           last_addr = addr;
2263 
2264           return EXCEPTION_CONTINUE_EXECUTION;
2265         }
2266       }
2267 
2268       // Last unguard failed or not unguarding
2269       tty->print_raw_cr("Execution protection violation");
2270       report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2271                    exceptionInfo->ContextRecord);
2272       return EXCEPTION_CONTINUE_SEARCH;
2273     }
2274   }
2275 #endif // _WIN64
2276 
2277   // Check to see if we caught the safepoint code in the
2278   // process of write protecting the memory serialization page.
2279   // It write enables the page immediately after protecting it
2280   // so just return.
2281   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2282     JavaThread* thread = (JavaThread*) t;
2283     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2284     address addr = (address) exceptionRecord->ExceptionInformation[1];
2285     if ( os::is_memory_serialize_page(thread, addr) ) {
2286       // Block current thread until the memory serialize page permission restored.
2287       os::block_on_serialize_page_trap();
2288       return EXCEPTION_CONTINUE_EXECUTION;
2289     }
2290   }
2291 
2292   if (t != NULL && t->is_Java_thread()) {
2293     JavaThread* thread = (JavaThread*) t;
2294     bool in_java = thread->thread_state() == _thread_in_Java;
2295 
2296     // Handle potential stack overflows up front.
2297     if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2298       if (os::uses_stack_guard_pages()) {
2299 #ifdef _M_IA64
2300         //
2301         // If it's a legal stack address continue, Windows will map it in.
2302         //
2303         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2304         address addr = (address) exceptionRecord->ExceptionInformation[1];
2305         if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2306           return EXCEPTION_CONTINUE_EXECUTION;
2307 
2308         // The register save area is the same size as the memory stack
2309         // and starts at the page just above the start of the memory stack.
2310         // If we get a fault in this area, we've run out of register
2311         // stack.  If we are in java, try throwing a stack overflow exception.
2312         if (addr > thread->stack_base() &&
2313                       addr <= (thread->stack_base()+thread->stack_size()) ) {
2314           char buf[256];
2315           jio_snprintf(buf, sizeof(buf),
2316                        "Register stack overflow, addr:%p, stack_base:%p\n",
2317                        addr, thread->stack_base() );
2318           tty->print_raw_cr(buf);
2319           // If not in java code, return and hope for the best.
2320           return in_java ? Handle_Exception(exceptionInfo,
2321             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2322             :  EXCEPTION_CONTINUE_EXECUTION;
2323         }
2324 #endif
2325         if (thread->stack_yellow_zone_enabled()) {
2326           // Yellow zone violation.  The o/s has unprotected the first yellow
2327           // zone page for us.  Note:  must call disable_stack_yellow_zone to
2328           // update the enabled status, even if the zone contains only one page.
2329           thread->disable_stack_yellow_zone();
2330           // If not in java code, return and hope for the best.
2331           return in_java ? Handle_Exception(exceptionInfo,
2332             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2333             :  EXCEPTION_CONTINUE_EXECUTION;
2334         } else {
2335           // Fatal red zone violation.
2336           thread->disable_stack_red_zone();
2337           tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2338           report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2339                        exceptionInfo->ContextRecord);
2340           return EXCEPTION_CONTINUE_SEARCH;
2341         }
2342       } else if (in_java) {
2343         // JVM-managed guard pages cannot be used on win95/98.  The o/s provides
2344         // a one-time-only guard page, which it has released to us.  The next
2345         // stack overflow on this thread will result in an ACCESS_VIOLATION.
2346         return Handle_Exception(exceptionInfo,
2347           SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2348       } else {
2349         // Can only return and hope for the best.  Further stack growth will
2350         // result in an ACCESS_VIOLATION.
2351         return EXCEPTION_CONTINUE_EXECUTION;
2352       }
2353     } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2354       // Either stack overflow or null pointer exception.
2355       if (in_java) {
2356         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2357         address addr = (address) exceptionRecord->ExceptionInformation[1];
2358         address stack_end = thread->stack_base() - thread->stack_size();
2359         if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2360           // Stack overflow.
2361           assert(!os::uses_stack_guard_pages(),
2362             "should be caught by red zone code above.");
2363           return Handle_Exception(exceptionInfo,
2364             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2365         }
2366         //
2367         // Check for safepoint polling and implicit null
2368         // We only expect null pointers in the stubs (vtable)
2369         // the rest are checked explicitly now.
2370         //
2371         CodeBlob* cb = CodeCache::find_blob(pc);
2372         if (cb != NULL) {
2373           if (os::is_poll_address(addr)) {
2374             address stub = SharedRuntime::get_poll_stub(pc);
2375             return Handle_Exception(exceptionInfo, stub);
2376           }
2377         }
2378         {
2379 #ifdef _WIN64
2380           //
2381           // If it's a legal stack address map the entire region in
2382           //
2383           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2384           address addr = (address) exceptionRecord->ExceptionInformation[1];
2385           if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2386                   addr = (address)((uintptr_t)addr &
2387                          (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2388                   os::commit_memory((char *)addr, thread->stack_base() - addr,
2389                                     false );
2390                   return EXCEPTION_CONTINUE_EXECUTION;
2391           }
2392           else
2393 #endif
2394           {
2395             // Null pointer exception.
2396 #ifdef _M_IA64
2397             // We catch register stack overflows in compiled code by doing
2398             // an explicit compare and executing a st8(G0, G0) if the
2399             // BSP enters into our guard area.  We test for the overflow
2400             // condition and fall into the normal null pointer exception
2401             // code if BSP hasn't overflowed.
2402             if ( in_java ) {
2403               if(thread->register_stack_overflow()) {
2404                 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2405                                 thread->register_stack_limit(),
2406                                "GR7 doesn't contain register_stack_limit");
2407                 // Disable the yellow zone which sets the state that
2408                 // we've got a stack overflow problem.
2409                 if (thread->stack_yellow_zone_enabled()) {
2410                   thread->disable_stack_yellow_zone();
2411                 }
2412                 // Give us some room to process the exception
2413                 thread->disable_register_stack_guard();
2414                 // Update GR7 with the new limit so we can continue running
2415                 // compiled code.
2416                 exceptionInfo->ContextRecord->IntS3 =
2417                                (ULONGLONG)thread->register_stack_limit();
2418                 return Handle_Exception(exceptionInfo,
2419                        SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2420               } else {
2421                 //
2422                 // Check for implicit null
2423                 // We only expect null pointers in the stubs (vtable)
2424                 // the rest are checked explicitly now.
2425                 //
2426                 if (((uintptr_t)addr) < os::vm_page_size() ) {
2427                   // an access to the first page of VM--assume it is a null pointer
2428                   address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2429                   if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2430                 }
2431               }
2432             } // in_java
2433 
2434             // IA64 doesn't use implicit null checking yet. So we shouldn't
2435             // get here.
2436             tty->print_raw_cr("Access violation, possible null pointer exception");
2437             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2438                          exceptionInfo->ContextRecord);
2439             return EXCEPTION_CONTINUE_SEARCH;
2440 #else /* !IA64 */
2441 
2442             // Windows 98 reports faulting addresses incorrectly
2443             if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2444                 !os::win32::is_nt()) {
2445               address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2446               if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2447             }
2448             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2449                          exceptionInfo->ContextRecord);
2450             return EXCEPTION_CONTINUE_SEARCH;
2451 #endif
2452           }
2453         }
2454       }
2455 
2456 #ifdef _WIN64
2457       // Special care for fast JNI field accessors.
2458       // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2459       // in and the heap gets shrunk before the field access.
2460       if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2461         address addr = JNI_FastGetField::find_slowcase_pc(pc);
2462         if (addr != (address)-1) {
2463           return Handle_Exception(exceptionInfo, addr);
2464         }
2465       }
2466 #endif
2467 
2468 #ifdef _WIN64
2469       // Windows will sometimes generate an access violation
2470       // when we call malloc.  Since we use VectoredExceptions
2471       // on 64 bit platforms, we see this exception.  We must
2472       // pass this exception on so Windows can recover.
2473       // We check to see if the pc of the fault is in NTDLL.DLL
2474       // if so, we pass control on to Windows for handling.
2475       if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2476 #endif
2477 
2478       // Stack overflow or null pointer exception in native code.
2479       report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2480                    exceptionInfo->ContextRecord);
2481       return EXCEPTION_CONTINUE_SEARCH;
2482     }
2483 
2484     if (in_java) {
2485       switch (exception_code) {
2486       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2487         return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2488 
2489       case EXCEPTION_INT_OVERFLOW:
2490         return Handle_IDiv_Exception(exceptionInfo);
2491 
2492       } // switch
2493     }
2494 #ifndef _WIN64
2495     if (((thread->thread_state() == _thread_in_Java) ||
2496         (thread->thread_state() == _thread_in_native)) &&
2497         exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2498     {
2499       LONG result=Handle_FLT_Exception(exceptionInfo);
2500       if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2501     }
2502 #endif //_WIN64
2503   }
2504 
2505   if (exception_code != EXCEPTION_BREAKPOINT) {
2506 #ifndef _WIN64
2507     report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2508                  exceptionInfo->ContextRecord);
2509 #else
2510     // Itanium Windows uses a VectoredExceptionHandler
2511     // Which means that C++ programatic exception handlers (try/except)
2512     // will get here.  Continue the search for the right except block if
2513     // the exception code is not a fatal code.
2514     switch ( exception_code ) {
2515       case EXCEPTION_ACCESS_VIOLATION:
2516       case EXCEPTION_STACK_OVERFLOW:
2517       case EXCEPTION_ILLEGAL_INSTRUCTION:
2518       case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2519       case EXCEPTION_INT_OVERFLOW:
2520       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2521       case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
2522       {  report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2523                        exceptionInfo->ContextRecord);
2524       }
2525         break;
2526       default:
2527         break;
2528     }
2529 #endif
2530   }
2531   return EXCEPTION_CONTINUE_SEARCH;
2532 }
2533 
2534 #ifndef _WIN64
2535 // Special care for fast JNI accessors.
2536 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2537 // the heap gets shrunk before the field access.
2538 // Need to install our own structured exception handler since native code may
2539 // install its own.
2540 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2541   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2542   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2543     address pc = (address) exceptionInfo->ContextRecord->Eip;
2544     address addr = JNI_FastGetField::find_slowcase_pc(pc);
2545     if (addr != (address)-1) {
2546       return Handle_Exception(exceptionInfo, addr);
2547     }
2548   }
2549   return EXCEPTION_CONTINUE_SEARCH;
2550 }
2551 
2552 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2553 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2554   __try { \
2555     return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2556   } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2557   } \
2558   return 0; \
2559 }
2560 
2561 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2562 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2563 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2564 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2565 DEFINE_FAST_GETFIELD(jint,     int,    Int)
2566 DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2567 DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2568 DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2569 
2570 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2571   switch (type) {
2572     case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2573     case T_BYTE:    return (address)jni_fast_GetByteField_wrapper;
2574     case T_CHAR:    return (address)jni_fast_GetCharField_wrapper;
2575     case T_SHORT:   return (address)jni_fast_GetShortField_wrapper;
2576     case T_INT:     return (address)jni_fast_GetIntField_wrapper;
2577     case T_LONG:    return (address)jni_fast_GetLongField_wrapper;
2578     case T_FLOAT:   return (address)jni_fast_GetFloatField_wrapper;
2579     case T_DOUBLE:  return (address)jni_fast_GetDoubleField_wrapper;
2580     default:        ShouldNotReachHere();
2581   }
2582   return (address)-1;
2583 }
2584 #endif
2585 
2586 // Virtual Memory
2587 
2588 int os::vm_page_size() { return os::win32::vm_page_size(); }
2589 int os::vm_allocation_granularity() {
2590   return os::win32::vm_allocation_granularity();
2591 }
2592 
2593 // Windows large page support is available on Windows 2003. In order to use
2594 // large page memory, the administrator must first assign additional privilege
2595 // to the user:
2596 //   + select Control Panel -> Administrative Tools -> Local Security Policy
2597 //   + select Local Policies -> User Rights Assignment
2598 //   + double click "Lock pages in memory", add users and/or groups
2599 //   + reboot
2600 // Note the above steps are needed for administrator as well, as administrators
2601 // by default do not have the privilege to lock pages in memory.
2602 //
2603 // Note about Windows 2003: although the API supports committing large page
2604 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2605 // scenario, I found through experiment it only uses large page if the entire
2606 // memory region is reserved and committed in a single VirtualAlloc() call.
2607 // This makes Windows large page support more or less like Solaris ISM, in
2608 // that the entire heap must be committed upfront. This probably will change
2609 // in the future, if so the code below needs to be revisited.
2610 
2611 #ifndef MEM_LARGE_PAGES
2612 #define MEM_LARGE_PAGES 0x20000000
2613 #endif
2614 
2615 static HANDLE    _hProcess;
2616 static HANDLE    _hToken;
2617 
2618 // Container for NUMA node list info
2619 class NUMANodeListHolder {
2620 private:
2621   int *_numa_used_node_list;  // allocated below
2622   int _numa_used_node_count;
2623 
2624   void free_node_list() {
2625     if (_numa_used_node_list != NULL) {
2626       FREE_C_HEAP_ARRAY(int, _numa_used_node_list);
2627     }
2628   }
2629 
2630 public:
2631   NUMANodeListHolder() {
2632     _numa_used_node_count = 0;
2633     _numa_used_node_list = NULL;
2634     // do rest of initialization in build routine (after function pointers are set up)
2635   }
2636 
2637   ~NUMANodeListHolder() {
2638     free_node_list();
2639   }
2640 
2641   bool build() {
2642     DWORD_PTR proc_aff_mask;
2643     DWORD_PTR sys_aff_mask;
2644     if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2645     ULONG highest_node_number;
2646     if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false;
2647     free_node_list();
2648     _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number);
2649     for (unsigned int i = 0; i <= highest_node_number; i++) {
2650       ULONGLONG proc_mask_numa_node;
2651       if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2652       if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2653         _numa_used_node_list[_numa_used_node_count++] = i;
2654       }
2655     }
2656     return (_numa_used_node_count > 1);
2657   }
2658 
2659   int get_count() {return _numa_used_node_count;}
2660   int get_node_list_entry(int n) {
2661     // for indexes out of range, returns -1
2662     return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2663   }
2664 
2665 } numa_node_list_holder;
2666 
2667 
2668 
2669 static size_t _large_page_size = 0;
2670 
2671 static bool resolve_functions_for_large_page_init() {
2672   return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2673     os::Advapi32Dll::AdvapiAvailable();
2674 }
2675 
2676 static bool request_lock_memory_privilege() {
2677   _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2678                                 os::current_process_id());
2679 
2680   LUID luid;
2681   if (_hProcess != NULL &&
2682       os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2683       os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2684 
2685     TOKEN_PRIVILEGES tp;
2686     tp.PrivilegeCount = 1;
2687     tp.Privileges[0].Luid = luid;
2688     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2689 
2690     // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2691     // privilege. Check GetLastError() too. See MSDN document.
2692     if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2693         (GetLastError() == ERROR_SUCCESS)) {
2694       return true;
2695     }
2696   }
2697 
2698   return false;
2699 }
2700 
2701 static void cleanup_after_large_page_init() {
2702   if (_hProcess) CloseHandle(_hProcess);
2703   _hProcess = NULL;
2704   if (_hToken) CloseHandle(_hToken);
2705   _hToken = NULL;
2706 }
2707 
2708 static bool numa_interleaving_init() {
2709   bool success = false;
2710   bool use_numa_specified = !FLAG_IS_DEFAULT(UseNUMA);
2711   bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2712 
2713   // print a warning if UseNUMA or UseNUMAInterleaving flag is specified on command line
2714   bool warn_on_failure =  use_numa_specified || use_numa_interleaving_specified;
2715 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2716 
2717   // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2718   size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2719   NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
2720 
2721   if (os::Kernel32Dll::NumaCallsAvailable()) {
2722     if (numa_node_list_holder.build()) {
2723       if (PrintMiscellaneous && Verbose) {
2724         tty->print("NUMA UsedNodeCount=%d, namely ", os::numa_get_groups_num());
2725         for (int i = 0; i < os::numa_get_groups_num(); i++) {
2726           tty->print("%d ", numa_node_list_holder.get_node_list_entry(i));
2727         }
2728         tty->print("\n");
2729       }
2730       success = true;
2731     } else {
2732       WARN("Process does not cover multiple NUMA nodes.");
2733     }
2734   } else {
2735     WARN("NUMA Interleaving is not supported by the operating system.");
2736   }
2737   if (!success) {
2738     if (use_numa_specified) WARN("...Ignoring UseNUMA flag.");
2739     if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2740   }
2741   return success;
2742 #undef WARN
2743 }
2744 
2745 // this routine is used whenever we need to reserve a contiguous VA range
2746 // but we need to make separate VirtualAlloc calls for each piece of the range
2747 // Reasons for doing this:
2748 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2749 //  * UseNUMAInterleaving requires a separate node for each piece
2750 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
2751                                          bool should_inject_error=false) {
2752   char * p_buf;
2753   // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2754   size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2755   size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2756 
2757   // first reserve enough address space in advance since we want to be
2758   // able to break a single contiguous virtual address range into multiple
2759   // large page commits but WS2003 does not allow reserving large page space
2760   // so we just use 4K pages for reserve, this gives us a legal contiguous
2761   // address space. then we will deallocate that reservation, and re alloc
2762   // using large pages
2763   const size_t size_of_reserve = bytes + chunk_size;
2764   if (bytes > size_of_reserve) {
2765     // Overflowed.
2766     return NULL;
2767   }
2768   p_buf = (char *) VirtualAlloc(addr,
2769                                 size_of_reserve,  // size of Reserve
2770                                 MEM_RESERVE,
2771                                 PAGE_READWRITE);
2772   // If reservation failed, return NULL
2773   if (p_buf == NULL) return NULL;
2774 
2775   os::release_memory(p_buf, bytes + chunk_size);
2776 
2777   // we still need to round up to a page boundary (in case we are using large pages)
2778   // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
2779   // instead we handle this in the bytes_to_rq computation below
2780   p_buf = (char *) align_size_up((size_t)p_buf, page_size);
2781 
2782   // now go through and allocate one chunk at a time until all bytes are
2783   // allocated
2784   size_t  bytes_remaining = bytes;   
2785   // An overflow of align_size_up() would have been caught above
2786   // in the calculation of size_of_reserve.
2787   char * next_alloc_addr = p_buf;
2788   HANDLE hProc = GetCurrentProcess();
2789 
2790 #ifdef ASSERT
2791   // Variable for the failure injection
2792   long ran_num = os::random();
2793   size_t fail_after = ran_num % bytes;
2794 #endif
2795 
2796   int count=0;
2797   while (bytes_remaining) {
2798     // select bytes_to_rq to get to the next chunk_size boundary
2799 
2800     size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
2801     // Note allocate and commit
2802     char * p_new;
2803 
2804 #ifdef ASSERT
2805     bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
2806 #else
2807     const bool inject_error_now = false;
2808 #endif
2809 
2810     if (inject_error_now) {
2811       p_new = NULL;
2812     } else {
2813       if (!UseNUMAInterleaving) {
2814         p_new = (char *) VirtualAlloc(next_alloc_addr,
2815                                       bytes_to_rq,
2816                                       flags,
2817                                       prot);
2818       } else {
2819         // get the next node to use from the used_node_list
2820         DWORD node = numa_node_list_holder.get_node_list_entry(count % os::numa_get_groups_num());
2821         p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc,
2822                                                             next_alloc_addr,
2823                                                             bytes_to_rq,
2824                                                             flags,
2825                                                             prot,
2826                                                             node);
2827       }
2828     }
2829 
2830     if (p_new == NULL) {
2831       // Free any allocated pages
2832       if (next_alloc_addr > p_buf) {
2833         // Some memory was committed so release it.
2834         size_t bytes_to_release = bytes - bytes_remaining;
2835         os::release_memory(p_buf, bytes_to_release);
2836       }
2837 #ifdef ASSERT
2838       if (should_inject_error) {
2839         if (TracePageSizes && Verbose) {
2840           tty->print_cr("Reserving pages individually failed.");
2841         }
2842       }
2843 #endif
2844       return NULL;
2845     }
2846     bytes_remaining -= bytes_to_rq;
2847     next_alloc_addr += bytes_to_rq;
2848     count++;
2849   }
2850   // made it this far, success
2851   return p_buf;
2852 }
2853 
2854 
2855 
2856 void os::large_page_init() {
2857   if (!UseLargePages) return;
2858 
2859   // print a warning if any large page related flag is specified on command line
2860   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2861                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2862   bool success = false;
2863 
2864 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2865   if (resolve_functions_for_large_page_init()) {
2866     if (request_lock_memory_privilege()) {
2867       size_t s = os::Kernel32Dll::GetLargePageMinimum();
2868       if (s) {
2869 #if defined(IA32) || defined(AMD64)
2870         if (s > 4*M || LargePageSizeInBytes > 4*M) {
2871           WARN("JVM cannot use large pages bigger than 4mb.");
2872         } else {
2873 #endif
2874           if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2875             _large_page_size = LargePageSizeInBytes;
2876           } else {
2877             _large_page_size = s;
2878           }
2879           success = true;
2880 #if defined(IA32) || defined(AMD64)
2881         }
2882 #endif
2883       } else {
2884         WARN("Large page is not supported by the processor.");
2885       }
2886     } else {
2887       WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2888     }
2889   } else {
2890     WARN("Large page is not supported by the operating system.");
2891   }
2892 #undef WARN
2893 
2894   const size_t default_page_size = (size_t) vm_page_size();
2895   if (success && _large_page_size > default_page_size) {
2896     _page_sizes[0] = _large_page_size;
2897     _page_sizes[1] = default_page_size;
2898     _page_sizes[2] = 0;
2899   }
2900 
2901   cleanup_after_large_page_init();
2902   UseLargePages = success;
2903 }
2904 
2905 // On win32, one cannot release just a part of reserved memory, it's an
2906 // all or nothing deal.  When we split a reservation, we must break the
2907 // reservation into two reservations.
2908 void os::split_reserved_memory(char *base, size_t size, size_t split,
2909                               bool realloc) {
2910   if (size > 0) {
2911     release_memory(base, size);
2912     if (realloc) {
2913       reserve_memory(split, base);
2914     }
2915     if (size != split) {
2916       reserve_memory(size - split, base + split);
2917     }
2918   }
2919 }
2920 
2921 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2922   assert((size_t)addr % os::vm_allocation_granularity() == 0,
2923          "reserve alignment");
2924   assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2925   char* res;
2926   // note that if UseLargePages is on, all the areas that require interleaving 
2927   // will go thru reserve_memory_special rather than thru here.
2928   bool use_individual = (UseNUMAInterleaving && !UseLargePages);
2929   if (!use_individual) {
2930     res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2931   } else {
2932     elapsedTimer reserveTimer;
2933     if( Verbose && PrintMiscellaneous ) reserveTimer.start();
2934     // in numa interleaving, we have to allocate pages individually
2935     // (well really chunks of allocation granularity size)
2936     res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
2937     if( Verbose && PrintMiscellaneous ) {
2938       reserveTimer.stop();
2939       tty->print_cr("reserve_memory of %Ix bytes took %ld ms (%ld ticks)", bytes,
2940                     reserveTimer.milliseconds(), reserveTimer.ticks());
2941     }
2942   }
2943   assert(res == NULL || addr == NULL || addr == res,
2944          "Unexpected address from reserve.");
2945   
2946   return res;
2947 }
2948 
2949 // Reserve memory at an arbitrary address, only if that area is
2950 // available (and not reserved for something else).
2951 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2952   // Windows os::reserve_memory() fails of the requested address range is
2953   // not avilable.
2954   return reserve_memory(bytes, requested_addr);
2955 }
2956 
2957 size_t os::large_page_size() {
2958   return _large_page_size;
2959 }
2960 
2961 bool os::can_commit_large_page_memory() {
2962   // Windows only uses large page memory when the entire region is reserved
2963   // and committed in a single VirtualAlloc() call. This may change in the
2964   // future, but with Windows 2003 it's not possible to commit on demand.
2965   return false;
2966 }
2967 
2968 bool os::can_execute_large_page_memory() {
2969   return true;
2970 }
2971 
2972 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2973 
2974   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
2975   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2976 
2977   // with large pages, there are two cases where we need to use Individual Allocation
2978   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
2979   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
2980   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
2981     if (TracePageSizes && Verbose) {
2982        tty->print_cr("Reserving large pages individually.");
2983     }
2984     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
2985     if (p_buf == NULL) {
2986       warning("Individually allocated pages failed, "
2987               "use -XX:-UseLargePagesIndividualAllocation to turn off");
2988       return NULL;
2989     }
2990 
2991     return p_buf;
2992 
2993   } else {
2994     // normal policy just allocate it all at once
2995     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2996     char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
2997     return res;
2998   }
2999 }
3000 
3001 bool os::release_memory_special(char* base, size_t bytes) {
3002   return release_memory(base, bytes);
3003 }
3004 
3005 void os::print_statistics() {
3006 }
3007 
3008 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
3009   if (bytes == 0) {
3010     // Don't bother the OS with noops.
3011     return true;
3012   }
3013   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3014   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3015   // Don't attempt to print anything if the OS call fails. We're
3016   // probably low on resources, so the print itself may cause crashes.
3017 
3018   // unless we have NUMAInterleavaing enabled, the range of a commit
3019   // is always within a reserve covered by a single VirtualAlloc
3020   // in that case we can just do a single commit for the requested size
3021   if (!UseNUMAInterleaving) {
3022     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
3023     if (exec) {
3024       DWORD oldprot;
3025       // Windows doc says to use VirtualProtect to get execute permissions
3026       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
3027     }
3028     return true;
3029   } else {
3030     // when NUMAInterleaving is enabled, the commit might cover a range that
3031     // came from multiple VirtualAlloc reserves  using allocate_pages_individually
3032     // VirtualQuery can help us determine that, the RegionSize that it returns
3033     // represents the number of bytes thNUMANodeListHolderat can be committed in one step.
3034     size_t bytes_remaining = bytes;
3035     char * next_alloc_addr = addr;
3036     while (bytes_remaining > 0) {
3037       MEMORY_BASIC_INFORMATION alloc_info;
3038       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3039       size_t bytes_to_rq = MIN2(bytes_remaining, alloc_info.RegionSize);
3040       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
3041       if (exec) {
3042         DWORD oldprot;
3043         if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
3044       }
3045       bytes_remaining -= bytes_to_rq;
3046       next_alloc_addr += bytes_to_rq;
3047     }
3048   }
3049   // if we made it this far, return true
3050   return true;
3051 }
3052 
3053 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
3054                        bool exec) {
3055   return commit_memory(addr, size, exec);
3056 }
3057 
3058 bool os::uncommit_memory(char* addr, size_t bytes) {
3059   if (bytes == 0) {
3060     // Don't bother the OS with noops.
3061     return true;
3062   }
3063   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3064   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3065   return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0;
3066 }
3067 
3068 bool os::release_memory(char* addr, size_t bytes) {
3069   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3070 }
3071 
3072 bool os::create_stack_guard_pages(char* addr, size_t size) {
3073   return os::commit_memory(addr, size);
3074 }
3075 
3076 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3077   return os::uncommit_memory(addr, size);
3078 }
3079 
3080 // Set protections specified
3081 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3082                         bool is_committed) {
3083   unsigned int p = 0;
3084   switch (prot) {
3085   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3086   case MEM_PROT_READ: p = PAGE_READONLY; break;
3087   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3088   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3089   default:
3090     ShouldNotReachHere();
3091   }
3092 
3093   DWORD old_status;
3094 
3095   // Strange enough, but on Win32 one can change protection only for committed
3096   // memory, not a big deal anyway, as bytes less or equal than 64K
3097   if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
3098     fatal("cannot commit protection page");
3099   }
3100   // One cannot use os::guard_memory() here, as on Win32 guard page
3101   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3102   //
3103   // Pages in the region become guard pages. Any attempt to access a guard page
3104   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3105   // the guard page status. Guard pages thus act as a one-time access alarm.
3106   return VirtualProtect(addr, bytes, p, &old_status) != 0;
3107 }
3108 
3109 bool os::guard_memory(char* addr, size_t bytes) {
3110   DWORD old_status;
3111   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3112 }
3113 
3114 bool os::unguard_memory(char* addr, size_t bytes) {
3115   DWORD old_status;
3116   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3117 }
3118 
3119 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3120 void os::free_memory(char *addr, size_t bytes)         { }
3121 void os::numa_make_global(char *addr, size_t bytes)    { }
3122 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3123 bool os::numa_topology_changed()                       { return false; }
3124 size_t os::numa_get_groups_num()                       { return numa_node_list_holder.get_count(); }
3125 int os::numa_get_group_id()                            { return 0; }
3126 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3127   // check for size bigger than actual groups_num
3128   size = MIN2(size, numa_get_groups_num());
3129   for (int i = 0; i < size; i++) {
3130     ids[i] = numa_node_list_holder.get_node_list_entry(i);
3131   }
3132   return size;
3133 }
3134 
3135 bool os::get_page_info(char *start, page_info* info) {
3136   return false;
3137 }
3138 
3139 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3140   return end;
3141 }
3142 
3143 char* os::non_memory_address_word() {
3144   // Must never look like an address returned by reserve_memory,
3145   // even in its subfields (as defined by the CPU immediate fields,
3146   // if the CPU splits constants across multiple instructions).
3147   return (char*)-1;
3148 }
3149 
3150 #define MAX_ERROR_COUNT 100
3151 #define SYS_THREAD_ERROR 0xffffffffUL
3152 
3153 void os::pd_start_thread(Thread* thread) {
3154   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3155   // Returns previous suspend state:
3156   // 0:  Thread was not suspended
3157   // 1:  Thread is running now
3158   // >1: Thread is still suspended.
3159   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3160 }
3161 
3162 class HighResolutionInterval {
3163   // The default timer resolution seems to be 10 milliseconds.
3164   // (Where is this written down?)
3165   // If someone wants to sleep for only a fraction of the default,
3166   // then we set the timer resolution down to 1 millisecond for
3167   // the duration of their interval.
3168   // We carefully set the resolution back, since otherwise we
3169   // seem to incur an overhead (3%?) that we don't need.
3170   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3171   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3172   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3173   // timeBeginPeriod() if the relative error exceeded some threshold.
3174   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3175   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3176   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3177   // resolution timers running.
3178 private:
3179     jlong resolution;
3180 public:
3181   HighResolutionInterval(jlong ms) {
3182     resolution = ms % 10L;
3183     if (resolution != 0) {
3184       MMRESULT result = timeBeginPeriod(1L);
3185     }
3186   }
3187   ~HighResolutionInterval() {
3188     if (resolution != 0) {
3189       MMRESULT result = timeEndPeriod(1L);
3190     }
3191     resolution = 0L;
3192   }
3193 };
3194 
3195 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3196   jlong limit = (jlong) MAXDWORD;
3197 
3198   while(ms > limit) {
3199     int res;
3200     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3201       return res;
3202     ms -= limit;
3203   }
3204 
3205   assert(thread == Thread::current(),  "thread consistency check");
3206   OSThread* osthread = thread->osthread();
3207   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3208   int result;
3209   if (interruptable) {
3210     assert(thread->is_Java_thread(), "must be java thread");
3211     JavaThread *jt = (JavaThread *) thread;
3212     ThreadBlockInVM tbivm(jt);
3213 
3214     jt->set_suspend_equivalent();
3215     // cleared by handle_special_suspend_equivalent_condition() or
3216     // java_suspend_self() via check_and_wait_while_suspended()
3217 
3218     HANDLE events[1];
3219     events[0] = osthread->interrupt_event();
3220     HighResolutionInterval *phri=NULL;
3221     if(!ForceTimeHighResolution)
3222       phri = new HighResolutionInterval( ms );
3223     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3224       result = OS_TIMEOUT;
3225     } else {
3226       ResetEvent(osthread->interrupt_event());
3227       osthread->set_interrupted(false);
3228       result = OS_INTRPT;
3229     }
3230     delete phri; //if it is NULL, harmless
3231 
3232     // were we externally suspended while we were waiting?
3233     jt->check_and_wait_while_suspended();
3234   } else {
3235     assert(!thread->is_Java_thread(), "must not be java thread");
3236     Sleep((long) ms);
3237     result = OS_TIMEOUT;
3238   }
3239   return result;
3240 }
3241 
3242 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3243 void os::infinite_sleep() {
3244   while (true) {    // sleep forever ...
3245     Sleep(100000);  // ... 100 seconds at a time
3246   }
3247 }
3248 
3249 typedef BOOL (WINAPI * STTSignature)(void) ;
3250 
3251 os::YieldResult os::NakedYield() {
3252   // Use either SwitchToThread() or Sleep(0)
3253   // Consider passing back the return value from SwitchToThread().
3254   if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3255     return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3256   } else {
3257     Sleep(0);
3258   }
3259   return os::YIELD_UNKNOWN ;
3260 }
3261 
3262 void os::yield() {  os::NakedYield(); }
3263 
3264 void os::yield_all(int attempts) {
3265   // Yields to all threads, including threads with lower priorities
3266   Sleep(1);
3267 }
3268 
3269 // Win32 only gives you access to seven real priorities at a time,
3270 // so we compress Java's ten down to seven.  It would be better
3271 // if we dynamically adjusted relative priorities.
3272 
3273 int os::java_to_os_priority[MaxPriority + 1] = {
3274   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3275   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3276   THREAD_PRIORITY_LOWEST,                       // 2
3277   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3278   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3279   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3280   THREAD_PRIORITY_NORMAL,                       // 6
3281   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3282   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3283   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3284   THREAD_PRIORITY_HIGHEST                       // 10 MaxPriority
3285 };
3286 
3287 int prio_policy1[MaxPriority + 1] = {
3288   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3289   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3290   THREAD_PRIORITY_LOWEST,                       // 2
3291   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3292   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3293   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3294   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3295   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3296   THREAD_PRIORITY_HIGHEST,                      // 8
3297   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3298   THREAD_PRIORITY_TIME_CRITICAL                 // 10 MaxPriority
3299 };
3300 
3301 static int prio_init() {
3302   // If ThreadPriorityPolicy is 1, switch tables
3303   if (ThreadPriorityPolicy == 1) {
3304     int i;
3305     for (i = 0; i < MaxPriority + 1; i++) {
3306       os::java_to_os_priority[i] = prio_policy1[i];
3307     }
3308   }
3309   return 0;
3310 }
3311 
3312 OSReturn os::set_native_priority(Thread* thread, int priority) {
3313   if (!UseThreadPriorities) return OS_OK;
3314   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3315   return ret ? OS_OK : OS_ERR;
3316 }
3317 
3318 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3319   if ( !UseThreadPriorities ) {
3320     *priority_ptr = java_to_os_priority[NormPriority];
3321     return OS_OK;
3322   }
3323   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3324   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3325     assert(false, "GetThreadPriority failed");
3326     return OS_ERR;
3327   }
3328   *priority_ptr = os_prio;
3329   return OS_OK;
3330 }
3331 
3332 
3333 // Hint to the underlying OS that a task switch would not be good.
3334 // Void return because it's a hint and can fail.
3335 void os::hint_no_preempt() {}
3336 
3337 void os::interrupt(Thread* thread) {
3338   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3339          "possibility of dangling Thread pointer");
3340 
3341   OSThread* osthread = thread->osthread();
3342   osthread->set_interrupted(true);
3343   // More than one thread can get here with the same value of osthread,
3344   // resulting in multiple notifications.  We do, however, want the store
3345   // to interrupted() to be visible to other threads before we post
3346   // the interrupt event.
3347   OrderAccess::release();
3348   SetEvent(osthread->interrupt_event());
3349   // For JSR166:  unpark after setting status
3350   if (thread->is_Java_thread())
3351     ((JavaThread*)thread)->parker()->unpark();
3352 
3353   ParkEvent * ev = thread->_ParkEvent ;
3354   if (ev != NULL) ev->unpark() ;
3355 
3356 }
3357 
3358 
3359 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3360   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3361          "possibility of dangling Thread pointer");
3362 
3363   OSThread* osthread = thread->osthread();
3364   bool interrupted = osthread->interrupted();
3365   // There is no synchronization between the setting of the interrupt
3366   // and it being cleared here. It is critical - see 6535709 - that
3367   // we only clear the interrupt state, and reset the interrupt event,
3368   // if we are going to report that we were indeed interrupted - else
3369   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3370   // depending on the timing
3371   if (interrupted && clear_interrupted) {
3372     osthread->set_interrupted(false);
3373     ResetEvent(osthread->interrupt_event());
3374   } // Otherwise leave the interrupted state alone
3375 
3376   return interrupted;
3377 }
3378 
3379 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3380 ExtendedPC os::get_thread_pc(Thread* thread) {
3381   CONTEXT context;
3382   context.ContextFlags = CONTEXT_CONTROL;
3383   HANDLE handle = thread->osthread()->thread_handle();
3384 #ifdef _M_IA64
3385   assert(0, "Fix get_thread_pc");
3386   return ExtendedPC(NULL);
3387 #else
3388   if (GetThreadContext(handle, &context)) {
3389 #ifdef _M_AMD64
3390     return ExtendedPC((address) context.Rip);
3391 #else
3392     return ExtendedPC((address) context.Eip);
3393 #endif
3394   } else {
3395     return ExtendedPC(NULL);
3396   }
3397 #endif
3398 }
3399 
3400 // GetCurrentThreadId() returns DWORD
3401 intx os::current_thread_id()          { return GetCurrentThreadId(); }
3402 
3403 static int _initial_pid = 0;
3404 
3405 int os::current_process_id()
3406 {
3407   return (_initial_pid ? _initial_pid : _getpid());
3408 }
3409 
3410 int    os::win32::_vm_page_size       = 0;
3411 int    os::win32::_vm_allocation_granularity = 0;
3412 int    os::win32::_processor_type     = 0;
3413 // Processor level is not available on non-NT systems, use vm_version instead
3414 int    os::win32::_processor_level    = 0;
3415 julong os::win32::_physical_memory    = 0;
3416 size_t os::win32::_default_stack_size = 0;
3417 
3418          intx os::win32::_os_thread_limit    = 0;
3419 volatile intx os::win32::_os_thread_count    = 0;
3420 
3421 bool   os::win32::_is_nt              = false;
3422 bool   os::win32::_is_windows_2003    = false;
3423 bool   os::win32::_is_windows_server  = false;
3424 
3425 void os::win32::initialize_system_info() {
3426   SYSTEM_INFO si;
3427   GetSystemInfo(&si);
3428   _vm_page_size    = si.dwPageSize;
3429   _vm_allocation_granularity = si.dwAllocationGranularity;
3430   _processor_type  = si.dwProcessorType;
3431   _processor_level = si.wProcessorLevel;
3432   set_processor_count(si.dwNumberOfProcessors);
3433 
3434   MEMORYSTATUSEX ms;
3435   ms.dwLength = sizeof(ms);
3436 
3437   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3438   // dwMemoryLoad (% of memory in use)
3439   GlobalMemoryStatusEx(&ms);
3440   _physical_memory = ms.ullTotalPhys;
3441 
3442   OSVERSIONINFOEX oi;
3443   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3444   GetVersionEx((OSVERSIONINFO*)&oi);
3445   switch(oi.dwPlatformId) {
3446     case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3447     case VER_PLATFORM_WIN32_NT:
3448       _is_nt = true;
3449       {
3450         int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3451         if (os_vers == 5002) {
3452           _is_windows_2003 = true;
3453         }
3454         if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3455           oi.wProductType == VER_NT_SERVER) {
3456             _is_windows_server = true;
3457         }
3458       }
3459       break;
3460     default: fatal("Unknown platform");
3461   }
3462 
3463   _default_stack_size = os::current_stack_size();
3464   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3465   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3466     "stack size not a multiple of page size");
3467 
3468   initialize_performance_counter();
3469 
3470   // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3471   // known to deadlock the system, if the VM issues to thread operations with
3472   // a too high frequency, e.g., such as changing the priorities.
3473   // The 6000 seems to work well - no deadlocks has been notices on the test
3474   // programs that we have seen experience this problem.
3475   if (!os::win32::is_nt()) {
3476     StarvationMonitorInterval = 6000;
3477   }
3478 }
3479 
3480 
3481 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3482   char path[MAX_PATH];
3483   DWORD size;
3484   DWORD pathLen = (DWORD)sizeof(path);
3485   HINSTANCE result = NULL;
3486 
3487   // only allow library name without path component
3488   assert(strchr(name, '\\') == NULL, "path not allowed");
3489   assert(strchr(name, ':') == NULL, "path not allowed");
3490   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3491     jio_snprintf(ebuf, ebuflen,
3492       "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3493     return NULL;
3494   }
3495 
3496   // search system directory
3497   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3498     strcat(path, "\\");
3499     strcat(path, name);
3500     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3501       return result;
3502     }
3503   }
3504 
3505   // try Windows directory
3506   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3507     strcat(path, "\\");
3508     strcat(path, name);
3509     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3510       return result;
3511     }
3512   }
3513 
3514   jio_snprintf(ebuf, ebuflen,
3515     "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3516   return NULL;
3517 }
3518 
3519 void os::win32::setmode_streams() {
3520   _setmode(_fileno(stdin), _O_BINARY);
3521   _setmode(_fileno(stdout), _O_BINARY);
3522   _setmode(_fileno(stderr), _O_BINARY);
3523 }
3524 
3525 
3526 bool os::is_debugger_attached() {
3527   return IsDebuggerPresent() ? true : false;
3528 }
3529 
3530 
3531 void os::wait_for_keypress_at_exit(void) {
3532   if (PauseAtExit) {
3533     fprintf(stderr, "Press any key to continue...\n");
3534     fgetc(stdin);
3535   }
3536 }
3537 
3538 
3539 int os::message_box(const char* title, const char* message) {
3540   int result = MessageBox(NULL, message, title,
3541                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3542   return result == IDYES;
3543 }
3544 
3545 int os::allocate_thread_local_storage() {
3546   return TlsAlloc();
3547 }
3548 
3549 
3550 void os::free_thread_local_storage(int index) {
3551   TlsFree(index);
3552 }
3553 
3554 
3555 void os::thread_local_storage_at_put(int index, void* value) {
3556   TlsSetValue(index, value);
3557   assert(thread_local_storage_at(index) == value, "Just checking");
3558 }
3559 
3560 
3561 void* os::thread_local_storage_at(int index) {
3562   return TlsGetValue(index);
3563 }
3564 
3565 
3566 #ifndef PRODUCT
3567 #ifndef _WIN64
3568 // Helpers to check whether NX protection is enabled
3569 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3570   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3571       pex->ExceptionRecord->NumberParameters > 0 &&
3572       pex->ExceptionRecord->ExceptionInformation[0] ==
3573       EXCEPTION_INFO_EXEC_VIOLATION) {
3574     return EXCEPTION_EXECUTE_HANDLER;
3575   }
3576   return EXCEPTION_CONTINUE_SEARCH;
3577 }
3578 
3579 void nx_check_protection() {
3580   // If NX is enabled we'll get an exception calling into code on the stack
3581   char code[] = { (char)0xC3 }; // ret
3582   void *code_ptr = (void *)code;
3583   __try {
3584     __asm call code_ptr
3585   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3586     tty->print_raw_cr("NX protection detected.");
3587   }
3588 }
3589 #endif // _WIN64
3590 #endif // PRODUCT
3591 
3592 // this is called _before_ the global arguments have been parsed
3593 void os::init(void) {
3594   _initial_pid = _getpid();
3595 
3596   init_random(1234567);
3597 
3598   win32::initialize_system_info();
3599   win32::setmode_streams();
3600   init_page_sizes((size_t) win32::vm_page_size());
3601 
3602   // For better scalability on MP systems (must be called after initialize_system_info)
3603 #ifndef PRODUCT
3604   if (is_MP()) {
3605     NoYieldsInMicrolock = true;
3606   }
3607 #endif
3608   // This may be overridden later when argument processing is done.
3609   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3610     os::win32::is_windows_2003());
3611 
3612   // Initialize main_process and main_thread
3613   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
3614  if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3615                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3616     fatal("DuplicateHandle failed\n");
3617   }
3618   main_thread_id = (int) GetCurrentThreadId();
3619 }
3620 
3621 // To install functions for atexit processing
3622 extern "C" {
3623   static void perfMemory_exit_helper() {
3624     perfMemory_exit();
3625   }
3626 }
3627 
3628 // this is called _after_ the global arguments have been parsed
3629 jint os::init_2(void) {
3630   // Allocate a single page and mark it as readable for safepoint polling
3631   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3632   guarantee( polling_page != NULL, "Reserve Failed for polling page");
3633 
3634   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3635   guarantee( return_page != NULL, "Commit Failed for polling page");
3636 
3637   os::set_polling_page( polling_page );
3638 
3639 #ifndef PRODUCT
3640   if( Verbose && PrintMiscellaneous )
3641     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3642 #endif
3643 
3644   if (!UseMembar) {
3645     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3646     guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3647 
3648     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3649     guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3650 
3651     os::set_memory_serialize_page( mem_serialize_page );
3652 
3653 #ifndef PRODUCT
3654     if(Verbose && PrintMiscellaneous)
3655       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3656 #endif
3657   }
3658 
3659   os::large_page_init();
3660 
3661   // Setup Windows Exceptions
3662 
3663   // On Itanium systems, Structured Exception Handling does not
3664   // work since stack frames must be walkable by the OS.  Since
3665   // much of our code is dynamically generated, and we do not have
3666   // proper unwind .xdata sections, the system simply exits
3667   // rather than delivering the exception.  To work around
3668   // this we use VectorExceptions instead.
3669 #ifdef _WIN64
3670   if (UseVectoredExceptions) {
3671     topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3672   }
3673 #endif
3674 
3675   // for debugging float code generation bugs
3676   if (ForceFloatExceptions) {
3677 #ifndef  _WIN64
3678     static long fp_control_word = 0;
3679     __asm { fstcw fp_control_word }
3680     // see Intel PPro Manual, Vol. 2, p 7-16
3681     const long precision = 0x20;
3682     const long underflow = 0x10;
3683     const long overflow  = 0x08;
3684     const long zero_div  = 0x04;
3685     const long denorm    = 0x02;
3686     const long invalid   = 0x01;
3687     fp_control_word |= invalid;
3688     __asm { fldcw fp_control_word }
3689 #endif
3690   }
3691 
3692   // If stack_commit_size is 0, windows will reserve the default size,
3693   // but only commit a small portion of it.
3694   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3695   size_t default_reserve_size = os::win32::default_stack_size();
3696   size_t actual_reserve_size = stack_commit_size;
3697   if (stack_commit_size < default_reserve_size) {
3698     // If stack_commit_size == 0, we want this too
3699     actual_reserve_size = default_reserve_size;
3700   }
3701 
3702   // Check minimum allowable stack size for thread creation and to initialize
3703   // the java system classes, including StackOverflowError - depends on page
3704   // size.  Add a page for compiler2 recursion in main thread.
3705   // Add in 2*BytesPerWord times page size to account for VM stack during
3706   // class initialization depending on 32 or 64 bit VM.
3707   size_t min_stack_allowed =
3708             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3709             2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3710   if (actual_reserve_size < min_stack_allowed) {
3711     tty->print_cr("\nThe stack size specified is too small, "
3712                   "Specify at least %dk",
3713                   min_stack_allowed / K);
3714     return JNI_ERR;
3715   }
3716 
3717   JavaThread::set_stack_size_at_create(stack_commit_size);
3718 
3719   // Calculate theoretical max. size of Threads to guard gainst artifical
3720   // out-of-memory situations, where all available address-space has been
3721   // reserved by thread stacks.
3722   assert(actual_reserve_size != 0, "Must have a stack");
3723 
3724   // Calculate the thread limit when we should start doing Virtual Memory
3725   // banging. Currently when the threads will have used all but 200Mb of space.
3726   //
3727   // TODO: consider performing a similar calculation for commit size instead
3728   // as reserve size, since on a 64-bit platform we'll run into that more
3729   // often than running out of virtual memory space.  We can use the
3730   // lower value of the two calculations as the os_thread_limit.
3731   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3732   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3733 
3734   // at exit methods are called in the reverse order of their registration.
3735   // there is no limit to the number of functions registered. atexit does
3736   // not set errno.
3737 
3738   if (PerfAllowAtExitRegistration) {
3739     // only register atexit functions if PerfAllowAtExitRegistration is set.
3740     // atexit functions can be delayed until process exit time, which
3741     // can be problematic for embedded VM situations. Embedded VMs should
3742     // call DestroyJavaVM() to assure that VM resources are released.
3743 
3744     // note: perfMemory_exit_helper atexit function may be removed in
3745     // the future if the appropriate cleanup code can be added to the
3746     // VM_Exit VMOperation's doit method.
3747     if (atexit(perfMemory_exit_helper) != 0) {
3748       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3749     }
3750   }
3751 
3752 #ifndef _WIN64
3753   // Print something if NX is enabled (win32 on AMD64)
3754   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3755 #endif
3756 
3757   // initialize thread priority policy
3758   prio_init();
3759 
3760   if (UseNUMAInterleaving) {
3761     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
3762     bool success = numa_interleaving_init();
3763     if (!success) UseNUMAInterleaving = false;
3764   }
3765 
3766   return JNI_OK;
3767 }
3768 
3769 void os::init_3(void) {
3770   return;
3771 }
3772 
3773 // Mark the polling page as unreadable
3774 void os::make_polling_page_unreadable(void) {
3775   DWORD old_status;
3776   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3777     fatal("Could not disable polling page");
3778 };
3779 
3780 // Mark the polling page as readable
3781 void os::make_polling_page_readable(void) {
3782   DWORD old_status;
3783   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3784     fatal("Could not enable polling page");
3785 };
3786 
3787 
3788 int os::stat(const char *path, struct stat *sbuf) {
3789   char pathbuf[MAX_PATH];
3790   if (strlen(path) > MAX_PATH - 1) {
3791     errno = ENAMETOOLONG;
3792     return -1;
3793   }
3794   os::native_path(strcpy(pathbuf, path));
3795   int ret = ::stat(pathbuf, sbuf);
3796   if (sbuf != NULL && UseUTCFileTimestamp) {
3797     // Fix for 6539723.  st_mtime returned from stat() is dependent on
3798     // the system timezone and so can return different values for the
3799     // same file if/when daylight savings time changes.  This adjustment
3800     // makes sure the same timestamp is returned regardless of the TZ.
3801     //
3802     // See:
3803     // http://msdn.microsoft.com/library/
3804     //   default.asp?url=/library/en-us/sysinfo/base/
3805     //   time_zone_information_str.asp
3806     // and
3807     // http://msdn.microsoft.com/library/default.asp?url=
3808     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
3809     //
3810     // NOTE: there is a insidious bug here:  If the timezone is changed
3811     // after the call to stat() but before 'GetTimeZoneInformation()', then
3812     // the adjustment we do here will be wrong and we'll return the wrong
3813     // value (which will likely end up creating an invalid class data
3814     // archive).  Absent a better API for this, or some time zone locking
3815     // mechanism, we'll have to live with this risk.
3816     TIME_ZONE_INFORMATION tz;
3817     DWORD tzid = GetTimeZoneInformation(&tz);
3818     int daylightBias =
3819       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
3820     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3821   }
3822   return ret;
3823 }
3824 
3825 
3826 #define FT2INT64(ft) \
3827   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3828 
3829 
3830 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3831 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3832 // of a thread.
3833 //
3834 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3835 // the fast estimate available on the platform.
3836 
3837 // current_thread_cpu_time() is not optimized for Windows yet
3838 jlong os::current_thread_cpu_time() {
3839   // return user + sys since the cost is the same
3840   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3841 }
3842 
3843 jlong os::thread_cpu_time(Thread* thread) {
3844   // consistent with what current_thread_cpu_time() returns.
3845   return os::thread_cpu_time(thread, true /* user+sys */);
3846 }
3847 
3848 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3849   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3850 }
3851 
3852 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3853   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3854   // If this function changes, os::is_thread_cpu_time_supported() should too
3855   if (os::win32::is_nt()) {
3856     FILETIME CreationTime;
3857     FILETIME ExitTime;
3858     FILETIME KernelTime;
3859     FILETIME UserTime;
3860 
3861     if ( GetThreadTimes(thread->osthread()->thread_handle(),
3862                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3863       return -1;
3864     else
3865       if (user_sys_cpu_time) {
3866         return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3867       } else {
3868         return FT2INT64(UserTime) * 100;
3869       }
3870   } else {
3871     return (jlong) timeGetTime() * 1000000;
3872   }
3873 }
3874 
3875 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3876   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3877   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3878   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3879   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3880 }
3881 
3882 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3883   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3884   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3885   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3886   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3887 }
3888 
3889 bool os::is_thread_cpu_time_supported() {
3890   // see os::thread_cpu_time
3891   if (os::win32::is_nt()) {
3892     FILETIME CreationTime;
3893     FILETIME ExitTime;
3894     FILETIME KernelTime;
3895     FILETIME UserTime;
3896 
3897     if ( GetThreadTimes(GetCurrentThread(),
3898                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3899       return false;
3900     else
3901       return true;
3902   } else {
3903     return false;
3904   }
3905 }
3906 
3907 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3908 // It does have primitives (PDH API) to get CPU usage and run queue length.
3909 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3910 // If we wanted to implement loadavg on Windows, we have a few options:
3911 //
3912 // a) Query CPU usage and run queue length and "fake" an answer by
3913 //    returning the CPU usage if it's under 100%, and the run queue
3914 //    length otherwise.  It turns out that querying is pretty slow
3915 //    on Windows, on the order of 200 microseconds on a fast machine.
3916 //    Note that on the Windows the CPU usage value is the % usage
3917 //    since the last time the API was called (and the first call
3918 //    returns 100%), so we'd have to deal with that as well.
3919 //
3920 // b) Sample the "fake" answer using a sampling thread and store
3921 //    the answer in a global variable.  The call to loadavg would
3922 //    just return the value of the global, avoiding the slow query.
3923 //
3924 // c) Sample a better answer using exponential decay to smooth the
3925 //    value.  This is basically the algorithm used by UNIX kernels.
3926 //
3927 // Note that sampling thread starvation could affect both (b) and (c).
3928 int os::loadavg(double loadavg[], int nelem) {
3929   return -1;
3930 }
3931 
3932 
3933 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3934 bool os::dont_yield() {
3935   return DontYieldALot;
3936 }
3937 
3938 // This method is a slightly reworked copy of JDK's sysOpen
3939 // from src/windows/hpi/src/sys_api_md.c
3940 
3941 int os::open(const char *path, int oflag, int mode) {
3942   char pathbuf[MAX_PATH];
3943 
3944   if (strlen(path) > MAX_PATH - 1) {
3945     errno = ENAMETOOLONG;
3946           return -1;
3947   }
3948   os::native_path(strcpy(pathbuf, path));
3949   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
3950 }
3951 
3952 // Is a (classpath) directory empty?
3953 bool os::dir_is_empty(const char* path) {
3954   WIN32_FIND_DATA fd;
3955   HANDLE f = FindFirstFile(path, &fd);
3956   if (f == INVALID_HANDLE_VALUE) {
3957     return true;
3958   }
3959   FindClose(f);
3960   return false;
3961 }
3962 
3963 // create binary file, rewriting existing file if required
3964 int os::create_binary_file(const char* path, bool rewrite_existing) {
3965   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
3966   if (!rewrite_existing) {
3967     oflags |= _O_EXCL;
3968   }
3969   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
3970 }
3971 
3972 // return current position of file pointer
3973 jlong os::current_file_offset(int fd) {
3974   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
3975 }
3976 
3977 // move file pointer to the specified offset
3978 jlong os::seek_to_file_offset(int fd, jlong offset) {
3979   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
3980 }
3981 
3982 
3983 jlong os::lseek(int fd, jlong offset, int whence) {
3984   return (jlong) ::_lseeki64(fd, offset, whence);
3985 }
3986 
3987 // This method is a slightly reworked copy of JDK's sysNativePath
3988 // from src/windows/hpi/src/path_md.c
3989 
3990 /* Convert a pathname to native format.  On win32, this involves forcing all
3991    separators to be '\\' rather than '/' (both are legal inputs, but Win95
3992    sometimes rejects '/') and removing redundant separators.  The input path is
3993    assumed to have been converted into the character encoding used by the local
3994    system.  Because this might be a double-byte encoding, care is taken to
3995    treat double-byte lead characters correctly.
3996 
3997    This procedure modifies the given path in place, as the result is never
3998    longer than the original.  There is no error return; this operation always
3999    succeeds. */
4000 char * os::native_path(char *path) {
4001   char *src = path, *dst = path, *end = path;
4002   char *colon = NULL;           /* If a drive specifier is found, this will
4003                                         point to the colon following the drive
4004                                         letter */
4005 
4006   /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4007   assert(((!::IsDBCSLeadByte('/'))
4008     && (!::IsDBCSLeadByte('\\'))
4009     && (!::IsDBCSLeadByte(':'))),
4010     "Illegal lead byte");
4011 
4012   /* Check for leading separators */
4013 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4014   while (isfilesep(*src)) {
4015     src++;
4016   }
4017 
4018   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4019     /* Remove leading separators if followed by drive specifier.  This
4020       hack is necessary to support file URLs containing drive
4021       specifiers (e.g., "file://c:/path").  As a side effect,
4022       "/c:/path" can be used as an alternative to "c:/path". */
4023     *dst++ = *src++;
4024     colon = dst;
4025     *dst++ = ':';
4026     src++;
4027   } else {
4028     src = path;
4029     if (isfilesep(src[0]) && isfilesep(src[1])) {
4030       /* UNC pathname: Retain first separator; leave src pointed at
4031          second separator so that further separators will be collapsed
4032          into the second separator.  The result will be a pathname
4033          beginning with "\\\\" followed (most likely) by a host name. */
4034       src = dst = path + 1;
4035       path[0] = '\\';     /* Force first separator to '\\' */
4036     }
4037   }
4038 
4039   end = dst;
4040 
4041   /* Remove redundant separators from remainder of path, forcing all
4042       separators to be '\\' rather than '/'. Also, single byte space
4043       characters are removed from the end of the path because those
4044       are not legal ending characters on this operating system.
4045   */
4046   while (*src != '\0') {
4047     if (isfilesep(*src)) {
4048       *dst++ = '\\'; src++;
4049       while (isfilesep(*src)) src++;
4050       if (*src == '\0') {
4051         /* Check for trailing separator */
4052         end = dst;
4053         if (colon == dst - 2) break;                      /* "z:\\" */
4054         if (dst == path + 1) break;                       /* "\\" */
4055         if (dst == path + 2 && isfilesep(path[0])) {
4056           /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4057             beginning of a UNC pathname.  Even though it is not, by
4058             itself, a valid UNC pathname, we leave it as is in order
4059             to be consistent with the path canonicalizer as well
4060             as the win32 APIs, which treat this case as an invalid
4061             UNC pathname rather than as an alias for the root
4062             directory of the current drive. */
4063           break;
4064         }
4065         end = --dst;  /* Path does not denote a root directory, so
4066                                     remove trailing separator */
4067         break;
4068       }
4069       end = dst;
4070     } else {
4071       if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4072         *dst++ = *src++;
4073         if (*src) *dst++ = *src++;
4074         end = dst;
4075       } else {         /* Copy a single-byte character */
4076         char c = *src++;
4077         *dst++ = c;
4078         /* Space is not a legal ending character */
4079         if (c != ' ') end = dst;
4080       }
4081     }
4082   }
4083 
4084   *end = '\0';
4085 
4086   /* For "z:", add "." to work around a bug in the C runtime library */
4087   if (colon == dst - 1) {
4088           path[2] = '.';
4089           path[3] = '\0';
4090   }
4091 
4092   #ifdef DEBUG
4093     jio_fprintf(stderr, "sysNativePath: %s\n", path);
4094   #endif DEBUG
4095   return path;
4096 }
4097 
4098 // This code is a copy of JDK's sysSetLength
4099 // from src/windows/hpi/src/sys_api_md.c
4100 
4101 int os::ftruncate(int fd, jlong length) {
4102   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4103   long high = (long)(length >> 32);
4104   DWORD ret;
4105 
4106   if (h == (HANDLE)(-1)) {
4107     return -1;
4108   }
4109 
4110   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4111   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4112       return -1;
4113   }
4114 
4115   if (::SetEndOfFile(h) == FALSE) {
4116     return -1;
4117   }
4118 
4119   return 0;
4120 }
4121 
4122 
4123 // This code is a copy of JDK's sysSync
4124 // from src/windows/hpi/src/sys_api_md.c
4125 // except for the legacy workaround for a bug in Win 98
4126 
4127 int os::fsync(int fd) {
4128   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4129 
4130   if ( (!::FlushFileBuffers(handle)) &&
4131          (GetLastError() != ERROR_ACCESS_DENIED) ) {
4132     /* from winerror.h */
4133     return -1;
4134   }
4135   return 0;
4136 }
4137 
4138 static int nonSeekAvailable(int, long *);
4139 static int stdinAvailable(int, long *);
4140 
4141 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4142 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4143 
4144 // This code is a copy of JDK's sysAvailable
4145 // from src/windows/hpi/src/sys_api_md.c
4146 
4147 int os::available(int fd, jlong *bytes) {
4148   jlong cur, end;
4149   struct _stati64 stbuf64;
4150 
4151   if (::_fstati64(fd, &stbuf64) >= 0) {
4152     int mode = stbuf64.st_mode;
4153     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4154       int ret;
4155       long lpbytes;
4156       if (fd == 0) {
4157         ret = stdinAvailable(fd, &lpbytes);
4158       } else {
4159         ret = nonSeekAvailable(fd, &lpbytes);
4160       }
4161       (*bytes) = (jlong)(lpbytes);
4162       return ret;
4163     }
4164     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4165       return FALSE;
4166     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4167       return FALSE;
4168     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4169       return FALSE;
4170     }
4171     *bytes = end - cur;
4172     return TRUE;
4173   } else {
4174     return FALSE;
4175   }
4176 }
4177 
4178 // This code is a copy of JDK's nonSeekAvailable
4179 // from src/windows/hpi/src/sys_api_md.c
4180 
4181 static int nonSeekAvailable(int fd, long *pbytes) {
4182   /* This is used for available on non-seekable devices
4183     * (like both named and anonymous pipes, such as pipes
4184     *  connected to an exec'd process).
4185     * Standard Input is a special case.
4186     *
4187     */
4188   HANDLE han;
4189 
4190   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4191     return FALSE;
4192   }
4193 
4194   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4195         /* PeekNamedPipe fails when at EOF.  In that case we
4196          * simply make *pbytes = 0 which is consistent with the
4197          * behavior we get on Solaris when an fd is at EOF.
4198          * The only alternative is to raise an Exception,
4199          * which isn't really warranted.
4200          */
4201     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4202       return FALSE;
4203     }
4204     *pbytes = 0;
4205   }
4206   return TRUE;
4207 }
4208 
4209 #define MAX_INPUT_EVENTS 2000
4210 
4211 // This code is a copy of JDK's stdinAvailable
4212 // from src/windows/hpi/src/sys_api_md.c
4213 
4214 static int stdinAvailable(int fd, long *pbytes) {
4215   HANDLE han;
4216   DWORD numEventsRead = 0;      /* Number of events read from buffer */
4217   DWORD numEvents = 0;  /* Number of events in buffer */
4218   DWORD i = 0;          /* Loop index */
4219   DWORD curLength = 0;  /* Position marker */
4220   DWORD actualLength = 0;       /* Number of bytes readable */
4221   BOOL error = FALSE;         /* Error holder */
4222   INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
4223 
4224   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4225         return FALSE;
4226   }
4227 
4228   /* Construct an array of input records in the console buffer */
4229   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4230   if (error == 0) {
4231     return nonSeekAvailable(fd, pbytes);
4232   }
4233 
4234   /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4235   if (numEvents > MAX_INPUT_EVENTS) {
4236     numEvents = MAX_INPUT_EVENTS;
4237   }
4238 
4239   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD));
4240   if (lpBuffer == NULL) {
4241     return FALSE;
4242   }
4243 
4244   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4245   if (error == 0) {
4246     os::free(lpBuffer);
4247     return FALSE;
4248   }
4249 
4250   /* Examine input records for the number of bytes available */
4251   for(i=0; i<numEvents; i++) {
4252     if (lpBuffer[i].EventType == KEY_EVENT) {
4253 
4254       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4255                                       &(lpBuffer[i].Event);
4256       if (keyRecord->bKeyDown == TRUE) {
4257         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4258         curLength++;
4259         if (*keyPressed == '\r') {
4260           actualLength = curLength;
4261         }
4262       }
4263     }
4264   }
4265 
4266   if(lpBuffer != NULL) {
4267     os::free(lpBuffer);
4268   }
4269 
4270   *pbytes = (long) actualLength;
4271   return TRUE;
4272 }
4273 
4274 // Map a block of memory.
4275 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
4276                      char *addr, size_t bytes, bool read_only,
4277                      bool allow_exec) {
4278   HANDLE hFile;
4279   char* base;
4280 
4281   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4282                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4283   if (hFile == NULL) {
4284     if (PrintMiscellaneous && Verbose) {
4285       DWORD err = GetLastError();
4286       tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4287     }
4288     return NULL;
4289   }
4290 
4291   if (allow_exec) {
4292     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4293     // unless it comes from a PE image (which the shared archive is not.)
4294     // Even VirtualProtect refuses to give execute access to mapped memory
4295     // that was not previously executable.
4296     //
4297     // Instead, stick the executable region in anonymous memory.  Yuck.
4298     // Penalty is that ~4 pages will not be shareable - in the future
4299     // we might consider DLLizing the shared archive with a proper PE
4300     // header so that mapping executable + sharing is possible.
4301 
4302     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4303                                 PAGE_READWRITE);
4304     if (base == NULL) {
4305       if (PrintMiscellaneous && Verbose) {
4306         DWORD err = GetLastError();
4307         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4308       }
4309       CloseHandle(hFile);
4310       return NULL;
4311     }
4312 
4313     DWORD bytes_read;
4314     OVERLAPPED overlapped;
4315     overlapped.Offset = (DWORD)file_offset;
4316     overlapped.OffsetHigh = 0;
4317     overlapped.hEvent = NULL;
4318     // ReadFile guarantees that if the return value is true, the requested
4319     // number of bytes were read before returning.
4320     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4321     if (!res) {
4322       if (PrintMiscellaneous && Verbose) {
4323         DWORD err = GetLastError();
4324         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4325       }
4326       release_memory(base, bytes);
4327       CloseHandle(hFile);
4328       return NULL;
4329     }
4330   } else {
4331     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4332                                     NULL /*file_name*/);
4333     if (hMap == NULL) {
4334       if (PrintMiscellaneous && Verbose) {
4335         DWORD err = GetLastError();
4336         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4337       }
4338       CloseHandle(hFile);
4339       return NULL;
4340     }
4341 
4342     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4343     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4344                                   (DWORD)bytes, addr);
4345     if (base == NULL) {
4346       if (PrintMiscellaneous && Verbose) {
4347         DWORD err = GetLastError();
4348         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4349       }
4350       CloseHandle(hMap);
4351       CloseHandle(hFile);
4352       return NULL;
4353     }
4354 
4355     if (CloseHandle(hMap) == 0) {
4356       if (PrintMiscellaneous && Verbose) {
4357         DWORD err = GetLastError();
4358         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4359       }
4360       CloseHandle(hFile);
4361       return base;
4362     }
4363   }
4364 
4365   if (allow_exec) {
4366     DWORD old_protect;
4367     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4368     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4369 
4370     if (!res) {
4371       if (PrintMiscellaneous && Verbose) {
4372         DWORD err = GetLastError();
4373         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4374       }
4375       // Don't consider this a hard error, on IA32 even if the
4376       // VirtualProtect fails, we should still be able to execute
4377       CloseHandle(hFile);
4378       return base;
4379     }
4380   }
4381 
4382   if (CloseHandle(hFile) == 0) {
4383     if (PrintMiscellaneous && Verbose) {
4384       DWORD err = GetLastError();
4385       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4386     }
4387     return base;
4388   }
4389 
4390   return base;
4391 }
4392 
4393 
4394 // Remap a block of memory.
4395 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
4396                        char *addr, size_t bytes, bool read_only,
4397                        bool allow_exec) {
4398   // This OS does not allow existing memory maps to be remapped so we
4399   // have to unmap the memory before we remap it.
4400   if (!os::unmap_memory(addr, bytes)) {
4401     return NULL;
4402   }
4403 
4404   // There is a very small theoretical window between the unmap_memory()
4405   // call above and the map_memory() call below where a thread in native
4406   // code may be able to access an address that is no longer mapped.
4407 
4408   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4409                         allow_exec);
4410 }
4411 
4412 
4413 // Unmap a block of memory.
4414 // Returns true=success, otherwise false.
4415 
4416 bool os::unmap_memory(char* addr, size_t bytes) {
4417   BOOL result = UnmapViewOfFile(addr);
4418   if (result == 0) {
4419     if (PrintMiscellaneous && Verbose) {
4420       DWORD err = GetLastError();
4421       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4422     }
4423     return false;
4424   }
4425   return true;
4426 }
4427 
4428 void os::pause() {
4429   char filename[MAX_PATH];
4430   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4431     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4432   } else {
4433     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4434   }
4435 
4436   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4437   if (fd != -1) {
4438     struct stat buf;
4439     ::close(fd);
4440     while (::stat(filename, &buf) == 0) {
4441       Sleep(100);
4442     }
4443   } else {
4444     jio_fprintf(stderr,
4445       "Could not open pause file '%s', continuing immediately.\n", filename);
4446   }
4447 }
4448 
4449 // An Event wraps a win32 "CreateEvent" kernel handle.
4450 //
4451 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4452 //
4453 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4454 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
4455 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4456 //     In addition, an unpark() operation might fetch the handle field, but the
4457 //     event could recycle between the fetch and the SetEvent() operation.
4458 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
4459 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
4460 //     on an stale but recycled handle would be harmless, but in practice this might
4461 //     confuse other non-Sun code, so it's not a viable approach.
4462 //
4463 // 2:  Once a win32 event handle is associated with an Event, it remains associated
4464 //     with the Event.  The event handle is never closed.  This could be construed
4465 //     as handle leakage, but only up to the maximum # of threads that have been extant
4466 //     at any one time.  This shouldn't be an issue, as windows platforms typically
4467 //     permit a process to have hundreds of thousands of open handles.
4468 //
4469 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4470 //     and release unused handles.
4471 //
4472 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4473 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
4474 //
4475 // 5.  Use an RCU-like mechanism (Read-Copy Update).
4476 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
4477 //
4478 // We use (2).
4479 //
4480 // TODO-FIXME:
4481 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4482 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4483 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
4484 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4485 //     into a single win32 CreateEvent() handle.
4486 //
4487 // _Event transitions in park()
4488 //   -1 => -1 : illegal
4489 //    1 =>  0 : pass - return immediately
4490 //    0 => -1 : block
4491 //
4492 // _Event serves as a restricted-range semaphore :
4493 //    -1 : thread is blocked
4494 //     0 : neutral  - thread is running or ready
4495 //     1 : signaled - thread is running or ready
4496 //
4497 // Another possible encoding of _Event would be
4498 // with explicit "PARKED" and "SIGNALED" bits.
4499 
4500 int os::PlatformEvent::park (jlong Millis) {
4501     guarantee (_ParkHandle != NULL , "Invariant") ;
4502     guarantee (Millis > 0          , "Invariant") ;
4503     int v ;
4504 
4505     // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4506     // the initial park() operation.
4507 
4508     for (;;) {
4509         v = _Event ;
4510         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4511     }
4512     guarantee ((v == 0) || (v == 1), "invariant") ;
4513     if (v != 0) return OS_OK ;
4514 
4515     // Do this the hard way by blocking ...
4516     // TODO: consider a brief spin here, gated on the success of recent
4517     // spin attempts by this thread.
4518     //
4519     // We decompose long timeouts into series of shorter timed waits.
4520     // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4521     // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
4522     // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4523     // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
4524     // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4525     // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
4526     // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4527     // for the already waited time.  This policy does not admit any new outcomes.
4528     // In the future, however, we might want to track the accumulated wait time and
4529     // adjust Millis accordingly if we encounter a spurious wakeup.
4530 
4531     const int MAXTIMEOUT = 0x10000000 ;
4532     DWORD rv = WAIT_TIMEOUT ;
4533     while (_Event < 0 && Millis > 0) {
4534        DWORD prd = Millis ;     // set prd = MAX (Millis, MAXTIMEOUT)
4535        if (Millis > MAXTIMEOUT) {
4536           prd = MAXTIMEOUT ;
4537        }
4538        rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4539        assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4540        if (rv == WAIT_TIMEOUT) {
4541            Millis -= prd ;
4542        }
4543     }
4544     v = _Event ;
4545     _Event = 0 ;
4546     OrderAccess::fence() ;
4547     // If we encounter a nearly simultanous timeout expiry and unpark()
4548     // we return OS_OK indicating we awoke via unpark().
4549     // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4550     return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4551 }
4552 
4553 void os::PlatformEvent::park () {
4554     guarantee (_ParkHandle != NULL, "Invariant") ;
4555     // Invariant: Only the thread associated with the Event/PlatformEvent
4556     // may call park().
4557     int v ;
4558     for (;;) {
4559         v = _Event ;
4560         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4561     }
4562     guarantee ((v == 0) || (v == 1), "invariant") ;
4563     if (v != 0) return ;
4564 
4565     // Do this the hard way by blocking ...
4566     // TODO: consider a brief spin here, gated on the success of recent
4567     // spin attempts by this thread.
4568     while (_Event < 0) {
4569        DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4570        assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4571     }
4572 
4573     // Usually we'll find _Event == 0 at this point, but as
4574     // an optional optimization we clear it, just in case can
4575     // multiple unpark() operations drove _Event up to 1.
4576     _Event = 0 ;
4577     OrderAccess::fence() ;
4578     guarantee (_Event >= 0, "invariant") ;
4579 }
4580 
4581 void os::PlatformEvent::unpark() {
4582   guarantee (_ParkHandle != NULL, "Invariant") ;
4583   int v ;
4584   for (;;) {
4585       v = _Event ;      // Increment _Event if it's < 1.
4586       if (v > 0) {
4587          // If it's already signaled just return.
4588          // The LD of _Event could have reordered or be satisfied
4589          // by a read-aside from this processor's write buffer.
4590          // To avoid problems execute a barrier and then
4591          // ratify the value.  A degenerate CAS() would also work.
4592          // Viz., CAS (v+0, &_Event, v) == v).
4593          OrderAccess::fence() ;
4594          if (_Event == v) return ;
4595          continue ;
4596       }
4597       if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4598   }
4599   if (v < 0) {
4600      ::SetEvent (_ParkHandle) ;
4601   }
4602 }
4603 
4604 
4605 // JSR166
4606 // -------------------------------------------------------
4607 
4608 /*
4609  * The Windows implementation of Park is very straightforward: Basic
4610  * operations on Win32 Events turn out to have the right semantics to
4611  * use them directly. We opportunistically resuse the event inherited
4612  * from Monitor.
4613  */
4614 
4615 
4616 void Parker::park(bool isAbsolute, jlong time) {
4617   guarantee (_ParkEvent != NULL, "invariant") ;
4618   // First, demultiplex/decode time arguments
4619   if (time < 0) { // don't wait
4620     return;
4621   }
4622   else if (time == 0 && !isAbsolute) {
4623     time = INFINITE;
4624   }
4625   else if  (isAbsolute) {
4626     time -= os::javaTimeMillis(); // convert to relative time
4627     if (time <= 0) // already elapsed
4628       return;
4629   }
4630   else { // relative
4631     time /= 1000000; // Must coarsen from nanos to millis
4632     if (time == 0)   // Wait for the minimal time unit if zero
4633       time = 1;
4634   }
4635 
4636   JavaThread* thread = (JavaThread*)(Thread::current());
4637   assert(thread->is_Java_thread(), "Must be JavaThread");
4638   JavaThread *jt = (JavaThread *)thread;
4639 
4640   // Don't wait if interrupted or already triggered
4641   if (Thread::is_interrupted(thread, false) ||
4642     WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4643     ResetEvent(_ParkEvent);
4644     return;
4645   }
4646   else {
4647     ThreadBlockInVM tbivm(jt);
4648     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4649     jt->set_suspend_equivalent();
4650 
4651     WaitForSingleObject(_ParkEvent,  time);
4652     ResetEvent(_ParkEvent);
4653 
4654     // If externally suspended while waiting, re-suspend
4655     if (jt->handle_special_suspend_equivalent_condition()) {
4656       jt->java_suspend_self();
4657     }
4658   }
4659 }
4660 
4661 void Parker::unpark() {
4662   guarantee (_ParkEvent != NULL, "invariant") ;
4663   SetEvent(_ParkEvent);
4664 }
4665 
4666 // Run the specified command in a separate process. Return its exit value,
4667 // or -1 on failure (e.g. can't create a new process).
4668 int os::fork_and_exec(char* cmd) {
4669   STARTUPINFO si;
4670   PROCESS_INFORMATION pi;
4671 
4672   memset(&si, 0, sizeof(si));
4673   si.cb = sizeof(si);
4674   memset(&pi, 0, sizeof(pi));
4675   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
4676                             cmd,    // command line
4677                             NULL,   // process security attribute
4678                             NULL,   // thread security attribute
4679                             TRUE,   // inherits system handles
4680                             0,      // no creation flags
4681                             NULL,   // use parent's environment block
4682                             NULL,   // use parent's starting directory
4683                             &si,    // (in) startup information
4684                             &pi);   // (out) process information
4685 
4686   if (rslt) {
4687     // Wait until child process exits.
4688     WaitForSingleObject(pi.hProcess, INFINITE);
4689 
4690     DWORD exit_code;
4691     GetExitCodeProcess(pi.hProcess, &exit_code);
4692 
4693     // Close process and thread handles.
4694     CloseHandle(pi.hProcess);
4695     CloseHandle(pi.hThread);
4696 
4697     return (int)exit_code;
4698   } else {
4699     return -1;
4700   }
4701 }
4702 
4703 //--------------------------------------------------------------------------------------------------
4704 // Non-product code
4705 
4706 static int mallocDebugIntervalCounter = 0;
4707 static int mallocDebugCounter = 0;
4708 bool os::check_heap(bool force) {
4709   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4710   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4711     // Note: HeapValidate executes two hardware breakpoints when it finds something
4712     // wrong; at these points, eax contains the address of the offending block (I think).
4713     // To get to the exlicit error message(s) below, just continue twice.
4714     HANDLE heap = GetProcessHeap();
4715     { HeapLock(heap);
4716       PROCESS_HEAP_ENTRY phe;
4717       phe.lpData = NULL;
4718       while (HeapWalk(heap, &phe) != 0) {
4719         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4720             !HeapValidate(heap, 0, phe.lpData)) {
4721           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4722           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4723           fatal("corrupted C heap");
4724         }
4725       }
4726       int err = GetLastError();
4727       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4728         fatal(err_msg("heap walk aborted with error %d", err));
4729       }
4730       HeapUnlock(heap);
4731     }
4732     mallocDebugIntervalCounter = 0;
4733   }
4734   return true;
4735 }
4736 
4737 
4738 bool os::find(address addr, outputStream* st) {
4739   // Nothing yet
4740   return false;
4741 }
4742 
4743 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4744   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4745 
4746   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4747     JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4748     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4749     address addr = (address) exceptionRecord->ExceptionInformation[1];
4750 
4751     if (os::is_memory_serialize_page(thread, addr))
4752       return EXCEPTION_CONTINUE_EXECUTION;
4753   }
4754 
4755   return EXCEPTION_CONTINUE_SEARCH;
4756 }
4757 
4758 static int getLastErrorString(char *buf, size_t len)
4759 {
4760     long errval;
4761 
4762     if ((errval = GetLastError()) != 0)
4763     {
4764       /* DOS error */
4765       size_t n = (size_t)FormatMessage(
4766             FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
4767             NULL,
4768             errval,
4769             0,
4770             buf,
4771             (DWORD)len,
4772             NULL);
4773       if (n > 3) {
4774         /* Drop final '.', CR, LF */
4775         if (buf[n - 1] == '\n') n--;
4776         if (buf[n - 1] == '\r') n--;
4777         if (buf[n - 1] == '.') n--;
4778         buf[n] = '\0';
4779       }
4780       return (int)n;
4781     }
4782 
4783     if (errno != 0)
4784     {
4785       /* C runtime error that has no corresponding DOS error code */
4786       const char *s = strerror(errno);
4787       size_t n = strlen(s);
4788       if (n >= len) n = len - 1;
4789       strncpy(buf, s, n);
4790       buf[n] = '\0';
4791       return (int)n;
4792     }
4793     return 0;
4794 }
4795 
4796 
4797 // We don't build a headless jre for Windows
4798 bool os::is_headless_jre() { return false; }
4799 
4800 
4801 typedef CRITICAL_SECTION mutex_t;
4802 #define mutexInit(m)    InitializeCriticalSection(m)
4803 #define mutexDestroy(m) DeleteCriticalSection(m)
4804 #define mutexLock(m)    EnterCriticalSection(m)
4805 #define mutexUnlock(m)  LeaveCriticalSection(m)
4806 
4807 static bool sock_initialized = FALSE;
4808 static mutex_t sockFnTableMutex;
4809 
4810 static void initSock() {
4811   WSADATA wsadata;
4812 
4813   if (!os::WinSock2Dll::WinSock2Available()) {
4814     jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4815       ::GetLastError());
4816     return;
4817   }
4818   if (sock_initialized == TRUE) return;
4819 
4820   ::mutexInit(&sockFnTableMutex);
4821   ::mutexLock(&sockFnTableMutex);
4822   if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) {
4823       jio_fprintf(stderr, "Could not initialize Winsock\n");
4824   }
4825   sock_initialized = TRUE;
4826   ::mutexUnlock(&sockFnTableMutex);
4827 }
4828 
4829 struct hostent*  os::get_host_by_name(char* name) {
4830   if (!sock_initialized) {
4831     initSock();
4832   }
4833   if (!os::WinSock2Dll::WinSock2Available()) {
4834     return NULL;
4835   }
4836   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
4837 }
4838 
4839 
4840 int os::socket_close(int fd) {
4841   ShouldNotReachHere();
4842   return 0;
4843 }
4844 
4845 int os::socket_available(int fd, jint *pbytes) {
4846   ShouldNotReachHere();
4847   return 0;
4848 }
4849 
4850 int os::socket(int domain, int type, int protocol) {
4851   ShouldNotReachHere();
4852   return 0;
4853 }
4854 
4855 int os::listen(int fd, int count) {
4856   ShouldNotReachHere();
4857   return 0;
4858 }
4859 
4860 int os::connect(int fd, struct sockaddr *him, int len) {
4861   ShouldNotReachHere();
4862   return 0;
4863 }
4864 
4865 int os::accept(int fd, struct sockaddr *him, int *len) {
4866   ShouldNotReachHere();
4867   return 0;
4868 }
4869 
4870 int os::sendto(int fd, char *buf, int len, int flags,
4871                         struct sockaddr *to, int tolen) {
4872   ShouldNotReachHere();
4873   return 0;
4874 }
4875 
4876 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
4877                          sockaddr *from, int *fromlen) {
4878   ShouldNotReachHere();
4879   return 0;
4880 }
4881 
4882 int os::recv(int fd, char *buf, int nBytes, int flags) {
4883   ShouldNotReachHere();
4884   return 0;
4885 }
4886 
4887 int os::send(int fd, char *buf, int nBytes, int flags) {
4888   ShouldNotReachHere();
4889   return 0;
4890 }
4891 
4892 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
4893   ShouldNotReachHere();
4894   return 0;
4895 }
4896 
4897 int os::timeout(int fd, long timeout) {
4898   ShouldNotReachHere();
4899   return 0;
4900 }
4901 
4902 int os::get_host_name(char* name, int namelen) {
4903   ShouldNotReachHere();
4904   return 0;
4905 }
4906 
4907 int os::socket_shutdown(int fd, int howto) {
4908   ShouldNotReachHere();
4909   return 0;
4910 }
4911 
4912 int os::bind(int fd, struct sockaddr *him, int len) {
4913   ShouldNotReachHere();
4914   return 0;
4915 }
4916 
4917 int os::get_sock_name(int fd, struct sockaddr *him, int *len) {
4918   ShouldNotReachHere();
4919   return 0;
4920 }
4921 
4922 int os::get_sock_opt(int fd, int level, int optname,
4923                              char *optval, int* optlen) {
4924   ShouldNotReachHere();
4925   return 0;
4926 }
4927 
4928 int os::set_sock_opt(int fd, int level, int optname,
4929                              const char *optval, int optlen) {
4930   ShouldNotReachHere();
4931   return 0;
4932 }
4933 
4934 
4935 // Kernel32 API
4936 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
4937 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
4938 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
4939 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
4940 
4941 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
4942 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
4943 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
4944 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
4945 BOOL                        os::Kernel32Dll::initialized = FALSE;
4946 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
4947   assert(initialized && _GetLargePageMinimum != NULL,
4948     "GetLargePageMinimumAvailable() not yet called");
4949   return _GetLargePageMinimum();
4950 }
4951 
4952 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
4953   if (!initialized) {
4954     initialize();
4955   }
4956   return _GetLargePageMinimum != NULL;
4957 }
4958 
4959 BOOL os::Kernel32Dll::NumaCallsAvailable() {
4960   if (!initialized) {
4961     initialize();
4962   }
4963   return _VirtualAllocExNuma != NULL;
4964 }
4965 
4966 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
4967   assert(initialized && _VirtualAllocExNuma != NULL,
4968     "NUMACallsAvailable() not yet called");
4969 
4970   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
4971 }
4972 
4973 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
4974   assert(initialized && _GetNumaHighestNodeNumber != NULL,
4975     "NUMACallsAvailable() not yet called");
4976 
4977   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
4978 }
4979 
4980 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
4981   assert(initialized && _GetNumaNodeProcessorMask != NULL,
4982     "NUMACallsAvailable() not yet called");
4983 
4984   return _GetNumaNodeProcessorMask(node, proc_mask);
4985 }
4986 
4987 
4988 void os::Kernel32Dll::initializeCommon() {
4989   if (!initialized) {
4990     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
4991     assert(handle != NULL, "Just check");
4992     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
4993     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
4994     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
4995     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
4996     initialized = TRUE;
4997   }
4998 }
4999 
5000 
5001 
5002 #ifndef JDK6_OR_EARLIER
5003 
5004 void os::Kernel32Dll::initialize() {
5005   initializeCommon();
5006 }
5007 
5008 
5009 // Kernel32 API
5010 inline BOOL os::Kernel32Dll::SwitchToThread() {
5011   return ::SwitchToThread();
5012 }
5013 
5014 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5015   return true;
5016 }
5017 
5018   // Help tools
5019 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5020   return true;
5021 }
5022 
5023 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5024   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5025 }
5026 
5027 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5028   return ::Module32First(hSnapshot, lpme);
5029 }
5030 
5031 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5032   return ::Module32Next(hSnapshot, lpme);
5033 }
5034 
5035 
5036 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5037   return true;
5038 }
5039 
5040 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5041   ::GetNativeSystemInfo(lpSystemInfo);
5042 }
5043 
5044 // PSAPI API
5045 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5046   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5047 }
5048 
5049 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5050   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5051 }
5052 
5053 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5054   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5055 }
5056 
5057 inline BOOL os::PSApiDll::PSApiAvailable() {
5058   return true;
5059 }
5060 
5061 
5062 // WinSock2 API
5063 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5064   return ::WSAStartup(wVersionRequested, lpWSAData);
5065 }
5066 
5067 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5068   return ::gethostbyname(name);
5069 }
5070 
5071 inline BOOL os::WinSock2Dll::WinSock2Available() {
5072   return true;
5073 }
5074 
5075 // Advapi API
5076 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5077    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5078    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5079      return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5080        BufferLength, PreviousState, ReturnLength);
5081 }
5082 
5083 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5084   PHANDLE TokenHandle) {
5085     return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5086 }
5087 
5088 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5089   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5090 }
5091 
5092 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5093   return true;
5094 }
5095 
5096 #else
5097 // Kernel32 API
5098 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5099 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5100 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5101 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5102 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5103 
5104 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
5105 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5106 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
5107 Module32Next_Fn             os::Kernel32Dll::_Module32Next = NULL;
5108 GetNativeSystemInfo_Fn      os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5109 
5110 
5111 void os::Kernel32Dll::initialize() {
5112   if (!initialized) {
5113     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5114     assert(handle != NULL, "Just check");
5115 
5116     _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5117     _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5118       ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5119     _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5120     _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5121     _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5122     initializeCommon();  // resolve the functions that always need resolving
5123 
5124     initialized = TRUE;
5125   }
5126 }
5127 
5128 BOOL os::Kernel32Dll::SwitchToThread() {
5129   assert(initialized && _SwitchToThread != NULL,
5130     "SwitchToThreadAvailable() not yet called");
5131   return _SwitchToThread();
5132 }
5133 
5134 
5135 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5136   if (!initialized) {
5137     initialize();
5138   }
5139   return _SwitchToThread != NULL;
5140 }
5141 
5142 // Help tools
5143 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5144   if (!initialized) {
5145     initialize();
5146   }
5147   return _CreateToolhelp32Snapshot != NULL &&
5148          _Module32First != NULL &&
5149          _Module32Next != NULL;
5150 }
5151 
5152 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5153   assert(initialized && _CreateToolhelp32Snapshot != NULL,
5154     "HelpToolsAvailable() not yet called");
5155 
5156   return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5157 }
5158 
5159 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5160   assert(initialized && _Module32First != NULL,
5161     "HelpToolsAvailable() not yet called");
5162 
5163   return _Module32First(hSnapshot, lpme);
5164 }
5165 
5166 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5167   assert(initialized && _Module32Next != NULL,
5168     "HelpToolsAvailable() not yet called");
5169 
5170   return _Module32Next(hSnapshot, lpme);
5171 }
5172 
5173 
5174 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5175   if (!initialized) {
5176     initialize();
5177   }
5178   return _GetNativeSystemInfo != NULL;
5179 }
5180 
5181 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5182   assert(initialized && _GetNativeSystemInfo != NULL,
5183     "GetNativeSystemInfoAvailable() not yet called");
5184 
5185   _GetNativeSystemInfo(lpSystemInfo);
5186 }
5187 
5188 
5189 
5190 // PSAPI API
5191 
5192 
5193 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5194 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5195 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5196 
5197 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
5198 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
5199 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5200 BOOL                    os::PSApiDll::initialized = FALSE;
5201 
5202 void os::PSApiDll::initialize() {
5203   if (!initialized) {
5204     HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5205     if (handle != NULL) {
5206       _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5207         "EnumProcessModules");
5208       _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5209         "GetModuleFileNameExA");
5210       _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5211         "GetModuleInformation");
5212     }
5213     initialized = TRUE;
5214   }
5215 }
5216 
5217 
5218 
5219 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5220   assert(initialized && _EnumProcessModules != NULL,
5221     "PSApiAvailable() not yet called");
5222   return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5223 }
5224 
5225 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5226   assert(initialized && _GetModuleFileNameEx != NULL,
5227     "PSApiAvailable() not yet called");
5228   return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5229 }
5230 
5231 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5232   assert(initialized && _GetModuleInformation != NULL,
5233     "PSApiAvailable() not yet called");
5234   return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5235 }
5236 
5237 BOOL os::PSApiDll::PSApiAvailable() {
5238   if (!initialized) {
5239     initialize();
5240   }
5241   return _EnumProcessModules != NULL &&
5242     _GetModuleFileNameEx != NULL &&
5243     _GetModuleInformation != NULL;
5244 }
5245 
5246 
5247 // WinSock2 API
5248 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5249 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5250 
5251 WSAStartup_Fn    os::WinSock2Dll::_WSAStartup = NULL;
5252 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5253 BOOL             os::WinSock2Dll::initialized = FALSE;
5254 
5255 void os::WinSock2Dll::initialize() {
5256   if (!initialized) {
5257     HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5258     if (handle != NULL) {
5259       _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5260       _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5261     }
5262     initialized = TRUE;
5263   }
5264 }
5265 
5266 
5267 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5268   assert(initialized && _WSAStartup != NULL,
5269     "WinSock2Available() not yet called");
5270   return _WSAStartup(wVersionRequested, lpWSAData);
5271 }
5272 
5273 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5274   assert(initialized && _gethostbyname != NULL,
5275     "WinSock2Available() not yet called");
5276   return _gethostbyname(name);
5277 }
5278 
5279 BOOL os::WinSock2Dll::WinSock2Available() {
5280   if (!initialized) {
5281     initialize();
5282   }
5283   return _WSAStartup != NULL &&
5284     _gethostbyname != NULL;
5285 }
5286 
5287 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5288 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5289 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5290 
5291 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5292 OpenProcessToken_Fn      os::Advapi32Dll::_OpenProcessToken = NULL;
5293 LookupPrivilegeValue_Fn  os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5294 BOOL                     os::Advapi32Dll::initialized = FALSE;
5295 
5296 void os::Advapi32Dll::initialize() {
5297   if (!initialized) {
5298     HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5299     if (handle != NULL) {
5300       _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5301         "AdjustTokenPrivileges");
5302       _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5303         "OpenProcessToken");
5304       _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5305         "LookupPrivilegeValueA");
5306     }
5307     initialized = TRUE;
5308   }
5309 }
5310 
5311 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5312    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5313    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5314    assert(initialized && _AdjustTokenPrivileges != NULL,
5315      "AdvapiAvailable() not yet called");
5316    return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5317        BufferLength, PreviousState, ReturnLength);
5318 }
5319 
5320 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5321   PHANDLE TokenHandle) {
5322    assert(initialized && _OpenProcessToken != NULL,
5323      "AdvapiAvailable() not yet called");
5324     return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5325 }
5326 
5327 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5328    assert(initialized && _LookupPrivilegeValue != NULL,
5329      "AdvapiAvailable() not yet called");
5330   return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5331 }
5332 
5333 BOOL os::Advapi32Dll::AdvapiAvailable() {
5334   if (!initialized) {
5335     initialize();
5336   }
5337   return _AdjustTokenPrivileges != NULL &&
5338     _OpenProcessToken != NULL &&
5339     _LookupPrivilegeValue != NULL;
5340 }
5341 
5342 #endif
5343