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