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