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