truffle: src/os/windows/vm/os_windows.cpp comparison

comparison src/os/windows/vm/os_windows.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 09259e52a610
children	be896a1983c0

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/java.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/objectMonitor.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/osThread.hpp"
 #include "runtime/perfMemory.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/statSampler.hpp"
 #include "runtime/stubRoutines.hpp"
 timeBeginPeriod(1L);
 break;
 case DLL_PROCESS_DETACH:
 if(ForceTimeHighResolution)
 timeEndPeriod(1L);
 break;
 default:
 break;
 }
 return true;
 bool os::getenv(const char* name, char* buffer, int len) {
 int result = GetEnvironmentVariable(name, buffer, len);
 return result > 0 && result < len;
 }
+bool os::unsetenv(const char* name) {
+assert(name != NULL, "Null pointer");
+return (SetEnvironmentVariable(name, NULL) == TRUE);
+}
 // No setuid programs under Windows.
 bool os::have_special_privileges() {
 return false;
 }
 /*
 * RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.
 * So far, this method is only used by Native Memory Tracking, which is
 * only supported on Windows XP or later.
 */
-address os::get_caller_pc(int n) {
+int os::get_native_stack(address* stack, int frames, int toSkip) {
 #ifdef _NMT_NOINLINE_
-n ++;
+toSkip ++;
 #endif
-address pc;
+int captured = Kernel32Dll::RtlCaptureStackBackTrace(toSkip + 1, frames,
-if (os::Kernel32Dll::RtlCaptureStackBackTrace(n + 1, 1, (PVOID*)&pc, NULL) == 1) {
+(PVOID*)stack, NULL);
-return pc;
+for (int index = captured; index < frames; index ++) {
-}
+stack[index] = NULL;
-return NULL;
+}
+return captured;
 }
 // os::current_stack_base()
 //
 os::win32::print_windows_version(st);
 }
 void os::win32::print_windows_version(outputStream* st) {
 OSVERSIONINFOEX osvi;
-SYSTEM_INFO si;
+VS_FIXEDFILEINFO *file_info;
+TCHAR kernel32_path[MAX_PATH];
+UINT len, ret;
+// Use the GetVersionEx information to see if we're on a server or
+// workstation edition of Windows. Starting with Windows 8.1 we can't
+// trust the OS version information returned by this API.
 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
-st->print_cr("N/A");
+st->print_cr("Call to GetVersionEx failed");
 return;
 }
+bool is_workstation = (osvi.wProductType == VER_NT_WORKSTATION);
-int os_vers = osvi.dwMajorVersion * 1000 + osvi.dwMinorVersion;
+// Get the full path to \Windows\System32\kernel32.dll and use that for
+// determining what version of Windows we're running on.
+len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1;
+ret = GetSystemDirectory(kernel32_path, len);
+if (ret == 0 || ret > len) {
+st->print_cr("Call to GetSystemDirectory failed");
+return;
+}
+strncat(kernel32_path, "\\kernel32.dll", MAX_PATH - ret);
+DWORD version_size = GetFileVersionInfoSize(kernel32_path, NULL);
+if (version_size == 0) {
+st->print_cr("Call to GetFileVersionInfoSize failed");
+return;
+}
+LPTSTR version_info = (LPTSTR)os::malloc(version_size, mtInternal);
+if (version_info == NULL) {
+st->print_cr("Failed to allocate version_info");
+return;
+}
+if (!GetFileVersionInfo(kernel32_path, NULL, version_size, version_info)) {
+os::free(version_info);
+st->print_cr("Call to GetFileVersionInfo failed");
+return;
+}
+if (!VerQueryValue(version_info, TEXT("\\"), (LPVOID*)&file_info, &len)) {
+os::free(version_info);
+st->print_cr("Call to VerQueryValue failed");
+return;
+}
+int major_version = HIWORD(file_info->dwProductVersionMS);
+int minor_version = LOWORD(file_info->dwProductVersionMS);
+int build_number = HIWORD(file_info->dwProductVersionLS);
+int build_minor = LOWORD(file_info->dwProductVersionLS);
+int os_vers = major_version * 1000 + minor_version;
+os::free(version_info);
+st->print(" Windows ");
+switch (os_vers) {
+case 6000:
+if (is_workstation) {
+st->print("Vista");
+} else {
+st->print("Server 2008");
+}
+break;
+case 6001:
+if (is_workstation) {
+st->print("7");
+} else {
+st->print("Server 2008 R2");
+}
+break;
+case 6002:
+if (is_workstation) {
+st->print("8");
+} else {
+st->print("Server 2012");
+}
+break;
+case 6003:
+if (is_workstation) {
+st->print("8.1");
+} else {
+st->print("Server 2012 R2");
+}
+break;
+case 6004:
+if (is_workstation) {
+st->print("10");
+} else {
+// The server version name of Windows 10 is not known at this time
+st->print("%d.%d", major_version, minor_version);
+}
+break;
+default:
+// Unrecognized windows, print out its major and minor versions
+st->print("%d.%d", major_version, minor_version);
+break;
+}
+// Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
+// find out whether we are running on 64 bit processor or not
+SYSTEM_INFO si;
 ZeroMemory(&si, sizeof(SYSTEM_INFO));
