os_windows.cpp revision 10870:5bc83f454d50
169626Sru/*
269626Sru * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3104862Sru * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4104862Sru *
569626Sru * This code is free software; you can redistribute it and/or modify it
6104862Sru * under the terms of the GNU General Public License version 2 only, as
769626Sru * published by the Free Software Foundation.
8104862Sru *
969626Sru * This code is distributed in the hope that it will be useful, but WITHOUT
1069626Sru * 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
109static HANDLE main_process;
110static HANDLE main_thread;
111static int    main_thread_id;
112
113static FILETIME process_creation_time;
114static FILETIME process_exit_time;
115static FILETIME process_user_time;
116static 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
130HINSTANCE vm_lib_handle;
131
132BOOL 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
151static 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
161bool 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.
167bool 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
175void os::run_periodic_checks() {
176  return;
177}
178
179// previous UnhandledExceptionFilter, if there is one
180static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
181
182LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
183
184void 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
308void os::breakpoint() {
309  DebugBreak();
310}
311
312// Invoked from the BREAKPOINT Macro
313extern "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//
321int 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
339address 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
393size_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
401struct 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
410LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
411
412// Thread start routine for all new Java threads
413static 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
467static 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
499bool 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
525bool 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()
545static 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
565bool 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
671void 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
678static jlong first_filetime;
679static jlong initial_performance_count;
680static jlong performance_frequency;
681
682
683jlong 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
691jlong os::elapsed_counter() {
692  LARGE_INTEGER count;
693  QueryPerformanceCounter(&count);
694  return as_long(count) - initial_performance_count;
695}
696
697
698jlong os::elapsed_frequency() {
699  return performance_frequency;
700}
701
702
703julong os::available_memory() {
704  return win32::available_memory();
705}
706
707julong 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
717julong os::physical_memory() {
718  return win32::physical_memory();
719}
720
721bool 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
735int 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
753void 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
779bool os::distribute_processes(uint length, uint* distribution) {
780  // Not yet implemented.
781  return false;
782}
783
784bool os::bind_to_processor(uint processor_id) {
785  // Not yet implemented.
786  return false;
787}
788
789void 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
798double 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()
809static jlong  _offset   = 116444736000000000;
810// Fake time counter for reproducible results when debugging
811static jlong  fake_time = 0;
812
813#ifdef ASSERT
814// Just to be safe, recalculate the offset in debug mode
815static jlong _calculated_offset = 0;
816static int   _has_calculated_offset = 0;
817
818jlong 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
839jlong offset() {
840  return _offset;
841}
842#endif
843
844jlong 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)
850jlong windows_to_time_ticks(FILETIME wt) {
851  jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
852  return (a - offset());
853}
854
855FILETIME 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
863bool os::supports_vtime() { return true; }
864bool os::enable_vtime() { return false; }
865bool os::vtime_enabled() { return false; }
866
867double 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
880jlong 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
890void 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
899jlong 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
908void 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
932char* 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
940bool 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
965void 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
980static BOOL (WINAPI *_MiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
981                                         PMINIDUMP_EXCEPTION_INFORMATION,
982                                         PMINIDUMP_USER_STREAM_INFORMATION,
983                                         PMINIDUMP_CALLBACK_INFORMATION);
984
985static HANDLE dumpFile = NULL;
986
987// Check if dump file can be created.
988void 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
1021void 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.
1086void 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
1098DIR * 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
1165struct 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
1185int 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.
1201const 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
1211static 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
1218bool 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>
1277const 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//
1289static 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
1309struct _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
1316static 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
1333bool 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
1358bool 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]
1373static 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
1386address vm_lib_location[2];    // start and end address of jvm.dll
1387
1388// check if addr is inside jvm.dll
1389bool 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*
1401static 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
1414void * 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
1526void os::print_dll_info(outputStream *st) {
1527  st->print_cr("Dynamic libraries:");
1528  get_loaded_modules_info(_print_module, (void *)st);
1529}
1530
1531int 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
1575bool os::get_host_name(char* buf, size_t buflen) {
1576  DWORD size = (DWORD)buflen;
1577  return (GetComputerNameEx(ComputerNameDnsHostname, buf, &size) == TRUE);
1578}
1579
1580void 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
1588int 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
1597static 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
1604int 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
1610void os::print_os_info_brief(outputStream* st) {
1611  os::print_os_info(st);
1612}
1613
1614void 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
1628void 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
1749void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
1750  // Nothing to do for now.
1751}
1752
1753void 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
1770void 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
1788void 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
1821void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1822  // do nothing
1823}
1824
1825static char saved_jvm_path[MAX_PATH] = {0};
1826
1827// Find the full path to the current module, jvm.dll
1828void 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
1873void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1874#ifndef _WIN64
1875  st->print("_");
1876#endif
1877}
1878
1879
1880void 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
1889size_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
1925int os::get_last_error() {
1926  DWORD error = GetLastError();
1927  if (error == 0) {
1928    error = errno;
1929  }
1930  return (int)error;
1931}
1932
1933WindowsSemaphore::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
1939WindowsSemaphore::~WindowsSemaphore() {
1940  ::CloseHandle(_semaphore);
1941}
1942
1943void 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
1951void 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.
1962static void (*sigbreakHandler)(int) = NULL;
1963
1964static 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
1970void* os::user_handler() {
1971  return (void*) UserHandler;
1972}
1973
1974void* 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
1984void 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//
1993static 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
2042int os::sigexitnum_pd() {
2043  return NSIG;
2044}
2045
2046// a counter for each possible signal value, including signal_thread exit signal
2047static volatile jint pending_signals[NSIG+1] = { 0 };
2048static HANDLE sig_sem = NULL;
2049
2050void 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
2076void 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
2085static 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
2125int os::signal_lookup() {
2126  return check_pending_signals(false);
2127}
2128
2129int os::signal_wait() {
2130  return check_pending_signals(true);
2131}
2132
2133// Implicit OS exception handling
2134
2135LONG 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
2178extern "C" void safepoints();
2179extern "C" void find(int x);
2180extern "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
2213static 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
2246const 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//-----------------------------------------------------------------------------
2259LONG 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//-----------------------------------------------------------------------------
2298LONG 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
2343static 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
2351bool 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//-----------------------------------------------------------------------------
2385LONG 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.
2727LONG 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
2753DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2754DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2755DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2756DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2757DEFINE_FAST_GETFIELD(jint,     int,    Int)
2758DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2759DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2760DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2761
2762address 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
2780int os::vm_page_size() { return os::win32::vm_page_size(); }
2781int 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
2807static HANDLE    _hProcess;
2808static HANDLE    _hToken;
2809
2810// Container for NUMA node list info
2811class 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
2861static size_t _large_page_size = 0;
2862
2863static 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
2888static void cleanup_after_large_page_init() {
2889  if (_hProcess) CloseHandle(_hProcess);
2890  _hProcess = NULL;
2891  if (_hToken) CloseHandle(_hToken);
2892  _hToken = NULL;
2893}
2894
2895static 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
2931static 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
3046void 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.
3094void 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.
3110char* 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
3137char* 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).
3170char* 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
3176size_t os::large_page_size() {
3177  return _large_page_size;
3178}
3179
3180bool 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
3187bool os::can_execute_large_page_memory() {
3188  return true;
3189}
3190
3191char* 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
3237bool os::release_memory_special(char* base, size_t bytes) {
3238  assert(base != NULL, "Sanity check");
3239  return release_memory(base, bytes);
3240}
3241
3242void os::print_statistics() {
3243}
3244
3245static 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
3254bool 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
3316bool 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
3322void 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
3331void 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
3338bool 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
3348bool os::pd_release_memory(char* addr, size_t bytes) {
3349  return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3350}
3351
3352bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3353  return os::commit_memory(addr, size, !ExecMem);
3354}
3355
3356bool os::remove_stack_guard_pages(char* addr, size_t size) {
3357  return os::uncommit_memory(addr, size);
3358}
3359
3360static 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
3390bool 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
3437bool 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
3442bool os::unguard_memory(char* addr, size_t bytes) {
3443  DWORD old_status;
3444  return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3445}
3446
3447void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3448void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3449void os::numa_make_global(char *addr, size_t bytes)    { }
3450void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3451bool os::numa_topology_changed()                       { return false; }
3452size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3453int os::numa_get_group_id()                            { return 0; }
3454size_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
3469bool os::get_page_info(char *start, page_info* info) {
3470  return false;
3471}
3472
3473char *os::scan_pages(char *start, char* end, page_info* page_expected,
3474                     page_info* page_found) {
3475  return end;
3476}
3477
3478char* 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
3488void 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
3497class 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
3530int 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//
3583void 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
3589void os::infinite_sleep() {
3590  while (true) {    // sleep forever ...
3591    Sleep(100000);  // ... 100 seconds at a time
3592  }
3593}
3594
3595typedef BOOL (WINAPI * STTSignature)(void);
3596
3597void 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
3606int 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
3621int 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
3636static 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
3650OSReturn 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
3656OSReturn 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.
3674void os::hint_no_preempt() {}
3675
3676void 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
3699bool 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.
3721ExtendedPC 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
3742intx os::current_thread_id()  { return GetCurrentThreadId(); }
3743
3744static int _initial_pid = 0;
3745
3746int os::current_process_id() {
3747  return (_initial_pid ? _initial_pid : _getpid());
3748}
3749
3750int    os::win32::_vm_page_size              = 0;
3751int    os::win32::_vm_allocation_granularity = 0;
3752int    os::win32::_processor_type            = 0;
3753// Processor level is not available on non-NT systems, use vm_version instead
3754int    os::win32::_processor_level           = 0;
3755julong os::win32::_physical_memory           = 0;
3756size_t os::win32::_default_stack_size        = 0;
3757
3758intx          os::win32::_os_thread_limit    = 0;
3759volatile intx os::win32::_os_thread_count    = 0;
3760
3761bool   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)
3766bool   os::win32::_has_exit_bug              = true;
3767
3768void 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
3810HINSTANCE 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
3860static BOOL CALLBACK init_crit_sect_call(PINIT_ONCE, PVOID pcrit_sect, PVOID*) {
3861  InitializeCriticalSection((CRITICAL_SECTION*)pcrit_sect);
3862  return TRUE;
3863}
3864
3865int 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
4031void 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
4038bool os::is_debugger_attached() {
4039  return IsDebuggerPresent() ? true : false;
4040}
4041
4042
4043void 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
4051bool 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
4060int 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
4070void 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
4084void 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
4109extern "C" {
4110  static void perfMemory_exit_helper() {
4111    perfMemory_exit();
4112  }
4113}
4114
4115static jint initSock();
4116
4117// this is called _after_ the global arguments have been parsed
4118jint 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
4246void 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
4255void 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
4264int 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
4314jlong 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
4319jlong 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
4324jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4325  return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4326}
4327
4328jlong 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
4346void 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
4353void 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
4360bool 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).
4396int 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()
4402bool 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
4409int 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
4420FILE* os::open(int fd, const char* mode) {
4421  return ::_fdopen(fd, mode);
4422}
4423
4424// Is a (classpath) directory empty?
4425bool 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
4436int 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
4445jlong 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
4450jlong os::seek_to_file_offset(int fd, jlong offset) {
4451  return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4452}
4453
4454
4455jlong os::lseek(int fd, jlong offset, int whence) {
4456  return (jlong) ::_lseeki64(fd, offset, whence);
4457}
4458
4459size_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.
4489char * 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
4584int 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
4605int 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
4613int 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
4624static int nonSeekAvailable(int, long *);
4625static 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
4633int 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
4667static 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
4698static 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.
4759char* 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.
4855char* 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
4876bool 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
4902void 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
4923os::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//
4933bool 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
5014int 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
5074void 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
5108void 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
5139void 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
5180void 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).
5187int 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
5225static int mallocDebugIntervalCounter = 0;
5226static int mallocDebugCounter = 0;
5227bool 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
5269bool 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
5295LONG 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
5312bool os::is_headless_jre() { return false; }
5313
5314static 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
5325struct hostent* os::get_host_by_name(char* name) {
5326  return (struct hostent*)gethostbyname(name);
5327}
5328
5329int os::socket_close(int fd) {
5330  return ::closesocket(fd);
5331}
5332
5333int os::socket(int domain, int type, int protocol) {
5334  return ::socket(domain, type, protocol);
5335}
5336
5337int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5338  return ::connect(fd, him, len);
5339}
5340
5341int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5342  return ::recv(fd, buf, (int)nBytes, flags);
5343}
5344
5345int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5346  return ::send(fd, buf, (int)nBytes, flags);
5347}
5348
5349int 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
5362static 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
5373static 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.
5381void 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//
5390void 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
5418bool 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
5444void* 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"
5458char* 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.
5526void 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*/
5590int 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
5613int os::win32::_thread_ptr_offset = 0;
5614
5615static 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.
5619void os::win32::initialize_thread_ptr_offset() {
5620  os::os_exception_wrapper((java_call_t)call_wrapper_dummy,
5621                           NULL, NULL, NULL, NULL);
5622}
5623