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