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 
 136 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
 137   switch (reason) {
 138     case DLL_PROCESS_ATTACH:
 139       vm_lib_handle = hinst;
 140       if(ForceTimeHighResolution)
 141         timeBeginPeriod(1L);
 142       break;
 143     case DLL_PROCESS_DETACH:
 144       if(ForceTimeHighResolution)
 145         timeEndPeriod(1L);
 146 #ifdef _WIN64
 147       if (topLevelVectoredExceptionHandler != NULL) {
 148         RemoveVectoredExceptionHandler(topLevelVectoredExceptionHandler);
 149         topLevelVectoredExceptionHandler = NULL;
 150       }
 151 #endif
 152       break;
 153     default:
 154       break;
 155   }
 156   return true;
 157 }
 158 
 159 static inline double fileTimeAsDouble(FILETIME* time) {
 160   const double high  = (double) ((unsigned int) ~0);
 161   const double split = 10000000.0;
 162   double result = (time->dwLowDateTime / split) +
 163                    time->dwHighDateTime * (high/split);
 164   return result;
 165 }
 166 
 167 // Implementation of os
 168 
 169 bool os::getenv(const char* name, char* buffer, int len) {
 170  int result = GetEnvironmentVariable(name, buffer, len);
 171  return result > 0 && result < len;
 172 }
 173 
 174 
 175 // No setuid programs under Windows.
 176 bool os::have_special_privileges() {
 177   return false;
 178 }
 179 
 180 
 181 // This method is  a periodic task to check for misbehaving JNI applications
 182 // under CheckJNI, we can add any periodic checks here.
 183 // For Windows at the moment does nothing
 184 void os::run_periodic_checks() {
 185   return;
 186 }
 187 
 188 #ifndef _WIN64
 189 // previous UnhandledExceptionFilter, if there is one
 190 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
 191 
 192 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
 193 #endif
 194 void os::init_system_properties_values() {
 195   /* sysclasspath, java_home, dll_dir */
 196   {
 197       char *home_path;
 198       char *dll_path;
 199       char *pslash;
 200       char *bin = "\\bin";
 201       char home_dir[MAX_PATH];
 202 
 203       if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) {
 204           os::jvm_path(home_dir, sizeof(home_dir));
 205           // Found the full path to jvm[_g].dll.
 206           // Now cut the path to <java_home>/jre if we can.
 207           *(strrchr(home_dir, '\\')) = '\0';  /* get rid of \jvm.dll */
 208           pslash = strrchr(home_dir, '\\');
 209           if (pslash != NULL) {
 210               *pslash = '\0';                 /* get rid of \{client|server} */
 211               pslash = strrchr(home_dir, '\\');
 212               if (pslash != NULL)
 213                   *pslash = '\0';             /* get rid of \bin */
 214           }
 215       }
 216 
 217       home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1);
 218       if (home_path == NULL)
 219           return;
 220       strcpy(home_path, home_dir);
 221       Arguments::set_java_home(home_path);
 222 
 223       dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1);
 224       if (dll_path == NULL)
 225           return;
 226       strcpy(dll_path, home_dir);
 227       strcat(dll_path, bin);
 228       Arguments::set_dll_dir(dll_path);
 229 
 230       if (!set_boot_path('\\', ';'))
 231           return;
 232   }
 233 
 234   /* library_path */
 235   #define EXT_DIR "\\lib\\ext"
 236   #define BIN_DIR "\\bin"
 237   #define PACKAGE_DIR "\\Sun\\Java"
 238   {
 239     /* Win32 library search order (See the documentation for LoadLibrary):
 240      *
 241      * 1. The directory from which application is loaded.
 242      * 2. The system wide Java Extensions directory (Java only)
 243      * 3. System directory (GetSystemDirectory)
 244      * 4. Windows directory (GetWindowsDirectory)
 245      * 5. The PATH environment variable
 246      * 6. The current directory
 247      */
 248 
 249     char *library_path;
 250     char tmp[MAX_PATH];
 251     char *path_str = ::getenv("PATH");
 252 
 253     library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) +
 254         sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10);
 255 
 256     library_path[0] = '\0';
 257 
 258     GetModuleFileName(NULL, tmp, sizeof(tmp));
 259     *(strrchr(tmp, '\\')) = '\0';
 260     strcat(library_path, tmp);
 261 
 262     GetWindowsDirectory(tmp, sizeof(tmp));
 263     strcat(library_path, ";");
 264     strcat(library_path, tmp);
 265     strcat(library_path, PACKAGE_DIR BIN_DIR);
 266 
 267     GetSystemDirectory(tmp, sizeof(tmp));
 268     strcat(library_path, ";");
 269     strcat(library_path, tmp);
 270 
 271     GetWindowsDirectory(tmp, sizeof(tmp));
 272     strcat(library_path, ";");
 273     strcat(library_path, tmp);
 274 
 275     if (path_str) {
 276         strcat(library_path, ";");
 277         strcat(library_path, path_str);
 278     }
 279 
 280     strcat(library_path, ";.");
 281 
 282     Arguments::set_library_path(library_path);
 283     FREE_C_HEAP_ARRAY(char, library_path);
 284   }
 285 
 286   /* Default extensions directory */
 287   {
 288     char path[MAX_PATH];
 289     char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1];
 290     GetWindowsDirectory(path, MAX_PATH);
 291     sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR,
 292         path, PACKAGE_DIR, EXT_DIR);
 293     Arguments::set_ext_dirs(buf);
 294   }
 295   #undef EXT_DIR
 296   #undef BIN_DIR
 297   #undef PACKAGE_DIR
 298 
 299   /* Default endorsed standards directory. */
 300   {
 301     #define ENDORSED_DIR "\\lib\\endorsed"
 302     size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR);
 303     char * buf = NEW_C_HEAP_ARRAY(char, len);
 304     sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR);
 305     Arguments::set_endorsed_dirs(buf);
 306     #undef ENDORSED_DIR
 307   }
 308 
 309 #ifndef _WIN64
 310   // set our UnhandledExceptionFilter and save any previous one
 311   prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);
 312 #endif
 313 
 314   // Done
 315   return;
 316 }
 317 
 318 void os::breakpoint() {
 319   DebugBreak();
 320 }
 321 
 322 // Invoked from the BREAKPOINT Macro
 323 extern "C" void breakpoint() {
 324   os::breakpoint();
 325 }
 326 
 327 // Returns an estimate of the current stack pointer. Result must be guaranteed
 328 // to point into the calling threads stack, and be no lower than the current
 329 // stack pointer.
 330 
 331 address os::current_stack_pointer() {
 332   int dummy;
 333   address sp = (address)&dummy;
 334   return sp;
 335 }
 336 
 337 // os::current_stack_base()
 338 //
 339 //   Returns the base of the stack, which is the stack's
 340 //   starting address.  This function must be called
 341 //   while running on the stack of the thread being queried.
 342 
 343 address os::current_stack_base() {
 344   MEMORY_BASIC_INFORMATION minfo;
 345   address stack_bottom;
 346   size_t stack_size;
 347 
 348   VirtualQuery(&minfo, &minfo, sizeof(minfo));
 349   stack_bottom =  (address)minfo.AllocationBase;
 350   stack_size = minfo.RegionSize;
 351 
 352   // Add up the sizes of all the regions with the same
 353   // AllocationBase.
 354   while( 1 )
 355   {
 356     VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));
 357     if ( stack_bottom == (address)minfo.AllocationBase )
 358       stack_size += minfo.RegionSize;
 359     else
 360       break;
 361   }
 362 
 363 #ifdef _M_IA64
 364   // IA64 has memory and register stacks
 365   stack_size = stack_size / 2;
 366 #endif
 367   return stack_bottom + stack_size;
 368 }
 369 
 370 size_t os::current_stack_size() {
 371   size_t sz;
 372   MEMORY_BASIC_INFORMATION minfo;
 373   VirtualQuery(&minfo, &minfo, sizeof(minfo));
 374   sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase;
 375   return sz;
 376 }
 377 
 378 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
 379   const struct tm* time_struct_ptr = localtime(clock);
 380   if (time_struct_ptr != NULL) {
 381     *res = *time_struct_ptr;
 382     return res;
 383   }
 384   return NULL;
 385 }
 386 
 387 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
 388 
 389 // Thread start routine for all new Java threads
 390 static unsigned __stdcall java_start(Thread* thread) {
 391   // Try to randomize the cache line index of hot stack frames.
 392   // This helps when threads of the same stack traces evict each other's
 393   // cache lines. The threads can be either from the same JVM instance, or
 394   // from different JVM instances. The benefit is especially true for
 395   // processors with hyperthreading technology.
 396   static int counter = 0;
 397   int pid = os::current_process_id();
 398   _alloca(((pid ^ counter++) & 7) * 128);
 399 
 400   OSThread* osthr = thread->osthread();
 401   assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
 402 
 403   if (UseNUMA) {
 404     int lgrp_id = os::numa_get_group_id();
 405     if (lgrp_id != -1) {
 406       thread->set_lgrp_id(lgrp_id);
 407     }
 408   }
 409 
 410 
 411   if (UseVectoredExceptions) {
 412     // If we are using vectored exception we don't need to set a SEH
 413     thread->run();
 414   }
 415   else {
 416     // Install a win32 structured exception handler around every thread created
 417     // by VM, so VM can genrate error dump when an exception occurred in non-
 418     // Java thread (e.g. VM thread).
 419     __try {
 420        thread->run();
 421     } __except(topLevelExceptionFilter(
 422                (_EXCEPTION_POINTERS*)_exception_info())) {
 423         // Nothing to do.
 424     }
 425   }
 426 
 427   // One less thread is executing
 428   // When the VMThread gets here, the main thread may have already exited
 429   // which frees the CodeHeap containing the Atomic::add code
 430   if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
 431     Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count);
 432   }
 433 
 434   return 0;
 435 }
 436 
 437 static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, int thread_id) {
 438   // Allocate the OSThread object
 439   OSThread* osthread = new OSThread(NULL, NULL);
 440   if (osthread == NULL) return NULL;
 441 
 442   // Initialize support for Java interrupts
 443   HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
 444   if (interrupt_event == NULL) {
 445     delete osthread;
 446     return NULL;
 447   }
 448   osthread->set_interrupt_event(interrupt_event);
 449 
 450   // Store info on the Win32 thread into the OSThread
 451   osthread->set_thread_handle(thread_handle);
 452   osthread->set_thread_id(thread_id);
 453 
 454   if (UseNUMA) {
 455     int lgrp_id = os::numa_get_group_id();
 456     if (lgrp_id != -1) {
 457       thread->set_lgrp_id(lgrp_id);
 458     }
 459   }
 460 
 461   // Initial thread state is INITIALIZED, not SUSPENDED
 462   osthread->set_state(INITIALIZED);
 463 
 464   return osthread;
 465 }
 466 
 467 
 468 bool os::create_attached_thread(JavaThread* thread) {
 469 #ifdef ASSERT
 470   thread->verify_not_published();
 471 #endif
 472   HANDLE thread_h;
 473   if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(),
 474                        &thread_h, THREAD_ALL_ACCESS, false, 0)) {
 475     fatal("DuplicateHandle failed\n");
 476   }
 477   OSThread* osthread = create_os_thread(thread, thread_h,
 478                                         (int)current_thread_id());
 479   if (osthread == NULL) {
 480      return false;
 481   }
 482 
 483   // Initial thread state is RUNNABLE
 484   osthread->set_state(RUNNABLE);
 485 
 486   thread->set_osthread(osthread);
 487   return true;
 488 }
 489 
 490 bool os::create_main_thread(JavaThread* thread) {
 491 #ifdef ASSERT
 492   thread->verify_not_published();
 493 #endif
 494   if (_starting_thread == NULL) {
 495     _starting_thread = create_os_thread(thread, main_thread, main_thread_id);
 496      if (_starting_thread == NULL) {
 497         return false;
 498      }
 499   }
 500 
 501   // The primordial thread is runnable from the start)
 502   _starting_thread->set_state(RUNNABLE);
 503 
 504   thread->set_osthread(_starting_thread);
 505   return true;
 506 }
 507 
 508 // Allocate and initialize a new OSThread
 509 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
 510   unsigned thread_id;
 511 
 512   // Allocate the OSThread object
 513   OSThread* osthread = new OSThread(NULL, NULL);
 514   if (osthread == NULL) {
 515     return false;
 516   }
 517 
 518   // Initialize support for Java interrupts
 519   HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
 520   if (interrupt_event == NULL) {
 521     delete osthread;
 522     return NULL;
 523   }
 524   osthread->set_interrupt_event(interrupt_event);
 525   osthread->set_interrupted(false);
 526 
 527   thread->set_osthread(osthread);
 528 
 529   if (stack_size == 0) {
 530     switch (thr_type) {
 531     case os::java_thread:
 532       // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
 533       if (JavaThread::stack_size_at_create() > 0)
 534         stack_size = JavaThread::stack_size_at_create();
 535       break;
 536     case os::compiler_thread:
 537       if (CompilerThreadStackSize > 0) {
 538         stack_size = (size_t)(CompilerThreadStackSize * K);
 539         break;
 540       } // else fall through:
 541         // use VMThreadStackSize if CompilerThreadStackSize is not defined
 542     case os::vm_thread:
 543     case os::pgc_thread:
 544     case os::cgc_thread:
 545     case os::watcher_thread:
 546       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
 547       break;
 548     }
 549   }
 550 
 551   // Create the Win32 thread
 552   //
 553   // Contrary to what MSDN document says, "stack_size" in _beginthreadex()
 554   // does not specify stack size. Instead, it specifies the size of
 555   // initially committed space. The stack size is determined by
 556   // PE header in the executable. If the committed "stack_size" is larger
 557   // than default value in the PE header, the stack is rounded up to the
 558   // nearest multiple of 1MB. For example if the launcher has default
 559   // stack size of 320k, specifying any size less than 320k does not
 560   // affect the actual stack size at all, it only affects the initial
 561   // commitment. On the other hand, specifying 'stack_size' larger than
 562   // default value may cause significant increase in memory usage, because
 563   // not only the stack space will be rounded up to MB, but also the
 564   // entire space is committed upfront.
 565   //
 566   // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION'
 567   // for CreateThread() that can treat 'stack_size' as stack size. However we
 568   // are not supposed to call CreateThread() directly according to MSDN
 569   // document because JVM uses C runtime library. The good news is that the
 570   // flag appears to work with _beginthredex() as well.
 571 
 572 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
 573 #define STACK_SIZE_PARAM_IS_A_RESERVATION  (0x10000)
 574 #endif
 575 
 576   HANDLE thread_handle =
 577     (HANDLE)_beginthreadex(NULL,
 578                            (unsigned)stack_size,
 579                            (unsigned (__stdcall *)(void*)) java_start,
 580                            thread,
 581                            CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION,
 582                            &thread_id);
 583   if (thread_handle == NULL) {
 584     // perhaps STACK_SIZE_PARAM_IS_A_RESERVATION is not supported, try again
 585     // without the flag.
 586     thread_handle =
 587     (HANDLE)_beginthreadex(NULL,
 588                            (unsigned)stack_size,
 589                            (unsigned (__stdcall *)(void*)) java_start,
 590                            thread,
 591                            CREATE_SUSPENDED,
 592                            &thread_id);
 593   }
 594   if (thread_handle == NULL) {
 595     // Need to clean up stuff we've allocated so far
 596     CloseHandle(osthread->interrupt_event());
 597     thread->set_osthread(NULL);
 598     delete osthread;
 599     return NULL;
 600   }
 601 
 602   Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
 603 
 604   // Store info on the Win32 thread into the OSThread
 605   osthread->set_thread_handle(thread_handle);
 606   osthread->set_thread_id(thread_id);
 607 
 608   // Initial thread state is INITIALIZED, not SUSPENDED
 609   osthread->set_state(INITIALIZED);
 610 
 611   // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
 612   return true;
 613 }
 614 
 615 
 616 // Free Win32 resources related to the OSThread
 617 void os::free_thread(OSThread* osthread) {
 618   assert(osthread != NULL, "osthread not set");
 619   CloseHandle(osthread->thread_handle());
 620   CloseHandle(osthread->interrupt_event());
 621   delete osthread;
 622 }
 623 
 624 
 625 static int    has_performance_count = 0;
 626 static jlong first_filetime;
 627 static jlong initial_performance_count;
 628 static jlong performance_frequency;
 629 
 630 
 631 jlong as_long(LARGE_INTEGER x) {
 632   jlong result = 0; // initialization to avoid warning
 633   set_high(&result, x.HighPart);
 634   set_low(&result,  x.LowPart);
 635   return result;
 636 }
 637 
 638 
 639 jlong os::elapsed_counter() {
 640   LARGE_INTEGER count;
 641   if (has_performance_count) {
 642     QueryPerformanceCounter(&count);
 643     return as_long(count) - initial_performance_count;
 644   } else {
 645     FILETIME wt;
 646     GetSystemTimeAsFileTime(&wt);
 647     return (jlong_from(wt.dwHighDateTime, wt.dwLowDateTime) - first_filetime);
 648   }
 649 }
 650 
 651 
 652 jlong os::elapsed_frequency() {
 653   if (has_performance_count) {
 654     return performance_frequency;
 655   } else {
 656    // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601.
 657    return 10000000;
 658   }
 659 }
 660 
 661 
 662 julong os::available_memory() {
 663   return win32::available_memory();
 664 }
 665 
 666 julong os::win32::available_memory() {
 667   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
 668   // value if total memory is larger than 4GB
 669   MEMORYSTATUSEX ms;
 670   ms.dwLength = sizeof(ms);
 671   GlobalMemoryStatusEx(&ms);
 672 
 673   return (julong)ms.ullAvailPhys;
 674 }
 675 
 676 julong os::physical_memory() {
 677   return win32::physical_memory();
 678 }
 679 
 680 julong os::allocatable_physical_memory(julong size) {
 681 #ifdef _LP64
 682   return size;
 683 #else
 684   // Limit to 1400m because of the 2gb address space wall
 685   return MIN2(size, (julong)1400*M);
 686 #endif
 687 }
 688 
 689 // VC6 lacks DWORD_PTR
 690 #if _MSC_VER < 1300
 691 typedef UINT_PTR DWORD_PTR;
 692 #endif
 693 
 694 int os::active_processor_count() {
 695   DWORD_PTR lpProcessAffinityMask = 0;
 696   DWORD_PTR lpSystemAffinityMask = 0;
 697   int proc_count = processor_count();
 698   if (proc_count <= sizeof(UINT_PTR) * BitsPerByte &&
 699       GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) {
 700     // Nof active processors is number of bits in process affinity mask
 701     int bitcount = 0;
 702     while (lpProcessAffinityMask != 0) {
 703       lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1);
 704       bitcount++;
 705     }
 706     return bitcount;
 707   } else {
 708     return proc_count;
 709   }
 710 }
 711 
 712 void os::set_native_thread_name(const char *name) {
 713   // Not yet implemented.
 714   return;
 715 }
 716 
 717 bool os::distribute_processes(uint length, uint* distribution) {
 718   // Not yet implemented.
 719   return false;
 720 }
 721 
 722 bool os::bind_to_processor(uint processor_id) {
 723   // Not yet implemented.
 724   return false;
 725 }
 726 
 727 static void initialize_performance_counter() {
 728   LARGE_INTEGER count;
 729   if (QueryPerformanceFrequency(&count)) {
 730     has_performance_count = 1;
 731     performance_frequency = as_long(count);
 732     QueryPerformanceCounter(&count);
 733     initial_performance_count = as_long(count);
 734   } else {
 735     has_performance_count = 0;
 736     FILETIME wt;
 737     GetSystemTimeAsFileTime(&wt);
 738     first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
 739   }
 740 }
 741 
 742 
 743 double os::elapsedTime() {
 744   return (double) elapsed_counter() / (double) elapsed_frequency();
 745 }
 746 
 747 
 748 // Windows format:
 749 //   The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601.
 750 // Java format:
 751 //   Java standards require the number of milliseconds since 1/1/1970
 752 
 753 // Constant offset - calculated using offset()
 754 static jlong  _offset   = 116444736000000000;
 755 // Fake time counter for reproducible results when debugging
 756 static jlong  fake_time = 0;
 757 
 758 #ifdef ASSERT
 759 // Just to be safe, recalculate the offset in debug mode
 760 static jlong _calculated_offset = 0;
 761 static int   _has_calculated_offset = 0;
 762 
 763 jlong offset() {
 764   if (_has_calculated_offset) return _calculated_offset;
 765   SYSTEMTIME java_origin;
 766   java_origin.wYear          = 1970;
 767   java_origin.wMonth         = 1;
 768   java_origin.wDayOfWeek     = 0; // ignored
 769   java_origin.wDay           = 1;
 770   java_origin.wHour          = 0;
 771   java_origin.wMinute        = 0;
 772   java_origin.wSecond        = 0;
 773   java_origin.wMilliseconds  = 0;
 774   FILETIME jot;
 775   if (!SystemTimeToFileTime(&java_origin, &jot)) {
 776     fatal(err_msg("Error = %d\nWindows error", GetLastError()));
 777   }
 778   _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime);
 779   _has_calculated_offset = 1;
 780   assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal");
 781   return _calculated_offset;
 782 }
 783 #else
 784 jlong offset() {
 785   return _offset;
 786 }
 787 #endif
 788 
 789 jlong windows_to_java_time(FILETIME wt) {
 790   jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
 791   return (a - offset()) / 10000;
 792 }
 793 
 794 FILETIME java_to_windows_time(jlong l) {
 795   jlong a = (l * 10000) + offset();
 796   FILETIME result;
 797   result.dwHighDateTime = high(a);
 798   result.dwLowDateTime  = low(a);
 799   return result;
 800 }
 801 
 802 // For now, we say that Windows does not support vtime.  I have no idea
 803 // whether it can actually be made to (DLD, 9/13/05).
 804 
 805 bool os::supports_vtime() { return false; }
 806 bool os::enable_vtime() { return false; }
 807 bool os::vtime_enabled() { return false; }
 808 double os::elapsedVTime() {
 809   // better than nothing, but not much
 810   return elapsedTime();
 811 }
 812 
 813 jlong os::javaTimeMillis() {
 814   if (UseFakeTimers) {
 815     return fake_time++;
 816   } else {
 817     FILETIME wt;
 818     GetSystemTimeAsFileTime(&wt);
 819     return windows_to_java_time(wt);
 820   }
 821 }
 822 
 823 jlong os::javaTimeNanos() {
 824   if (!has_performance_count) {
 825     return javaTimeMillis() * NANOSECS_PER_MILLISEC; // the best we can do.
 826   } else {
 827     LARGE_INTEGER current_count;
 828     QueryPerformanceCounter(&current_count);
 829     double current = as_long(current_count);
 830     double freq = performance_frequency;
 831     jlong time = (jlong)((current/freq) * NANOSECS_PER_SEC);
 832     return time;
 833   }
 834 }
 835 
 836 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
 837   if (!has_performance_count) {
 838     // javaTimeMillis() doesn't have much percision,
 839     // but it is not going to wrap -- so all 64 bits
 840     info_ptr->max_value = ALL_64_BITS;
 841 
 842     // this is a wall clock timer, so may skip
 843     info_ptr->may_skip_backward = true;
 844     info_ptr->may_skip_forward = true;
 845   } else {
 846     jlong freq = performance_frequency;
 847     if (freq < NANOSECS_PER_SEC) {
 848       // the performance counter is 64 bits and we will
 849       // be multiplying it -- so no wrap in 64 bits
 850       info_ptr->max_value = ALL_64_BITS;
 851     } else if (freq > NANOSECS_PER_SEC) {
 852       // use the max value the counter can reach to
 853       // determine the max value which could be returned
 854       julong max_counter = (julong)ALL_64_BITS;
 855       info_ptr->max_value = (jlong)(max_counter / (freq / NANOSECS_PER_SEC));
 856     } else {
 857       // the performance counter is 64 bits and we will
 858       // be using it directly -- so no wrap in 64 bits
 859       info_ptr->max_value = ALL_64_BITS;
 860     }
 861 
 862     // using a counter, so no skipping
 863     info_ptr->may_skip_backward = false;
 864     info_ptr->may_skip_forward = false;
 865   }
 866   info_ptr->kind = JVMTI_TIMER_ELAPSED;                // elapsed not CPU time
 867 }
 868 
 869 char* os::local_time_string(char *buf, size_t buflen) {
 870   SYSTEMTIME st;
 871   GetLocalTime(&st);
 872   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
 873                st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
 874   return buf;
 875 }
 876 
 877 bool os::getTimesSecs(double* process_real_time,
 878                      double* process_user_time,
 879                      double* process_system_time) {
 880   HANDLE h_process = GetCurrentProcess();
 881   FILETIME create_time, exit_time, kernel_time, user_time;
 882   BOOL result = GetProcessTimes(h_process,
 883                                &create_time,
 884                                &exit_time,
 885                                &kernel_time,
 886                                &user_time);
 887   if (result != 0) {
 888     FILETIME wt;
 889     GetSystemTimeAsFileTime(&wt);
 890     jlong rtc_millis = windows_to_java_time(wt);
 891     jlong user_millis = windows_to_java_time(user_time);
 892     jlong system_millis = windows_to_java_time(kernel_time);
 893     *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS);
 894     *process_user_time = ((double) user_millis) / ((double) MILLIUNITS);
 895     *process_system_time = ((double) system_millis) / ((double) MILLIUNITS);
 896     return true;
 897   } else {
 898     return false;
 899   }
 900 }
 901 
 902 void os::shutdown() {
 903 
 904   // allow PerfMemory to attempt cleanup of any persistent resources
 905   perfMemory_exit();
 906 
 907   // flush buffered output, finish log files
 908   ostream_abort();
 909 
 910   // Check for abort hook
 911   abort_hook_t abort_hook = Arguments::abort_hook();
 912   if (abort_hook != NULL) {
 913     abort_hook();
 914   }
 915 }
 916 
 917 
 918 static BOOL  (WINAPI *_MiniDumpWriteDump)  ( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
 919                                             PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION);
 920 
 921 void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) {
 922   HINSTANCE dbghelp;
 923   EXCEPTION_POINTERS ep;
 924   MINIDUMP_EXCEPTION_INFORMATION mei;
 925   MINIDUMP_EXCEPTION_INFORMATION* pmei;
 926 
 927   HANDLE hProcess = GetCurrentProcess();
 928   DWORD processId = GetCurrentProcessId();
 929   HANDLE dumpFile;
 930   MINIDUMP_TYPE dumpType;
 931   static const char* cwd;
 932 
 933   // If running on a client version of Windows and user has not explicitly enabled dumping
 934   if (!os::win32::is_windows_server() && !CreateMinidumpOnCrash) {
 935     VMError::report_coredump_status("Minidumps are not enabled by default on client versions of Windows", false);
 936     return;
 937     // If running on a server version of Windows and user has explictly disabled dumping
 938   } else if (os::win32::is_windows_server() && !FLAG_IS_DEFAULT(CreateMinidumpOnCrash) && !CreateMinidumpOnCrash) {
 939     VMError::report_coredump_status("Minidump has been disabled from the command line", false);
 940     return;
 941   }
 942 
 943   dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0);
 944 
 945   if (dbghelp == NULL) {
 946     VMError::report_coredump_status("Failed to load dbghelp.dll", false);
 947     return;
 948   }
 949 
 950   _MiniDumpWriteDump = CAST_TO_FN_PTR(
 951     BOOL(WINAPI *)( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
 952     PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION),
 953     GetProcAddress(dbghelp, "MiniDumpWriteDump"));
 954 
 955   if (_MiniDumpWriteDump == NULL) {
 956     VMError::report_coredump_status("Failed to find MiniDumpWriteDump() in module dbghelp.dll", false);
 957     return;
 958   }
 959 
 960   dumpType = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | MiniDumpWithHandleData);
 961 
 962 // Older versions of dbghelp.h doesn't contain all the dumptypes we want, dbghelp.h with
 963 // API_VERSION_NUMBER 11 or higher contains the ones we want though
 964 #if API_VERSION_NUMBER >= 11
 965   dumpType = (MINIDUMP_TYPE)(dumpType | MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo |
 966     MiniDumpWithUnloadedModules);
 967 #endif
 968 
 969   cwd = get_current_directory(NULL, 0);
 970   jio_snprintf(buffer, bufferSize, "%s\\hs_err_pid%u.mdmp",cwd, current_process_id());
 971   dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 972 
 973   if (dumpFile == INVALID_HANDLE_VALUE) {
 974     VMError::report_coredump_status("Failed to create file for dumping", false);
 975     return;
 976   }
 977   if (exceptionRecord != NULL && contextRecord != NULL) {
 978     ep.ContextRecord = (PCONTEXT) contextRecord;
 979     ep.ExceptionRecord = (PEXCEPTION_RECORD) exceptionRecord;
 980 
 981     mei.ThreadId = GetCurrentThreadId();
 982     mei.ExceptionPointers = &ep;
 983     pmei = &mei;
 984   } else {
 985     pmei = NULL;
 986   }
 987 
 988 
 989   // Older versions of dbghelp.dll (the one shipped with Win2003 for example) may not support all
 990   // the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then.
 991   if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false &&
 992       _MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) {
 993     VMError::report_coredump_status("Call to MiniDumpWriteDump() failed", false);
 994   } else {
 995     VMError::report_coredump_status(buffer, true);
 996   }
 997 
 998   CloseHandle(dumpFile);
 999 }
