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