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