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