-if (os_vers >= 5002) {
+os::Kernel32Dll::GetNativeSystemInfo(&si);
-// Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
+if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
-// find out whether we are running on 64 bit processor or not.
-if (os::Kernel32Dll::GetNativeSystemInfoAvailable()) {
-os::Kernel32Dll::GetNativeSystemInfo(&si);
-} else {
-GetSystemInfo(&si);
-}
-}
-if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
-switch (os_vers) {
-case 3051: st->print(" Windows NT 3.51"); break;
-case 4000: st->print(" Windows NT 4.0"); break;
-case 5000: st->print(" Windows 2000"); break;
-case 5001: st->print(" Windows XP"); break;
-case 5002:
-if (osvi.wProductType == VER_NT_WORKSTATION &&
-si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
-st->print(" Windows XP x64 Edition");
-} else {
-st->print(" Windows Server 2003 family");
-}
-break;
-case 6000:
-if (osvi.wProductType == VER_NT_WORKSTATION) {
-st->print(" Windows Vista");
-} else {
-st->print(" Windows Server 2008");
-}
-break;
-case 6001:
-if (osvi.wProductType == VER_NT_WORKSTATION) {
-st->print(" Windows 7");
-} else {
-st->print(" Windows Server 2008 R2");
-}
-break;
-case 6002:
-if (osvi.wProductType == VER_NT_WORKSTATION) {
-st->print(" Windows 8");
-} else {
-st->print(" Windows Server 2012");
-}
-break;
-case 6003:
-if (osvi.wProductType == VER_NT_WORKSTATION) {
-st->print(" Windows 8.1");
-} else {
-st->print(" Windows Server 2012 R2");
-}
-break;
-default: // future os
-// Unrecognized windows, print out its major and minor versions
-st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
-}
-} else {
-switch (os_vers) {
-case 4000: st->print(" Windows 95"); break;
-case 4010: st->print(" Windows 98"); break;
-case 4090: st->print(" Windows Me"); break;
-default: // future windows, print out its major and minor versions
-st->print(" Windows %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
-}
-}
-if (os_vers >= 6000 && si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
 st->print(" , 64 bit");
 }
-st->print(" Build %d", osvi.dwBuildNumber);
+st->print(" Build %d", build_number);
-st->print(" %s", osvi.szCSDVersion);           // service pack
+st->print(" (%d.%d.%d.%d)", major_version, minor_version, build_number, build_minor);
 st->cr();
 }
 void os::pd_print_cpu_info(outputStream* st) {
 // Nothing to do for now.
 size_of_reserve,  // size of Reserve
 MEM_RESERVE,
 PAGE_READWRITE);
 // If reservation failed, return NULL
 if (p_buf == NULL) return NULL;
-MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, mtNone, CALLER_PC);
+MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
 os::release_memory(p_buf, bytes + chunk_size);
 // we still need to round up to a page boundary (in case we are using large pages)
 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
 // instead we handle this in the bytes_to_rq computation below
 size_t bytes_to_release = bytes - bytes_remaining;
 // NMT has yet to record any individual blocks, so it
 // need to create a dummy 'reserve' record to match
 // the release.
 MemTracker::record_virtual_memory_reserve((address)p_buf,
-bytes_to_release, mtNone, CALLER_PC);
+bytes_to_release, CALLER_PC);
 os::release_memory(p_buf, bytes_to_release);
 }
 #ifdef ASSERT
 if (should_inject_error) {
 if (TracePageSizes && Verbose) {
 next_alloc_addr += bytes_to_rq;
 count++;
 }
 // Although the memory is allocated individually, it is returned as one.
 // NMT records it as one block.
-address pc = CALLER_PC;
 if ((flags & MEM_COMMIT) != 0) {
-MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, mtNone, pc);
+MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC);
 } else {
-MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, mtNone, pc);
+MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC);
 }
 // made it this far, success
 return p_buf;
 }
 }
 // normal policy just allocate it all at once
 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
 char * res = (char *)VirtualAlloc(addr, bytes, flag, prot);
 if (res != NULL) {
-address pc = CALLER_PC;
+MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, CALLER_PC);
-MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, mtNone, pc);
 }
 return res;
 }
 }
 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
 return ::Module32Next(hSnapshot, lpme);
 }
-inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
-return true;
-}
 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
 ::GetNativeSystemInfo(lpSystemInfo);
 }
 // PSAPI API

Mercurial > hg > truffle

comparison src/os/windows/vm/os_windows.cpp @ 20804:7848fc12602b