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