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