1000 
1001 
1002 
1003 void os::abort(bool dump_core)
1004 {
1005   os::shutdown();
1006   // no core dump on Windows
1007   ::exit(1);
1008 }
1009 
1010 // Die immediately, no exit hook, no abort hook, no cleanup.
1011 void os::die() {
1012   _exit(-1);
1013 }
1014 
1015 // Directory routines copied from src/win32/native/java/io/dirent_md.c
1016 //  * dirent_md.c       1.15 00/02/02
1017 //
1018 // The declarations for DIR and struct dirent are in jvm_win32.h.
1019 
1020 /* Caller must have already run dirname through JVM_NativePath, which removes
1021    duplicate slashes and converts all instances of '/' into '\\'. */
1022 
1023 DIR *
1024 os::opendir(const char *dirname)
1025 {
1026     assert(dirname != NULL, "just checking");   // hotspot change
1027     DIR *dirp = (DIR *)malloc(sizeof(DIR));
1028     DWORD fattr;                                // hotspot change
1029     char alt_dirname[4] = { 0, 0, 0, 0 };
1030 
1031     if (dirp == 0) {
1032         errno = ENOMEM;
1033         return 0;
1034     }
1035 
1036     /*
1037      * Win32 accepts "\" in its POSIX stat(), but refuses to treat it
1038      * as a directory in FindFirstFile().  We detect this case here and
1039      * prepend the current drive name.
1040      */
1041     if (dirname[1] == '\0' && dirname[0] == '\\') {
1042         alt_dirname[0] = _getdrive() + 'A' - 1;
1043         alt_dirname[1] = ':';
1044         alt_dirname[2] = '\\';
1045         alt_dirname[3] = '\0';
1046         dirname = alt_dirname;
1047     }
1048 
1049     dirp->path = (char *)malloc(strlen(dirname) + 5);
1050     if (dirp->path == 0) {
1051         free(dirp);
1052         errno = ENOMEM;
1053         return 0;
1054     }
1055     strcpy(dirp->path, dirname);
1056 
1057     fattr = GetFileAttributes(dirp->path);
1058     if (fattr == 0xffffffff) {
1059         free(dirp->path);
1060         free(dirp);
1061         errno = ENOENT;
1062         return 0;
1063     } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
1064         free(dirp->path);
1065         free(dirp);
1066         errno = ENOTDIR;
1067         return 0;
1068     }
1069 
1070     /* Append "*.*", or possibly "\\*.*", to path */
1071     if (dirp->path[1] == ':'
1072         && (dirp->path[2] == '\0'
1073             || (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
1074         /* No '\\' needed for cases like "Z:" or "Z:\" */
1075         strcat(dirp->path, "*.*");
1076     } else {
1077         strcat(dirp->path, "\\*.*");
1078     }
1079 
1080     dirp->handle = FindFirstFile(dirp->path, &dirp->find_data);
1081     if (dirp->handle == INVALID_HANDLE_VALUE) {
1082         if (GetLastError() != ERROR_FILE_NOT_FOUND) {
1083             free(dirp->path);
1084             free(dirp);
1085             errno = EACCES;
1086             return 0;
1087         }
1088     }
1089     return dirp;
1090 }
1091 
1092 /* parameter dbuf unused on Windows */
1093 
1094 struct dirent *
1095 os::readdir(DIR *dirp, dirent *dbuf)
1096 {
1097     assert(dirp != NULL, "just checking");      // hotspot change
1098     if (dirp->handle == INVALID_HANDLE_VALUE) {
1099         return 0;
1100     }
1101 
1102     strcpy(dirp->dirent.d_name, dirp->find_data.cFileName);
1103 
1104     if (!FindNextFile(dirp->handle, &dirp->find_data)) {
1105         if (GetLastError() == ERROR_INVALID_HANDLE) {
1106             errno = EBADF;
1107             return 0;
1108         }
1109         FindClose(dirp->handle);
1110         dirp->handle = INVALID_HANDLE_VALUE;
1111     }
1112 
1113     return &dirp->dirent;
1114 }
1115 
1116 int
1117 os::closedir(DIR *dirp)
1118 {
1119     assert(dirp != NULL, "just checking");      // hotspot change
1120     if (dirp->handle != INVALID_HANDLE_VALUE) {
1121         if (!FindClose(dirp->handle)) {
1122             errno = EBADF;
1123             return -1;
1124         }
1125         dirp->handle = INVALID_HANDLE_VALUE;
1126     }
1127     free(dirp->path);
1128     free(dirp);
1129     return 0;
1130 }
1131 
1132 // This must be hard coded because it's the system's temporary
1133 // directory not the java application's temp directory, ala java.io.tmpdir.
1134 const char* os::get_temp_directory() {
1135   static char path_buf[MAX_PATH];
1136   if (GetTempPath(MAX_PATH, path_buf)>0)
1137     return path_buf;
1138   else{
1139     path_buf[0]='\0';
1140     return path_buf;
1141   }
1142 }
1143 
1144 static bool file_exists(const char* filename) {
1145   if (filename == NULL || strlen(filename) == 0) {
1146     return false;
1147   }
1148   return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
1149 }
1150 
1151 void os::dll_build_name(char *buffer, size_t buflen,
1152                         const char* pname, const char* fname) {
1153   const size_t pnamelen = pname ? strlen(pname) : 0;
1154   const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
1155 
1156   // Quietly truncates on buffer overflow. Should be an error.
1157   if (pnamelen + strlen(fname) + 10 > buflen) {
1158     *buffer = '\0';
1159     return;
1160   }
1161 
1162   if (pnamelen == 0) {
1163     jio_snprintf(buffer, buflen, "%s.dll", fname);
1164   } else if (c == ':' || c == '\\') {
1165     jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname);
1166   } else if (strchr(pname, *os::path_separator()) != NULL) {
1167     int n;
1168     char** pelements = split_path(pname, &n);
1169     for (int i = 0 ; i < n ; i++) {
1170       char* path = pelements[i];
1171       // Really shouldn't be NULL, but check can't hurt
1172       size_t plen = (path == NULL) ? 0 : strlen(path);
1173       if (plen == 0) {
1174         continue; // skip the empty path values
1175       }
1176       const char lastchar = path[plen - 1];
1177       if (lastchar == ':' || lastchar == '\\') {
1178         jio_snprintf(buffer, buflen, "%s%s.dll", path, fname);
1179       } else {
1180         jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname);
1181       }
1182       if (file_exists(buffer)) {
1183         break;
1184       }
1185     }
1186     // release the storage
1187     for (int i = 0 ; i < n ; i++) {
1188       if (pelements[i] != NULL) {
1189         FREE_C_HEAP_ARRAY(char, pelements[i]);
1190       }
1191     }
1192     if (pelements != NULL) {
1193       FREE_C_HEAP_ARRAY(char*, pelements);
1194     }
1195   } else {
1196     jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname);
1197   }
1198 }
1199 
1200 // Needs to be in os specific directory because windows requires another
1201 // header file <direct.h>
1202 const char* os::get_current_directory(char *buf, int buflen) {
1203   return _getcwd(buf, buflen);
1204 }
1205 
1206 //-----------------------------------------------------------
1207 // Helper functions for fatal error handler
1208 #ifdef _WIN64
1209 // Helper routine which returns true if address in
1210 // within the NTDLL address space.
1211 //
1212 static bool _addr_in_ntdll( address addr )
1213 {
1214   HMODULE hmod;
1215   MODULEINFO minfo;
1216 
1217   hmod = GetModuleHandle("NTDLL.DLL");
1218   if ( hmod == NULL ) return false;
1219   if ( !os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
1220                                &minfo, sizeof(MODULEINFO)) )
1221     return false;
1222 
1223   if ( (addr >= minfo.lpBaseOfDll) &&
1224        (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
1225     return true;
1226   else
1227     return false;
1228 }
1229 #endif
1230 
1231 
1232 // Enumerate all modules for a given process ID
1233 //
1234 // Notice that Windows 95/98/Me and Windows NT/2000/XP have
1235 // different API for doing this. We use PSAPI.DLL on NT based
1236 // Windows and ToolHelp on 95/98/Me.
1237 
1238 // Callback function that is called by enumerate_modules() on
1239 // every DLL module.
1240 // Input parameters:
1241 //    int       pid,
1242 //    char*     module_file_name,
1243 //    address   module_base_addr,
1244 //    unsigned  module_size,
1245 //    void*     param
1246 typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
1247 
1248 // enumerate_modules for Windows NT, using PSAPI
1249 static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
1250 {
1251   HANDLE   hProcess ;
1252 
1253 # define MAX_NUM_MODULES 128
1254   HMODULE     modules[MAX_NUM_MODULES];
1255   static char filename[ MAX_PATH ];
1256   int         result = 0;
1257 
1258   if (!os::PSApiDll::PSApiAvailable()) {
1259     return 0;
1260   }
1261 
1262   hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1263                          FALSE, pid ) ;
1264   if (hProcess == NULL) return 0;
1265 
1266   DWORD size_needed;
1267   if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
1268                            sizeof(modules), &size_needed)) {
1269       CloseHandle( hProcess );
1270       return 0;
1271   }
1272 
1273   // number of modules that are currently loaded
1274   int num_modules = size_needed / sizeof(HMODULE);
1275 
1276   for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1277     // Get Full pathname:
1278     if(!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
1279                              filename, sizeof(filename))) {
1280         filename[0] = '\0';
1281     }
1282 
1283     MODULEINFO modinfo;
1284     if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i],
1285                                &modinfo, sizeof(modinfo))) {
1286         modinfo.lpBaseOfDll = NULL;
1287         modinfo.SizeOfImage = 0;
1288     }
1289 
1290     // Invoke callback function
1291     result = func(pid, filename, (address)modinfo.lpBaseOfDll,
1292                   modinfo.SizeOfImage, param);
1293     if (result) break;
1294   }
1295 
1296   CloseHandle( hProcess ) ;
1297   return result;
1298 }
1299 
1300 
1301 // enumerate_modules for Windows 95/98/ME, using TOOLHELP
1302 static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
1303 {
1304   HANDLE                hSnapShot ;
1305   static MODULEENTRY32  modentry ;
1306   int                   result = 0;
1307 
1308   if (!os::Kernel32Dll::HelpToolsAvailable()) {
1309     return 0;
1310   }
1311 
1312   // Get a handle to a Toolhelp snapshot of the system
1313   hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ;
1314   if( hSnapShot == INVALID_HANDLE_VALUE ) {
1315       return FALSE ;
1316   }
1317 
1318   // iterate through all modules
1319   modentry.dwSize = sizeof(MODULEENTRY32) ;
1320   bool not_done = os::Kernel32Dll::Module32First( hSnapShot, &modentry ) != 0;
1321 
1322   while( not_done ) {
1323     // invoke the callback
1324     result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
1325                 modentry.modBaseSize, param);
1326     if (result) break;
1327 
1328     modentry.dwSize = sizeof(MODULEENTRY32) ;
1329     not_done = os::Kernel32Dll::Module32Next( hSnapShot, &modentry ) != 0;
1330   }
1331 
1332   CloseHandle(hSnapShot);
1333   return result;
1334 }
1335 
1336 int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param )
1337 {
1338   // Get current process ID if caller doesn't provide it.
1339   if (!pid) pid = os::current_process_id();
1340 
1341   if (os::win32::is_nt()) return _enumerate_modules_winnt  (pid, func, param);
1342   else                    return _enumerate_modules_windows(pid, func, param);
1343 }
1344 
1345 struct _modinfo {
1346    address addr;
1347    char*   full_path;   // point to a char buffer
1348    int     buflen;      // size of the buffer
1349    address base_addr;
1350 };
1351 
1352 static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr,
1353                                   unsigned size, void * param) {
1354    struct _modinfo *pmod = (struct _modinfo *)param;
1355    if (!pmod) return -1;
1356 
1357    if (base_addr     <= pmod->addr &&
1358        base_addr+size > pmod->addr) {
1359      // if a buffer is provided, copy path name to the buffer
1360      if (pmod->full_path) {
1361        jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
1362      }
1363      pmod->base_addr = base_addr;
1364      return 1;
1365    }
1366    return 0;
1367 }
1368 
1369 bool os::dll_address_to_library_name(address addr, char* buf,
1370                                      int buflen, int* offset) {
1371 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
1372 //       return the full path to the DLL file, sometimes it returns path
1373 //       to the corresponding PDB file (debug info); sometimes it only
1374 //       returns partial path, which makes life painful.
1375 
1376    struct _modinfo mi;
1377    mi.addr      = addr;
1378    mi.full_path = buf;
1379    mi.buflen    = buflen;
1380    int pid = os::current_process_id();
1381    if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
1382       // buf already contains path name
1383       if (offset) *offset = addr - mi.base_addr;
1384       return true;
1385    } else {
1386       if (buf) buf[0] = '\0';
1387       if (offset) *offset = -1;
1388       return false;
1389    }
1390 }
1391 
1392 bool os::dll_address_to_function_name(address addr, char *buf,
1393                                       int buflen, int *offset) {
1394   if (Decoder::decode(addr, buf, buflen, offset)) {
1395     return true;
1396   }
1397   if (offset != NULL)  *offset  = -1;
1398   if (buf != NULL) buf[0] = '\0';
1399   return false;
1400 }
1401 
1402 // save the start and end address of jvm.dll into param[0] and param[1]
1403 static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
1404                     unsigned size, void * param) {
1405    if (!param) return -1;
1406 
1407    if (base_addr     <= (address)_locate_jvm_dll &&
1408        base_addr+size > (address)_locate_jvm_dll) {
1409          ((address*)param)[0] = base_addr;
1410          ((address*)param)[1] = base_addr + size;
1411          return 1;
1412    }
1413    return 0;
1414 }
1415 
1416 address vm_lib_location[2];    // start and end address of jvm.dll
1417 
1418 // check if addr is inside jvm.dll
1419 bool os::address_is_in_vm(address addr) {
1420   if (!vm_lib_location[0] || !vm_lib_location[1]) {
1421     int pid = os::current_process_id();
1422     if (!enumerate_modules(pid, _locate_jvm_dll, (void *)vm_lib_location)) {
1423       assert(false, "Can't find jvm module.");
1424       return false;
1425     }
1426   }
1427 
1428   return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]);
1429 }
1430 
1431 // print module info; param is outputStream*
1432 static int _print_module(int pid, char* fname, address base,
1433                          unsigned size, void* param) {
1434    if (!param) return -1;
1435 
1436    outputStream* st = (outputStream*)param;
1437 
1438    address end_addr = base + size;
1439    st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname);
1440    return 0;
1441 }
1442 
1443 // Loads .dll/.so and
1444 // in case of error it checks if .dll/.so was built for the
1445 // same architecture as Hotspot is running on
1446 void * os::dll_load(const char *name, char *ebuf, int ebuflen)
1447 {
1448   void * result = LoadLibrary(name);
1449   if (result != NULL)
1450   {
1451     return result;
1452   }
1453 
1454   DWORD errcode = GetLastError();
1455   if (errcode == ERROR_MOD_NOT_FOUND) {
1456     strncpy(ebuf, "Can't find dependent libraries", ebuflen-1);
1457     ebuf[ebuflen-1]='\0';
1458     return NULL;
1459   }
1460 
1461   // Parsing dll below
1462   // If we can read dll-info and find that dll was built
1463   // for an architecture other than Hotspot is running in
1464   // - then print to buffer "DLL was built for a different architecture"
1465   // else call os::lasterror to obtain system error message
1466 
1467   // Read system error message into ebuf
1468   // It may or may not be overwritten below (in the for loop and just above)
1469   lasterror(ebuf, (size_t) ebuflen);
1470   ebuf[ebuflen-1]='\0';
1471   int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0);
1472   if (file_descriptor<0)
1473   {
1474     return NULL;
1475   }
1476 
1477   uint32_t signature_offset;
1478   uint16_t lib_arch=0;
1479   bool failed_to_get_lib_arch=
1480   (
1481     //Go to position 3c in the dll
1482     (os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0)
1483     ||
1484     // Read loacation of signature
1485     (sizeof(signature_offset)!=
1486       (os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset))))
1487     ||
1488     //Go to COFF File Header in dll
1489     //that is located after"signature" (4 bytes long)
1490     (os::seek_to_file_offset(file_descriptor,
1491       signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0)
1492     ||
1493     //Read field that contains code of architecture
1494     // that dll was build for
1495     (sizeof(lib_arch)!=
1496       (os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch))))
1497   );
1498 
1499   ::close(file_descriptor);
1500   if (failed_to_get_lib_arch)
1501   {
1502     // file i/o error - report os::lasterror(...) msg
1503     return NULL;
1504   }
1505 
1506   typedef struct
1507   {
1508     uint16_t arch_code;
1509     char* arch_name;
1510   } arch_t;
1511 
1512   static const arch_t arch_array[]={
1513     {IMAGE_FILE_MACHINE_I386,      (char*)"IA 32"},
1514     {IMAGE_FILE_MACHINE_AMD64,     (char*)"AMD 64"},
1515     {IMAGE_FILE_MACHINE_IA64,      (char*)"IA 64"}
1516   };
1517   #if   (defined _M_IA64)
1518     static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64;
1519   #elif (defined _M_AMD64)
1520     static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64;
1521   #elif (defined _M_IX86)
1522     static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386;
1523   #else
1524     #error Method os::dll_load requires that one of following \
1525            is defined :_M_IA64,_M_AMD64 or _M_IX86
1526   #endif
1527 
1528 
1529   // Obtain a string for printf operation
1530   // lib_arch_str shall contain string what platform this .dll was built for
1531   // running_arch_str shall string contain what platform Hotspot was built for
1532   char *running_arch_str=NULL,*lib_arch_str=NULL;
1533   for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++)
1534   {
1535     if (lib_arch==arch_array[i].arch_code)
1536       lib_arch_str=arch_array[i].arch_name;
1537     if (running_arch==arch_array[i].arch_code)
1538       running_arch_str=arch_array[i].arch_name;
1539   }
1540 
1541   assert(running_arch_str,
1542     "Didn't find runing architecture code in arch_array");
1543 
1544   // If the architure is right
1545   // but some other error took place - report os::lasterror(...) msg
1546   if (lib_arch == running_arch)
1547   {
1548     return NULL;
1549   }
1550 
1551   if (lib_arch_str!=NULL)
1552   {
1553     ::_snprintf(ebuf, ebuflen-1,
1554       "Can't load %s-bit .dll on a %s-bit platform",
1555       lib_arch_str,running_arch_str);
1556   }
1557   else
1558   {
1559     // don't know what architecture this dll was build for
1560     ::_snprintf(ebuf, ebuflen-1,
1561       "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
1562       lib_arch,running_arch_str);
1563   }
1564 
1565   return NULL;
1566 }
1567 
1568 
1569 void os::print_dll_info(outputStream *st) {
1570    int pid = os::current_process_id();
1571    st->print_cr("Dynamic libraries:");
1572    enumerate_modules(pid, _print_module, (void *)st);
1573 }
1574 
1575 void os::print_os_info(outputStream* st) {
1576   st->print("OS:");
1577 
1578   OSVERSIONINFOEX osvi;
1579   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1580   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1581 
1582   if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1583     st->print_cr("N/A");
1584     return;
1585   }
1586 
1587   int os_vers = osvi.dwMajorVersion * 1000 + osvi.dwMinorVersion;
1588   if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1589     switch (os_vers) {
1590     case 3051: st->print(" Windows NT 3.51"); break;
1591     case 4000: st->print(" Windows NT 4.0"); break;
1592     case 5000: st->print(" Windows 2000"); break;
1593     case 5001: st->print(" Windows XP"); break;
1594     case 5002:
1595     case 6000:
1596     case 6001: {
1597       // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1598       // find out whether we are running on 64 bit processor or not.
1599       SYSTEM_INFO si;
1600       ZeroMemory(&si, sizeof(SYSTEM_INFO));
1601         if (!os::Kernel32Dll::GetNativeSystemInfoAvailable()){
1602           GetSystemInfo(&si);
1603       } else {
1604         os::Kernel32Dll::GetNativeSystemInfo(&si);
1605       }
1606       if (os_vers == 5002) {
1607         if (osvi.wProductType == VER_NT_WORKSTATION &&
1608             si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1609           st->print(" Windows XP x64 Edition");
1610         else
1611             st->print(" Windows Server 2003 family");
1612       } else if (os_vers == 6000) {
1613         if (osvi.wProductType == VER_NT_WORKSTATION)
1614             st->print(" Windows Vista");
1615         else
1616             st->print(" Windows Server 2008");
1617         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1618             st->print(" , 64 bit");
1619       } else if (os_vers == 6001) {
1620         if (osvi.wProductType == VER_NT_WORKSTATION) {
1621             st->print(" Windows 7");
1622         } else {
1623             // Unrecognized windows, print out its major and minor versions
1624             st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1625         }
1626         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1627             st->print(" , 64 bit");
1628       } else { // future os
1629         // Unrecognized windows, print out its major and minor versions
1630         st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1631         if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1632             st->print(" , 64 bit");
1633       }
1634       break;
1635     }
1636     default: // future windows, print out its major and minor versions
1637       st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1638     }
1639   } else {
1640     switch (os_vers) {
1641     case 4000: st->print(" Windows 95"); break;
1642     case 4010: st->print(" Windows 98"); break;
1643     case 4090: st->print(" Windows Me"); break;
1644     default: // future windows, print out its major and minor versions
1645       st->print(" Windows %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1646     }
1647   }
1648   st->print(" Build %d", osvi.dwBuildNumber);
1649   st->print(" %s", osvi.szCSDVersion);           // service pack
1650   st->cr();
1651 }
1652 
1653 void os::pd_print_cpu_info(outputStream* st) {
1654   // Nothing to do for now.
1655 }
1656 
1657 void os::print_memory_info(outputStream* st) {
1658   st->print("Memory:");
1659   st->print(" %dk page", os::vm_page_size()>>10);
1660 
1661   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1662   // value if total memory is larger than 4GB
1663   MEMORYSTATUSEX ms;
1664   ms.dwLength = sizeof(ms);
1665   GlobalMemoryStatusEx(&ms);
1666 
1667   st->print(", physical %uk", os::physical_memory() >> 10);
1668   st->print("(%uk free)", os::available_memory() >> 10);
1669 
1670   st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1671   st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1672   st->cr();
1673 }
1674 
1675 void os::print_siginfo(outputStream *st, void *siginfo) {
1676   EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo;
1677   st->print("siginfo:");
1678   st->print(" ExceptionCode=0x%x", er->ExceptionCode);
1679 
1680   if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1681       er->NumberParameters >= 2) {
1682       switch (er->ExceptionInformation[0]) {
1683       case 0: st->print(", reading address"); break;
1684       case 1: st->print(", writing address"); break;
1685       default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1686                             er->ExceptionInformation[0]);
1687       }
1688       st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1689   } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
1690              er->NumberParameters >= 2 && UseSharedSpaces) {
1691     FileMapInfo* mapinfo = FileMapInfo::current_info();
1692     if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) {
1693       st->print("\n\nError accessing class data sharing archive."       \
1694                 " Mapped file inaccessible during execution, "          \
1695                 " possible disk/network problem.");
1696     }
1697   } else {
1698     int num = er->NumberParameters;
1699     if (num > 0) {
1700       st->print(", ExceptionInformation=");
1701       for (int i = 0; i < num; i++) {
1702         st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1703       }
1704     }
1705   }
1706   st->cr();
1707 }
1708 
1709 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1710   // do nothing
1711 }
1712 
1713 static char saved_jvm_path[MAX_PATH] = {0};
1714 
1715 // Find the full path to the current module, jvm.dll or jvm_g.dll
1716 void os::jvm_path(char *buf, jint buflen) {
1717   // Error checking.
1718   if (buflen < MAX_PATH) {
1719     assert(false, "must use a large-enough buffer");
1720     buf[0] = '\0';
1721     return;
1722   }
1723   // Lazy resolve the path to current module.
1724   if (saved_jvm_path[0] != 0) {
1725     strcpy(buf, saved_jvm_path);
1726     return;
1727   }
1728 
1729   buf[0] = '\0';
1730   if (Arguments::created_by_gamma_launcher()) {
1731      // Support for the gamma launcher. Check for an
1732      // JAVA_HOME environment variable
1733      // and fix up the path so it looks like
1734      // libjvm.so is installed there (append a fake suffix
1735      // hotspot/libjvm.so).
1736      char* java_home_var = ::getenv("JAVA_HOME");
1737      if (java_home_var != NULL && java_home_var[0] != 0) {
1738 
1739         strncpy(buf, java_home_var, buflen);
1740 
1741         // determine if this is a legacy image or modules image
1742         // modules image doesn't have "jre" subdirectory
1743         size_t len = strlen(buf);
1744         char* jrebin_p = buf + len;
1745         jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1746         if (0 != _access(buf, 0)) {
1747           jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1748         }
1749         len = strlen(buf);
1750         jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1751      }
1752   }
1753 
1754   if(buf[0] == '\0') {
1755   GetModuleFileName(vm_lib_handle, buf, buflen);
1756   }
1757   strcpy(saved_jvm_path, buf);
1758 }
1759 
1760 
1761 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1762 #ifndef _WIN64
1763   st->print("_");
1764 #endif
1765 }
1766 
1767 
1768 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1769 #ifndef _WIN64
1770   st->print("@%d", args_size  * sizeof(int));
1771 #endif
1772 }
1773 
1774 // This method is a copy of JDK's sysGetLastErrorString
1775 // from src/windows/hpi/src/system_md.c
1776 
1777 size_t os::lasterror(char* buf, size_t len) {
1778   DWORD errval;
1779 
1780   if ((errval = GetLastError()) != 0) {
1781     // DOS error
1782     size_t n = (size_t)FormatMessage(
1783           FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1784           NULL,
1785           errval,
1786           0,
1787           buf,
1788           (DWORD)len,
1789           NULL);
1790     if (n > 3) {
1791       // Drop final '.', CR, LF
1792       if (buf[n - 1] == '\n') n--;
1793       if (buf[n - 1] == '\r') n--;
1794       if (buf[n - 1] == '.') n--;
1795       buf[n] = '\0';
1796     }
1797     return n;
1798   }
1799 
1800   if (errno != 0) {
1801     // C runtime error that has no corresponding DOS error code
1802     const char* s = strerror(errno);
1803     size_t n = strlen(s);
1804     if (n >= len) n = len - 1;
1805     strncpy(buf, s, n);
1806     buf[n] = '\0';
1807     return n;
1808   }
1809 
1810   return 0;
1811 }
1812 
1813 int os::get_last_error() {
1814   DWORD error = GetLastError();
1815   if (error == 0)
1816     error = errno;
1817   return (int)error;
1818 }
1819 
1820 // sun.misc.Signal
1821 // NOTE that this is a workaround for an apparent kernel bug where if
1822 // a signal handler for SIGBREAK is installed then that signal handler
1823 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1824 // See bug 4416763.
1825 static void (*sigbreakHandler)(int) = NULL;
1826 
1827 static void UserHandler(int sig, void *siginfo, void *context) {
1828   os::signal_notify(sig);
1829   // We need to reinstate the signal handler each time...
1830   os::signal(sig, (void*)UserHandler);
1831 }
1832 
1833 void* os::user_handler() {
1834   return (void*) UserHandler;
1835 }
1836 
1837 void* os::signal(int signal_number, void* handler) {
1838   if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1839     void (*oldHandler)(int) = sigbreakHandler;
1840     sigbreakHandler = (void (*)(int)) handler;
1841     return (void*) oldHandler;
1842   } else {
1843     return (void*)::signal(signal_number, (void (*)(int))handler);
1844   }
1845 }
1846 
1847 void os::signal_raise(int signal_number) {
1848   raise(signal_number);
1849 }
1850 
1851 // The Win32 C runtime library maps all console control events other than ^C
1852 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1853 // logoff, and shutdown events.  We therefore install our own console handler
1854 // that raises SIGTERM for the latter cases.
1855 //
1856 static BOOL WINAPI consoleHandler(DWORD event) {
1857   switch(event) {
1858     case CTRL_C_EVENT:
1859       if (is_error_reported()) {
1860         // Ctrl-C is pressed during error reporting, likely because the error
1861         // handler fails to abort. Let VM die immediately.
1862         os::die();
1863       }
1864 
1865       os::signal_raise(SIGINT);
1866       return TRUE;
1867       break;
1868     case CTRL_BREAK_EVENT:
1869       if (sigbreakHandler != NULL) {
1870         (*sigbreakHandler)(SIGBREAK);
1871       }
1872       return TRUE;
1873       break;
1874     case CTRL_CLOSE_EVENT:
1875     case CTRL_LOGOFF_EVENT:
1876     case CTRL_SHUTDOWN_EVENT:
1877       os::signal_raise(SIGTERM);
1878       return TRUE;
1879       break;
1880     default:
1881       break;
1882   }
1883   return FALSE;
1884 }
1885 
1886 /*
1887  * The following code is moved from os.cpp for making this
1888  * code platform specific, which it is by its very nature.
1889  */
1890 
1891 // Return maximum OS signal used + 1 for internal use only
1892 // Used as exit signal for signal_thread
1893 int os::sigexitnum_pd(){
1894   return NSIG;
1895 }
1896 
1897 // a counter for each possible signal value, including signal_thread exit signal
1898 static volatile jint pending_signals[NSIG+1] = { 0 };
1899 static HANDLE sig_sem;
1900 
1901 void os::signal_init_pd() {
1902   // Initialize signal structures
1903   memset((void*)pending_signals, 0, sizeof(pending_signals));
1904 
1905   sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
1906 
1907   // Programs embedding the VM do not want it to attempt to receive
1908   // events like CTRL_LOGOFF_EVENT, which are used to implement the
1909   // shutdown hooks mechanism introduced in 1.3.  For example, when
1910   // the VM is run as part of a Windows NT service (i.e., a servlet
1911   // engine in a web server), the correct behavior is for any console
1912   // control handler to return FALSE, not TRUE, because the OS's
1913   // "final" handler for such events allows the process to continue if
1914   // it is a service (while terminating it if it is not a service).
1915   // To make this behavior uniform and the mechanism simpler, we
1916   // completely disable the VM's usage of these console events if -Xrs
1917   // (=ReduceSignalUsage) is specified.  This means, for example, that
1918   // the CTRL-BREAK thread dump mechanism is also disabled in this
1919   // case.  See bugs 4323062, 4345157, and related bugs.
1920 
1921   if (!ReduceSignalUsage) {
1922     // Add a CTRL-C handler
1923     SetConsoleCtrlHandler(consoleHandler, TRUE);
1924   }
1925 }
1926 
1927 void os::signal_notify(int signal_number) {
1928   BOOL ret;
1929 
1930   Atomic::inc(&pending_signals[signal_number]);
1931   ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1932   assert(ret != 0, "ReleaseSemaphore() failed");
1933 }
1934 
1935 static int check_pending_signals(bool wait_for_signal) {
1936   DWORD ret;
1937   while (true) {
1938     for (int i = 0; i < NSIG + 1; i++) {
1939       jint n = pending_signals[i];
1940       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1941         return i;
1942       }
1943     }
1944     if (!wait_for_signal) {
1945       return -1;
1946     }
1947 
1948     JavaThread *thread = JavaThread::current();
1949 
1950     ThreadBlockInVM tbivm(thread);
1951 
1952     bool threadIsSuspended;
1953     do {
1954       thread->set_suspend_equivalent();
1955       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1956       ret = ::WaitForSingleObject(sig_sem, INFINITE);
1957       assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
1958 
1959       // were we externally suspended while we were waiting?
1960       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1961       if (threadIsSuspended) {
1962         //
1963         // The semaphore has been incremented, but while we were waiting
1964         // another thread suspended us. We don't want to continue running
1965         // while suspended because that would surprise the thread that
1966         // suspended us.
1967         //
1968         ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1969         assert(ret != 0, "ReleaseSemaphore() failed");
1970 
1971         thread->java_suspend_self();
1972       }
1973     } while (threadIsSuspended);
1974   }
1975 }
1976 
1977 int os::signal_lookup() {
1978   return check_pending_signals(false);
1979 }
1980 
1981 int os::signal_wait() {
1982   return check_pending_signals(true);
1983 }
1984 
1985 // Implicit OS exception handling
1986 
1987 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
1988   JavaThread* thread = JavaThread::current();
1989   // Save pc in thread
1990 #ifdef _M_IA64
1991   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
1992   // Set pc to handler
1993   exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
1994 #elif _M_AMD64
1995   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
1996   // Set pc to handler
1997   exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
1998 #else
1999   thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
2000   // Set pc to handler
2001   exceptionInfo->ContextRecord->Eip = (LONG)handler;
2002 #endif
2003 
2004   // Continue the execution
2005   return EXCEPTION_CONTINUE_EXECUTION;
2006 }
2007 
2008 
2009 // Used for PostMortemDump
2010 extern "C" void safepoints();
2011 extern "C" void find(int x);
2012 extern "C" void events();
2013 
2014 // According to Windows API documentation, an illegal instruction sequence should generate
2015 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2016 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2017 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2018 
2019 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2020 
2021 // From "Execution Protection in the Windows Operating System" draft 0.35
2022 // Once a system header becomes available, the "real" define should be
2023 // included or copied here.
2024 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2025 
2026 #define def_excpt(val) #val, val
2027 
2028 struct siglabel {
2029   char *name;
2030   int   number;
2031 };
2032 
2033 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2034 // C++ compiler contain this error code. Because this is a compiler-generated
2035 // error, the code is not listed in the Win32 API header files.
2036 // The code is actually a cryptic mnemonic device, with the initial "E"
2037 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2038 // ASCII values of "msc".
2039 
2040 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION    0xE06D7363
2041 
2042 
2043 struct siglabel exceptlabels[] = {
2044     def_excpt(EXCEPTION_ACCESS_VIOLATION),
2045     def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2046     def_excpt(EXCEPTION_BREAKPOINT),
2047     def_excpt(EXCEPTION_SINGLE_STEP),
2048     def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2049     def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2050     def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2051     def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2052     def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2053     def_excpt(EXCEPTION_FLT_OVERFLOW),
2054     def_excpt(EXCEPTION_FLT_STACK_CHECK),
2055     def_excpt(EXCEPTION_FLT_UNDERFLOW),
2056     def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2057     def_excpt(EXCEPTION_INT_OVERFLOW),
2058     def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2059     def_excpt(EXCEPTION_IN_PAGE_ERROR),
2060     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2061     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2062     def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2063     def_excpt(EXCEPTION_STACK_OVERFLOW),
2064     def_excpt(EXCEPTION_INVALID_DISPOSITION),
2065     def_excpt(EXCEPTION_GUARD_PAGE),
2066     def_excpt(EXCEPTION_INVALID_HANDLE),
2067     def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2068     NULL, 0
2069 };
2070 
2071 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2072   for (int i = 0; exceptlabels[i].name != NULL; i++) {
2073     if (exceptlabels[i].number == exception_code) {
2074        jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2075        return buf;
2076     }
2077   }
2078 
2079   return NULL;
2080 }
2081 
2082 //-----------------------------------------------------------------------------
2083 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2084   // handle exception caused by idiv; should only happen for -MinInt/-1
2085   // (division by zero is handled explicitly)
2086 #ifdef _M_IA64
2087   assert(0, "Fix Handle_IDiv_Exception");
2088 #elif _M_AMD64
2089   PCONTEXT ctx = exceptionInfo->ContextRecord;
2090   address pc = (address)ctx->Rip;
2091   NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2092   assert(pc[0] == 0xF7, "not an idiv opcode");
2093   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2094   assert(ctx->Rax == min_jint, "unexpected idiv exception");
2095   // set correct result values and continue after idiv instruction
2096   ctx->Rip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2097   ctx->Rax = (DWORD)min_jint;      // result
2098   ctx->Rdx = (DWORD)0;             // remainder
2099   // Continue the execution
2100 #else
2101   PCONTEXT ctx = exceptionInfo->ContextRecord;
2102   address pc = (address)ctx->Eip;
2103   NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2104   assert(pc[0] == 0xF7, "not an idiv opcode");
2105   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2106   assert(ctx->Eax == min_jint, "unexpected idiv exception");
2107   // set correct result values and continue after idiv instruction
2108   ctx->Eip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2109   ctx->Eax = (DWORD)min_jint;      // result
2110   ctx->Edx = (DWORD)0;             // remainder
2111   // Continue the execution
2112 #endif
2113   return EXCEPTION_CONTINUE_EXECUTION;
2114 }
2115 
2116 #ifndef  _WIN64
2117 //-----------------------------------------------------------------------------
2118 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2119   // handle exception caused by native method modifying control word
2120   PCONTEXT ctx = exceptionInfo->ContextRecord;
2121   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2122 
2123   switch (exception_code) {
2124     case EXCEPTION_FLT_DENORMAL_OPERAND:
2125     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2126     case EXCEPTION_FLT_INEXACT_RESULT:
2127     case EXCEPTION_FLT_INVALID_OPERATION:
2128     case EXCEPTION_FLT_OVERFLOW:
2129     case EXCEPTION_FLT_STACK_CHECK:
2130     case EXCEPTION_FLT_UNDERFLOW:
2131       jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2132       if (fp_control_word != ctx->FloatSave.ControlWord) {
2133         // Restore FPCW and mask out FLT exceptions
2134         ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2135         // Mask out pending FLT exceptions
2136         ctx->FloatSave.StatusWord &=  0xffffff00;
2137         return EXCEPTION_CONTINUE_EXECUTION;
2138       }
2139   }
2140 
2141   if (prev_uef_handler != NULL) {
2142     // We didn't handle this exception so pass it to the previous
2143     // UnhandledExceptionFilter.
2144     return (prev_uef_handler)(exceptionInfo);
2145   }
2146 
2147   return EXCEPTION_CONTINUE_SEARCH;
2148 }
2149 #else //_WIN64
2150 /*
2151   On Windows, the mxcsr control bits are non-volatile across calls
2152   See also CR 6192333
2153   If EXCEPTION_FLT_* happened after some native method modified
2154   mxcsr - it is not a jvm fault.
2155   However should we decide to restore of mxcsr after a faulty
2156   native method we can uncomment following code
2157       jint MxCsr = INITIAL_MXCSR;
2158         // we can't use StubRoutines::addr_mxcsr_std()
2159         // because in Win64 mxcsr is not saved there
2160       if (MxCsr != ctx->MxCsr) {
2161         ctx->MxCsr = MxCsr;
2162         return EXCEPTION_CONTINUE_EXECUTION;
2163       }
2164 
2165 */
2166 #endif //_WIN64
2167 
2168 
2169 // Fatal error reporting is single threaded so we can make this a
2170 // static and preallocated.  If it's more than MAX_PATH silently ignore
2171 // it.
2172 static char saved_error_file[MAX_PATH] = {0};
2173 
2174 void os::set_error_file(const char *logfile) {
2175   if (strlen(logfile) <= MAX_PATH) {
2176     strncpy(saved_error_file, logfile, MAX_PATH);
2177   }
2178 }
2179 
2180 static inline void report_error(Thread* t, DWORD exception_code,
2181                                 address addr, void* siginfo, void* context) {
2182   VMError err(t, exception_code, addr, siginfo, context);
2183   err.report_and_die();
2184 
2185   // If UseOsErrorReporting, this will return here and save the error file
2186   // somewhere where we can find it in the minidump.
2187 }
2188 
2189 //-----------------------------------------------------------------------------
2190 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2191   if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2192   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2193 #ifdef _M_IA64
2194   address pc = (address) exceptionInfo->ContextRecord->StIIP;
2195 #elif _M_AMD64
2196   address pc = (address) exceptionInfo->ContextRecord->Rip;
2197 #else
2198   address pc = (address) exceptionInfo->ContextRecord->Eip;
2199 #endif
2200   Thread* t = ThreadLocalStorage::get_thread_slow();          // slow & steady
2201 
2202 #ifndef _WIN64
2203   // Execution protection violation - win32 running on AMD64 only
2204   // Handled first to avoid misdiagnosis as a "normal" access violation;
2205   // This is safe to do because we have a new/unique ExceptionInformation
2206   // code for this condition.
2207   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2208     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2209     int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2210     address addr = (address) exceptionRecord->ExceptionInformation[1];
2211 
2212     if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2213       int page_size = os::vm_page_size();
2214 
2215       // Make sure the pc and the faulting address are sane.
2216       //
2217       // If an instruction spans a page boundary, and the page containing
2218       // the beginning of the instruction is executable but the following
2219       // page is not, the pc and the faulting address might be slightly
2220       // different - we still want to unguard the 2nd page in this case.
2221       //
2222       // 15 bytes seems to be a (very) safe value for max instruction size.
2223       bool pc_is_near_addr =
2224         (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2225       bool instr_spans_page_boundary =
2226         (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2227                          (intptr_t) page_size) > 0);
2228 
2229       if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2230         static volatile address last_addr =
2231           (address) os::non_memory_address_word();
2232 
2233         // In conservative mode, don't unguard unless the address is in the VM
2234         if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2235             (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2236 
2237           // Set memory to RWX and retry
2238           address page_start =
2239             (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2240           bool res = os::protect_memory((char*) page_start, page_size,
2241                                         os::MEM_PROT_RWX);
2242 
2243           if (PrintMiscellaneous && Verbose) {
2244             char buf[256];
2245             jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2246                          "at " INTPTR_FORMAT
2247                          ", unguarding " INTPTR_FORMAT ": %s", addr,
2248                          page_start, (res ? "success" : strerror(errno)));
2249             tty->print_raw_cr(buf);
2250           }
2251 
2252           // Set last_addr so if we fault again at the same address, we don't
2253           // end up in an endless loop.
2254           //
2255           // There are two potential complications here.  Two threads trapping
2256           // at the same address at the same time could cause one of the
2257           // threads to think it already unguarded, and abort the VM.  Likely
2258           // very rare.
2259           //
2260           // The other race involves two threads alternately trapping at
2261           // different addresses and failing to unguard the page, resulting in
2262           // an endless loop.  This condition is probably even more unlikely
2263           // than the first.
2264           //
2265           // Although both cases could be avoided by using locks or thread
2266           // local last_addr, these solutions are unnecessary complication:
2267           // this handler is a best-effort safety net, not a complete solution.
2268           // It is disabled by default and should only be used as a workaround
2269           // in case we missed any no-execute-unsafe VM code.
2270 
2271           last_addr = addr;
2272 
2273           return EXCEPTION_CONTINUE_EXECUTION;
2274         }
2275       }
2276 
2277       // Last unguard failed or not unguarding
2278       tty->print_raw_cr("Execution protection violation");
2279       report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2280                    exceptionInfo->ContextRecord);
2281       return EXCEPTION_CONTINUE_SEARCH;
2282     }
2283   }
2284 #endif // _WIN64
2285 
2286   // Check to see if we caught the safepoint code in the
2287   // process of write protecting the memory serialization page.
2288   // It write enables the page immediately after protecting it
2289   // so just return.
2290   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2291     JavaThread* thread = (JavaThread*) t;
2292     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2293     address addr = (address) exceptionRecord->ExceptionInformation[1];
2294     if ( os::is_memory_serialize_page(thread, addr) ) {
2295       // Block current thread until the memory serialize page permission restored.
2296       os::block_on_serialize_page_trap();
2297       return EXCEPTION_CONTINUE_EXECUTION;
2298     }
2299   }
2300 
2301   if (t != NULL && t->is_Java_thread()) {
2302     JavaThread* thread = (JavaThread*) t;
2303     bool in_java = thread->thread_state() == _thread_in_Java;
2304 
2305     // Handle potential stack overflows up front.
2306     if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2307       if (os::uses_stack_guard_pages()) {
2308 #ifdef _M_IA64
2309         //
2310         // If it's a legal stack address continue, Windows will map it in.
2311         //
2312         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2313         address addr = (address) exceptionRecord->ExceptionInformation[1];
2314         if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2315           return EXCEPTION_CONTINUE_EXECUTION;
2316 
2317         // The register save area is the same size as the memory stack
2318         // and starts at the page just above the start of the memory stack.
2319         // If we get a fault in this area, we've run out of register
2320         // stack.  If we are in java, try throwing a stack overflow exception.
2321         if (addr > thread->stack_base() &&
2322                       addr <= (thread->stack_base()+thread->stack_size()) ) {
2323           char buf[256];
2324           jio_snprintf(buf, sizeof(buf),
2325                        "Register stack overflow, addr:%p, stack_base:%p\n",
2326                        addr, thread->stack_base() );
2327           tty->print_raw_cr(buf);
2328           // If not in java code, return and hope for the best.
2329           return in_java ? Handle_Exception(exceptionInfo,
2330             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2331             :  EXCEPTION_CONTINUE_EXECUTION;
2332         }
2333 #endif
2334         if (thread->stack_yellow_zone_enabled()) {
2335           // Yellow zone violation.  The o/s has unprotected the first yellow
2336           // zone page for us.  Note:  must call disable_stack_yellow_zone to
2337           // update the enabled status, even if the zone contains only one page.
2338           thread->disable_stack_yellow_zone();
2339           // If not in java code, return and hope for the best.
2340           return in_java ? Handle_Exception(exceptionInfo,
2341             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2342             :  EXCEPTION_CONTINUE_EXECUTION;
2343         } else {
2344           // Fatal red zone violation.
2345           thread->disable_stack_red_zone();
2346           tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2347           report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2348                        exceptionInfo->ContextRecord);
2349           return EXCEPTION_CONTINUE_SEARCH;
2350         }
2351       } else if (in_java) {
2352         // JVM-managed guard pages cannot be used on win95/98.  The o/s provides
2353         // a one-time-only guard page, which it has released to us.  The next
2354         // stack overflow on this thread will result in an ACCESS_VIOLATION.
2355         return Handle_Exception(exceptionInfo,
2356           SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2357       } else {
2358         // Can only return and hope for the best.  Further stack growth will
2359         // result in an ACCESS_VIOLATION.
2360         return EXCEPTION_CONTINUE_EXECUTION;
2361       }
2362     } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2363       // Either stack overflow or null pointer exception.
2364       if (in_java) {
2365         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2366         address addr = (address) exceptionRecord->ExceptionInformation[1];
2367         address stack_end = thread->stack_base() - thread->stack_size();
2368         if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2369           // Stack overflow.
2370           assert(!os::uses_stack_guard_pages(),
2371             "should be caught by red zone code above.");
2372           return Handle_Exception(exceptionInfo,
2373             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2374         }
2375         //
2376         // Check for safepoint polling and implicit null
2377         // We only expect null pointers in the stubs (vtable)
2378         // the rest are checked explicitly now.
2379         //
2380         CodeBlob* cb = CodeCache::find_blob(pc);
2381         if (cb != NULL) {
2382           if (os::is_poll_address(addr)) {
2383             address stub = SharedRuntime::get_poll_stub(pc);
2384             return Handle_Exception(exceptionInfo, stub);
2385           }
2386         }
2387         {
2388 #ifdef _WIN64
2389           //
2390           // If it's a legal stack address map the entire region in
2391           //
2392           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2393           address addr = (address) exceptionRecord->ExceptionInformation[1];
2394           if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2395                   addr = (address)((uintptr_t)addr &
2396                          (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2397                   os::commit_memory((char *)addr, thread->stack_base() - addr,
2398                                     false );
2399                   return EXCEPTION_CONTINUE_EXECUTION;
2400           }
2401           else
2402 #endif
2403           {
2404             // Null pointer exception.
2405 #ifdef _M_IA64
2406             // We catch register stack overflows in compiled code by doing
2407             // an explicit compare and executing a st8(G0, G0) if the
2408             // BSP enters into our guard area.  We test for the overflow
2409             // condition and fall into the normal null pointer exception
2410             // code if BSP hasn't overflowed.
2411             if ( in_java ) {
2412               if(thread->register_stack_overflow()) {
2413                 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2414                                 thread->register_stack_limit(),
2415                                "GR7 doesn't contain register_stack_limit");
2416                 // Disable the yellow zone which sets the state that
2417                 // we've got a stack overflow problem.
2418                 if (thread->stack_yellow_zone_enabled()) {
2419                   thread->disable_stack_yellow_zone();
2420                 }
2421                 // Give us some room to process the exception
2422                 thread->disable_register_stack_guard();
2423                 // Update GR7 with the new limit so we can continue running
2424                 // compiled code.
2425                 exceptionInfo->ContextRecord->IntS3 =
2426                                (ULONGLONG)thread->register_stack_limit();
2427                 return Handle_Exception(exceptionInfo,
2428                        SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2429               } else {
2430                 //
2431                 // Check for implicit null
2432                 // We only expect null pointers in the stubs (vtable)
2433                 // the rest are checked explicitly now.
2434                 //
2435                 if (((uintptr_t)addr) < os::vm_page_size() ) {
2436                   // an access to the first page of VM--assume it is a null pointer
2437                   address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2438                   if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2439                 }
2440               }
2441             } // in_java
2442 
2443             // IA64 doesn't use implicit null checking yet. So we shouldn't
2444             // get here.
2445             tty->print_raw_cr("Access violation, possible null pointer exception");
2446             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2447                          exceptionInfo->ContextRecord);
2448             return EXCEPTION_CONTINUE_SEARCH;
2449 #else /* !IA64 */
2450 
2451             // Windows 98 reports faulting addresses incorrectly
2452             if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2453                 !os::win32::is_nt()) {
2454               address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2455               if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2456             }
2457             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2458                          exceptionInfo->ContextRecord);
2459             return EXCEPTION_CONTINUE_SEARCH;
2460 #endif
2461           }
2462         }
2463       }
2464 
2465 #ifdef _WIN64
2466       // Special care for fast JNI field accessors.
2467       // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2468       // in and the heap gets shrunk before the field access.
2469       if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2470         address addr = JNI_FastGetField::find_slowcase_pc(pc);
2471         if (addr != (address)-1) {
2472           return Handle_Exception(exceptionInfo, addr);
2473         }
2474       }
2475 #endif
2476 
2477 #ifdef _WIN64
2478       // Windows will sometimes generate an access violation
2479       // when we call malloc.  Since we use VectoredExceptions
2480       // on 64 bit platforms, we see this exception.  We must
2481       // pass this exception on so Windows can recover.
2482       // We check to see if the pc of the fault is in NTDLL.DLL
2483       // if so, we pass control on to Windows for handling.
2484       if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2485 #endif
2486 
2487       // Stack overflow or null pointer exception in native code.
2488       report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2489                    exceptionInfo->ContextRecord);
2490       return EXCEPTION_CONTINUE_SEARCH;
2491     }
2492 
2493     if (in_java) {
2494       switch (exception_code) {
2495       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2496         return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2497 
2498       case EXCEPTION_INT_OVERFLOW:
2499         return Handle_IDiv_Exception(exceptionInfo);
2500 
2501       } // switch
2502     }
2503 #ifndef _WIN64
2504     if (((thread->thread_state() == _thread_in_Java) ||
2505         (thread->thread_state() == _thread_in_native)) &&
2506         exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2507     {
2508       LONG result=Handle_FLT_Exception(exceptionInfo);
2509       if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2510     }
2511 #endif //_WIN64
2512   }
2513 
2514   if (exception_code != EXCEPTION_BREAKPOINT) {
2515 #ifndef _WIN64
2516     report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2517                  exceptionInfo->ContextRecord);
2518 #else
2519     // Itanium Windows uses a VectoredExceptionHandler
2520     // Which means that C++ programatic exception handlers (try/except)
2521     // will get here.  Continue the search for the right except block if
2522     // the exception code is not a fatal code.
2523     switch ( exception_code ) {
2524       case EXCEPTION_ACCESS_VIOLATION:
2525       case EXCEPTION_STACK_OVERFLOW:
2526       case EXCEPTION_ILLEGAL_INSTRUCTION:
2527       case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2528       case EXCEPTION_INT_OVERFLOW:
2529       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2530       case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
2531       {  report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2532                        exceptionInfo->ContextRecord);
2533       }
2534         break;
2535       default:
2536         break;
2537     }
2538 #endif
2539   }
2540   return EXCEPTION_CONTINUE_SEARCH;
2541 }
2542 
2543 #ifndef _WIN64
2544 // Special care for fast JNI accessors.
2545 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2546 // the heap gets shrunk before the field access.
2547 // Need to install our own structured exception handler since native code may
2548 // install its own.
2549 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2550   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2551   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2552     address pc = (address) exceptionInfo->ContextRecord->Eip;
2553     address addr = JNI_FastGetField::find_slowcase_pc(pc);
2554     if (addr != (address)-1) {
2555       return Handle_Exception(exceptionInfo, addr);
2556     }
2557   }
2558   return EXCEPTION_CONTINUE_SEARCH;
2559 }
2560 
2561 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2562 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2563   __try { \
2564     return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2565   } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2566   } \
2567   return 0; \
2568 }
2569 
2570 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2571 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2572 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2573 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2574 DEFINE_FAST_GETFIELD(jint,     int,    Int)
2575 DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2576 DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2577 DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2578 
2579 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2580   switch (type) {
2581     case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2582     case T_BYTE:    return (address)jni_fast_GetByteField_wrapper;
2583     case T_CHAR:    return (address)jni_fast_GetCharField_wrapper;
2584     case T_SHORT:   return (address)jni_fast_GetShortField_wrapper;
2585     case T_INT:     return (address)jni_fast_GetIntField_wrapper;
2586     case T_LONG:    return (address)jni_fast_GetLongField_wrapper;
2587     case T_FLOAT:   return (address)jni_fast_GetFloatField_wrapper;
2588     case T_DOUBLE:  return (address)jni_fast_GetDoubleField_wrapper;
2589     default:        ShouldNotReachHere();
2590   }
2591   return (address)-1;
2592 }
2593 #endif
2594 
2595 // Virtual Memory
2596 
2597 int os::vm_page_size() { return os::win32::vm_page_size(); }
2598 int os::vm_allocation_granularity() {
2599   return os::win32::vm_allocation_granularity();
2600 }
2601 
2602 // Windows large page support is available on Windows 2003. In order to use
2603 // large page memory, the administrator must first assign additional privilege
2604 // to the user:
2605 //   + select Control Panel -> Administrative Tools -> Local Security Policy
2606 //   + select Local Policies -> User Rights Assignment
2607 //   + double click "Lock pages in memory", add users and/or groups
2608 //   + reboot
2609 // Note the above steps are needed for administrator as well, as administrators
2610 // by default do not have the privilege to lock pages in memory.
2611 //
2612 // Note about Windows 2003: although the API supports committing large page
2613 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2614 // scenario, I found through experiment it only uses large page if the entire
2615 // memory region is reserved and committed in a single VirtualAlloc() call.
2616 // This makes Windows large page support more or less like Solaris ISM, in
2617 // that the entire heap must be committed upfront. This probably will change
2618 // in the future, if so the code below needs to be revisited.
2619 
2620 #ifndef MEM_LARGE_PAGES
2621 #define MEM_LARGE_PAGES 0x20000000
2622 #endif
2623 
2624 static HANDLE    _hProcess;
2625 static HANDLE    _hToken;
2626 
2627 // Container for NUMA node list info
2628 class NUMANodeListHolder {
2629 private:
2630   int *_numa_used_node_list;  // allocated below
2631   int _numa_used_node_count;
2632 
2633   void free_node_list() {
2634     if (_numa_used_node_list != NULL) {
2635       FREE_C_HEAP_ARRAY(int, _numa_used_node_list);
2636     }
2637   }
2638 
2639 public:
2640   NUMANodeListHolder() {
2641     _numa_used_node_count = 0;
2642     _numa_used_node_list = NULL;
2643     // do rest of initialization in build routine (after function pointers are set up)
2644   }
2645 
2646   ~NUMANodeListHolder() {
2647     free_node_list();
2648   }
2649 
2650   bool build() {
2651     DWORD_PTR proc_aff_mask;
2652     DWORD_PTR sys_aff_mask;
2653     if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2654     ULONG highest_node_number;
2655     if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false;
2656     free_node_list();
2657     _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1);
2658     for (unsigned int i = 0; i <= highest_node_number; i++) {
2659       ULONGLONG proc_mask_numa_node;
2660       if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2661       if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2662         _numa_used_node_list[_numa_used_node_count++] = i;
2663       }
2664     }
2665     return (_numa_used_node_count > 1);
2666   }
2667 
2668   int get_count() {return _numa_used_node_count;}
2669   int get_node_list_entry(int n) {
2670     // for indexes out of range, returns -1
2671     return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2672   }
2673 
2674 } numa_node_list_holder;
2675 
2676 
2677 
2678 static size_t _large_page_size = 0;
2679 
2680 static bool resolve_functions_for_large_page_init() {
2681   return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2682     os::Advapi32Dll::AdvapiAvailable();
2683 }
2684 
2685 static bool request_lock_memory_privilege() {
2686   _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2687                                 os::current_process_id());
2688 
2689   LUID luid;
2690   if (_hProcess != NULL &&
2691       os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2692       os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2693 
2694     TOKEN_PRIVILEGES tp;
2695     tp.PrivilegeCount = 1;
2696     tp.Privileges[0].Luid = luid;
2697     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2698 
2699     // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2700     // privilege. Check GetLastError() too. See MSDN document.
2701     if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2702         (GetLastError() == ERROR_SUCCESS)) {
2703       return true;
2704     }
2705   }
2706 
2707   return false;
2708 }
2709 
2710 static void cleanup_after_large_page_init() {
2711   if (_hProcess) CloseHandle(_hProcess);
2712   _hProcess = NULL;
2713   if (_hToken) CloseHandle(_hToken);
2714   _hToken = NULL;
2715 }
2716 
2717 static bool numa_interleaving_init() {
2718   bool success = false;
2719   bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2720 
2721   // print a warning if UseNUMAInterleaving flag is specified on command line
2722   bool warn_on_failure = use_numa_interleaving_specified;
2723 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2724 
2725   // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2726   size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2727   NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
2728 
2729   if (os::Kernel32Dll::NumaCallsAvailable()) {
2730     if (numa_node_list_holder.build()) {
2731       if (PrintMiscellaneous && Verbose) {
2732         tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
2733         for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
2734           tty->print("%d ", numa_node_list_holder.get_node_list_entry(i));
2735         }
2736         tty->print("\n");
2737       }
2738       success = true;
2739     } else {
2740       WARN("Process does not cover multiple NUMA nodes.");
2741     }
2742   } else {
2743     WARN("NUMA Interleaving is not supported by the operating system.");
2744   }
2745   if (!success) {
2746     if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2747   }
2748   return success;
2749 #undef WARN
2750 }
2751 
2752 // this routine is used whenever we need to reserve a contiguous VA range
2753 // but we need to make separate VirtualAlloc calls for each piece of the range
2754 // Reasons for doing this:
2755 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2756 //  * UseNUMAInterleaving requires a separate node for each piece
2757 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
2758                                          bool should_inject_error=false) {
2759   char * p_buf;
2760   // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2761   size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2762   size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2763 
2764   // first reserve enough address space in advance since we want to be
2765   // able to break a single contiguous virtual address range into multiple
2766   // large page commits but WS2003 does not allow reserving large page space
2767   // so we just use 4K pages for reserve, this gives us a legal contiguous
2768   // address space. then we will deallocate that reservation, and re alloc
2769   // using large pages
2770   const size_t size_of_reserve = bytes + chunk_size;
2771   if (bytes > size_of_reserve) {
2772     // Overflowed.
2773     return NULL;
2774   }
2775   p_buf = (char *) VirtualAlloc(addr,
2776                                 size_of_reserve,  // size of Reserve
2777                                 MEM_RESERVE,
2778                                 PAGE_READWRITE);
2779   // If reservation failed, return NULL
2780   if (p_buf == NULL) return NULL;
2781 
2782   os::release_memory(p_buf, bytes + chunk_size);
2783 
2784   // we still need to round up to a page boundary (in case we are using large pages)
2785   // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
2786   // instead we handle this in the bytes_to_rq computation below
2787   p_buf = (char *) align_size_up((size_t)p_buf, page_size);
2788 
2789   // now go through and allocate one chunk at a time until all bytes are
2790   // allocated
2791   size_t  bytes_remaining = bytes;
2792   // An overflow of align_size_up() would have been caught above
2793   // in the calculation of size_of_reserve.
2794   char * next_alloc_addr = p_buf;
2795   HANDLE hProc = GetCurrentProcess();
2796 
2797 #ifdef ASSERT
2798   // Variable for the failure injection
2799   long ran_num = os::random();
2800   size_t fail_after = ran_num % bytes;
2801 #endif
2802 
2803   int count=0;
2804   while (bytes_remaining) {
2805     // select bytes_to_rq to get to the next chunk_size boundary
2806 
2807     size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
2808     // Note allocate and commit
2809     char * p_new;
2810 
2811 #ifdef ASSERT
2812     bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
2813 #else
2814     const bool inject_error_now = false;
2815 #endif
2816 
2817     if (inject_error_now) {
2818       p_new = NULL;
2819     } else {
2820       if (!UseNUMAInterleaving) {
2821         p_new = (char *) VirtualAlloc(next_alloc_addr,
2822                                       bytes_to_rq,
2823                                       flags,
2824                                       prot);
2825       } else {
2826         // get the next node to use from the used_node_list
2827         assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
2828         DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
2829         p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc,
2830                                                             next_alloc_addr,
2831                                                             bytes_to_rq,
2832                                                             flags,
2833                                                             prot,
2834                                                             node);
2835       }
2836     }
2837 
2838     if (p_new == NULL) {
2839       // Free any allocated pages
2840       if (next_alloc_addr > p_buf) {
2841         // Some memory was committed so release it.
2842         size_t bytes_to_release = bytes - bytes_remaining;
2843         os::release_memory(p_buf, bytes_to_release);
2844       }
2845 #ifdef ASSERT
2846       if (should_inject_error) {
2847         if (TracePageSizes && Verbose) {
2848           tty->print_cr("Reserving pages individually failed.");
2849         }
2850       }
2851 #endif
2852       return NULL;
2853     }
2854     bytes_remaining -= bytes_to_rq;
2855     next_alloc_addr += bytes_to_rq;
2856     count++;
2857   }
2858   // made it this far, success
2859   return p_buf;
2860 }
2861 
2862 
2863 
2864 void os::large_page_init() {
2865   if (!UseLargePages) return;
2866 
2867   // print a warning if any large page related flag is specified on command line
2868   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2869                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2870   bool success = false;
2871 
2872 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2873   if (resolve_functions_for_large_page_init()) {
2874     if (request_lock_memory_privilege()) {
2875       size_t s = os::Kernel32Dll::GetLargePageMinimum();
2876       if (s) {
2877 #if defined(IA32) || defined(AMD64)
2878         if (s > 4*M || LargePageSizeInBytes > 4*M) {
2879           WARN("JVM cannot use large pages bigger than 4mb.");
2880         } else {
2881 #endif
2882           if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2883             _large_page_size = LargePageSizeInBytes;
2884           } else {
2885             _large_page_size = s;
2886           }
2887           success = true;
2888 #if defined(IA32) || defined(AMD64)
2889         }
2890 #endif
2891       } else {
2892         WARN("Large page is not supported by the processor.");
2893       }
2894     } else {
2895       WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2896     }
2897   } else {
2898     WARN("Large page is not supported by the operating system.");
2899   }
2900 #undef WARN
2901 
2902   const size_t default_page_size = (size_t) vm_page_size();
2903   if (success && _large_page_size > default_page_size) {
2904     _page_sizes[0] = _large_page_size;
2905     _page_sizes[1] = default_page_size;
2906     _page_sizes[2] = 0;
2907   }
2908 
2909   cleanup_after_large_page_init();
2910   UseLargePages = success;
2911 }
2912 
2913 // On win32, one cannot release just a part of reserved memory, it's an
2914 // all or nothing deal.  When we split a reservation, we must break the
2915 // reservation into two reservations.
2916 void os::split_reserved_memory(char *base, size_t size, size_t split,
2917                               bool realloc) {
2918   if (size > 0) {
2919     release_memory(base, size);
2920     if (realloc) {
2921       reserve_memory(split, base);
2922     }
2923     if (size != split) {
2924       reserve_memory(size - split, base + split);
2925     }
2926   }
2927 }
2928 
2929 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2930   assert((size_t)addr % os::vm_allocation_granularity() == 0,
2931          "reserve alignment");
2932   assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2933   char* res;
2934   // note that if UseLargePages is on, all the areas that require interleaving
2935   // will go thru reserve_memory_special rather than thru here.
2936   bool use_individual = (UseNUMAInterleaving && !UseLargePages);
2937   if (!use_individual) {
2938     res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2939   } else {
2940     elapsedTimer reserveTimer;
2941     if( Verbose && PrintMiscellaneous ) reserveTimer.start();
2942     // in numa interleaving, we have to allocate pages individually
2943     // (well really chunks of NUMAInterleaveGranularity size)
2944     res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
2945     if (res == NULL) {
2946       warning("NUMA page allocation failed");
2947     }
2948     if( Verbose && PrintMiscellaneous ) {
2949       reserveTimer.stop();
2950       tty->print_cr("reserve_memory of %Ix bytes took %ld ms (%ld ticks)", bytes,
2951                     reserveTimer.milliseconds(), reserveTimer.ticks());
2952     }
2953   }
2954   assert(res == NULL || addr == NULL || addr == res,
2955          "Unexpected address from reserve.");
2956 
2957   return res;
2958 }
2959 
2960 // Reserve memory at an arbitrary address, only if that area is
2961 // available (and not reserved for something else).
2962 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2963   // Windows os::reserve_memory() fails of the requested address range is
2964   // not avilable.
2965   return reserve_memory(bytes, requested_addr);
2966 }
2967 
2968 size_t os::large_page_size() {
2969   return _large_page_size;
2970 }
2971 
2972 bool os::can_commit_large_page_memory() {
2973   // Windows only uses large page memory when the entire region is reserved
2974   // and committed in a single VirtualAlloc() call. This may change in the
2975   // future, but with Windows 2003 it's not possible to commit on demand.
2976   return false;
2977 }
2978 
2979 bool os::can_execute_large_page_memory() {
2980   return true;
2981 }
2982 
2983 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2984 
2985   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
2986   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2987 
2988   // with large pages, there are two cases where we need to use Individual Allocation
2989   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
2990   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
2991   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
2992     if (TracePageSizes && Verbose) {
2993        tty->print_cr("Reserving large pages individually.");
2994     }
2995     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
2996     if (p_buf == NULL) {
2997       // give an appropriate warning message
2998       if (UseNUMAInterleaving) {
2999         warning("NUMA large page allocation failed, UseLargePages flag ignored");
3000       }
3001       if (UseLargePagesIndividualAllocation) {
3002         warning("Individually allocated large pages failed, "
3003                 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3004       }
3005       return NULL;
3006     }
3007 
3008     return p_buf;
3009 
3010   } else {
3011     // normal policy just allocate it all at once
3012     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3013     char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
3014     return res;
3015   }
3016 }
3017 
3018 bool os::release_memory_special(char* base, size_t bytes) {
3019   return release_memory(base, bytes);
3020 }
3021 
3022 void os::print_statistics() {
3023 }
3024 
3025 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
3026   if (bytes == 0) {
3027     // Don't bother the OS with noops.
3028     return true;
3029   }
3030   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3031   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3032   // Don't attempt to print anything if the OS call fails. We're
3033   // probably low on resources, so the print itself may cause crashes.
3034 
3035   // unless we have NUMAInterleaving enabled, the range of a commit
3036   // is always within a reserve covered by a single VirtualAlloc
3037   // in that case we can just do a single commit for the requested size
3038   if (!UseNUMAInterleaving) {
3039     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
3040     if (exec) {
3041       DWORD oldprot;
3042       // Windows doc says to use VirtualProtect to get execute permissions
3043       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
3044     }
3045     return true;
3046   } else {
3047 
3048     // when NUMAInterleaving is enabled, the commit might cover a range that
3049     // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3050     // VirtualQuery can help us determine that.  The RegionSize that VirtualQuery
3051     // returns represents the number of bytes that can be committed in one step.
3052     size_t bytes_remaining = bytes;
3053     char * next_alloc_addr = addr;
3054     while (bytes_remaining > 0) {
3055       MEMORY_BASIC_INFORMATION alloc_info;
3056       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3057       size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3058       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL)
3059         return false;
3060       if (exec) {
3061         DWORD oldprot;
3062         if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot))
3063           return false;
3064       }
3065       bytes_remaining -= bytes_to_rq;
3066       next_alloc_addr += bytes_to_rq;
3067     }
3068   }
3069   // if we made it this far, return true
3070   return true;
3071 }
3072 
3073 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
3074                        bool exec) {
3075   return commit_memory(addr, size, exec);
3076 }
3077 
3078 bool os::uncommit_memory(char* addr, size_t bytes) {
3079   if (bytes == 0) {
3080     // Don't bother the OS with noops.
3081     return true;
3082   }
3083   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3084   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3085   return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0;
3086 }
3087 
3088 bool os::release_memory(char* addr, size_t bytes) {
3089   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3090 }
3091 
3092 bool os::create_stack_guard_pages(char* addr, size_t size) {
3093   return os::commit_memory(addr, size);
3094 }
3095 
3096 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3097   return os::uncommit_memory(addr, size);
3098 }
3099 
3100 // Set protections specified
3101 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3102                         bool is_committed) {
3103   unsigned int p = 0;
3104   switch (prot) {
3105   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3106   case MEM_PROT_READ: p = PAGE_READONLY; break;
3107   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3108   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3109   default:
3110     ShouldNotReachHere();
3111   }
3112 
3113   DWORD old_status;
3114 
3115   // Strange enough, but on Win32 one can change protection only for committed
3116   // memory, not a big deal anyway, as bytes less or equal than 64K
3117   if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
3118     fatal("cannot commit protection page");
3119   }
3120   // One cannot use os::guard_memory() here, as on Win32 guard page
3121   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3122   //
3123   // Pages in the region become guard pages. Any attempt to access a guard page
3124   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3125   // the guard page status. Guard pages thus act as a one-time access alarm.
3126   return VirtualProtect(addr, bytes, p, &old_status) != 0;
3127 }
3128 
3129 bool os::guard_memory(char* addr, size_t bytes) {
3130   DWORD old_status;
3131   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3132 }
3133 
3134 bool os::unguard_memory(char* addr, size_t bytes) {
3135   DWORD old_status;
3136   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3137 }
3138 
3139 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3140 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint)    { }
3141 void os::numa_make_global(char *addr, size_t bytes)    { }
3142 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3143 bool os::numa_topology_changed()                       { return false; }
3144 size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3145 int os::numa_get_group_id()                            { return 0; }
3146 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3147   if (numa_node_list_holder.get_count() == 0 && size > 0) {
3148     // Provide an answer for UMA systems
3149     ids[0] = 0;
3150     return 1;
3151   } else {
3152     // check for size bigger than actual groups_num
3153     size = MIN2(size, numa_get_groups_num());
3154     for (int i = 0; i < (int)size; i++) {
3155       ids[i] = numa_node_list_holder.get_node_list_entry(i);
3156     }
3157     return size;
3158   }
3159 }
3160 
3161 bool os::get_page_info(char *start, page_info* info) {
3162   return false;
3163 }
3164 
3165 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3166   return end;
3167 }
3168 
3169 char* os::non_memory_address_word() {
3170   // Must never look like an address returned by reserve_memory,
3171   // even in its subfields (as defined by the CPU immediate fields,
3172   // if the CPU splits constants across multiple instructions).
3173   return (char*)-1;
3174 }
3175 
3176 #define MAX_ERROR_COUNT 100
3177 #define SYS_THREAD_ERROR 0xffffffffUL
3178 
3179 void os::pd_start_thread(Thread* thread) {
3180   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3181   // Returns previous suspend state:
3182   // 0:  Thread was not suspended
3183   // 1:  Thread is running now
3184   // >1: Thread is still suspended.
3185   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3186 }
3187 
3188 class HighResolutionInterval {
3189   // The default timer resolution seems to be 10 milliseconds.
3190   // (Where is this written down?)
3191   // If someone wants to sleep for only a fraction of the default,
3192   // then we set the timer resolution down to 1 millisecond for
3193   // the duration of their interval.
3194   // We carefully set the resolution back, since otherwise we
3195   // seem to incur an overhead (3%?) that we don't need.
3196   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3197   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3198   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3199   // timeBeginPeriod() if the relative error exceeded some threshold.
3200   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3201   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3202   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3203   // resolution timers running.
3204 private:
3205     jlong resolution;
3206 public:
3207   HighResolutionInterval(jlong ms) {
3208     resolution = ms % 10L;
3209     if (resolution != 0) {
3210       MMRESULT result = timeBeginPeriod(1L);
3211     }
3212   }
3213   ~HighResolutionInterval() {
3214     if (resolution != 0) {
3215       MMRESULT result = timeEndPeriod(1L);
3216     }
3217     resolution = 0L;
3218   }
3219 };
3220 
3221 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3222   jlong limit = (jlong) MAXDWORD;
3223 
3224   while(ms > limit) {
3225     int res;
3226     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3227       return res;
3228     ms -= limit;
3229   }
3230 
3231   assert(thread == Thread::current(),  "thread consistency check");
3232   OSThread* osthread = thread->osthread();
3233   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3234   int result;
3235   if (interruptable) {
3236     assert(thread->is_Java_thread(), "must be java thread");
3237     JavaThread *jt = (JavaThread *) thread;
3238     ThreadBlockInVM tbivm(jt);
3239 
3240     jt->set_suspend_equivalent();
3241     // cleared by handle_special_suspend_equivalent_condition() or
3242     // java_suspend_self() via check_and_wait_while_suspended()
3243 
3244     HANDLE events[1];
3245     events[0] = osthread->interrupt_event();
3246     HighResolutionInterval *phri=NULL;
3247     if(!ForceTimeHighResolution)
3248       phri = new HighResolutionInterval( ms );
3249     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3250       result = OS_TIMEOUT;
3251     } else {
3252       ResetEvent(osthread->interrupt_event());
3253       osthread->set_interrupted(false);
3254       result = OS_INTRPT;
3255     }
3256     delete phri; //if it is NULL, harmless
3257 
3258     // were we externally suspended while we were waiting?
3259     jt->check_and_wait_while_suspended();
3260   } else {
3261     assert(!thread->is_Java_thread(), "must not be java thread");
3262     Sleep((long) ms);
3263     result = OS_TIMEOUT;
3264   }
3265   return result;
3266 }
3267 
3268 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3269 void os::infinite_sleep() {
3270   while (true) {    // sleep forever ...
3271     Sleep(100000);  // ... 100 seconds at a time
3272   }
3273 }
3274 
3275 typedef BOOL (WINAPI * STTSignature)(void) ;
3276 
3277 os::YieldResult os::NakedYield() {
3278   // Use either SwitchToThread() or Sleep(0)
3279   // Consider passing back the return value from SwitchToThread().
3280   if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3281     return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3282   } else {
3283     Sleep(0);
3284   }
3285   return os::YIELD_UNKNOWN ;
3286 }
3287 
3288 void os::yield() {  os::NakedYield(); }
3289 
3290 void os::yield_all(int attempts) {
3291   // Yields to all threads, including threads with lower priorities
3292   Sleep(1);
3293 }
3294 
3295 // Win32 only gives you access to seven real priorities at a time,
3296 // so we compress Java's ten down to seven.  It would be better
3297 // if we dynamically adjusted relative priorities.
3298 
3299 int os::java_to_os_priority[MaxPriority + 1] = {
3300   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3301   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3302   THREAD_PRIORITY_LOWEST,                       // 2
3303   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3304   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3305   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3306   THREAD_PRIORITY_NORMAL,                       // 6
3307   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3308   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3309   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3310   THREAD_PRIORITY_HIGHEST                       // 10 MaxPriority

3311 };
3312 
3313 int prio_policy1[MaxPriority + 1] = {
3314   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3315   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3316   THREAD_PRIORITY_LOWEST,                       // 2
3317   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3318   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3319   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3320   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3321   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3322   THREAD_PRIORITY_HIGHEST,                      // 8
3323   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3324   THREAD_PRIORITY_TIME_CRITICAL                 // 10 MaxPriority

3325 };
3326 
3327 static int prio_init() {
3328   // If ThreadPriorityPolicy is 1, switch tables
3329   if (ThreadPriorityPolicy == 1) {
3330     int i;
3331     for (i = 0; i < MaxPriority + 1; i++) {
3332       os::java_to_os_priority[i] = prio_policy1[i];
3333     }
3334   }
3335   return 0;
3336 }
3337 
3338 OSReturn os::set_native_priority(Thread* thread, int priority) {
3339   if (!UseThreadPriorities) return OS_OK;
3340   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3341   return ret ? OS_OK : OS_ERR;
3342 }
3343 
3344 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3345   if ( !UseThreadPriorities ) {
3346     *priority_ptr = java_to_os_priority[NormPriority];
3347     return OS_OK;
3348   }
3349   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3350   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3351     assert(false, "GetThreadPriority failed");
3352     return OS_ERR;
3353   }
3354   *priority_ptr = os_prio;
3355   return OS_OK;
3356 }
3357 
3358 
3359 // Hint to the underlying OS that a task switch would not be good.
3360 // Void return because it's a hint and can fail.
3361 void os::hint_no_preempt() {}
3362 
3363 void os::interrupt(Thread* thread) {
3364   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3365          "possibility of dangling Thread pointer");
3366 
3367   OSThread* osthread = thread->osthread();
3368   osthread->set_interrupted(true);
3369   // More than one thread can get here with the same value of osthread,
3370   // resulting in multiple notifications.  We do, however, want the store
3371   // to interrupted() to be visible to other threads before we post
3372   // the interrupt event.
3373   OrderAccess::release();
3374   SetEvent(osthread->interrupt_event());
3375   // For JSR166:  unpark after setting status
3376   if (thread->is_Java_thread())
3377     ((JavaThread*)thread)->parker()->unpark();
3378 
3379   ParkEvent * ev = thread->_ParkEvent ;
3380   if (ev != NULL) ev->unpark() ;
3381 
3382 }
3383 
3384 
3385 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3386   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3387          "possibility of dangling Thread pointer");
3388 
3389   OSThread* osthread = thread->osthread();
3390   bool interrupted = osthread->interrupted();
3391   // There is no synchronization between the setting of the interrupt
3392   // and it being cleared here. It is critical - see 6535709 - that
3393   // we only clear the interrupt state, and reset the interrupt event,
3394   // if we are going to report that we were indeed interrupted - else
3395   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3396   // depending on the timing
3397   if (interrupted && clear_interrupted) {
3398     osthread->set_interrupted(false);
3399     ResetEvent(osthread->interrupt_event());
3400   } // Otherwise leave the interrupted state alone
3401 
3402   return interrupted;
3403 }
3404 
3405 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3406 ExtendedPC os::get_thread_pc(Thread* thread) {
3407   CONTEXT context;
3408   context.ContextFlags = CONTEXT_CONTROL;
3409   HANDLE handle = thread->osthread()->thread_handle();
3410 #ifdef _M_IA64
3411   assert(0, "Fix get_thread_pc");
3412   return ExtendedPC(NULL);
3413 #else
3414   if (GetThreadContext(handle, &context)) {
3415 #ifdef _M_AMD64
3416     return ExtendedPC((address) context.Rip);
3417 #else
3418     return ExtendedPC((address) context.Eip);
3419 #endif
3420   } else {
3421     return ExtendedPC(NULL);
3422   }
3423 #endif
3424 }
3425 
3426 // GetCurrentThreadId() returns DWORD
3427 intx os::current_thread_id()          { return GetCurrentThreadId(); }
3428 
3429 static int _initial_pid = 0;
3430 
3431 int os::current_process_id()
3432 {
3433   return (_initial_pid ? _initial_pid : _getpid());
3434 }
3435 
3436 int    os::win32::_vm_page_size       = 0;
3437 int    os::win32::_vm_allocation_granularity = 0;
3438 int    os::win32::_processor_type     = 0;
3439 // Processor level is not available on non-NT systems, use vm_version instead
3440 int    os::win32::_processor_level    = 0;
3441 julong os::win32::_physical_memory    = 0;
3442 size_t os::win32::_default_stack_size = 0;
3443 
3444          intx os::win32::_os_thread_limit    = 0;
3445 volatile intx os::win32::_os_thread_count    = 0;
3446 
3447 bool   os::win32::_is_nt              = false;
3448 bool   os::win32::_is_windows_2003    = false;
3449 bool   os::win32::_is_windows_server  = false;
3450 
3451 void os::win32::initialize_system_info() {
3452   SYSTEM_INFO si;
3453   GetSystemInfo(&si);
3454   _vm_page_size    = si.dwPageSize;
3455   _vm_allocation_granularity = si.dwAllocationGranularity;
3456   _processor_type  = si.dwProcessorType;
3457   _processor_level = si.wProcessorLevel;
3458   set_processor_count(si.dwNumberOfProcessors);
3459 
3460   MEMORYSTATUSEX ms;
3461   ms.dwLength = sizeof(ms);
3462 
3463   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3464   // dwMemoryLoad (% of memory in use)
3465   GlobalMemoryStatusEx(&ms);
3466   _physical_memory = ms.ullTotalPhys;
3467 
3468   OSVERSIONINFOEX oi;
3469   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3470   GetVersionEx((OSVERSIONINFO*)&oi);
3471   switch(oi.dwPlatformId) {
3472     case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3473     case VER_PLATFORM_WIN32_NT:
3474       _is_nt = true;
3475       {
3476         int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3477         if (os_vers == 5002) {
3478           _is_windows_2003 = true;
3479         }
3480         if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3481           oi.wProductType == VER_NT_SERVER) {
3482             _is_windows_server = true;
3483         }
3484       }
3485       break;
3486     default: fatal("Unknown platform");
3487   }
3488 
3489   _default_stack_size = os::current_stack_size();
3490   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3491   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3492     "stack size not a multiple of page size");
3493 
3494   initialize_performance_counter();
3495 
3496   // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3497   // known to deadlock the system, if the VM issues to thread operations with
3498   // a too high frequency, e.g., such as changing the priorities.
3499   // The 6000 seems to work well - no deadlocks has been notices on the test
3500   // programs that we have seen experience this problem.
3501   if (!os::win32::is_nt()) {
3502     StarvationMonitorInterval = 6000;
3503   }
3504 }
3505 
3506 
3507 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3508   char path[MAX_PATH];
3509   DWORD size;
3510   DWORD pathLen = (DWORD)sizeof(path);
3511   HINSTANCE result = NULL;
3512 
3513   // only allow library name without path component
3514   assert(strchr(name, '\\') == NULL, "path not allowed");
3515   assert(strchr(name, ':') == NULL, "path not allowed");
3516   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3517     jio_snprintf(ebuf, ebuflen,
3518       "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3519     return NULL;
3520   }
3521 
3522   // search system directory
3523   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3524     strcat(path, "\\");
3525     strcat(path, name);
3526     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3527       return result;
3528     }
3529   }
3530 
3531   // try Windows directory
3532   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3533     strcat(path, "\\");
3534     strcat(path, name);
3535     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3536       return result;
3537     }
3538   }
3539 
3540   jio_snprintf(ebuf, ebuflen,
3541     "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3542   return NULL;
3543 }
3544 
3545 void os::win32::setmode_streams() {
3546   _setmode(_fileno(stdin), _O_BINARY);
3547   _setmode(_fileno(stdout), _O_BINARY);
3548   _setmode(_fileno(stderr), _O_BINARY);
3549 }
3550 
3551 
3552 bool os::is_debugger_attached() {
3553   return IsDebuggerPresent() ? true : false;
3554 }
3555 
3556 
3557 void os::wait_for_keypress_at_exit(void) {
3558   if (PauseAtExit) {
3559     fprintf(stderr, "Press any key to continue...\n");
3560     fgetc(stdin);
3561   }
3562 }
3563 
3564 
3565 int os::message_box(const char* title, const char* message) {
3566   int result = MessageBox(NULL, message, title,
3567                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3568   return result == IDYES;
3569 }
3570 
3571 int os::allocate_thread_local_storage() {
3572   return TlsAlloc();
3573 }
3574 
3575 
3576 void os::free_thread_local_storage(int index) {
3577   TlsFree(index);
3578 }
3579 
3580 
3581 void os::thread_local_storage_at_put(int index, void* value) {
3582   TlsSetValue(index, value);
3583   assert(thread_local_storage_at(index) == value, "Just checking");
3584 }
3585 
3586 
3587 void* os::thread_local_storage_at(int index) {
3588   return TlsGetValue(index);
3589 }
3590 
3591 
3592 #ifndef PRODUCT
3593 #ifndef _WIN64
3594 // Helpers to check whether NX protection is enabled
3595 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3596   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3597       pex->ExceptionRecord->NumberParameters > 0 &&
3598       pex->ExceptionRecord->ExceptionInformation[0] ==
3599       EXCEPTION_INFO_EXEC_VIOLATION) {
3600     return EXCEPTION_EXECUTE_HANDLER;
3601   }
3602   return EXCEPTION_CONTINUE_SEARCH;
3603 }
3604 
3605 void nx_check_protection() {
3606   // If NX is enabled we'll get an exception calling into code on the stack
3607   char code[] = { (char)0xC3 }; // ret
3608   void *code_ptr = (void *)code;
3609   __try {
3610     __asm call code_ptr
3611   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3612     tty->print_raw_cr("NX protection detected.");
3613   }
3614 }
3615 #endif // _WIN64
3616 #endif // PRODUCT
3617 
3618 // this is called _before_ the global arguments have been parsed
3619 void os::init(void) {
3620   _initial_pid = _getpid();
3621 
3622   init_random(1234567);
3623 
3624   win32::initialize_system_info();
3625   win32::setmode_streams();
3626   init_page_sizes((size_t) win32::vm_page_size());
3627 
3628   // For better scalability on MP systems (must be called after initialize_system_info)
3629 #ifndef PRODUCT
3630   if (is_MP()) {
3631     NoYieldsInMicrolock = true;
3632   }
3633 #endif
3634   // This may be overridden later when argument processing is done.
3635   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3636     os::win32::is_windows_2003());
3637 
3638   // Initialize main_process and main_thread
3639   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
3640  if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3641                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3642     fatal("DuplicateHandle failed\n");
3643   }
3644   main_thread_id = (int) GetCurrentThreadId();
3645 }
3646 
3647 // To install functions for atexit processing
3648 extern "C" {
3649   static void perfMemory_exit_helper() {
3650     perfMemory_exit();
3651   }
3652 }
3653 
3654 // this is called _after_ the global arguments have been parsed
3655 jint os::init_2(void) {
3656   // Allocate a single page and mark it as readable for safepoint polling
3657   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3658   guarantee( polling_page != NULL, "Reserve Failed for polling page");
3659 
3660   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3661   guarantee( return_page != NULL, "Commit Failed for polling page");
3662 
3663   os::set_polling_page( polling_page );
3664 
3665 #ifndef PRODUCT
3666   if( Verbose && PrintMiscellaneous )
3667     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3668 #endif
3669 
3670   if (!UseMembar) {
3671     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3672     guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3673 
3674     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3675     guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3676 
3677     os::set_memory_serialize_page( mem_serialize_page );
3678 
3679 #ifndef PRODUCT
3680     if(Verbose && PrintMiscellaneous)
3681       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3682 #endif
3683   }
3684 
3685   os::large_page_init();
3686 
3687   // Setup Windows Exceptions
3688 
3689   // On Itanium systems, Structured Exception Handling does not
3690   // work since stack frames must be walkable by the OS.  Since
3691   // much of our code is dynamically generated, and we do not have
3692   // proper unwind .xdata sections, the system simply exits
3693   // rather than delivering the exception.  To work around
3694   // this we use VectorExceptions instead.
3695 #ifdef _WIN64
3696   if (UseVectoredExceptions) {
3697     topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3698   }
3699 #endif
3700 
3701   // for debugging float code generation bugs
3702   if (ForceFloatExceptions) {
3703 #ifndef  _WIN64
3704     static long fp_control_word = 0;
3705     __asm { fstcw fp_control_word }
3706     // see Intel PPro Manual, Vol. 2, p 7-16
3707     const long precision = 0x20;
3708     const long underflow = 0x10;
3709     const long overflow  = 0x08;
3710     const long zero_div  = 0x04;
3711     const long denorm    = 0x02;
3712     const long invalid   = 0x01;
3713     fp_control_word |= invalid;
3714     __asm { fldcw fp_control_word }
3715 #endif
3716   }
3717 
3718   // If stack_commit_size is 0, windows will reserve the default size,
3719   // but only commit a small portion of it.
3720   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3721   size_t default_reserve_size = os::win32::default_stack_size();
3722   size_t actual_reserve_size = stack_commit_size;
3723   if (stack_commit_size < default_reserve_size) {
3724     // If stack_commit_size == 0, we want this too
3725     actual_reserve_size = default_reserve_size;
3726   }
3727 
3728   // Check minimum allowable stack size for thread creation and to initialize
3729   // the java system classes, including StackOverflowError - depends on page
3730   // size.  Add a page for compiler2 recursion in main thread.
3731   // Add in 2*BytesPerWord times page size to account for VM stack during
3732   // class initialization depending on 32 or 64 bit VM.
3733   size_t min_stack_allowed =
3734             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3735             2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3736   if (actual_reserve_size < min_stack_allowed) {
3737     tty->print_cr("\nThe stack size specified is too small, "
3738                   "Specify at least %dk",
3739                   min_stack_allowed / K);
3740     return JNI_ERR;
3741   }
3742 
3743   JavaThread::set_stack_size_at_create(stack_commit_size);
3744 
3745   // Calculate theoretical max. size of Threads to guard gainst artifical
3746   // out-of-memory situations, where all available address-space has been
3747   // reserved by thread stacks.
3748   assert(actual_reserve_size != 0, "Must have a stack");
3749 
3750   // Calculate the thread limit when we should start doing Virtual Memory
3751   // banging. Currently when the threads will have used all but 200Mb of space.
3752   //
3753   // TODO: consider performing a similar calculation for commit size instead
3754   // as reserve size, since on a 64-bit platform we'll run into that more
3755   // often than running out of virtual memory space.  We can use the
3756   // lower value of the two calculations as the os_thread_limit.
3757   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3758   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3759 
3760   // at exit methods are called in the reverse order of their registration.
3761   // there is no limit to the number of functions registered. atexit does
3762   // not set errno.
3763 
3764   if (PerfAllowAtExitRegistration) {
3765     // only register atexit functions if PerfAllowAtExitRegistration is set.
3766     // atexit functions can be delayed until process exit time, which
3767     // can be problematic for embedded VM situations. Embedded VMs should
3768     // call DestroyJavaVM() to assure that VM resources are released.
3769 
3770     // note: perfMemory_exit_helper atexit function may be removed in
3771     // the future if the appropriate cleanup code can be added to the
3772     // VM_Exit VMOperation's doit method.
3773     if (atexit(perfMemory_exit_helper) != 0) {
3774       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3775     }
3776   }
3777 
3778 #ifndef _WIN64
3779   // Print something if NX is enabled (win32 on AMD64)
3780   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3781 #endif
3782 
3783   // initialize thread priority policy
3784   prio_init();
3785 
3786   if (UseNUMA && !ForceNUMA) {
3787     UseNUMA = false; // We don't fully support this yet
3788   }
3789 
3790   if (UseNUMAInterleaving) {
3791     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
3792     bool success = numa_interleaving_init();
3793     if (!success) UseNUMAInterleaving = false;
3794   }
3795 
3796   return JNI_OK;
3797 }
3798 
3799 void os::init_3(void) {
3800   return;
3801 }
3802 
3803 // Mark the polling page as unreadable
3804 void os::make_polling_page_unreadable(void) {
3805   DWORD old_status;
3806   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3807     fatal("Could not disable polling page");
3808 };
3809 
3810 // Mark the polling page as readable
3811 void os::make_polling_page_readable(void) {
3812   DWORD old_status;
3813   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3814     fatal("Could not enable polling page");
3815 };
3816 
3817 
3818 int os::stat(const char *path, struct stat *sbuf) {
3819   char pathbuf[MAX_PATH];
3820   if (strlen(path) > MAX_PATH - 1) {
3821     errno = ENAMETOOLONG;
3822     return -1;
3823   }
3824   os::native_path(strcpy(pathbuf, path));
3825   int ret = ::stat(pathbuf, sbuf);
3826   if (sbuf != NULL && UseUTCFileTimestamp) {
3827     // Fix for 6539723.  st_mtime returned from stat() is dependent on
3828     // the system timezone and so can return different values for the
3829     // same file if/when daylight savings time changes.  This adjustment
3830     // makes sure the same timestamp is returned regardless of the TZ.
3831     //
3832     // See:
3833     // http://msdn.microsoft.com/library/
3834     //   default.asp?url=/library/en-us/sysinfo/base/
3835     //   time_zone_information_str.asp
3836     // and
3837     // http://msdn.microsoft.com/library/default.asp?url=
3838     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
3839     //
3840     // NOTE: there is a insidious bug here:  If the timezone is changed
3841     // after the call to stat() but before 'GetTimeZoneInformation()', then
3842     // the adjustment we do here will be wrong and we'll return the wrong
3843     // value (which will likely end up creating an invalid class data
3844     // archive).  Absent a better API for this, or some time zone locking
3845     // mechanism, we'll have to live with this risk.
3846     TIME_ZONE_INFORMATION tz;
3847     DWORD tzid = GetTimeZoneInformation(&tz);
3848     int daylightBias =
3849       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
3850     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3851   }
3852   return ret;
3853 }
3854 
3855 
3856 #define FT2INT64(ft) \
3857   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3858 
3859 
3860 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3861 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3862 // of a thread.
3863 //
3864 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3865 // the fast estimate available on the platform.
3866 
3867 // current_thread_cpu_time() is not optimized for Windows yet
3868 jlong os::current_thread_cpu_time() {
3869   // return user + sys since the cost is the same
3870   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3871 }
3872 
3873 jlong os::thread_cpu_time(Thread* thread) {
3874   // consistent with what current_thread_cpu_time() returns.
3875   return os::thread_cpu_time(thread, true /* user+sys */);
3876 }
3877 
3878 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3879   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3880 }
3881 
3882 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3883   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3884   // If this function changes, os::is_thread_cpu_time_supported() should too
3885   if (os::win32::is_nt()) {
3886     FILETIME CreationTime;
3887     FILETIME ExitTime;
3888     FILETIME KernelTime;
3889     FILETIME UserTime;
3890 
3891     if ( GetThreadTimes(thread->osthread()->thread_handle(),
3892                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3893       return -1;
3894     else
3895       if (user_sys_cpu_time) {
3896         return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3897       } else {
3898         return FT2INT64(UserTime) * 100;
3899       }
3900   } else {
3901     return (jlong) timeGetTime() * 1000000;
3902   }
3903 }
3904 
3905 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3906   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3907   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3908   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3909   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3910 }
3911 
3912 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3913   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
3914   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
3915   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
3916   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
3917 }
3918 
3919 bool os::is_thread_cpu_time_supported() {
3920   // see os::thread_cpu_time
3921   if (os::win32::is_nt()) {
3922     FILETIME CreationTime;
3923     FILETIME ExitTime;
3924     FILETIME KernelTime;
3925     FILETIME UserTime;
3926 
3927     if ( GetThreadTimes(GetCurrentThread(),
3928                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3929       return false;
3930     else
3931       return true;
3932   } else {
3933     return false;
3934   }
3935 }
3936 
3937 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3938 // It does have primitives (PDH API) to get CPU usage and run queue length.
3939 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3940 // If we wanted to implement loadavg on Windows, we have a few options:
3941 //
3942 // a) Query CPU usage and run queue length and "fake" an answer by
3943 //    returning the CPU usage if it's under 100%, and the run queue
3944 //    length otherwise.  It turns out that querying is pretty slow
3945 //    on Windows, on the order of 200 microseconds on a fast machine.
3946 //    Note that on the Windows the CPU usage value is the % usage
3947 //    since the last time the API was called (and the first call
3948 //    returns 100%), so we'd have to deal with that as well.
3949 //
3950 // b) Sample the "fake" answer using a sampling thread and store
3951 //    the answer in a global variable.  The call to loadavg would
3952 //    just return the value of the global, avoiding the slow query.
3953 //
3954 // c) Sample a better answer using exponential decay to smooth the
3955 //    value.  This is basically the algorithm used by UNIX kernels.
3956 //
3957 // Note that sampling thread starvation could affect both (b) and (c).
3958 int os::loadavg(double loadavg[], int nelem) {
3959   return -1;
3960 }
3961 
3962 
3963 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3964 bool os::dont_yield() {
3965   return DontYieldALot;
3966 }
3967 
3968 // This method is a slightly reworked copy of JDK's sysOpen
3969 // from src/windows/hpi/src/sys_api_md.c
3970 
3971 int os::open(const char *path, int oflag, int mode) {
3972   char pathbuf[MAX_PATH];
3973 
3974   if (strlen(path) > MAX_PATH - 1) {
3975     errno = ENAMETOOLONG;
3976           return -1;
3977   }
3978   os::native_path(strcpy(pathbuf, path));
3979   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
3980 }
3981 
3982 // Is a (classpath) directory empty?
3983 bool os::dir_is_empty(const char* path) {
3984   WIN32_FIND_DATA fd;
3985   HANDLE f = FindFirstFile(path, &fd);
3986   if (f == INVALID_HANDLE_VALUE) {
3987     return true;
3988   }
3989   FindClose(f);
3990   return false;
3991 }
3992 
3993 // create binary file, rewriting existing file if required
3994 int os::create_binary_file(const char* path, bool rewrite_existing) {
3995   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
3996   if (!rewrite_existing) {
3997     oflags |= _O_EXCL;
3998   }
3999   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4000 }
4001 
4002 // return current position of file pointer
4003 jlong os::current_file_offset(int fd) {
4004   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4005 }
4006 
4007 // move file pointer to the specified offset
4008 jlong os::seek_to_file_offset(int fd, jlong offset) {
4009   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4010 }
4011 
4012 
4013 jlong os::lseek(int fd, jlong offset, int whence) {
4014   return (jlong) ::_lseeki64(fd, offset, whence);
4015 }
4016 
4017 // This method is a slightly reworked copy of JDK's sysNativePath
4018 // from src/windows/hpi/src/path_md.c
4019 
4020 /* Convert a pathname to native format.  On win32, this involves forcing all
4021    separators to be '\\' rather than '/' (both are legal inputs, but Win95
4022    sometimes rejects '/') and removing redundant separators.  The input path is
4023    assumed to have been converted into the character encoding used by the local
4024    system.  Because this might be a double-byte encoding, care is taken to
4025    treat double-byte lead characters correctly.
4026 
4027    This procedure modifies the given path in place, as the result is never
4028    longer than the original.  There is no error return; this operation always
4029    succeeds. */
4030 char * os::native_path(char *path) {
4031   char *src = path, *dst = path, *end = path;
4032   char *colon = NULL;           /* If a drive specifier is found, this will
4033                                         point to the colon following the drive
4034                                         letter */
4035 
4036   /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4037   assert(((!::IsDBCSLeadByte('/'))
4038     && (!::IsDBCSLeadByte('\\'))
4039     && (!::IsDBCSLeadByte(':'))),
4040     "Illegal lead byte");
4041 
4042   /* Check for leading separators */
4043 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4044   while (isfilesep(*src)) {
4045     src++;
4046   }
4047 
4048   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4049     /* Remove leading separators if followed by drive specifier.  This
4050       hack is necessary to support file URLs containing drive
4051       specifiers (e.g., "file://c:/path").  As a side effect,
4052       "/c:/path" can be used as an alternative to "c:/path". */
4053     *dst++ = *src++;
4054     colon = dst;
4055     *dst++ = ':';
4056     src++;
4057   } else {
4058     src = path;
4059     if (isfilesep(src[0]) && isfilesep(src[1])) {
4060       /* UNC pathname: Retain first separator; leave src pointed at
4061          second separator so that further separators will be collapsed
4062          into the second separator.  The result will be a pathname
4063          beginning with "\\\\" followed (most likely) by a host name. */
4064       src = dst = path + 1;
4065       path[0] = '\\';     /* Force first separator to '\\' */
4066     }
4067   }
4068 
4069   end = dst;
4070 
4071   /* Remove redundant separators from remainder of path, forcing all
4072       separators to be '\\' rather than '/'. Also, single byte space
4073       characters are removed from the end of the path because those
4074       are not legal ending characters on this operating system.
4075   */
4076   while (*src != '\0') {
4077     if (isfilesep(*src)) {
4078       *dst++ = '\\'; src++;
4079       while (isfilesep(*src)) src++;
4080       if (*src == '\0') {
4081         /* Check for trailing separator */
4082         end = dst;
4083         if (colon == dst - 2) break;                      /* "z:\\" */
4084         if (dst == path + 1) break;                       /* "\\" */
4085         if (dst == path + 2 && isfilesep(path[0])) {
4086           /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4087             beginning of a UNC pathname.  Even though it is not, by
4088             itself, a valid UNC pathname, we leave it as is in order
4089             to be consistent with the path canonicalizer as well
4090             as the win32 APIs, which treat this case as an invalid
4091             UNC pathname rather than as an alias for the root
4092             directory of the current drive. */
4093           break;
4094         }
4095         end = --dst;  /* Path does not denote a root directory, so
4096                                     remove trailing separator */
4097         break;
4098       }
4099       end = dst;
4100     } else {
4101       if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4102         *dst++ = *src++;
4103         if (*src) *dst++ = *src++;
4104         end = dst;
4105       } else {         /* Copy a single-byte character */
4106         char c = *src++;
4107         *dst++ = c;
4108         /* Space is not a legal ending character */
4109         if (c != ' ') end = dst;
4110       }
4111     }
4112   }
4113 
4114   *end = '\0';
4115 
4116   /* For "z:", add "." to work around a bug in the C runtime library */
4117   if (colon == dst - 1) {
4118           path[2] = '.';
4119           path[3] = '\0';
4120   }
4121 
4122   #ifdef DEBUG
4123     jio_fprintf(stderr, "sysNativePath: %s\n", path);
4124   #endif DEBUG
4125   return path;
4126 }
4127 
4128 // This code is a copy of JDK's sysSetLength
4129 // from src/windows/hpi/src/sys_api_md.c
4130 
4131 int os::ftruncate(int fd, jlong length) {
4132   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4133   long high = (long)(length >> 32);
4134   DWORD ret;
4135 
4136   if (h == (HANDLE)(-1)) {
4137     return -1;
4138   }
4139 
4140   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4141   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4142       return -1;
4143   }
4144 
4145   if (::SetEndOfFile(h) == FALSE) {
4146     return -1;
4147   }
4148 
4149   return 0;
4150 }
4151 
4152 
4153 // This code is a copy of JDK's sysSync
4154 // from src/windows/hpi/src/sys_api_md.c
4155 // except for the legacy workaround for a bug in Win 98
4156 
4157 int os::fsync(int fd) {
4158   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4159 
4160   if ( (!::FlushFileBuffers(handle)) &&
4161          (GetLastError() != ERROR_ACCESS_DENIED) ) {
4162     /* from winerror.h */
4163     return -1;
4164   }
4165   return 0;
4166 }
4167 
4168 static int nonSeekAvailable(int, long *);
4169 static int stdinAvailable(int, long *);
4170 
4171 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4172 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4173 
4174 // This code is a copy of JDK's sysAvailable
4175 // from src/windows/hpi/src/sys_api_md.c
4176 
4177 int os::available(int fd, jlong *bytes) {
4178   jlong cur, end;
4179   struct _stati64 stbuf64;
4180 
4181   if (::_fstati64(fd, &stbuf64) >= 0) {
4182     int mode = stbuf64.st_mode;
4183     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4184       int ret;
4185       long lpbytes;
4186       if (fd == 0) {
4187         ret = stdinAvailable(fd, &lpbytes);
4188       } else {
4189         ret = nonSeekAvailable(fd, &lpbytes);
4190       }
4191       (*bytes) = (jlong)(lpbytes);
4192       return ret;
4193     }
4194     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4195       return FALSE;
4196     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4197       return FALSE;
4198     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4199       return FALSE;
4200     }
4201     *bytes = end - cur;
4202     return TRUE;
4203   } else {
4204     return FALSE;
4205   }
4206 }
4207 
4208 // This code is a copy of JDK's nonSeekAvailable
4209 // from src/windows/hpi/src/sys_api_md.c
4210 
4211 static int nonSeekAvailable(int fd, long *pbytes) {
4212   /* This is used for available on non-seekable devices
4213     * (like both named and anonymous pipes, such as pipes
4214     *  connected to an exec'd process).
4215     * Standard Input is a special case.
4216     *
4217     */
4218   HANDLE han;
4219 
4220   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4221     return FALSE;
4222   }
4223 
4224   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4225         /* PeekNamedPipe fails when at EOF.  In that case we
4226          * simply make *pbytes = 0 which is consistent with the
4227          * behavior we get on Solaris when an fd is at EOF.
4228          * The only alternative is to raise an Exception,
4229          * which isn't really warranted.
4230          */
4231     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4232       return FALSE;
4233     }
4234     *pbytes = 0;
4235   }
4236   return TRUE;
4237 }
4238 
4239 #define MAX_INPUT_EVENTS 2000
4240 
4241 // This code is a copy of JDK's stdinAvailable
4242 // from src/windows/hpi/src/sys_api_md.c
4243 
4244 static int stdinAvailable(int fd, long *pbytes) {
4245   HANDLE han;
4246   DWORD numEventsRead = 0;      /* Number of events read from buffer */
4247   DWORD numEvents = 0;  /* Number of events in buffer */
4248   DWORD i = 0;          /* Loop index */
4249   DWORD curLength = 0;  /* Position marker */
4250   DWORD actualLength = 0;       /* Number of bytes readable */
4251   BOOL error = FALSE;         /* Error holder */
4252   INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
4253 
4254   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4255         return FALSE;
4256   }
4257 
4258   /* Construct an array of input records in the console buffer */
4259   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4260   if (error == 0) {
4261     return nonSeekAvailable(fd, pbytes);
4262   }
4263 
4264   /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4265   if (numEvents > MAX_INPUT_EVENTS) {
4266     numEvents = MAX_INPUT_EVENTS;
4267   }
4268 
4269   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD));
4270   if (lpBuffer == NULL) {
4271     return FALSE;
4272   }
4273 
4274   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4275   if (error == 0) {
4276     os::free(lpBuffer);
4277     return FALSE;
4278   }
4279 
4280   /* Examine input records for the number of bytes available */
4281   for(i=0; i<numEvents; i++) {
4282     if (lpBuffer[i].EventType == KEY_EVENT) {
4283 
4284       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4285                                       &(lpBuffer[i].Event);
4286       if (keyRecord->bKeyDown == TRUE) {
4287         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4288         curLength++;
4289         if (*keyPressed == '\r') {
4290           actualLength = curLength;
4291         }
4292       }
4293     }
4294   }
4295 
4296   if(lpBuffer != NULL) {
4297     os::free(lpBuffer);
4298   }
4299 
4300   *pbytes = (long) actualLength;
4301   return TRUE;
4302 }
4303 
4304 // Map a block of memory.
4305 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
4306                      char *addr, size_t bytes, bool read_only,
4307                      bool allow_exec) {
4308   HANDLE hFile;
4309   char* base;
4310 
4311   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4312                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4313   if (hFile == NULL) {
4314     if (PrintMiscellaneous && Verbose) {
4315       DWORD err = GetLastError();
4316       tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4317     }
4318     return NULL;
4319   }
4320 
4321   if (allow_exec) {
4322     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4323     // unless it comes from a PE image (which the shared archive is not.)
4324     // Even VirtualProtect refuses to give execute access to mapped memory
4325     // that was not previously executable.
4326     //
4327     // Instead, stick the executable region in anonymous memory.  Yuck.
4328     // Penalty is that ~4 pages will not be shareable - in the future
4329     // we might consider DLLizing the shared archive with a proper PE
4330     // header so that mapping executable + sharing is possible.
4331 
4332     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4333                                 PAGE_READWRITE);
4334     if (base == NULL) {
4335       if (PrintMiscellaneous && Verbose) {
4336         DWORD err = GetLastError();
4337         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4338       }
4339       CloseHandle(hFile);
4340       return NULL;
4341     }
4342 
4343     DWORD bytes_read;
4344     OVERLAPPED overlapped;
4345     overlapped.Offset = (DWORD)file_offset;
4346     overlapped.OffsetHigh = 0;
4347     overlapped.hEvent = NULL;
4348     // ReadFile guarantees that if the return value is true, the requested
4349     // number of bytes were read before returning.
4350     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4351     if (!res) {
4352       if (PrintMiscellaneous && Verbose) {
4353         DWORD err = GetLastError();
4354         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4355       }
4356       release_memory(base, bytes);
4357       CloseHandle(hFile);
4358       return NULL;
4359     }
4360   } else {
4361     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4362                                     NULL /*file_name*/);
4363     if (hMap == NULL) {
4364       if (PrintMiscellaneous && Verbose) {
4365         DWORD err = GetLastError();
4366         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4367       }
4368       CloseHandle(hFile);
4369       return NULL;
4370     }
4371 
4372     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4373     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4374                                   (DWORD)bytes, addr);
4375     if (base == NULL) {
4376       if (PrintMiscellaneous && Verbose) {
4377         DWORD err = GetLastError();
4378         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4379       }
4380       CloseHandle(hMap);
4381       CloseHandle(hFile);
4382       return NULL;
4383     }
4384 
4385     if (CloseHandle(hMap) == 0) {
4386       if (PrintMiscellaneous && Verbose) {
4387         DWORD err = GetLastError();
4388         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4389       }
4390       CloseHandle(hFile);
4391       return base;
4392     }
4393   }
4394 
4395   if (allow_exec) {
4396     DWORD old_protect;
4397     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4398     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4399 
4400     if (!res) {
4401       if (PrintMiscellaneous && Verbose) {
4402         DWORD err = GetLastError();
4403         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4404       }
4405       // Don't consider this a hard error, on IA32 even if the
4406       // VirtualProtect fails, we should still be able to execute
4407       CloseHandle(hFile);
4408       return base;
4409     }
4410   }
4411 
4412   if (CloseHandle(hFile) == 0) {
4413     if (PrintMiscellaneous && Verbose) {
4414       DWORD err = GetLastError();
4415       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4416     }
4417     return base;
4418   }
4419 
4420   return base;
4421 }
4422 
4423 
4424 // Remap a block of memory.
4425 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
4426                        char *addr, size_t bytes, bool read_only,
4427                        bool allow_exec) {
4428   // This OS does not allow existing memory maps to be remapped so we
4429   // have to unmap the memory before we remap it.
4430   if (!os::unmap_memory(addr, bytes)) {
4431     return NULL;
4432   }
4433 
4434   // There is a very small theoretical window between the unmap_memory()
4435   // call above and the map_memory() call below where a thread in native
4436   // code may be able to access an address that is no longer mapped.
4437 
4438   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4439                         allow_exec);
4440 }
4441 
4442 
4443 // Unmap a block of memory.
4444 // Returns true=success, otherwise false.
4445 
4446 bool os::unmap_memory(char* addr, size_t bytes) {
4447   BOOL result = UnmapViewOfFile(addr);
4448   if (result == 0) {
4449     if (PrintMiscellaneous && Verbose) {
4450       DWORD err = GetLastError();
4451       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4452     }
4453     return false;
4454   }
4455   return true;
4456 }
4457 
4458 void os::pause() {
4459   char filename[MAX_PATH];
4460   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4461     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4462   } else {
4463     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4464   }
4465 
4466   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4467   if (fd != -1) {
4468     struct stat buf;
4469     ::close(fd);
4470     while (::stat(filename, &buf) == 0) {
4471       Sleep(100);
4472     }
4473   } else {
4474     jio_fprintf(stderr,
4475       "Could not open pause file '%s', continuing immediately.\n", filename);
4476   }
4477 }
4478 
4479 // An Event wraps a win32 "CreateEvent" kernel handle.
4480 //
4481 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4482 //
4483 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4484 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
4485 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4486 //     In addition, an unpark() operation might fetch the handle field, but the
4487 //     event could recycle between the fetch and the SetEvent() operation.
4488 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
4489 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
4490 //     on an stale but recycled handle would be harmless, but in practice this might
4491 //     confuse other non-Sun code, so it's not a viable approach.
4492 //
4493 // 2:  Once a win32 event handle is associated with an Event, it remains associated
4494 //     with the Event.  The event handle is never closed.  This could be construed
4495 //     as handle leakage, but only up to the maximum # of threads that have been extant
4496 //     at any one time.  This shouldn't be an issue, as windows platforms typically
4497 //     permit a process to have hundreds of thousands of open handles.
4498 //
4499 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4500 //     and release unused handles.
4501 //
4502 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4503 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
4504 //
4505 // 5.  Use an RCU-like mechanism (Read-Copy Update).
4506 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
4507 //
4508 // We use (2).
4509 //
4510 // TODO-FIXME:
4511 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4512 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4513 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
4514 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4515 //     into a single win32 CreateEvent() handle.
4516 //
4517 // _Event transitions in park()
4518 //   -1 => -1 : illegal
4519 //    1 =>  0 : pass - return immediately
4520 //    0 => -1 : block
4521 //
4522 // _Event serves as a restricted-range semaphore :
4523 //    -1 : thread is blocked
4524 //     0 : neutral  - thread is running or ready
4525 //     1 : signaled - thread is running or ready
4526 //
4527 // Another possible encoding of _Event would be
4528 // with explicit "PARKED" and "SIGNALED" bits.
4529 
4530 int os::PlatformEvent::park (jlong Millis) {
4531     guarantee (_ParkHandle != NULL , "Invariant") ;
4532     guarantee (Millis > 0          , "Invariant") ;
4533     int v ;
4534 
4535     // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4536     // the initial park() operation.
4537 
4538     for (;;) {
4539         v = _Event ;
4540         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4541     }
4542     guarantee ((v == 0) || (v == 1), "invariant") ;
4543     if (v != 0) return OS_OK ;
4544 
4545     // Do this the hard way by blocking ...
4546     // TODO: consider a brief spin here, gated on the success of recent
4547     // spin attempts by this thread.
4548     //
4549     // We decompose long timeouts into series of shorter timed waits.
4550     // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4551     // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
4552     // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4553     // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
4554     // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4555     // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
4556     // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4557     // for the already waited time.  This policy does not admit any new outcomes.
4558     // In the future, however, we might want to track the accumulated wait time and
4559     // adjust Millis accordingly if we encounter a spurious wakeup.
4560 
4561     const int MAXTIMEOUT = 0x10000000 ;
4562     DWORD rv = WAIT_TIMEOUT ;
4563     while (_Event < 0 && Millis > 0) {
4564        DWORD prd = Millis ;     // set prd = MAX (Millis, MAXTIMEOUT)
4565        if (Millis > MAXTIMEOUT) {
4566           prd = MAXTIMEOUT ;
4567        }
4568        rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4569        assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4570        if (rv == WAIT_TIMEOUT) {
4571            Millis -= prd ;
4572        }
4573     }
4574     v = _Event ;
4575     _Event = 0 ;
4576     OrderAccess::fence() ;
4577     // If we encounter a nearly simultanous timeout expiry and unpark()
4578     // we return OS_OK indicating we awoke via unpark().
4579     // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4580     return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4581 }
4582 
4583 void os::PlatformEvent::park () {
4584     guarantee (_ParkHandle != NULL, "Invariant") ;
4585     // Invariant: Only the thread associated with the Event/PlatformEvent
4586     // may call park().
4587     int v ;
4588     for (;;) {
4589         v = _Event ;
4590         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4591     }
4592     guarantee ((v == 0) || (v == 1), "invariant") ;
4593     if (v != 0) return ;
4594 
4595     // Do this the hard way by blocking ...
4596     // TODO: consider a brief spin here, gated on the success of recent
4597     // spin attempts by this thread.
4598     while (_Event < 0) {
4599        DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4600        assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4601     }
4602 
4603     // Usually we'll find _Event == 0 at this point, but as
4604     // an optional optimization we clear it, just in case can
4605     // multiple unpark() operations drove _Event up to 1.
4606     _Event = 0 ;
4607     OrderAccess::fence() ;
4608     guarantee (_Event >= 0, "invariant") ;
4609 }
4610 
4611 void os::PlatformEvent::unpark() {
4612   guarantee (_ParkHandle != NULL, "Invariant") ;
4613   int v ;
4614   for (;;) {
4615       v = _Event ;      // Increment _Event if it's < 1.
4616       if (v > 0) {
4617          // If it's already signaled just return.
4618          // The LD of _Event could have reordered or be satisfied
4619          // by a read-aside from this processor's write buffer.
4620          // To avoid problems execute a barrier and then
4621          // ratify the value.  A degenerate CAS() would also work.
4622          // Viz., CAS (v+0, &_Event, v) == v).
4623          OrderAccess::fence() ;
4624          if (_Event == v) return ;
4625          continue ;
4626       }
4627       if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4628   }
4629   if (v < 0) {
4630      ::SetEvent (_ParkHandle) ;
4631   }
4632 }
4633 
4634 
4635 // JSR166
4636 // -------------------------------------------------------
4637 
4638 /*
4639  * The Windows implementation of Park is very straightforward: Basic
4640  * operations on Win32 Events turn out to have the right semantics to
4641  * use them directly. We opportunistically resuse the event inherited
4642  * from Monitor.
4643  */
4644 
4645 
4646 void Parker::park(bool isAbsolute, jlong time) {
4647   guarantee (_ParkEvent != NULL, "invariant") ;
4648   // First, demultiplex/decode time arguments
4649   if (time < 0) { // don't wait
4650     return;
4651   }
4652   else if (time == 0 && !isAbsolute) {
4653     time = INFINITE;
4654   }
4655   else if  (isAbsolute) {
4656     time -= os::javaTimeMillis(); // convert to relative time
4657     if (time <= 0) // already elapsed
4658       return;
4659   }
4660   else { // relative
4661     time /= 1000000; // Must coarsen from nanos to millis
4662     if (time == 0)   // Wait for the minimal time unit if zero
4663       time = 1;
4664   }
4665 
4666   JavaThread* thread = (JavaThread*)(Thread::current());
4667   assert(thread->is_Java_thread(), "Must be JavaThread");
4668   JavaThread *jt = (JavaThread *)thread;
4669 
4670   // Don't wait if interrupted or already triggered
4671   if (Thread::is_interrupted(thread, false) ||
4672     WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4673     ResetEvent(_ParkEvent);
4674     return;
4675   }
4676   else {
4677     ThreadBlockInVM tbivm(jt);
4678     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4679     jt->set_suspend_equivalent();
4680 
4681     WaitForSingleObject(_ParkEvent,  time);
4682     ResetEvent(_ParkEvent);
4683 
4684     // If externally suspended while waiting, re-suspend
4685     if (jt->handle_special_suspend_equivalent_condition()) {
4686       jt->java_suspend_self();
4687     }
4688   }
4689 }
4690 
4691 void Parker::unpark() {
4692   guarantee (_ParkEvent != NULL, "invariant") ;
4693   SetEvent(_ParkEvent);
4694 }
4695 
4696 // Run the specified command in a separate process. Return its exit value,
4697 // or -1 on failure (e.g. can't create a new process).
4698 int os::fork_and_exec(char* cmd) {
4699   STARTUPINFO si;
4700   PROCESS_INFORMATION pi;
4701 
4702   memset(&si, 0, sizeof(si));
4703   si.cb = sizeof(si);
4704   memset(&pi, 0, sizeof(pi));
4705   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
4706                             cmd,    // command line
4707                             NULL,   // process security attribute
4708                             NULL,   // thread security attribute
4709                             TRUE,   // inherits system handles
4710                             0,      // no creation flags
4711                             NULL,   // use parent's environment block
4712                             NULL,   // use parent's starting directory
4713                             &si,    // (in) startup information
4714                             &pi);   // (out) process information
4715 
4716   if (rslt) {
4717     // Wait until child process exits.
4718     WaitForSingleObject(pi.hProcess, INFINITE);
4719 
4720     DWORD exit_code;
4721     GetExitCodeProcess(pi.hProcess, &exit_code);
4722 
4723     // Close process and thread handles.
4724     CloseHandle(pi.hProcess);
4725     CloseHandle(pi.hThread);
4726 
4727     return (int)exit_code;
4728   } else {
4729     return -1;
4730   }
4731 }
4732 
4733 //--------------------------------------------------------------------------------------------------
4734 // Non-product code
4735 
4736 static int mallocDebugIntervalCounter = 0;
4737 static int mallocDebugCounter = 0;
4738 bool os::check_heap(bool force) {
4739   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4740   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4741     // Note: HeapValidate executes two hardware breakpoints when it finds something
4742     // wrong; at these points, eax contains the address of the offending block (I think).
4743     // To get to the exlicit error message(s) below, just continue twice.
4744     HANDLE heap = GetProcessHeap();
4745     { HeapLock(heap);
4746       PROCESS_HEAP_ENTRY phe;
4747       phe.lpData = NULL;
4748       while (HeapWalk(heap, &phe) != 0) {
4749         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4750             !HeapValidate(heap, 0, phe.lpData)) {
4751           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4752           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4753           fatal("corrupted C heap");
4754         }
4755       }
4756       DWORD err = GetLastError();
4757       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4758         fatal(err_msg("heap walk aborted with error %d", err));
4759       }
4760       HeapUnlock(heap);
4761     }
4762     mallocDebugIntervalCounter = 0;
4763   }
4764   return true;
4765 }
4766 
4767 
4768 bool os::find(address addr, outputStream* st) {
4769   // Nothing yet
4770   return false;
4771 }
4772 
4773 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4774   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4775 
4776   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4777     JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4778     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4779     address addr = (address) exceptionRecord->ExceptionInformation[1];
4780 
4781     if (os::is_memory_serialize_page(thread, addr))
4782       return EXCEPTION_CONTINUE_EXECUTION;
4783   }
4784 
4785   return EXCEPTION_CONTINUE_SEARCH;
4786 }
4787 
4788 // We don't build a headless jre for Windows
4789 bool os::is_headless_jre() { return false; }
4790 
4791 
4792 typedef CRITICAL_SECTION mutex_t;
4793 #define mutexInit(m)    InitializeCriticalSection(m)
4794 #define mutexDestroy(m) DeleteCriticalSection(m)
4795 #define mutexLock(m)    EnterCriticalSection(m)
4796 #define mutexUnlock(m)  LeaveCriticalSection(m)
4797 
4798 static bool sock_initialized = FALSE;
4799 static mutex_t sockFnTableMutex;
4800 
4801 static void initSock() {
4802   WSADATA wsadata;
4803 
4804   if (!os::WinSock2Dll::WinSock2Available()) {
4805     jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4806       ::GetLastError());
4807     return;
4808   }
4809   if (sock_initialized == TRUE) return;
4810 
4811   ::mutexInit(&sockFnTableMutex);
4812   ::mutexLock(&sockFnTableMutex);
4813   if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) {
4814       jio_fprintf(stderr, "Could not initialize Winsock\n");
4815   }
4816   sock_initialized = TRUE;
4817   ::mutexUnlock(&sockFnTableMutex);
4818 }
4819 
4820 struct hostent* os::get_host_by_name(char* name) {
4821   if (!sock_initialized) {
4822     initSock();
4823   }
4824   if (!os::WinSock2Dll::WinSock2Available()) {
4825     return NULL;
4826   }
4827   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
4828 }
4829 
4830 
4831 int os::socket_close(int fd) {
4832   ShouldNotReachHere();
4833   return 0;
4834 }
4835 
4836 int os::socket_available(int fd, jint *pbytes) {
4837   ShouldNotReachHere();
4838   return 0;
4839 }
4840 
4841 int os::socket(int domain, int type, int protocol) {
4842   ShouldNotReachHere();
4843   return 0;
4844 }
4845 
4846 int os::listen(int fd, int count) {
4847   ShouldNotReachHere();
4848   return 0;
4849 }
4850 
4851 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
4852   ShouldNotReachHere();
4853   return 0;
4854 }
4855 
4856 int os::accept(int fd, struct sockaddr* him, socklen_t* len) {
4857   ShouldNotReachHere();
4858   return 0;
4859 }
4860 
4861 int os::sendto(int fd, char* buf, size_t len, uint flags,
4862                struct sockaddr* to, socklen_t tolen) {
4863   ShouldNotReachHere();
4864   return 0;
4865 }
4866 
4867 int os::recvfrom(int fd, char *buf, size_t nBytes, uint flags,
4868                  sockaddr* from, socklen_t* fromlen) {
4869   ShouldNotReachHere();
4870   return 0;
4871 }
4872 
4873 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
4874   ShouldNotReachHere();
4875   return 0;
4876 }
4877 
4878 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
4879   ShouldNotReachHere();
4880   return 0;
4881 }
4882 
4883 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
4884   ShouldNotReachHere();
4885   return 0;
4886 }
4887 
4888 int os::timeout(int fd, long timeout) {
4889   ShouldNotReachHere();
4890   return 0;
4891 }
4892 
4893 int os::get_host_name(char* name, int namelen) {
4894   ShouldNotReachHere();
4895   return 0;
4896 }
4897 
4898 int os::socket_shutdown(int fd, int howto) {
4899   ShouldNotReachHere();
4900   return 0;
4901 }
4902 
4903 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
4904   ShouldNotReachHere();
4905   return 0;
4906 }
4907 
4908 int os::get_sock_name(int fd, struct sockaddr* him, socklen_t* len) {
4909   ShouldNotReachHere();
4910   return 0;
4911 }
4912 
4913 int os::get_sock_opt(int fd, int level, int optname,
4914                      char* optval, socklen_t* optlen) {
4915   ShouldNotReachHere();
4916   return 0;
4917 }
4918 
4919 int os::set_sock_opt(int fd, int level, int optname,
4920                      const char* optval, socklen_t optlen) {
4921   ShouldNotReachHere();
4922   return 0;
4923 }
4924 
4925 
4926 // Kernel32 API
4927 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
4928 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
4929 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
4930 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
4931 
4932 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
4933 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
4934 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
4935 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
4936 BOOL                        os::Kernel32Dll::initialized = FALSE;
4937 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
4938   assert(initialized && _GetLargePageMinimum != NULL,
4939     "GetLargePageMinimumAvailable() not yet called");
4940   return _GetLargePageMinimum();
4941 }
4942 
4943 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
4944   if (!initialized) {
4945     initialize();
4946   }
4947   return _GetLargePageMinimum != NULL;
4948 }
4949 
4950 BOOL os::Kernel32Dll::NumaCallsAvailable() {
4951   if (!initialized) {
4952     initialize();
4953   }
4954   return _VirtualAllocExNuma != NULL;
4955 }
4956 
4957 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
4958   assert(initialized && _VirtualAllocExNuma != NULL,
4959     "NUMACallsAvailable() not yet called");
4960 
4961   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
4962 }
4963 
4964 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
4965   assert(initialized && _GetNumaHighestNodeNumber != NULL,
4966     "NUMACallsAvailable() not yet called");
4967 
4968   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
4969 }
4970 
4971 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
4972   assert(initialized && _GetNumaNodeProcessorMask != NULL,
4973     "NUMACallsAvailable() not yet called");
4974 
4975   return _GetNumaNodeProcessorMask(node, proc_mask);
4976 }
4977 
4978 
4979 void os::Kernel32Dll::initializeCommon() {
4980   if (!initialized) {
4981     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
4982     assert(handle != NULL, "Just check");
4983     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
4984     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
4985     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
4986     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
4987     initialized = TRUE;
4988   }
4989 }
4990 
4991 
4992 
4993 #ifndef JDK6_OR_EARLIER
4994 
4995 void os::Kernel32Dll::initialize() {
4996   initializeCommon();
4997 }
4998 
4999 
5000 // Kernel32 API
5001 inline BOOL os::Kernel32Dll::SwitchToThread() {
5002   return ::SwitchToThread();
5003 }
5004 
5005 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5006   return true;
5007 }
5008 
5009   // Help tools
5010 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5011   return true;
5012 }
5013 
5014 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5015   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5016 }
5017 
5018 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5019   return ::Module32First(hSnapshot, lpme);
5020 }
5021 
5022 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5023   return ::Module32Next(hSnapshot, lpme);
5024 }
5025 
5026 
5027 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5028   return true;
5029 }
5030 
5031 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5032   ::GetNativeSystemInfo(lpSystemInfo);
5033 }
5034 
5035 // PSAPI API
5036 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5037   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5038 }
5039 
5040 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5041   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5042 }
5043 
5044 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5045   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5046 }
5047 
5048 inline BOOL os::PSApiDll::PSApiAvailable() {
5049   return true;
5050 }
5051 
5052 
5053 // WinSock2 API
5054 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5055   return ::WSAStartup(wVersionRequested, lpWSAData);
5056 }
5057 
5058 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5059   return ::gethostbyname(name);
5060 }
5061 
5062 inline BOOL os::WinSock2Dll::WinSock2Available() {
5063   return true;
5064 }
5065 
5066 // Advapi API
5067 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5068    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5069    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5070      return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5071        BufferLength, PreviousState, ReturnLength);
5072 }
5073 
5074 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5075   PHANDLE TokenHandle) {
5076     return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5077 }
5078 
5079 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5080   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5081 }
5082 
5083 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5084   return true;
5085 }
5086 
5087 #else
5088 // Kernel32 API
5089 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5090 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5091 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5092 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5093 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5094 
5095 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
5096 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5097 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
5098 Module32Next_Fn             os::Kernel32Dll::_Module32Next = NULL;
5099 GetNativeSystemInfo_Fn      os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5100 
5101 
5102 void os::Kernel32Dll::initialize() {
5103   if (!initialized) {
5104     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5105     assert(handle != NULL, "Just check");
5106 
5107     _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5108     _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5109       ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5110     _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5111     _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5112     _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5113     initializeCommon();  // resolve the functions that always need resolving
5114 
5115     initialized = TRUE;
5116   }
5117 }
5118 
5119 BOOL os::Kernel32Dll::SwitchToThread() {
5120   assert(initialized && _SwitchToThread != NULL,
5121     "SwitchToThreadAvailable() not yet called");
5122   return _SwitchToThread();
5123 }
5124 
5125 
5126 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5127   if (!initialized) {
5128     initialize();
5129   }
5130   return _SwitchToThread != NULL;
5131 }
5132 
5133 // Help tools
5134 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5135   if (!initialized) {
5136     initialize();
5137   }
5138   return _CreateToolhelp32Snapshot != NULL &&
5139          _Module32First != NULL &&
5140          _Module32Next != NULL;
5141 }
5142 
5143 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5144   assert(initialized && _CreateToolhelp32Snapshot != NULL,
5145     "HelpToolsAvailable() not yet called");
5146 
5147   return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5148 }
5149 
5150 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5151   assert(initialized && _Module32First != NULL,
5152     "HelpToolsAvailable() not yet called");
5153 
5154   return _Module32First(hSnapshot, lpme);
5155 }
5156 
5157 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5158   assert(initialized && _Module32Next != NULL,
5159     "HelpToolsAvailable() not yet called");
5160 
5161   return _Module32Next(hSnapshot, lpme);
5162 }
5163 
5164 
5165 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5166   if (!initialized) {
5167     initialize();
5168   }
5169   return _GetNativeSystemInfo != NULL;
5170 }
5171 
5172 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5173   assert(initialized && _GetNativeSystemInfo != NULL,
5174     "GetNativeSystemInfoAvailable() not yet called");
5175 
5176   _GetNativeSystemInfo(lpSystemInfo);
5177 }
5178 
5179 
5180 
5181 // PSAPI API
5182 
5183 
5184 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5185 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5186 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5187 
5188 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
5189 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
5190 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5191 BOOL                    os::PSApiDll::initialized = FALSE;
5192 
5193 void os::PSApiDll::initialize() {
5194   if (!initialized) {
5195     HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5196     if (handle != NULL) {
5197       _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5198         "EnumProcessModules");
5199       _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5200         "GetModuleFileNameExA");
5201       _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5202         "GetModuleInformation");
5203     }
5204     initialized = TRUE;
5205   }
5206 }
5207 
5208 
5209 
5210 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5211   assert(initialized && _EnumProcessModules != NULL,
5212     "PSApiAvailable() not yet called");
5213   return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5214 }
5215 
5216 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5217   assert(initialized && _GetModuleFileNameEx != NULL,
5218     "PSApiAvailable() not yet called");
5219   return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5220 }
5221 
5222 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5223   assert(initialized && _GetModuleInformation != NULL,
5224     "PSApiAvailable() not yet called");
5225   return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5226 }
5227 
5228 BOOL os::PSApiDll::PSApiAvailable() {
5229   if (!initialized) {
5230     initialize();
5231   }
5232   return _EnumProcessModules != NULL &&
5233     _GetModuleFileNameEx != NULL &&
5234     _GetModuleInformation != NULL;
5235 }
5236 
5237 
5238 // WinSock2 API
5239 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5240 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5241 
5242 WSAStartup_Fn    os::WinSock2Dll::_WSAStartup = NULL;
5243 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5244 BOOL             os::WinSock2Dll::initialized = FALSE;
5245 
5246 void os::WinSock2Dll::initialize() {
5247   if (!initialized) {
5248     HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5249     if (handle != NULL) {
5250       _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5251       _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5252     }
5253     initialized = TRUE;
5254   }
5255 }
5256 
5257 
5258 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5259   assert(initialized && _WSAStartup != NULL,
5260     "WinSock2Available() not yet called");
5261   return _WSAStartup(wVersionRequested, lpWSAData);
5262 }
5263 
5264 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5265   assert(initialized && _gethostbyname != NULL,
5266     "WinSock2Available() not yet called");
5267   return _gethostbyname(name);
5268 }
5269 
5270 BOOL os::WinSock2Dll::WinSock2Available() {
5271   if (!initialized) {
5272     initialize();
5273   }
5274   return _WSAStartup != NULL &&
5275     _gethostbyname != NULL;
5276 }
5277 
5278 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5279 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5280 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5281 
5282 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5283 OpenProcessToken_Fn      os::Advapi32Dll::_OpenProcessToken = NULL;
5284 LookupPrivilegeValue_Fn  os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5285 BOOL                     os::Advapi32Dll::initialized = FALSE;
5286 
5287 void os::Advapi32Dll::initialize() {
5288   if (!initialized) {
5289     HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5290     if (handle != NULL) {
5291       _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5292         "AdjustTokenPrivileges");
5293       _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5294         "OpenProcessToken");
5295       _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5296         "LookupPrivilegeValueA");
5297     }
5298     initialized = TRUE;
5299   }
5300 }
5301 
5302 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5303    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5304    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5305    assert(initialized && _AdjustTokenPrivileges != NULL,
5306      "AdvapiAvailable() not yet called");
5307    return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5308        BufferLength, PreviousState, ReturnLength);
5309 }
5310 
5311 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5312   PHANDLE TokenHandle) {
5313    assert(initialized && _OpenProcessToken != NULL,
5314      "AdvapiAvailable() not yet called");
5315     return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5316 }
5317 
5318 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5319    assert(initialized && _LookupPrivilegeValue != NULL,
5320      "AdvapiAvailable() not yet called");
5321   return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5322 }
5323 
5324 BOOL os::Advapi32Dll::AdvapiAvailable() {
5325   if (!initialized) {
5326     initialize();
5327   }
5328   return _AdjustTokenPrivileges != NULL &&
5329     _OpenProcessToken != NULL &&
5330     _LookupPrivilegeValue != NULL;
5331 }
5332 
5333 #endif
5334 
--- EOF ---