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, size_t alignment, char* addr, bool exec) {
3160   assert(UseLargePages, "only for large pages");
3161 
3162   if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3163     return NULL; // Fallback to small pages.
3164   }
3165 
3166   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3167   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3168 
3169   // with large pages, there are two cases where we need to use Individual Allocation
3170   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3171   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3172   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3173     if (TracePageSizes && Verbose) {
3174        tty->print_cr("Reserving large pages individually.");
3175     }
3176     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3177     if (p_buf == NULL) {
3178       // give an appropriate warning message
3179       if (UseNUMAInterleaving) {
3180         warning("NUMA large page allocation failed, UseLargePages flag ignored");
3181       }
3182       if (UseLargePagesIndividualAllocation) {
3183         warning("Individually allocated large pages failed, "
3184                 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3185       }
3186       return NULL;
3187     }
3188 
3189     return p_buf;
3190 
3191   } else {
3192     if (TracePageSizes && Verbose) {
3193        tty->print_cr("Reserving large pages in a single large chunk.");
3194     }
3195     // normal policy just allocate it all at once
3196     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3197     char * res = (char *)VirtualAlloc(addr, bytes, flag, prot);
3198     if (res != NULL) {
3199       address pc = CALLER_PC;
3200       MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, mtNone, pc);
3201     }
3202 
3203     return res;
3204   }
3205 }
3206 
3207 bool os::release_memory_special(char* base, size_t bytes) {
3208   assert(base != NULL, "Sanity check");
3209   return release_memory(base, bytes);
3210 }
3211 
3212 void os::print_statistics() {
3213 }
3214 
3215 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
3216   int err = os::get_last_error();
3217   char buf[256];
3218   size_t buf_len = os::lasterror(buf, sizeof(buf));
3219   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
3220           ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
3221           exec, buf_len != 0 ? buf : "<no_error_string>", err);
3222 }
3223 
3224 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
3225   if (bytes == 0) {
3226     // Don't bother the OS with noops.
3227     return true;
3228   }
3229   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3230   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3231   // Don't attempt to print anything if the OS call fails. We're
3232   // probably low on resources, so the print itself may cause crashes.
3233 
3234   // unless we have NUMAInterleaving enabled, the range of a commit
3235   // is always within a reserve covered by a single VirtualAlloc
3236   // in that case we can just do a single commit for the requested size
3237   if (!UseNUMAInterleaving) {
3238     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
3239       NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3240       return false;
3241     }
3242     if (exec) {
3243       DWORD oldprot;
3244       // Windows doc says to use VirtualProtect to get execute permissions
3245       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
3246         NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3247         return false;
3248       }
3249     }
3250     return true;
3251   } else {
3252 
3253     // when NUMAInterleaving is enabled, the commit might cover a range that
3254     // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3255     // VirtualQuery can help us determine that.  The RegionSize that VirtualQuery
3256     // returns represents the number of bytes that can be committed in one step.
3257     size_t bytes_remaining = bytes;
3258     char * next_alloc_addr = addr;
3259     while (bytes_remaining > 0) {
3260       MEMORY_BASIC_INFORMATION alloc_info;
3261       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3262       size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3263       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
3264                        PAGE_READWRITE) == NULL) {
3265         NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3266                                             exec);)
3267         return false;
3268       }
3269       if (exec) {
3270         DWORD oldprot;
3271         if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
3272                             PAGE_EXECUTE_READWRITE, &oldprot)) {
3273           NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3274                                               exec);)
3275           return false;
3276         }
3277       }
3278       bytes_remaining -= bytes_to_rq;
3279       next_alloc_addr += bytes_to_rq;
3280     }
3281   }
3282   // if we made it this far, return true
3283   return true;
3284 }
3285 
3286 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
3287                        bool exec) {
3288   // alignment_hint is ignored on this OS
3289   return pd_commit_memory(addr, size, exec);
3290 }
3291 
3292 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
3293                                   const char* mesg) {
3294   assert(mesg != NULL, "mesg must be specified");
3295   if (!pd_commit_memory(addr, size, exec)) {
3296     warn_fail_commit_memory(addr, size, exec);
3297     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
3298   }
3299 }
3300 
3301 void os::pd_commit_memory_or_exit(char* addr, size_t size,
3302                                   size_t alignment_hint, bool exec,
3303                                   const char* mesg) {
3304   // alignment_hint is ignored on this OS
3305   pd_commit_memory_or_exit(addr, size, exec, mesg);
3306 }
3307 
3308 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
3309   if (bytes == 0) {
3310     // Don't bother the OS with noops.
3311     return true;
3312   }
3313   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3314   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3315   return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0);
3316 }
3317 
3318 bool os::pd_release_memory(char* addr, size_t bytes) {
3319   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3320 }
3321 
3322 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3323   return os::commit_memory(addr, size, !ExecMem);
3324 }
3325 
3326 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3327   return os::uncommit_memory(addr, size);
3328 }
3329 
3330 // Set protections specified
3331 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3332                         bool is_committed) {
3333   unsigned int p = 0;
3334   switch (prot) {
3335   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3336   case MEM_PROT_READ: p = PAGE_READONLY; break;
3337   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3338   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3339   default:
3340     ShouldNotReachHere();
3341   }
3342 
3343   DWORD old_status;
3344 
3345   // Strange enough, but on Win32 one can change protection only for committed
3346   // memory, not a big deal anyway, as bytes less or equal than 64K
3347   if (!is_committed) {
3348     commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
3349                           "cannot commit protection page");
3350   }
3351   // One cannot use os::guard_memory() here, as on Win32 guard page
3352   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3353   //
3354   // Pages in the region become guard pages. Any attempt to access a guard page
3355   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3356   // the guard page status. Guard pages thus act as a one-time access alarm.
3357   return VirtualProtect(addr, bytes, p, &old_status) != 0;
3358 }
3359 
3360 bool os::guard_memory(char* addr, size_t bytes) {
3361   DWORD old_status;
3362   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3363 }
3364 
3365 bool os::unguard_memory(char* addr, size_t bytes) {
3366   DWORD old_status;
3367   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3368 }
3369 
3370 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3371 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3372 void os::numa_make_global(char *addr, size_t bytes)    { }
3373 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3374 bool os::numa_topology_changed()                       { return false; }
3375 size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3376 int os::numa_get_group_id()                            { return 0; }
3377 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3378   if (numa_node_list_holder.get_count() == 0 && size > 0) {
3379     // Provide an answer for UMA systems
3380     ids[0] = 0;
3381     return 1;
3382   } else {
3383     // check for size bigger than actual groups_num
3384     size = MIN2(size, numa_get_groups_num());
3385     for (int i = 0; i < (int)size; i++) {
3386       ids[i] = numa_node_list_holder.get_node_list_entry(i);
3387     }
3388     return size;
3389   }
3390 }
3391 
3392 bool os::get_page_info(char *start, page_info* info) {
3393   return false;
3394 }
3395 
3396 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3397   return end;
3398 }
3399 
3400 char* os::non_memory_address_word() {
3401   // Must never look like an address returned by reserve_memory,
3402   // even in its subfields (as defined by the CPU immediate fields,
3403   // if the CPU splits constants across multiple instructions).
3404   return (char*)-1;
3405 }
3406 
3407 #define MAX_ERROR_COUNT 100
3408 #define SYS_THREAD_ERROR 0xffffffffUL
3409 
3410 void os::pd_start_thread(Thread* thread) {
3411   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3412   // Returns previous suspend state:
3413   // 0:  Thread was not suspended
3414   // 1:  Thread is running now
3415   // >1: Thread is still suspended.
3416   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3417 }
3418 
3419 class HighResolutionInterval : public CHeapObj<mtThread> {
3420   // The default timer resolution seems to be 10 milliseconds.
3421   // (Where is this written down?)
3422   // If someone wants to sleep for only a fraction of the default,
3423   // then we set the timer resolution down to 1 millisecond for
3424   // the duration of their interval.
3425   // We carefully set the resolution back, since otherwise we
3426   // seem to incur an overhead (3%?) that we don't need.
3427   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3428   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3429   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3430   // timeBeginPeriod() if the relative error exceeded some threshold.
3431   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3432   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3433   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3434   // resolution timers running.
3435 private:
3436     jlong resolution;
3437 public:
3438   HighResolutionInterval(jlong ms) {
3439     resolution = ms % 10L;
3440     if (resolution != 0) {
3441       MMRESULT result = timeBeginPeriod(1L);
3442     }
3443   }
3444   ~HighResolutionInterval() {
3445     if (resolution != 0) {
3446       MMRESULT result = timeEndPeriod(1L);
3447     }
3448     resolution = 0L;
3449   }
3450 };
3451 
3452 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3453   jlong limit = (jlong) MAXDWORD;
3454 
3455   while(ms > limit) {
3456     int res;
3457     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3458       return res;
3459     ms -= limit;
3460   }
3461 
3462   assert(thread == Thread::current(),  "thread consistency check");
3463   OSThread* osthread = thread->osthread();
3464   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3465   int result;
3466   if (interruptable) {
3467     assert(thread->is_Java_thread(), "must be java thread");
3468     JavaThread *jt = (JavaThread *) thread;
3469     ThreadBlockInVM tbivm(jt);
3470 
3471     jt->set_suspend_equivalent();
3472     // cleared by handle_special_suspend_equivalent_condition() or
3473     // java_suspend_self() via check_and_wait_while_suspended()
3474 
3475     HANDLE events[1];
3476     events[0] = osthread->interrupt_event();
3477     HighResolutionInterval *phri=NULL;
3478     if(!ForceTimeHighResolution)
3479       phri = new HighResolutionInterval( ms );
3480     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3481       result = OS_TIMEOUT;
3482     } else {
3483       ResetEvent(osthread->interrupt_event());
3484       osthread->set_interrupted(false);
3485       result = OS_INTRPT;
3486     }
3487     delete phri; //if it is NULL, harmless
3488 
3489     // were we externally suspended while we were waiting?
3490     jt->check_and_wait_while_suspended();
3491   } else {
3492     assert(!thread->is_Java_thread(), "must not be java thread");
3493     Sleep((long) ms);
3494     result = OS_TIMEOUT;
3495   }
3496   return result;
3497 }
3498 
3499 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3500 void os::infinite_sleep() {
3501   while (true) {    // sleep forever ...
3502     Sleep(100000);  // ... 100 seconds at a time
3503   }
3504 }
3505 
3506 typedef BOOL (WINAPI * STTSignature)(void) ;
3507 
3508 os::YieldResult os::NakedYield() {
3509   // Use either SwitchToThread() or Sleep(0)
3510   // Consider passing back the return value from SwitchToThread().
3511   if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3512     return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3513   } else {
3514     Sleep(0);
3515   }
3516   return os::YIELD_UNKNOWN ;
3517 }
3518 
3519 void os::yield() {  os::NakedYield(); }
3520 
3521 void os::yield_all(int attempts) {
3522   // Yields to all threads, including threads with lower priorities
3523   Sleep(1);
3524 }
3525 
3526 // Win32 only gives you access to seven real priorities at a time,
3527 // so we compress Java's ten down to seven.  It would be better
3528 // if we dynamically adjusted relative priorities.
3529 
3530 int os::java_to_os_priority[CriticalPriority + 1] = {
3531   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3532   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3533   THREAD_PRIORITY_LOWEST,                       // 2
3534   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3535   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3536   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3537   THREAD_PRIORITY_NORMAL,                       // 6
3538   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3539   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3540   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3541   THREAD_PRIORITY_HIGHEST,                      // 10 MaxPriority
3542   THREAD_PRIORITY_HIGHEST                       // 11 CriticalPriority
3543 };
3544 
3545 int prio_policy1[CriticalPriority + 1] = {
3546   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3547   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3548   THREAD_PRIORITY_LOWEST,                       // 2
3549   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3550   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3551   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3552   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3553   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3554   THREAD_PRIORITY_HIGHEST,                      // 8
3555   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3556   THREAD_PRIORITY_TIME_CRITICAL,                // 10 MaxPriority
3557   THREAD_PRIORITY_TIME_CRITICAL                 // 11 CriticalPriority
3558 };
3559 
3560 static int prio_init() {
3561   // If ThreadPriorityPolicy is 1, switch tables
3562   if (ThreadPriorityPolicy == 1) {
3563     int i;
3564     for (i = 0; i < CriticalPriority + 1; i++) {
3565       os::java_to_os_priority[i] = prio_policy1[i];
3566     }
3567   }
3568   if (UseCriticalJavaThreadPriority) {
3569     os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority] ;
3570   }
3571   return 0;
3572 }
3573 
3574 OSReturn os::set_native_priority(Thread* thread, int priority) {
3575   if (!UseThreadPriorities) return OS_OK;
3576   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3577   return ret ? OS_OK : OS_ERR;
3578 }
3579 
3580 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3581   if ( !UseThreadPriorities ) {
3582     *priority_ptr = java_to_os_priority[NormPriority];
3583     return OS_OK;
3584   }
3585   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3586   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3587     assert(false, "GetThreadPriority failed");
3588     return OS_ERR;
3589   }
3590   *priority_ptr = os_prio;
3591   return OS_OK;
3592 }
3593 
3594 
3595 // Hint to the underlying OS that a task switch would not be good.
3596 // Void return because it's a hint and can fail.
3597 void os::hint_no_preempt() {}
3598 
3599 void os::interrupt(Thread* thread) {
3600   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3601          "possibility of dangling Thread pointer");
3602 
3603   OSThread* osthread = thread->osthread();
3604   osthread->set_interrupted(true);
3605   // More than one thread can get here with the same value of osthread,
3606   // resulting in multiple notifications.  We do, however, want the store
3607   // to interrupted() to be visible to other threads before we post
3608   // the interrupt event.
3609   OrderAccess::release();
3610   SetEvent(osthread->interrupt_event());
3611   // For JSR166:  unpark after setting status
3612   if (thread->is_Java_thread())
3613     ((JavaThread*)thread)->parker()->unpark();
3614 
3615   ParkEvent * ev = thread->_ParkEvent ;
3616   if (ev != NULL) ev->unpark() ;
3617 
3618 }
3619 
3620 
3621 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3622   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3623          "possibility of dangling Thread pointer");
3624 
3625   OSThread* osthread = thread->osthread();
3626   bool interrupted = osthread->interrupted();
3627   // There is no synchronization between the setting of the interrupt
3628   // and it being cleared here. It is critical - see 6535709 - that
3629   // we only clear the interrupt state, and reset the interrupt event,
3630   // if we are going to report that we were indeed interrupted - else
3631   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3632   // depending on the timing
3633   if (interrupted && clear_interrupted) {
3634     osthread->set_interrupted(false);
3635     ResetEvent(osthread->interrupt_event());
3636   } // Otherwise leave the interrupted state alone
3637 
3638   return interrupted;
3639 }
3640 
3641 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3642 ExtendedPC os::get_thread_pc(Thread* thread) {
3643   CONTEXT context;
3644   context.ContextFlags = CONTEXT_CONTROL;
3645   HANDLE handle = thread->osthread()->thread_handle();
3646 #ifdef _M_IA64
3647   assert(0, "Fix get_thread_pc");
3648   return ExtendedPC(NULL);
3649 #else
3650   if (GetThreadContext(handle, &context)) {
3651 #ifdef _M_AMD64
3652     return ExtendedPC((address) context.Rip);
3653 #else
3654     return ExtendedPC((address) context.Eip);
3655 #endif
3656   } else {
3657     return ExtendedPC(NULL);
3658   }
3659 #endif
3660 }
3661 
3662 // GetCurrentThreadId() returns DWORD
3663 intx os::current_thread_id()          { return GetCurrentThreadId(); }
3664 
3665 static int _initial_pid = 0;
3666 
3667 int os::current_process_id()
3668 {
3669   return (_initial_pid ? _initial_pid : _getpid());
3670 }
3671 
3672 int    os::win32::_vm_page_size       = 0;
3673 int    os::win32::_vm_allocation_granularity = 0;
3674 int    os::win32::_processor_type     = 0;
3675 // Processor level is not available on non-NT systems, use vm_version instead
3676 int    os::win32::_processor_level    = 0;
3677 julong os::win32::_physical_memory    = 0;
3678 size_t os::win32::_default_stack_size = 0;
3679 
3680          intx os::win32::_os_thread_limit    = 0;
3681 volatile intx os::win32::_os_thread_count    = 0;
3682 
3683 bool   os::win32::_is_nt              = false;
3684 bool   os::win32::_is_windows_2003    = false;
3685 bool   os::win32::_is_windows_server  = false;
3686 
3687 void os::win32::initialize_system_info() {
3688   SYSTEM_INFO si;
3689   GetSystemInfo(&si);
3690   _vm_page_size    = si.dwPageSize;
3691   _vm_allocation_granularity = si.dwAllocationGranularity;
3692   _processor_type  = si.dwProcessorType;
3693   _processor_level = si.wProcessorLevel;
3694   set_processor_count(si.dwNumberOfProcessors);
3695 
3696   MEMORYSTATUSEX ms;
3697   ms.dwLength = sizeof(ms);
3698 
3699   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3700   // dwMemoryLoad (% of memory in use)
3701   GlobalMemoryStatusEx(&ms);
3702   _physical_memory = ms.ullTotalPhys;
3703 
3704   OSVERSIONINFOEX oi;
3705   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3706   GetVersionEx((OSVERSIONINFO*)&oi);
3707   switch(oi.dwPlatformId) {
3708     case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3709     case VER_PLATFORM_WIN32_NT:
3710       _is_nt = true;
3711       {
3712         int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3713         if (os_vers == 5002) {
3714           _is_windows_2003 = true;
3715         }
3716         if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3717           oi.wProductType == VER_NT_SERVER) {
3718             _is_windows_server = true;
3719         }
3720       }
3721       break;
3722     default: fatal("Unknown platform");
3723   }
3724 
3725   _default_stack_size = os::current_stack_size();
3726   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3727   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3728     "stack size not a multiple of page size");
3729 
3730   initialize_performance_counter();
3731 
3732   // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3733   // known to deadlock the system, if the VM issues to thread operations with
3734   // a too high frequency, e.g., such as changing the priorities.
3735   // The 6000 seems to work well - no deadlocks has been notices on the test
3736   // programs that we have seen experience this problem.
3737   if (!os::win32::is_nt()) {
3738     StarvationMonitorInterval = 6000;
3739   }
3740 }
3741 
3742 
3743 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3744   char path[MAX_PATH];
3745   DWORD size;
3746   DWORD pathLen = (DWORD)sizeof(path);
3747   HINSTANCE result = NULL;
3748 
3749   // only allow library name without path component
3750   assert(strchr(name, '\\') == NULL, "path not allowed");
3751   assert(strchr(name, ':') == NULL, "path not allowed");
3752   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3753     jio_snprintf(ebuf, ebuflen,
3754       "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3755     return NULL;
3756   }
3757 
3758   // search system directory
3759   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3760     strcat(path, "\\");
3761     strcat(path, name);
3762     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3763       return result;
3764     }
3765   }
3766 
3767   // try Windows directory
3768   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3769     strcat(path, "\\");
3770     strcat(path, name);
3771     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3772       return result;
3773     }
3774   }
3775 
3776   jio_snprintf(ebuf, ebuflen,
3777     "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3778   return NULL;
3779 }
3780 
3781 void os::win32::setmode_streams() {
3782   _setmode(_fileno(stdin), _O_BINARY);
3783   _setmode(_fileno(stdout), _O_BINARY);
3784   _setmode(_fileno(stderr), _O_BINARY);
3785 }
3786 
3787 
3788 bool os::is_debugger_attached() {
3789   return IsDebuggerPresent() ? true : false;
3790 }
3791 
3792 
3793 void os::wait_for_keypress_at_exit(void) {
3794   if (PauseAtExit) {
3795     fprintf(stderr, "Press any key to continue...\n");
3796     fgetc(stdin);
3797   }
3798 }
3799 
3800 
3801 int os::message_box(const char* title, const char* message) {
3802   int result = MessageBox(NULL, message, title,
3803                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3804   return result == IDYES;
3805 }
3806 
3807 int os::allocate_thread_local_storage() {
3808   return TlsAlloc();
3809 }
3810 
3811 
3812 void os::free_thread_local_storage(int index) {
3813   TlsFree(index);
3814 }
3815 
3816 
3817 void os::thread_local_storage_at_put(int index, void* value) {
3818   TlsSetValue(index, value);
3819   assert(thread_local_storage_at(index) == value, "Just checking");
3820 }
3821 
3822 
3823 void* os::thread_local_storage_at(int index) {
3824   return TlsGetValue(index);
3825 }
3826 
3827 
3828 #ifndef PRODUCT
3829 #ifndef _WIN64
3830 // Helpers to check whether NX protection is enabled
3831 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3832   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3833       pex->ExceptionRecord->NumberParameters > 0 &&
3834       pex->ExceptionRecord->ExceptionInformation[0] ==
3835       EXCEPTION_INFO_EXEC_VIOLATION) {
3836     return EXCEPTION_EXECUTE_HANDLER;
3837   }
3838   return EXCEPTION_CONTINUE_SEARCH;
3839 }
3840 
3841 void nx_check_protection() {
3842   // If NX is enabled we'll get an exception calling into code on the stack
3843   char code[] = { (char)0xC3 }; // ret
3844   void *code_ptr = (void *)code;
3845   __try {
3846     __asm call code_ptr
3847   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3848     tty->print_raw_cr("NX protection detected.");
3849   }
3850 }
3851 #endif // _WIN64
3852 #endif // PRODUCT
3853 
3854 // this is called _before_ the global arguments have been parsed
3855 void os::init(void) {
3856   _initial_pid = _getpid();
3857 
3858   init_random(1234567);
3859 
3860   win32::initialize_system_info();
3861   win32::setmode_streams();
3862   init_page_sizes((size_t) win32::vm_page_size());
3863 
3864   // For better scalability on MP systems (must be called after initialize_system_info)
3865 #ifndef PRODUCT
3866   if (is_MP()) {
3867     NoYieldsInMicrolock = true;
3868   }
3869 #endif
3870   // This may be overridden later when argument processing is done.
3871   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3872     os::win32::is_windows_2003());
3873 
3874   // Initialize main_process and main_thread
3875   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
3876  if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3877                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3878     fatal("DuplicateHandle failed\n");
3879   }
3880   main_thread_id = (int) GetCurrentThreadId();
3881 }
3882 
3883 // To install functions for atexit processing
3884 extern "C" {
3885   static void perfMemory_exit_helper() {
3886     perfMemory_exit();
3887   }
3888 }
3889 
3890 static jint initSock();
3891 
3892 // this is called _after_ the global arguments have been parsed
3893 jint os::init_2(void) {
3894   // Allocate a single page and mark it as readable for safepoint polling
3895   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3896   guarantee( polling_page != NULL, "Reserve Failed for polling page");
3897 
3898   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3899   guarantee( return_page != NULL, "Commit Failed for polling page");
3900 
3901   os::set_polling_page( polling_page );
3902 
3903 #ifndef PRODUCT
3904   if( Verbose && PrintMiscellaneous )
3905     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3906 #endif
3907 
3908   if (!UseMembar) {
3909     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3910     guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3911 
3912     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3913     guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3914 
3915     os::set_memory_serialize_page( mem_serialize_page );
3916 
3917 #ifndef PRODUCT
3918     if(Verbose && PrintMiscellaneous)
3919       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3920 #endif
3921   }
3922 
3923   os::large_page_init();
3924 
3925   // Setup Windows Exceptions
3926 
3927   // for debugging float code generation bugs
3928   if (ForceFloatExceptions) {
3929 #ifndef  _WIN64
3930     static long fp_control_word = 0;
3931     __asm { fstcw fp_control_word }
3932     // see Intel PPro Manual, Vol. 2, p 7-16
3933     const long precision = 0x20;
3934     const long underflow = 0x10;
3935     const long overflow  = 0x08;
3936     const long zero_div  = 0x04;
3937     const long denorm    = 0x02;
3938     const long invalid   = 0x01;
3939     fp_control_word |= invalid;
3940     __asm { fldcw fp_control_word }
3941 #endif
3942   }
3943 
3944   // If stack_commit_size is 0, windows will reserve the default size,
3945   // but only commit a small portion of it.
3946   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3947   size_t default_reserve_size = os::win32::default_stack_size();
3948   size_t actual_reserve_size = stack_commit_size;
3949   if (stack_commit_size < default_reserve_size) {
3950     // If stack_commit_size == 0, we want this too
3951     actual_reserve_size = default_reserve_size;
3952   }
3953 
3954   // Check minimum allowable stack size for thread creation and to initialize
3955   // the java system classes, including StackOverflowError - depends on page
3956   // size.  Add a page for compiler2 recursion in main thread.
3957   // Add in 2*BytesPerWord times page size to account for VM stack during
3958   // class initialization depending on 32 or 64 bit VM.
3959   size_t min_stack_allowed =
3960             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3961             2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3962   if (actual_reserve_size < min_stack_allowed) {
3963     tty->print_cr("\nThe stack size specified is too small, "
3964                   "Specify at least %dk",
3965                   min_stack_allowed / K);
3966     return JNI_ERR;
3967   }
3968 
3969   JavaThread::set_stack_size_at_create(stack_commit_size);
3970 
3971   // Calculate theoretical max. size of Threads to guard gainst artifical
3972   // out-of-memory situations, where all available address-space has been
3973   // reserved by thread stacks.
3974   assert(actual_reserve_size != 0, "Must have a stack");
3975 
3976   // Calculate the thread limit when we should start doing Virtual Memory
3977   // banging. Currently when the threads will have used all but 200Mb of space.
3978   //
3979   // TODO: consider performing a similar calculation for commit size instead
3980   // as reserve size, since on a 64-bit platform we'll run into that more
3981   // often than running out of virtual memory space.  We can use the
3982   // lower value of the two calculations as the os_thread_limit.
3983   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3984   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3985 
3986   // at exit methods are called in the reverse order of their registration.
3987   // there is no limit to the number of functions registered. atexit does
3988   // not set errno.
3989 
3990   if (PerfAllowAtExitRegistration) {
3991     // only register atexit functions if PerfAllowAtExitRegistration is set.
3992     // atexit functions can be delayed until process exit time, which
3993     // can be problematic for embedded VM situations. Embedded VMs should
3994     // call DestroyJavaVM() to assure that VM resources are released.
3995 
3996     // note: perfMemory_exit_helper atexit function may be removed in
3997     // the future if the appropriate cleanup code can be added to the
3998     // VM_Exit VMOperation's doit method.
3999     if (atexit(perfMemory_exit_helper) != 0) {
4000       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4001     }
4002   }
4003 
4004 #ifndef _WIN64
4005   // Print something if NX is enabled (win32 on AMD64)
4006   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4007 #endif
4008 
4009   // initialize thread priority policy
4010   prio_init();
4011 
4012   if (UseNUMA && !ForceNUMA) {
4013     UseNUMA = false; // We don't fully support this yet
4014   }
4015 
4016   if (UseNUMAInterleaving) {
4017     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4018     bool success = numa_interleaving_init();
4019     if (!success) UseNUMAInterleaving = false;
4020   }
4021 
4022   if (initSock() != JNI_OK) {
4023     return JNI_ERR;
4024   }
4025 
4026   return JNI_OK;
4027 }
4028 
4029 void os::init_3(void) {
4030   return;
4031 }
4032 
4033 // Mark the polling page as unreadable
4034 void os::make_polling_page_unreadable(void) {
4035   DWORD old_status;
4036   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
4037     fatal("Could not disable polling page");
4038 };
4039 
4040 // Mark the polling page as readable
4041 void os::make_polling_page_readable(void) {
4042   DWORD old_status;
4043   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
4044     fatal("Could not enable polling page");
4045 };
4046 
4047 
4048 int os::stat(const char *path, struct stat *sbuf) {
4049   char pathbuf[MAX_PATH];
4050   if (strlen(path) > MAX_PATH - 1) {
4051     errno = ENAMETOOLONG;
4052     return -1;
4053   }
4054   os::native_path(strcpy(pathbuf, path));
4055   int ret = ::stat(pathbuf, sbuf);
4056   if (sbuf != NULL && UseUTCFileTimestamp) {
4057     // Fix for 6539723.  st_mtime returned from stat() is dependent on
4058     // the system timezone and so can return different values for the
4059     // same file if/when daylight savings time changes.  This adjustment
4060     // makes sure the same timestamp is returned regardless of the TZ.
4061     //
4062     // See:
4063     // http://msdn.microsoft.com/library/
4064     //   default.asp?url=/library/en-us/sysinfo/base/
4065     //   time_zone_information_str.asp
4066     // and
4067     // http://msdn.microsoft.com/library/default.asp?url=
4068     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
4069     //
4070     // NOTE: there is a insidious bug here:  If the timezone is changed
4071     // after the call to stat() but before 'GetTimeZoneInformation()', then
4072     // the adjustment we do here will be wrong and we'll return the wrong
4073     // value (which will likely end up creating an invalid class data
4074     // archive).  Absent a better API for this, or some time zone locking
4075     // mechanism, we'll have to live with this risk.
4076     TIME_ZONE_INFORMATION tz;
4077     DWORD tzid = GetTimeZoneInformation(&tz);
4078     int daylightBias =
4079       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
4080     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
4081   }
4082   return ret;
4083 }
4084 
4085 
4086 #define FT2INT64(ft) \
4087   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4088 
4089 
4090 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4091 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4092 // of a thread.
4093 //
4094 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4095 // the fast estimate available on the platform.
4096 
4097 // current_thread_cpu_time() is not optimized for Windows yet
4098 jlong os::current_thread_cpu_time() {
4099   // return user + sys since the cost is the same
4100   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4101 }
4102 
4103 jlong os::thread_cpu_time(Thread* thread) {
4104   // consistent with what current_thread_cpu_time() returns.
4105   return os::thread_cpu_time(thread, true /* user+sys */);
4106 }
4107 
4108 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4109   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4110 }
4111 
4112 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4113   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4114   // If this function changes, os::is_thread_cpu_time_supported() should too
4115   if (os::win32::is_nt()) {
4116     FILETIME CreationTime;
4117     FILETIME ExitTime;
4118     FILETIME KernelTime;
4119     FILETIME UserTime;
4120 
4121     if ( GetThreadTimes(thread->osthread()->thread_handle(),
4122                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4123       return -1;
4124     else
4125       if (user_sys_cpu_time) {
4126         return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4127       } else {
4128         return FT2INT64(UserTime) * 100;
4129       }
4130   } else {
4131     return (jlong) timeGetTime() * 1000000;
4132   }
4133 }
4134 
4135 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4136   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4137   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4138   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4139   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4140 }
4141 
4142 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4143   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4144   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4145   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4146   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4147 }
4148 
4149 bool os::is_thread_cpu_time_supported() {
4150   // see os::thread_cpu_time
4151   if (os::win32::is_nt()) {
4152     FILETIME CreationTime;
4153     FILETIME ExitTime;
4154     FILETIME KernelTime;
4155     FILETIME UserTime;
4156 
4157     if ( GetThreadTimes(GetCurrentThread(),
4158                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4159       return false;
4160     else
4161       return true;
4162   } else {
4163     return false;
4164   }
4165 }
4166 
4167 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4168 // It does have primitives (PDH API) to get CPU usage and run queue length.
4169 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4170 // If we wanted to implement loadavg on Windows, we have a few options:
4171 //
4172 // a) Query CPU usage and run queue length and "fake" an answer by
4173 //    returning the CPU usage if it's under 100%, and the run queue
4174 //    length otherwise.  It turns out that querying is pretty slow
4175 //    on Windows, on the order of 200 microseconds on a fast machine.
4176 //    Note that on the Windows the CPU usage value is the % usage
4177 //    since the last time the API was called (and the first call
4178 //    returns 100%), so we'd have to deal with that as well.
4179 //
4180 // b) Sample the "fake" answer using a sampling thread and store
4181 //    the answer in a global variable.  The call to loadavg would
4182 //    just return the value of the global, avoiding the slow query.
4183 //
4184 // c) Sample a better answer using exponential decay to smooth the
4185 //    value.  This is basically the algorithm used by UNIX kernels.
4186 //
4187 // Note that sampling thread starvation could affect both (b) and (c).
4188 int os::loadavg(double loadavg[], int nelem) {
4189   return -1;
4190 }
4191 
4192 
4193 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4194 bool os::dont_yield() {
4195   return DontYieldALot;
4196 }
4197 
4198 // This method is a slightly reworked copy of JDK's sysOpen
4199 // from src/windows/hpi/src/sys_api_md.c
4200 
4201 int os::open(const char *path, int oflag, int mode) {
4202   char pathbuf[MAX_PATH];
4203 
4204   if (strlen(path) > MAX_PATH - 1) {
4205     errno = ENAMETOOLONG;
4206           return -1;
4207   }
4208   os::native_path(strcpy(pathbuf, path));
4209   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4210 }
4211 
4212 FILE* os::open(int fd, const char* mode) {
4213   return ::_fdopen(fd, mode);
4214 }
4215 
4216 // Is a (classpath) directory empty?
4217 bool os::dir_is_empty(const char* path) {
4218   WIN32_FIND_DATA fd;
4219   HANDLE f = FindFirstFile(path, &fd);
4220   if (f == INVALID_HANDLE_VALUE) {
4221     return true;
4222   }
4223   FindClose(f);
4224   return false;
4225 }
4226 
4227 // create binary file, rewriting existing file if required
4228 int os::create_binary_file(const char* path, bool rewrite_existing) {
4229   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4230   if (!rewrite_existing) {
4231     oflags |= _O_EXCL;
4232   }
4233   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4234 }
4235 
4236 // return current position of file pointer
4237 jlong os::current_file_offset(int fd) {
4238   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4239 }
4240 
4241 // move file pointer to the specified offset
4242 jlong os::seek_to_file_offset(int fd, jlong offset) {
4243   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4244 }
4245 
4246 
4247 jlong os::lseek(int fd, jlong offset, int whence) {
4248   return (jlong) ::_lseeki64(fd, offset, whence);
4249 }
4250 
4251 // This method is a slightly reworked copy of JDK's sysNativePath
4252 // from src/windows/hpi/src/path_md.c
4253 
4254 /* Convert a pathname to native format.  On win32, this involves forcing all
4255    separators to be '\\' rather than '/' (both are legal inputs, but Win95
4256    sometimes rejects '/') and removing redundant separators.  The input path is
4257    assumed to have been converted into the character encoding used by the local
4258    system.  Because this might be a double-byte encoding, care is taken to
4259    treat double-byte lead characters correctly.
4260 
4261    This procedure modifies the given path in place, as the result is never
4262    longer than the original.  There is no error return; this operation always
4263    succeeds. */
4264 char * os::native_path(char *path) {
4265   char *src = path, *dst = path, *end = path;
4266   char *colon = NULL;           /* If a drive specifier is found, this will
4267                                         point to the colon following the drive
4268                                         letter */
4269 
4270   /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4271   assert(((!::IsDBCSLeadByte('/'))
4272     && (!::IsDBCSLeadByte('\\'))
4273     && (!::IsDBCSLeadByte(':'))),
4274     "Illegal lead byte");
4275 
4276   /* Check for leading separators */
4277 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4278   while (isfilesep(*src)) {
4279     src++;
4280   }
4281 
4282   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4283     /* Remove leading separators if followed by drive specifier.  This
4284       hack is necessary to support file URLs containing drive
4285       specifiers (e.g., "file://c:/path").  As a side effect,
4286       "/c:/path" can be used as an alternative to "c:/path". */
4287     *dst++ = *src++;
4288     colon = dst;
4289     *dst++ = ':';
4290     src++;
4291   } else {
4292     src = path;
4293     if (isfilesep(src[0]) && isfilesep(src[1])) {
4294       /* UNC pathname: Retain first separator; leave src pointed at
4295          second separator so that further separators will be collapsed
4296          into the second separator.  The result will be a pathname
4297          beginning with "\\\\" followed (most likely) by a host name. */
4298       src = dst = path + 1;
4299       path[0] = '\\';     /* Force first separator to '\\' */
4300     }
4301   }
4302 
4303   end = dst;
4304 
4305   /* Remove redundant separators from remainder of path, forcing all
4306       separators to be '\\' rather than '/'. Also, single byte space
4307       characters are removed from the end of the path because those
4308       are not legal ending characters on this operating system.
4309   */
4310   while (*src != '\0') {
4311     if (isfilesep(*src)) {
4312       *dst++ = '\\'; src++;
4313       while (isfilesep(*src)) src++;
4314       if (*src == '\0') {
4315         /* Check for trailing separator */
4316         end = dst;
4317         if (colon == dst - 2) break;                      /* "z:\\" */
4318         if (dst == path + 1) break;                       /* "\\" */
4319         if (dst == path + 2 && isfilesep(path[0])) {
4320           /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4321             beginning of a UNC pathname.  Even though it is not, by
4322             itself, a valid UNC pathname, we leave it as is in order
4323             to be consistent with the path canonicalizer as well
4324             as the win32 APIs, which treat this case as an invalid
4325             UNC pathname rather than as an alias for the root
4326             directory of the current drive. */
4327           break;
4328         }
4329         end = --dst;  /* Path does not denote a root directory, so
4330                                     remove trailing separator */
4331         break;
4332       }
4333       end = dst;
4334     } else {
4335       if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4336         *dst++ = *src++;
4337         if (*src) *dst++ = *src++;
4338         end = dst;
4339       } else {         /* Copy a single-byte character */
4340         char c = *src++;
4341         *dst++ = c;
4342         /* Space is not a legal ending character */
4343         if (c != ' ') end = dst;
4344       }
4345     }
4346   }
4347 
4348   *end = '\0';
4349 
4350   /* For "z:", add "." to work around a bug in the C runtime library */
4351   if (colon == dst - 1) {
4352           path[2] = '.';
4353           path[3] = '\0';
4354   }
4355 
4356   return path;
4357 }
4358 
4359 // This code is a copy of JDK's sysSetLength
4360 // from src/windows/hpi/src/sys_api_md.c
4361 
4362 int os::ftruncate(int fd, jlong length) {
4363   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4364   long high = (long)(length >> 32);
4365   DWORD ret;
4366 
4367   if (h == (HANDLE)(-1)) {
4368     return -1;
4369   }
4370 
4371   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4372   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4373       return -1;
4374   }
4375 
4376   if (::SetEndOfFile(h) == FALSE) {
4377     return -1;
4378   }
4379 
4380   return 0;
4381 }
4382 
4383 
4384 // This code is a copy of JDK's sysSync
4385 // from src/windows/hpi/src/sys_api_md.c
4386 // except for the legacy workaround for a bug in Win 98
4387 
4388 int os::fsync(int fd) {
4389   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4390 
4391   if ( (!::FlushFileBuffers(handle)) &&
4392          (GetLastError() != ERROR_ACCESS_DENIED) ) {
4393     /* from winerror.h */
4394     return -1;
4395   }
4396   return 0;
4397 }
4398 
4399 static int nonSeekAvailable(int, long *);
4400 static int stdinAvailable(int, long *);
4401 
4402 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4403 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4404 
4405 // This code is a copy of JDK's sysAvailable
4406 // from src/windows/hpi/src/sys_api_md.c
4407 
4408 int os::available(int fd, jlong *bytes) {
4409   jlong cur, end;
4410   struct _stati64 stbuf64;
4411 
4412   if (::_fstati64(fd, &stbuf64) >= 0) {
4413     int mode = stbuf64.st_mode;
4414     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4415       int ret;
4416       long lpbytes;
4417       if (fd == 0) {
4418         ret = stdinAvailable(fd, &lpbytes);
4419       } else {
4420         ret = nonSeekAvailable(fd, &lpbytes);
4421       }
4422       (*bytes) = (jlong)(lpbytes);
4423       return ret;
4424     }
4425     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4426       return FALSE;
4427     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4428       return FALSE;
4429     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4430       return FALSE;
4431     }
4432     *bytes = end - cur;
4433     return TRUE;
4434   } else {
4435     return FALSE;
4436   }
4437 }
4438 
4439 // This code is a copy of JDK's nonSeekAvailable
4440 // from src/windows/hpi/src/sys_api_md.c
4441 
4442 static int nonSeekAvailable(int fd, long *pbytes) {
4443   /* This is used for available on non-seekable devices
4444     * (like both named and anonymous pipes, such as pipes
4445     *  connected to an exec'd process).
4446     * Standard Input is a special case.
4447     *
4448     */
4449   HANDLE han;
4450 
4451   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4452     return FALSE;
4453   }
4454 
4455   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4456         /* PeekNamedPipe fails when at EOF.  In that case we
4457          * simply make *pbytes = 0 which is consistent with the
4458          * behavior we get on Solaris when an fd is at EOF.
4459          * The only alternative is to raise an Exception,
4460          * which isn't really warranted.
4461          */
4462     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4463       return FALSE;
4464     }
4465     *pbytes = 0;
4466   }
4467   return TRUE;
4468 }
4469 
4470 #define MAX_INPUT_EVENTS 2000
4471 
4472 // This code is a copy of JDK's stdinAvailable
4473 // from src/windows/hpi/src/sys_api_md.c
4474 
4475 static int stdinAvailable(int fd, long *pbytes) {
4476   HANDLE han;
4477   DWORD numEventsRead = 0;      /* Number of events read from buffer */
4478   DWORD numEvents = 0;  /* Number of events in buffer */
4479   DWORD i = 0;          /* Loop index */
4480   DWORD curLength = 0;  /* Position marker */
4481   DWORD actualLength = 0;       /* Number of bytes readable */
4482   BOOL error = FALSE;         /* Error holder */
4483   INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
4484 
4485   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4486         return FALSE;
4487   }
4488 
4489   /* Construct an array of input records in the console buffer */
4490   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4491   if (error == 0) {
4492     return nonSeekAvailable(fd, pbytes);
4493   }
4494 
4495   /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4496   if (numEvents > MAX_INPUT_EVENTS) {
4497     numEvents = MAX_INPUT_EVENTS;
4498   }
4499 
4500   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4501   if (lpBuffer == NULL) {
4502     return FALSE;
4503   }
4504 
4505   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4506   if (error == 0) {
4507     os::free(lpBuffer, mtInternal);
4508     return FALSE;
4509   }
4510 
4511   /* Examine input records for the number of bytes available */
4512   for(i=0; i<numEvents; i++) {
4513     if (lpBuffer[i].EventType == KEY_EVENT) {
4514 
4515       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4516                                       &(lpBuffer[i].Event);
4517       if (keyRecord->bKeyDown == TRUE) {
4518         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4519         curLength++;
4520         if (*keyPressed == '\r') {
4521           actualLength = curLength;
4522         }
4523       }
4524     }
4525   }
4526 
4527   if(lpBuffer != NULL) {
4528     os::free(lpBuffer, mtInternal);
4529   }
4530 
4531   *pbytes = (long) actualLength;
4532   return TRUE;
4533 }
4534 
4535 // Map a block of memory.
4536 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4537                      char *addr, size_t bytes, bool read_only,
4538                      bool allow_exec) {
4539   HANDLE hFile;
4540   char* base;
4541 
4542   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4543                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4544   if (hFile == NULL) {
4545     if (PrintMiscellaneous && Verbose) {
4546       DWORD err = GetLastError();
4547       tty->print_cr("CreateFile() failed: GetLastError->%ld.", err);
4548     }
4549     return NULL;
4550   }
4551 
4552   if (allow_exec) {
4553     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4554     // unless it comes from a PE image (which the shared archive is not.)
4555     // Even VirtualProtect refuses to give execute access to mapped memory
4556     // that was not previously executable.
4557     //
4558     // Instead, stick the executable region in anonymous memory.  Yuck.
4559     // Penalty is that ~4 pages will not be shareable - in the future
4560     // we might consider DLLizing the shared archive with a proper PE
4561     // header so that mapping executable + sharing is possible.
4562 
4563     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4564                                 PAGE_READWRITE);
4565     if (base == NULL) {
4566       if (PrintMiscellaneous && Verbose) {
4567         DWORD err = GetLastError();
4568         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4569       }
4570       CloseHandle(hFile);
4571       return NULL;
4572     }
4573 
4574     DWORD bytes_read;
4575     OVERLAPPED overlapped;
4576     overlapped.Offset = (DWORD)file_offset;
4577     overlapped.OffsetHigh = 0;
4578     overlapped.hEvent = NULL;
4579     // ReadFile guarantees that if the return value is true, the requested
4580     // number of bytes were read before returning.
4581     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4582     if (!res) {
4583       if (PrintMiscellaneous && Verbose) {
4584         DWORD err = GetLastError();
4585         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4586       }
4587       release_memory(base, bytes);
4588       CloseHandle(hFile);
4589       return NULL;
4590     }
4591   } else {
4592     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4593                                     NULL /*file_name*/);
4594     if (hMap == NULL) {
4595       if (PrintMiscellaneous && Verbose) {
4596         DWORD err = GetLastError();
4597         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err);
4598       }
4599       CloseHandle(hFile);
4600       return NULL;
4601     }
4602 
4603     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4604     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4605                                   (DWORD)bytes, addr);
4606     if (base == NULL) {
4607       if (PrintMiscellaneous && Verbose) {
4608         DWORD err = GetLastError();
4609         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4610       }
4611       CloseHandle(hMap);
4612       CloseHandle(hFile);
4613       return NULL;
4614     }
4615 
4616     if (CloseHandle(hMap) == 0) {
4617       if (PrintMiscellaneous && Verbose) {
4618         DWORD err = GetLastError();
4619         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4620       }
4621       CloseHandle(hFile);
4622       return base;
4623     }
4624   }
4625 
4626   if (allow_exec) {
4627     DWORD old_protect;
4628     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4629     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4630 
4631     if (!res) {
4632       if (PrintMiscellaneous && Verbose) {
4633         DWORD err = GetLastError();
4634         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4635       }
4636       // Don't consider this a hard error, on IA32 even if the
4637       // VirtualProtect fails, we should still be able to execute
4638       CloseHandle(hFile);
4639       return base;
4640     }
4641   }
4642 
4643   if (CloseHandle(hFile) == 0) {
4644     if (PrintMiscellaneous && Verbose) {
4645       DWORD err = GetLastError();
4646       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4647     }
4648     return base;
4649   }
4650 
4651   return base;
4652 }
4653 
4654 
4655 // Remap a block of memory.
4656 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4657                        char *addr, size_t bytes, bool read_only,
4658                        bool allow_exec) {
4659   // This OS does not allow existing memory maps to be remapped so we
4660   // have to unmap the memory before we remap it.
4661   if (!os::unmap_memory(addr, bytes)) {
4662     return NULL;
4663   }
4664 
4665   // There is a very small theoretical window between the unmap_memory()
4666   // call above and the map_memory() call below where a thread in native
4667   // code may be able to access an address that is no longer mapped.
4668 
4669   return os::map_memory(fd, file_name, file_offset, addr, bytes,
4670            read_only, allow_exec);
4671 }
4672 
4673 
4674 // Unmap a block of memory.
4675 // Returns true=success, otherwise false.
4676 
4677 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4678   BOOL result = UnmapViewOfFile(addr);
4679   if (result == 0) {
4680     if (PrintMiscellaneous && Verbose) {
4681       DWORD err = GetLastError();
4682       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4683     }
4684     return false;
4685   }
4686   return true;
4687 }
4688 
4689 void os::pause() {
4690   char filename[MAX_PATH];
4691   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4692     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4693   } else {
4694     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4695   }
4696 
4697   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4698   if (fd != -1) {
4699     struct stat buf;
4700     ::close(fd);
4701     while (::stat(filename, &buf) == 0) {
4702       Sleep(100);
4703     }
4704   } else {
4705     jio_fprintf(stderr,
4706       "Could not open pause file '%s', continuing immediately.\n", filename);
4707   }
4708 }
4709 
4710 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
4711   assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
4712 }
4713 
4714 /*
4715  * See the caveats for this class in os_windows.hpp
4716  * Protects the callback call so that raised OS EXCEPTIONS causes a jump back
4717  * into this method and returns false. If no OS EXCEPTION was raised, returns
4718  * true.
4719  * The callback is supposed to provide the method that should be protected.
4720  */
4721 bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
4722   assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
4723   assert(!WatcherThread::watcher_thread()->has_crash_protection(),
4724       "crash_protection already set?");
4725 
4726   bool success = true;
4727   __try {
4728     WatcherThread::watcher_thread()->set_crash_protection(this);
4729     cb.call();
4730   } __except(EXCEPTION_EXECUTE_HANDLER) {
4731     // only for protection, nothing to do
4732     success = false;
4733   }
4734   WatcherThread::watcher_thread()->set_crash_protection(NULL);
4735   return success;
4736 }
4737 
4738 // An Event wraps a win32 "CreateEvent" kernel handle.
4739 //
4740 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4741 //
4742 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4743 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
4744 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4745 //     In addition, an unpark() operation might fetch the handle field, but the
4746 //     event could recycle between the fetch and the SetEvent() operation.
4747 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
4748 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
4749 //     on an stale but recycled handle would be harmless, but in practice this might
4750 //     confuse other non-Sun code, so it's not a viable approach.
4751 //
4752 // 2:  Once a win32 event handle is associated with an Event, it remains associated
4753 //     with the Event.  The event handle is never closed.  This could be construed
4754 //     as handle leakage, but only up to the maximum # of threads that have been extant
4755 //     at any one time.  This shouldn't be an issue, as windows platforms typically
4756 //     permit a process to have hundreds of thousands of open handles.
4757 //
4758 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4759 //     and release unused handles.
4760 //
4761 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4762 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
4763 //
4764 // 5.  Use an RCU-like mechanism (Read-Copy Update).
4765 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
4766 //
4767 // We use (2).
4768 //
4769 // TODO-FIXME:
4770 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4771 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4772 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
4773 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4774 //     into a single win32 CreateEvent() handle.
4775 //
4776 // _Event transitions in park()
4777 //   -1 => -1 : illegal
4778 //    1 =>  0 : pass - return immediately
4779 //    0 => -1 : block
4780 //
4781 // _Event serves as a restricted-range semaphore :
4782 //    -1 : thread is blocked
4783 //     0 : neutral  - thread is running or ready
4784 //     1 : signaled - thread is running or ready
4785 //
4786 // Another possible encoding of _Event would be
4787 // with explicit "PARKED" and "SIGNALED" bits.
4788 
4789 int os::PlatformEvent::park (jlong Millis) {
4790     guarantee (_ParkHandle != NULL , "Invariant") ;
4791     guarantee (Millis > 0          , "Invariant") ;
4792     int v ;
4793 
4794     // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4795     // the initial park() operation.
4796 
4797     for (;;) {
4798         v = _Event ;
4799         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4800     }
4801     guarantee ((v == 0) || (v == 1), "invariant") ;
4802     if (v != 0) return OS_OK ;
4803 
4804     // Do this the hard way by blocking ...
4805     // TODO: consider a brief spin here, gated on the success of recent
4806     // spin attempts by this thread.
4807     //
4808     // We decompose long timeouts into series of shorter timed waits.
4809     // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4810     // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
4811     // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4812     // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
4813     // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4814     // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
4815     // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4816     // for the already waited time.  This policy does not admit any new outcomes.
4817     // In the future, however, we might want to track the accumulated wait time and
4818     // adjust Millis accordingly if we encounter a spurious wakeup.
4819 
4820     const int MAXTIMEOUT = 0x10000000 ;
4821     DWORD rv = WAIT_TIMEOUT ;
4822     while (_Event < 0 && Millis > 0) {
4823        DWORD prd = Millis ;     // set prd = MAX (Millis, MAXTIMEOUT)
4824        if (Millis > MAXTIMEOUT) {
4825           prd = MAXTIMEOUT ;
4826        }
4827        rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4828        assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4829        if (rv == WAIT_TIMEOUT) {
4830            Millis -= prd ;
4831        }
4832     }
4833     v = _Event ;
4834     _Event = 0 ;
4835     // see comment at end of os::PlatformEvent::park() below:
4836     OrderAccess::fence() ;
4837     // If we encounter a nearly simultanous timeout expiry and unpark()
4838     // we return OS_OK indicating we awoke via unpark().
4839     // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4840     return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4841 }
4842 
4843 void os::PlatformEvent::park () {
4844     guarantee (_ParkHandle != NULL, "Invariant") ;
4845     // Invariant: Only the thread associated with the Event/PlatformEvent
4846     // may call park().
4847     int v ;
4848     for (;;) {
4849         v = _Event ;
4850         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4851     }
4852     guarantee ((v == 0) || (v == 1), "invariant") ;
4853     if (v != 0) return ;
4854 
4855     // Do this the hard way by blocking ...
4856     // TODO: consider a brief spin here, gated on the success of recent
4857     // spin attempts by this thread.
4858     while (_Event < 0) {
4859        DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4860        assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4861     }
4862 
4863     // Usually we'll find _Event == 0 at this point, but as
4864     // an optional optimization we clear it, just in case can
4865     // multiple unpark() operations drove _Event up to 1.
4866     _Event = 0 ;
4867     OrderAccess::fence() ;
4868     guarantee (_Event >= 0, "invariant") ;
4869 }
4870 
4871 void os::PlatformEvent::unpark() {
4872   guarantee (_ParkHandle != NULL, "Invariant") ;
4873 
4874   // Transitions for _Event:
4875   //    0 :=> 1
4876   //    1 :=> 1
4877   //   -1 :=> either 0 or 1; must signal target thread
4878   //          That is, we can safely transition _Event from -1 to either
4879   //          0 or 1. Forcing 1 is slightly more efficient for back-to-back
4880   //          unpark() calls.
4881   // See also: "Semaphores in Plan 9" by Mullender & Cox
4882   //
4883   // Note: Forcing a transition from "-1" to "1" on an unpark() means
4884   // that it will take two back-to-back park() calls for the owning
4885   // thread to block. This has the benefit of forcing a spurious return
4886   // from the first park() call after an unpark() call which will help
4887   // shake out uses of park() and unpark() without condition variables.
4888 
4889   if (Atomic::xchg(1, &_Event) >= 0) return;
4890 
4891   ::SetEvent(_ParkHandle);
4892 }
4893 
4894 
4895 // JSR166
4896 // -------------------------------------------------------
4897 
4898 /*
4899  * The Windows implementation of Park is very straightforward: Basic
4900  * operations on Win32 Events turn out to have the right semantics to
4901  * use them directly. We opportunistically resuse the event inherited
4902  * from Monitor.
4903  */
4904 
4905 
4906 void Parker::park(bool isAbsolute, jlong time) {
4907   guarantee (_ParkEvent != NULL, "invariant") ;
4908   // First, demultiplex/decode time arguments
4909   if (time < 0) { // don't wait
4910     return;
4911   }
4912   else if (time == 0 && !isAbsolute) {
4913     time = INFINITE;
4914   }
4915   else if  (isAbsolute) {
4916     time -= os::javaTimeMillis(); // convert to relative time
4917     if (time <= 0) // already elapsed
4918       return;
4919   }
4920   else { // relative
4921     time /= 1000000; // Must coarsen from nanos to millis
4922     if (time == 0)   // Wait for the minimal time unit if zero
4923       time = 1;
4924   }
4925 
4926   JavaThread* thread = (JavaThread*)(Thread::current());
4927   assert(thread->is_Java_thread(), "Must be JavaThread");
4928   JavaThread *jt = (JavaThread *)thread;
4929 
4930   // Don't wait if interrupted or already triggered
4931   if (Thread::is_interrupted(thread, false) ||
4932     WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4933     ResetEvent(_ParkEvent);
4934     return;
4935   }
4936   else {
4937     ThreadBlockInVM tbivm(jt);
4938     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4939     jt->set_suspend_equivalent();
4940 
4941     WaitForSingleObject(_ParkEvent,  time);
4942     ResetEvent(_ParkEvent);
4943 
4944     // If externally suspended while waiting, re-suspend
4945     if (jt->handle_special_suspend_equivalent_condition()) {
4946       jt->java_suspend_self();
4947     }
4948   }
4949 }
4950 
4951 void Parker::unpark() {
4952   guarantee (_ParkEvent != NULL, "invariant") ;
4953   SetEvent(_ParkEvent);
4954 }
4955 
4956 // Run the specified command in a separate process. Return its exit value,
4957 // or -1 on failure (e.g. can't create a new process).
4958 int os::fork_and_exec(char* cmd) {
4959   STARTUPINFO si;
4960   PROCESS_INFORMATION pi;
4961 
4962   memset(&si, 0, sizeof(si));
4963   si.cb = sizeof(si);
4964   memset(&pi, 0, sizeof(pi));
4965   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
4966                             cmd,    // command line
4967                             NULL,   // process security attribute
4968                             NULL,   // thread security attribute
4969                             TRUE,   // inherits system handles
4970                             0,      // no creation flags
4971                             NULL,   // use parent's environment block
4972                             NULL,   // use parent's starting directory
4973                             &si,    // (in) startup information
4974                             &pi);   // (out) process information
4975 
4976   if (rslt) {
4977     // Wait until child process exits.
4978     WaitForSingleObject(pi.hProcess, INFINITE);
4979 
4980     DWORD exit_code;
4981     GetExitCodeProcess(pi.hProcess, &exit_code);
4982 
4983     // Close process and thread handles.
4984     CloseHandle(pi.hProcess);
4985     CloseHandle(pi.hThread);
4986 
4987     return (int)exit_code;
4988   } else {
4989     return -1;
4990   }
4991 }
4992 
4993 //--------------------------------------------------------------------------------------------------
4994 // Non-product code
4995 
4996 static int mallocDebugIntervalCounter = 0;
4997 static int mallocDebugCounter = 0;
4998 bool os::check_heap(bool force) {
4999   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
5000   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
5001     // Note: HeapValidate executes two hardware breakpoints when it finds something
5002     // wrong; at these points, eax contains the address of the offending block (I think).
5003     // To get to the exlicit error message(s) below, just continue twice.
5004     HANDLE heap = GetProcessHeap();
5005     { HeapLock(heap);
5006       PROCESS_HEAP_ENTRY phe;
5007       phe.lpData = NULL;
5008       while (HeapWalk(heap, &phe) != 0) {
5009         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
5010             !HeapValidate(heap, 0, phe.lpData)) {
5011           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
5012           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
5013           fatal("corrupted C heap");
5014         }
5015       }
5016       DWORD err = GetLastError();
5017       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
5018         fatal(err_msg("heap walk aborted with error %d", err));
5019       }
5020       HeapUnlock(heap);
5021     }
5022     mallocDebugIntervalCounter = 0;
5023   }
5024   return true;
5025 }
5026 
5027 
5028 bool os::find(address addr, outputStream* st) {
5029   // Nothing yet
5030   return false;
5031 }
5032 
5033 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5034   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5035 
5036   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
5037     JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
5038     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5039     address addr = (address) exceptionRecord->ExceptionInformation[1];
5040 
5041     if (os::is_memory_serialize_page(thread, addr))
5042       return EXCEPTION_CONTINUE_EXECUTION;
5043   }
5044 
5045   return EXCEPTION_CONTINUE_SEARCH;
5046 }
5047 
5048 // We don't build a headless jre for Windows
5049 bool os::is_headless_jre() { return false; }
5050 
5051 static jint initSock() {
5052   WSADATA wsadata;
5053 
5054   if (!os::WinSock2Dll::WinSock2Available()) {
5055     jio_fprintf(stderr, "Could not load Winsock (error: %d)\n",
5056       ::GetLastError());
5057     return JNI_ERR;
5058   }
5059 
5060   if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5061     jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5062       ::GetLastError());
5063     return JNI_ERR;
5064   }
5065   return JNI_OK;
5066 }
5067 
5068 struct hostent* os::get_host_by_name(char* name) {
5069   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
5070 }
5071 
5072 int os::socket_close(int fd) {
5073   return ::closesocket(fd);
5074 }
5075 
5076 int os::socket_available(int fd, jint *pbytes) {
5077   int ret = ::ioctlsocket(fd, FIONREAD, (u_long*)pbytes);
5078   return (ret < 0) ? 0 : 1;
5079 }
5080 
5081 int os::socket(int domain, int type, int protocol) {
5082   return ::socket(domain, type, protocol);
5083 }
5084 
5085 int os::listen(int fd, int count) {
5086   return ::listen(fd, count);
5087 }
5088 
5089 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5090   return ::connect(fd, him, len);
5091 }
5092 
5093 int os::accept(int fd, struct sockaddr* him, socklen_t* len) {
5094   return ::accept(fd, him, len);
5095 }
5096 
5097 int os::sendto(int fd, char* buf, size_t len, uint flags,
5098                struct sockaddr* to, socklen_t tolen) {
5099 
5100   return ::sendto(fd, buf, (int)len, flags, to, tolen);
5101 }
5102 
5103 int os::recvfrom(int fd, char *buf, size_t nBytes, uint flags,
5104                  sockaddr* from, socklen_t* fromlen) {
5105 
5106   return ::recvfrom(fd, buf, (int)nBytes, flags, from, fromlen);
5107 }
5108 
5109 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5110   return ::recv(fd, buf, (int)nBytes, flags);
5111 }
5112 
5113 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5114   return ::send(fd, buf, (int)nBytes, flags);
5115 }
5116 
5117 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5118   return ::send(fd, buf, (int)nBytes, flags);
5119 }
5120 
5121 int os::timeout(int fd, long timeout) {
5122   fd_set tbl;
5123   struct timeval t;
5124 
5125   t.tv_sec  = timeout / 1000;
5126   t.tv_usec = (timeout % 1000) * 1000;
5127 
5128   tbl.fd_count    = 1;
5129   tbl.fd_array[0] = fd;
5130 
5131   return ::select(1, &tbl, 0, 0, &t);
5132 }
5133 
5134 int os::get_host_name(char* name, int namelen) {
5135   return ::gethostname(name, namelen);
5136 }
5137 
5138 int os::socket_shutdown(int fd, int howto) {
5139   return ::shutdown(fd, howto);
5140 }
5141 
5142 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
5143   return ::bind(fd, him, len);
5144 }
5145 
5146 int os::get_sock_name(int fd, struct sockaddr* him, socklen_t* len) {
5147   return ::getsockname(fd, him, len);
5148 }
5149 
5150 int os::get_sock_opt(int fd, int level, int optname,
5151                      char* optval, socklen_t* optlen) {
5152   return ::getsockopt(fd, level, optname, optval, optlen);
5153 }
5154 
5155 int os::set_sock_opt(int fd, int level, int optname,
5156                      const char* optval, socklen_t optlen) {
5157   return ::setsockopt(fd, level, optname, optval, optlen);
5158 }
5159 
5160 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5161 #if defined(IA32)
5162 #  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5163 #elif defined (AMD64)
5164 #  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5165 #endif
5166 
5167 // returns true if thread could be suspended,
5168 // false otherwise
5169 static bool do_suspend(HANDLE* h) {
5170   if (h != NULL) {
5171     if (SuspendThread(*h) != ~0) {
5172       return true;
5173     }
5174   }
5175   return false;
5176 }
5177 
5178 // resume the thread
5179 // calling resume on an active thread is a no-op
5180 static void do_resume(HANDLE* h) {
5181   if (h != NULL) {
5182     ResumeThread(*h);
5183   }
5184 }
5185 
5186 // retrieve a suspend/resume context capable handle
5187 // from the tid. Caller validates handle return value.
5188 void get_thread_handle_for_extended_context(HANDLE* h, OSThread::thread_id_t tid) {
5189   if (h != NULL) {
5190     *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5191   }
5192 }
5193 
5194 //
5195 // Thread sampling implementation
5196 //
5197 void os::SuspendedThreadTask::internal_do_task() {
5198   CONTEXT    ctxt;
5199   HANDLE     h = NULL;
5200 
5201   // get context capable handle for thread
5202   get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5203 
5204   // sanity
5205   if (h == NULL || h == INVALID_HANDLE_VALUE) {
5206     return;
5207   }
5208 
5209   // suspend the thread
5210   if (do_suspend(&h)) {
5211     ctxt.ContextFlags = sampling_context_flags;
5212     // get thread context
5213     GetThreadContext(h, &ctxt);
5214     SuspendedThreadTaskContext context(_thread, &ctxt);
5215     // pass context to Thread Sampling impl
5216     do_task(context);
5217     // resume thread
5218     do_resume(&h);
5219   }
5220 
5221   // close handle
5222   CloseHandle(h);
5223 }
5224 
5225 
5226 // Kernel32 API
5227 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
5228 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
5229 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
5230 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
5231 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
5232 
5233 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
5234 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
5235 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
5236 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
5237 RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL;
5238 
5239 
5240 BOOL                        os::Kernel32Dll::initialized = FALSE;
5241 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
5242   assert(initialized && _GetLargePageMinimum != NULL,
5243     "GetLargePageMinimumAvailable() not yet called");
5244   return _GetLargePageMinimum();
5245 }
5246 
5247 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
5248   if (!initialized) {
5249     initialize();
5250   }
5251   return _GetLargePageMinimum != NULL;
5252 }
5253 
5254 BOOL os::Kernel32Dll::NumaCallsAvailable() {
5255   if (!initialized) {
5256     initialize();
5257   }
5258   return _VirtualAllocExNuma != NULL;
5259 }
5260 
5261 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
5262   assert(initialized && _VirtualAllocExNuma != NULL,
5263     "NUMACallsAvailable() not yet called");
5264 
5265   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
5266 }
5267 
5268 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
5269   assert(initialized && _GetNumaHighestNodeNumber != NULL,
5270     "NUMACallsAvailable() not yet called");
5271 
5272   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
5273 }
5274 
5275 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
5276   assert(initialized && _GetNumaNodeProcessorMask != NULL,
5277     "NUMACallsAvailable() not yet called");
5278 
5279   return _GetNumaNodeProcessorMask(node, proc_mask);
5280 }
5281 
5282 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
5283   ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) {
5284     if (!initialized) {
5285       initialize();
5286     }
5287 
5288     if (_RtlCaptureStackBackTrace != NULL) {
5289       return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture,
5290         BackTrace, BackTraceHash);
5291     } else {
5292       return 0;
5293     }
5294 }
5295 
5296 void os::Kernel32Dll::initializeCommon() {
5297   if (!initialized) {
5298     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5299     assert(handle != NULL, "Just check");
5300     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
5301     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
5302     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
5303     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
5304     _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace");
5305     initialized = TRUE;
5306   }
5307 }
5308 
5309 
5310 
5311 #ifndef JDK6_OR_EARLIER
5312 
5313 void os::Kernel32Dll::initialize() {
5314   initializeCommon();
5315 }
5316 
5317 
5318 // Kernel32 API
5319 inline BOOL os::Kernel32Dll::SwitchToThread() {
5320   return ::SwitchToThread();
5321 }
5322 
5323 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5324   return true;
5325 }
5326 
5327   // Help tools
5328 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5329   return true;
5330 }
5331 
5332 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5333   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5334 }
5335 
5336 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5337   return ::Module32First(hSnapshot, lpme);
5338 }
5339 
5340 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5341   return ::Module32Next(hSnapshot, lpme);
5342 }
5343 
5344 
5345 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5346   return true;
5347 }
5348 
5349 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5350   ::GetNativeSystemInfo(lpSystemInfo);
5351 }
5352 
5353 // PSAPI API
5354 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5355   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5356 }
5357 
5358 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5359   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5360 }
5361 
5362 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5363   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5364 }
5365 
5366 inline BOOL os::PSApiDll::PSApiAvailable() {
5367   return true;
5368 }
5369 
5370 
5371 // WinSock2 API
5372 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5373   return ::WSAStartup(wVersionRequested, lpWSAData);
5374 }
5375 
5376 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5377   return ::gethostbyname(name);
5378 }
5379 
5380 inline BOOL os::WinSock2Dll::WinSock2Available() {
5381   return true;
5382 }
5383 
5384 // Advapi API
5385 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5386    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5387    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5388      return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5389        BufferLength, PreviousState, ReturnLength);
5390 }
5391 
5392 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5393   PHANDLE TokenHandle) {
5394     return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5395 }
5396 
5397 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5398   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5399 }
5400 
5401 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5402   return true;
5403 }
5404 
5405 #else
5406 // Kernel32 API
5407 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5408 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5409 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5410 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5411 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5412 
5413 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
5414 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5415 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
5416 Module32Next_Fn             os::Kernel32Dll::_Module32Next = NULL;
5417 GetNativeSystemInfo_Fn      os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5418 
5419 void os::Kernel32Dll::initialize() {
5420   if (!initialized) {
5421     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5422     assert(handle != NULL, "Just check");
5423 
5424     _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5425     _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5426       ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5427     _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5428     _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5429     _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5430     initializeCommon();  // resolve the functions that always need resolving
5431 
5432     initialized = TRUE;
5433   }
5434 }
5435 
5436 BOOL os::Kernel32Dll::SwitchToThread() {
5437   assert(initialized && _SwitchToThread != NULL,
5438     "SwitchToThreadAvailable() not yet called");
5439   return _SwitchToThread();
5440 }
5441 
5442 
5443 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5444   if (!initialized) {
5445     initialize();
5446   }
5447   return _SwitchToThread != NULL;
5448 }
5449 
5450 // Help tools
5451 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5452   if (!initialized) {
5453     initialize();
5454   }
5455   return _CreateToolhelp32Snapshot != NULL &&
5456          _Module32First != NULL &&
5457          _Module32Next != NULL;
5458 }
5459 
5460 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5461   assert(initialized && _CreateToolhelp32Snapshot != NULL,
5462     "HelpToolsAvailable() not yet called");
5463 
5464   return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5465 }
5466 
5467 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5468   assert(initialized && _Module32First != NULL,
5469     "HelpToolsAvailable() not yet called");
5470 
5471   return _Module32First(hSnapshot, lpme);
5472 }
5473 
5474 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5475   assert(initialized && _Module32Next != NULL,
5476     "HelpToolsAvailable() not yet called");
5477 
5478   return _Module32Next(hSnapshot, lpme);
5479 }
5480 
5481 
5482 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5483   if (!initialized) {
5484     initialize();
5485   }
5486   return _GetNativeSystemInfo != NULL;
5487 }
5488 
5489 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5490   assert(initialized && _GetNativeSystemInfo != NULL,
5491     "GetNativeSystemInfoAvailable() not yet called");
5492 
5493   _GetNativeSystemInfo(lpSystemInfo);
5494 }
5495 
5496 // PSAPI API
5497 
5498 
5499 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5500 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5501 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5502 
5503 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
5504 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
5505 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5506 BOOL                    os::PSApiDll::initialized = FALSE;
5507 
5508 void os::PSApiDll::initialize() {
5509   if (!initialized) {
5510     HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5511     if (handle != NULL) {
5512       _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5513         "EnumProcessModules");
5514       _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5515         "GetModuleFileNameExA");
5516       _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5517         "GetModuleInformation");
5518     }
5519     initialized = TRUE;
5520   }
5521 }
5522 
5523 
5524 
5525 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5526   assert(initialized && _EnumProcessModules != NULL,
5527     "PSApiAvailable() not yet called");
5528   return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5529 }
5530 
5531 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5532   assert(initialized && _GetModuleFileNameEx != NULL,
5533     "PSApiAvailable() not yet called");
5534   return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5535 }
5536 
5537 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5538   assert(initialized && _GetModuleInformation != NULL,
5539     "PSApiAvailable() not yet called");
5540   return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5541 }
5542 
5543 BOOL os::PSApiDll::PSApiAvailable() {
5544   if (!initialized) {
5545     initialize();
5546   }
5547   return _EnumProcessModules != NULL &&
5548     _GetModuleFileNameEx != NULL &&
5549     _GetModuleInformation != NULL;
5550 }
5551 
5552 
5553 // WinSock2 API
5554 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5555 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5556 
5557 WSAStartup_Fn    os::WinSock2Dll::_WSAStartup = NULL;
5558 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5559 BOOL             os::WinSock2Dll::initialized = FALSE;
5560 
5561 void os::WinSock2Dll::initialize() {
5562   if (!initialized) {
5563     HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5564     if (handle != NULL) {
5565       _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5566       _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5567     }
5568     initialized = TRUE;
5569   }
5570 }
5571 
5572 
5573 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5574   assert(initialized && _WSAStartup != NULL,
5575     "WinSock2Available() not yet called");
5576   return _WSAStartup(wVersionRequested, lpWSAData);
5577 }
5578 
5579 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5580   assert(initialized && _gethostbyname != NULL,
5581     "WinSock2Available() not yet called");
5582   return _gethostbyname(name);
5583 }
5584 
5585 BOOL os::WinSock2Dll::WinSock2Available() {
5586   if (!initialized) {
5587     initialize();
5588   }
5589   return _WSAStartup != NULL &&
5590     _gethostbyname != NULL;
5591 }
5592 
5593 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5594 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5595 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5596 
5597 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5598 OpenProcessToken_Fn      os::Advapi32Dll::_OpenProcessToken = NULL;
5599 LookupPrivilegeValue_Fn  os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5600 BOOL                     os::Advapi32Dll::initialized = FALSE;
5601 
5602 void os::Advapi32Dll::initialize() {
5603   if (!initialized) {
5604     HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5605     if (handle != NULL) {
5606       _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5607         "AdjustTokenPrivileges");
5608       _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5609         "OpenProcessToken");
5610       _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5611         "LookupPrivilegeValueA");
5612     }
5613     initialized = TRUE;
5614   }
5615 }
5616 
5617 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5618    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5619    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5620    assert(initialized && _AdjustTokenPrivileges != NULL,
5621      "AdvapiAvailable() not yet called");
5622    return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5623        BufferLength, PreviousState, ReturnLength);
5624 }
5625 
5626 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5627   PHANDLE TokenHandle) {
5628    assert(initialized && _OpenProcessToken != NULL,
5629      "AdvapiAvailable() not yet called");
5630     return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5631 }
5632 
5633 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5634    assert(initialized && _LookupPrivilegeValue != NULL,
5635      "AdvapiAvailable() not yet called");
5636   return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5637 }
5638 
5639 BOOL os::Advapi32Dll::AdvapiAvailable() {
5640   if (!initialized) {
5641     initialize();
5642   }
5643   return _AdjustTokenPrivileges != NULL &&
5644     _OpenProcessToken != NULL &&
5645     _LookupPrivilegeValue != NULL;
5646 }
5647 
5648 #endif
5649 
5650 #ifndef PRODUCT
5651 
5652 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5653 // contiguous memory block at a particular address.
5654 // The test first tries to find a good approximate address to allocate at by using the same
5655 // method to allocate some memory at any address. The test then tries to allocate memory in
5656 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5657 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5658 // the previously allocated memory is available for allocation. The only actual failure
5659 // that is reported is when the test tries to allocate at a particular location but gets a
5660 // different valid one. A NULL return value at this point is not considered an error but may
5661 // be legitimate.
5662 // If -XX:+Verbose is enabled, print some explanatory messages.
5663 void TestReserveMemorySpecial_test() {
5664   if (!UseLargePages) {
5665     if (VerboseInternalVMTests) {
5666       gclog_or_tty->print("Skipping test because large pages are disabled");
5667     }
5668     return;
5669   }
5670   // save current value of globals 
5671   bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5672   bool old_use_numa_interleaving = UseNUMAInterleaving;
5673 
5674   // set globals to make sure we hit the correct code path
5675   UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5676 
5677   // do an allocation at an address selected by the OS to get a good one.
5678   const size_t large_allocation_size = os::large_page_size() * 4; 
5679   char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5680   if (result == NULL) {
5681     if (VerboseInternalVMTests) {
5682       gclog_or_tty->print("Failed to allocate control block with size "SIZE_FORMAT". Skipping remainder of test.",
5683         large_allocation_size);
5684     }
5685   } else {
5686     os::release_memory_special(result, large_allocation_size);
5687 
5688     // allocate another page within the recently allocated memory area which seems to be a good location. At least
5689     // we managed to get it once.
5690     const size_t expected_allocation_size = os::large_page_size();
5691     char* expected_location = result + os::large_page_size();
5692     char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5693     if (actual_location == NULL) {
5694       if (VerboseInternalVMTests) {
5695         gclog_or_tty->print("Failed to allocate any memory at "PTR_FORMAT" size "SIZE_FORMAT". Skipping remainder of test.",
5696           expected_location, large_allocation_size);
5697       }
5698     } else {
5699       // release memory
5700       os::release_memory_special(actual_location, expected_allocation_size);
5701       // only now check, after releasing any memory to avoid any leaks.
5702       assert(actual_location == expected_location,
5703         err_msg("Failed to allocate memory at requested location "PTR_FORMAT" of size "SIZE_FORMAT", is "PTR_FORMAT" instead",
5704           expected_location, expected_allocation_size, actual_location));
5705     }
5706   }
5707 
5708   // restore globals
5709   UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5710   UseNUMAInterleaving = old_use_numa_interleaving;
5711 }
5712 #endif // PRODUCT