os_linux.cpp revision 0:a61af66fc99e
1/* 2 * Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 20 * CA 95054 USA or visit www.sun.com if you need additional information or 21 * have any questions. 22 * 23 */ 24 25// do not include precompiled header file 26# include "incls/_os_linux.cpp.incl" 27 28// put OS-includes here 29# include <sys/types.h> 30# include <sys/mman.h> 31# include <pthread.h> 32# include <signal.h> 33# include <errno.h> 34# include <dlfcn.h> 35# include <stdio.h> 36# include <unistd.h> 37# include <sys/resource.h> 38# include <pthread.h> 39# include <sys/stat.h> 40# include <sys/time.h> 41# include <sys/times.h> 42# include <sys/utsname.h> 43# include <sys/socket.h> 44# include <sys/wait.h> 45# include <pwd.h> 46# include <poll.h> 47# include <semaphore.h> 48# include <fcntl.h> 49# include <string.h> 50# include <syscall.h> 51# include <sys/sysinfo.h> 52# include <gnu/libc-version.h> 53# include <sys/ipc.h> 54# include <sys/shm.h> 55# include <link.h> 56 57#define MAX_PATH (2 * K) 58 59// for timer info max values which include all bits 60#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF) 61#define SEC_IN_NANOSECS 1000000000LL 62 63//////////////////////////////////////////////////////////////////////////////// 64// global variables 65julong os::Linux::_physical_memory = 0; 66 67address os::Linux::_initial_thread_stack_bottom = NULL; 68uintptr_t os::Linux::_initial_thread_stack_size = 0; 69 70int (*os::Linux::_clock_gettime)(clockid_t, struct timespec *) = NULL; 71int (*os::Linux::_pthread_getcpuclockid)(pthread_t, clockid_t *) = NULL; 72Mutex* os::Linux::_createThread_lock = NULL; 73pthread_t os::Linux::_main_thread; 74int os::Linux::_page_size = -1; 75bool os::Linux::_is_floating_stack = false; 76bool os::Linux::_is_NPTL = false; 77bool os::Linux::_supports_fast_thread_cpu_time = false; 78char * os::Linux::_glibc_version = NULL; 79char * os::Linux::_libpthread_version = NULL; 80 81static jlong initial_time_count=0; 82 83static int clock_tics_per_sec = 100; 84 85// For diagnostics to print a message once. see run_periodic_checks 86static sigset_t check_signal_done; 87static bool check_signals = true;; 88 89static pid_t _initial_pid = 0; 90 91/* Signal number used to suspend/resume a thread */ 92 93/* do not use any signal number less than SIGSEGV, see 4355769 */ 94static int SR_signum = SIGUSR2; 95sigset_t SR_sigset; 96 97//////////////////////////////////////////////////////////////////////////////// 98// utility functions 99 100static int SR_initialize(); 101static int SR_finalize(); 102 103julong os::available_memory() { 104 return Linux::available_memory(); 105} 106 107julong os::Linux::available_memory() { 108 // values in struct sysinfo are "unsigned long" 109 struct sysinfo si; 110 sysinfo(&si); 111 112 return (julong)si.freeram * si.mem_unit; 113} 114 115julong os::physical_memory() { 116 return Linux::physical_memory(); 117} 118 119//////////////////////////////////////////////////////////////////////////////// 120// environment support 121 122bool os::getenv(const char* name, char* buf, int len) { 123 const char* val = ::getenv(name); 124 if (val != NULL && strlen(val) < (size_t)len) { 125 strcpy(buf, val); 126 return true; 127 } 128 if (len > 0) buf[0] = 0; // return a null string 129 return false; 130} 131 132 133// Return true if user is running as root. 134 135bool os::have_special_privileges() { 136 static bool init = false; 137 static bool privileges = false; 138 if (!init) { 139 privileges = (getuid() != geteuid()) || (getgid() != getegid()); 140 init = true; 141 } 142 return privileges; 143} 144 145 146#ifndef SYS_gettid 147// i386: 224, ia64: 1105, amd64: 186, sparc 143 148#ifdef __ia64__ 149#define SYS_gettid 1105 150#elif __i386__ 151#define SYS_gettid 224 152#elif __amd64__ 153#define SYS_gettid 186 154#elif __sparc__ 155#define SYS_gettid 143 156#else 157#error define gettid for the arch 158#endif 159#endif 160 161// Cpu architecture string 162#if defined(IA64) 163static char cpu_arch[] = "ia64"; 164#elif defined(IA32) 165static char cpu_arch[] = "i386"; 166#elif defined(AMD64) 167static char cpu_arch[] = "amd64"; 168#elif defined(SPARC) 169# ifdef _LP64 170static char cpu_arch[] = "sparcv9"; 171# else 172static char cpu_arch[] = "sparc"; 173# endif 174#else 175#error Add appropriate cpu_arch setting 176#endif 177 178 179// pid_t gettid() 180// 181// Returns the kernel thread id of the currently running thread. Kernel 182// thread id is used to access /proc. 183// 184// (Note that getpid() on LinuxThreads returns kernel thread id too; but 185// on NPTL, it returns the same pid for all threads, as required by POSIX.) 186// 187pid_t os::Linux::gettid() { 188 int rslt = syscall(SYS_gettid); 189 if (rslt == -1) { 190 // old kernel, no NPTL support 191 return getpid(); 192 } else { 193 return (pid_t)rslt; 194 } 195} 196 197// Most versions of linux have a bug where the number of processors are 198// determined by looking at the /proc file system. In a chroot environment, 199// the system call returns 1. This causes the VM to act as if it is 200// a single processor and elide locking (see is_MP() call). 201static bool unsafe_chroot_detected = false; 202static char *unstable_chroot_error = "/proc file system not found.\n" 203 "Java may be unstable running multithreaded in a chroot " 204 "environment on Linux when /proc filesystem is not mounted."; 205 206void os::Linux::initialize_system_info() { 207 _processor_count = sysconf(_SC_NPROCESSORS_CONF); 208 if (_processor_count == 1) { 209 pid_t pid = os::Linux::gettid(); 210 char fname[32]; 211 jio_snprintf(fname, sizeof(fname), "/proc/%d", pid); 212 FILE *fp = fopen(fname, "r"); 213 if (fp == NULL) { 214 unsafe_chroot_detected = true; 215 } else { 216 fclose(fp); 217 } 218 } 219 _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE); 220 assert(_processor_count > 0, "linux error"); 221} 222 223void os::init_system_properties_values() { 224// char arch[12]; 225// sysinfo(SI_ARCHITECTURE, arch, sizeof(arch)); 226 227 // The next steps are taken in the product version: 228 // 229 // Obtain the JAVA_HOME value from the location of libjvm[_g].so. 230 // This library should be located at: 231 // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so. 232 // 233 // If "/jre/lib/" appears at the right place in the path, then we 234 // assume libjvm[_g].so is installed in a JDK and we use this path. 235 // 236 // Otherwise exit with message: "Could not create the Java virtual machine." 237 // 238 // The following extra steps are taken in the debugging version: 239 // 240 // If "/jre/lib/" does NOT appear at the right place in the path 241 // instead of exit check for $JAVA_HOME environment variable. 242 // 243 // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>, 244 // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so 245 // it looks like libjvm[_g].so is installed there 246 // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so. 247 // 248 // Otherwise exit. 249 // 250 // Important note: if the location of libjvm.so changes this 251 // code needs to be changed accordingly. 252 253 // The next few definitions allow the code to be verbatim: 254#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n)) 255#define getenv(n) ::getenv(n) 256 257/* 258 * See ld(1): 259 * The linker uses the following search paths to locate required 260 * shared libraries: 261 * 1: ... 262 * ... 263 * 7: The default directories, normally /lib and /usr/lib. 264 */ 265#define DEFAULT_LIBPATH "/lib:/usr/lib" 266 267#define EXTENSIONS_DIR "/lib/ext" 268#define ENDORSED_DIR "/lib/endorsed" 269#define REG_DIR "/usr/java/packages" 270 271 { 272 /* sysclasspath, java_home, dll_dir */ 273 { 274 char *home_path; 275 char *dll_path; 276 char *pslash; 277 char buf[MAXPATHLEN]; 278 os::jvm_path(buf, sizeof(buf)); 279 280 // Found the full path to libjvm.so. 281 // Now cut the path to <java_home>/jre if we can. 282 *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */ 283 pslash = strrchr(buf, '/'); 284 if (pslash != NULL) 285 *pslash = '\0'; /* get rid of /{client|server|hotspot} */ 286 dll_path = malloc(strlen(buf) + 1); 287 if (dll_path == NULL) 288 return; 289 strcpy(dll_path, buf); 290 Arguments::set_dll_dir(dll_path); 291 292 if (pslash != NULL) { 293 pslash = strrchr(buf, '/'); 294 if (pslash != NULL) { 295 *pslash = '\0'; /* get rid of /<arch> */ 296 pslash = strrchr(buf, '/'); 297 if (pslash != NULL) 298 *pslash = '\0'; /* get rid of /lib */ 299 } 300 } 301 302 home_path = malloc(strlen(buf) + 1); 303 if (home_path == NULL) 304 return; 305 strcpy(home_path, buf); 306 Arguments::set_java_home(home_path); 307 308 if (!set_boot_path('/', ':')) 309 return; 310 } 311 312 /* 313 * Where to look for native libraries 314 * 315 * Note: Due to a legacy implementation, most of the library path 316 * is set in the launcher. This was to accomodate linking restrictions 317 * on legacy Linux implementations (which are no longer supported). 318 * Eventually, all the library path setting will be done here. 319 * 320 * However, to prevent the proliferation of improperly built native 321 * libraries, the new path component /usr/java/packages is added here. 322 * Eventually, all the library path setting will be done here. 323 */ 324 { 325 char *ld_library_path; 326 327 /* 328 * Construct the invariant part of ld_library_path. Note that the 329 * space for the colon and the trailing null are provided by the 330 * nulls included by the sizeof operator (so actually we allocate 331 * a byte more than necessary). 332 */ 333 ld_library_path = (char *) malloc(sizeof(REG_DIR) + sizeof("/lib/") + 334 strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH)); 335 sprintf(ld_library_path, REG_DIR "/lib/%s:" DEFAULT_LIBPATH, cpu_arch); 336 337 /* 338 * Get the user setting of LD_LIBRARY_PATH, and prepended it. It 339 * should always exist (until the legacy problem cited above is 340 * addressed). 341 */ 342 char *v = getenv("LD_LIBRARY_PATH"); 343 if (v != NULL) { 344 char *t = ld_library_path; 345 /* That's +1 for the colon and +1 for the trailing '\0' */ 346 ld_library_path = (char *) malloc(strlen(v) + 1 + strlen(t) + 1); 347 sprintf(ld_library_path, "%s:%s", v, t); 348 } 349 Arguments::set_library_path(ld_library_path); 350 } 351 352 /* 353 * Extensions directories. 354 * 355 * Note that the space for the colon and the trailing null are provided 356 * by the nulls included by the sizeof operator (so actually one byte more 357 * than necessary is allocated). 358 */ 359 { 360 char *buf = malloc(strlen(Arguments::get_java_home()) + 361 sizeof(EXTENSIONS_DIR) + sizeof(REG_DIR) + sizeof(EXTENSIONS_DIR)); 362 sprintf(buf, "%s" EXTENSIONS_DIR ":" REG_DIR EXTENSIONS_DIR, 363 Arguments::get_java_home()); 364 Arguments::set_ext_dirs(buf); 365 } 366 367 /* Endorsed standards default directory. */ 368 { 369 char * buf; 370 buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR)); 371 sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home()); 372 Arguments::set_endorsed_dirs(buf); 373 } 374 } 375 376#undef malloc 377#undef getenv 378#undef EXTENSIONS_DIR 379#undef ENDORSED_DIR 380 381 // Done 382 return; 383} 384 385//////////////////////////////////////////////////////////////////////////////// 386// breakpoint support 387 388void os::breakpoint() { 389 BREAKPOINT; 390} 391 392extern "C" void breakpoint() { 393 // use debugger to set breakpoint here 394} 395 396//////////////////////////////////////////////////////////////////////////////// 397// signal support 398 399debug_only(static bool signal_sets_initialized = false); 400static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs; 401 402bool os::Linux::is_sig_ignored(int sig) { 403 struct sigaction oact; 404 sigaction(sig, (struct sigaction*)NULL, &oact); 405 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction) 406 : CAST_FROM_FN_PTR(void*, oact.sa_handler); 407 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) 408 return true; 409 else 410 return false; 411} 412 413void os::Linux::signal_sets_init() { 414 // Should also have an assertion stating we are still single-threaded. 415 assert(!signal_sets_initialized, "Already initialized"); 416 // Fill in signals that are necessarily unblocked for all threads in 417 // the VM. Currently, we unblock the following signals: 418 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden 419 // by -Xrs (=ReduceSignalUsage)); 420 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all 421 // other threads. The "ReduceSignalUsage" boolean tells us not to alter 422 // the dispositions or masks wrt these signals. 423 // Programs embedding the VM that want to use the above signals for their 424 // own purposes must, at this time, use the "-Xrs" option to prevent 425 // interference with shutdown hooks and BREAK_SIGNAL thread dumping. 426 // (See bug 4345157, and other related bugs). 427 // In reality, though, unblocking these signals is really a nop, since 428 // these signals are not blocked by default. 429 sigemptyset(&unblocked_sigs); 430 sigemptyset(&allowdebug_blocked_sigs); 431 sigaddset(&unblocked_sigs, SIGILL); 432 sigaddset(&unblocked_sigs, SIGSEGV); 433 sigaddset(&unblocked_sigs, SIGBUS); 434 sigaddset(&unblocked_sigs, SIGFPE); 435 sigaddset(&unblocked_sigs, SR_signum); 436 437 if (!ReduceSignalUsage) { 438 if (!os::Linux::is_sig_ignored(SHUTDOWN1_SIGNAL)) { 439 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL); 440 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL); 441 } 442 if (!os::Linux::is_sig_ignored(SHUTDOWN2_SIGNAL)) { 443 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL); 444 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL); 445 } 446 if (!os::Linux::is_sig_ignored(SHUTDOWN3_SIGNAL)) { 447 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL); 448 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL); 449 } 450 } 451 // Fill in signals that are blocked by all but the VM thread. 452 sigemptyset(&vm_sigs); 453 if (!ReduceSignalUsage) 454 sigaddset(&vm_sigs, BREAK_SIGNAL); 455 debug_only(signal_sets_initialized = true); 456 457} 458 459// These are signals that are unblocked while a thread is running Java. 460// (For some reason, they get blocked by default.) 461sigset_t* os::Linux::unblocked_signals() { 462 assert(signal_sets_initialized, "Not initialized"); 463 return &unblocked_sigs; 464} 465 466// These are the signals that are blocked while a (non-VM) thread is 467// running Java. Only the VM thread handles these signals. 468sigset_t* os::Linux::vm_signals() { 469 assert(signal_sets_initialized, "Not initialized"); 470 return &vm_sigs; 471} 472 473// These are signals that are blocked during cond_wait to allow debugger in 474sigset_t* os::Linux::allowdebug_blocked_signals() { 475 assert(signal_sets_initialized, "Not initialized"); 476 return &allowdebug_blocked_sigs; 477} 478 479void os::Linux::hotspot_sigmask(Thread* thread) { 480 481 //Save caller's signal mask before setting VM signal mask 482 sigset_t caller_sigmask; 483 pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask); 484 485 OSThread* osthread = thread->osthread(); 486 osthread->set_caller_sigmask(caller_sigmask); 487 488 pthread_sigmask(SIG_UNBLOCK, os::Linux::unblocked_signals(), NULL); 489 490 if (!ReduceSignalUsage) { 491 if (thread->is_VM_thread()) { 492 // Only the VM thread handles BREAK_SIGNAL ... 493 pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL); 494 } else { 495 // ... all other threads block BREAK_SIGNAL 496 pthread_sigmask(SIG_BLOCK, vm_signals(), NULL); 497 } 498 } 499} 500 501////////////////////////////////////////////////////////////////////////////// 502// detecting pthread library 503 504void os::Linux::libpthread_init() { 505 // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION 506 // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a 507 // generic name for earlier versions. 508 // Define macros here so we can build HotSpot on old systems. 509# ifndef _CS_GNU_LIBC_VERSION 510# define _CS_GNU_LIBC_VERSION 2 511# endif 512# ifndef _CS_GNU_LIBPTHREAD_VERSION 513# define _CS_GNU_LIBPTHREAD_VERSION 3 514# endif 515 516 size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0); 517 if (n > 0) { 518 char *str = (char *)malloc(n); 519 confstr(_CS_GNU_LIBC_VERSION, str, n); 520 os::Linux::set_glibc_version(str); 521 } else { 522 // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version() 523 static char _gnu_libc_version[32]; 524 jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version), 525 "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release()); 526 os::Linux::set_glibc_version(_gnu_libc_version); 527 } 528 529 n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0); 530 if (n > 0) { 531 char *str = (char *)malloc(n); 532 confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n); 533 534 // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells 535 // us "NPTL-0.29" even we are running with LinuxThreads. Check if this 536 // is the case: 537 if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 && 538 strstr(str, "NPTL")) { 539 // LinuxThreads has a hard limit on max number of threads. So 540 // sysconf(_SC_THREAD_THREADS_MAX) will return a positive value. 541 // On the other hand, NPTL does not have such a limit, sysconf() 542 // will return -1 and errno is not changed. Check if it is really 543 // NPTL: 544 if (sysconf(_SC_THREAD_THREADS_MAX) > 0) { 545 free(str); 546 str = "linuxthreads"; 547 } 548 } 549 os::Linux::set_libpthread_version(str); 550 } else { 551 // glibc before 2.3.2 only has LinuxThreads. 552 os::Linux::set_libpthread_version("linuxthreads"); 553 } 554 555 if (strstr(libpthread_version(), "NPTL")) { 556 os::Linux::set_is_NPTL(); 557 } else { 558 os::Linux::set_is_LinuxThreads(); 559 } 560 561 // LinuxThreads have two flavors: floating-stack mode, which allows variable 562 // stack size; and fixed-stack mode. NPTL is always floating-stack. 563 if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) { 564 os::Linux::set_is_floating_stack(); 565 } 566} 567 568///////////////////////////////////////////////////////////////////////////// 569// thread stack 570 571// Force Linux kernel to expand current thread stack. If "bottom" is close 572// to the stack guard, caller should block all signals. 573// 574// MAP_GROWSDOWN: 575// A special mmap() flag that is used to implement thread stacks. It tells 576// kernel that the memory region should extend downwards when needed. This 577// allows early versions of LinuxThreads to only mmap the first few pages 578// when creating a new thread. Linux kernel will automatically expand thread 579// stack as needed (on page faults). 580// 581// However, because the memory region of a MAP_GROWSDOWN stack can grow on 582// demand, if a page fault happens outside an already mapped MAP_GROWSDOWN 583// region, it's hard to tell if the fault is due to a legitimate stack 584// access or because of reading/writing non-exist memory (e.g. buffer 585// overrun). As a rule, if the fault happens below current stack pointer, 586// Linux kernel does not expand stack, instead a SIGSEGV is sent to the 587// application (see Linux kernel fault.c). 588// 589// This Linux feature can cause SIGSEGV when VM bangs thread stack for 590// stack overflow detection. 591// 592// Newer version of LinuxThreads (since glibc-2.2, or, RH-7.x) and NPTL do 593// not use this flag. However, the stack of initial thread is not created 594// by pthread, it is still MAP_GROWSDOWN. Also it's possible (though 595// unlikely) that user code can create a thread with MAP_GROWSDOWN stack 596// and then attach the thread to JVM. 597// 598// To get around the problem and allow stack banging on Linux, we need to 599// manually expand thread stack after receiving the SIGSEGV. 600// 601// There are two ways to expand thread stack to address "bottom", we used 602// both of them in JVM before 1.5: 603// 1. adjust stack pointer first so that it is below "bottom", and then 604// touch "bottom" 605// 2. mmap() the page in question 606// 607// Now alternate signal stack is gone, it's harder to use 2. For instance, 608// if current sp is already near the lower end of page 101, and we need to 609// call mmap() to map page 100, it is possible that part of the mmap() frame 610// will be placed in page 100. When page 100 is mapped, it is zero-filled. 611// That will destroy the mmap() frame and cause VM to crash. 612// 613// The following code works by adjusting sp first, then accessing the "bottom" 614// page to force a page fault. Linux kernel will then automatically expand the 615// stack mapping. 616// 617// _expand_stack_to() assumes its frame size is less than page size, which 618// should always be true if the function is not inlined. 619 620#if __GNUC__ < 3 // gcc 2.x does not support noinline attribute 621#define NOINLINE 622#else 623#define NOINLINE __attribute__ ((noinline)) 624#endif 625 626static void _expand_stack_to(address bottom) NOINLINE; 627 628static void _expand_stack_to(address bottom) { 629 address sp; 630 size_t size; 631 volatile char *p; 632 633 // Adjust bottom to point to the largest address within the same page, it 634 // gives us a one-page buffer if alloca() allocates slightly more memory. 635 bottom = (address)align_size_down((uintptr_t)bottom, os::Linux::page_size()); 636 bottom += os::Linux::page_size() - 1; 637 638 // sp might be slightly above current stack pointer; if that's the case, we 639 // will alloca() a little more space than necessary, which is OK. Don't use 640 // os::current_stack_pointer(), as its result can be slightly below current 641 // stack pointer, causing us to not alloca enough to reach "bottom". 642 sp = (address)&sp; 643 644 if (sp > bottom) { 645 size = sp - bottom; 646 p = (volatile char *)alloca(size); 647 assert(p != NULL && p <= (volatile char *)bottom, "alloca problem?"); 648 p[0] = '\0'; 649 } 650} 651 652bool os::Linux::manually_expand_stack(JavaThread * t, address addr) { 653 assert(t!=NULL, "just checking"); 654 assert(t->osthread()->expanding_stack(), "expand should be set"); 655 assert(t->stack_base() != NULL, "stack_base was not initialized"); 656 657 if (addr < t->stack_base() && addr >= t->stack_yellow_zone_base()) { 658 sigset_t mask_all, old_sigset; 659 sigfillset(&mask_all); 660 pthread_sigmask(SIG_SETMASK, &mask_all, &old_sigset); 661 _expand_stack_to(addr); 662 pthread_sigmask(SIG_SETMASK, &old_sigset, NULL); 663 return true; 664 } 665 return false; 666} 667 668////////////////////////////////////////////////////////////////////////////// 669// create new thread 670 671static address highest_vm_reserved_address(); 672 673// check if it's safe to start a new thread 674static bool _thread_safety_check(Thread* thread) { 675 if (os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack()) { 676 // Fixed stack LinuxThreads (SuSE Linux/x86, and some versions of Redhat) 677 // Heap is mmap'ed at lower end of memory space. Thread stacks are 678 // allocated (MAP_FIXED) from high address space. Every thread stack 679 // occupies a fixed size slot (usually 2Mbytes, but user can change 680 // it to other values if they rebuild LinuxThreads). 681 // 682 // Problem with MAP_FIXED is that mmap() can still succeed even part of 683 // the memory region has already been mmap'ed. That means if we have too 684 // many threads and/or very large heap, eventually thread stack will 685 // collide with heap. 686 // 687 // Here we try to prevent heap/stack collision by comparing current 688 // stack bottom with the highest address that has been mmap'ed by JVM 689 // plus a safety margin for memory maps created by native code. 690 // 691 // This feature can be disabled by setting ThreadSafetyMargin to 0 692 // 693 if (ThreadSafetyMargin > 0) { 694 address stack_bottom = os::current_stack_base() - os::current_stack_size(); 695 696 // not safe if our stack extends below the safety margin 697 return stack_bottom - ThreadSafetyMargin >= highest_vm_reserved_address(); 698 } else { 699 return true; 700 } 701 } else { 702 // Floating stack LinuxThreads or NPTL: 703 // Unlike fixed stack LinuxThreads, thread stacks are not MAP_FIXED. When 704 // there's not enough space left, pthread_create() will fail. If we come 705 // here, that means enough space has been reserved for stack. 706 return true; 707 } 708} 709 710// Thread start routine for all newly created threads 711static void *java_start(Thread *thread) { 712 // Try to randomize the cache line index of hot stack frames. 713 // This helps when threads of the same stack traces evict each other's 714 // cache lines. The threads can be either from the same JVM instance, or 715 // from different JVM instances. The benefit is especially true for 716 // processors with hyperthreading technology. 717 static int counter = 0; 718 int pid = os::current_process_id(); 719 alloca(((pid ^ counter++) & 7) * 128); 720 721 ThreadLocalStorage::set_thread(thread); 722 723 OSThread* osthread = thread->osthread(); 724 Monitor* sync = osthread->startThread_lock(); 725 726 // non floating stack LinuxThreads needs extra check, see above 727 if (!_thread_safety_check(thread)) { 728 // notify parent thread 729 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag); 730 osthread->set_state(ZOMBIE); 731 sync->notify_all(); 732 return NULL; 733 } 734 735 // thread_id is kernel thread id (similar to Solaris LWP id) 736 osthread->set_thread_id(os::Linux::gettid()); 737 738 if (UseNUMA) { 739 int lgrp_id = os::numa_get_group_id(); 740 if (lgrp_id != -1) { 741 thread->set_lgrp_id(lgrp_id); 742 } 743 } 744 // initialize signal mask for this thread 745 os::Linux::hotspot_sigmask(thread); 746 747 // initialize floating point control register 748 os::Linux::init_thread_fpu_state(); 749 750 // handshaking with parent thread 751 { 752 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag); 753 754 // notify parent thread 755 osthread->set_state(INITIALIZED); 756 sync->notify_all(); 757 758 // wait until os::start_thread() 759 while (osthread->get_state() == INITIALIZED) { 760 sync->wait(Mutex::_no_safepoint_check_flag); 761 } 762 } 763 764 // call one more level start routine 765 thread->run(); 766 767 return 0; 768} 769 770bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) { 771 assert(thread->osthread() == NULL, "caller responsible"); 772 773 // Allocate the OSThread object 774 OSThread* osthread = new OSThread(NULL, NULL); 775 if (osthread == NULL) { 776 return false; 777 } 778 779 // set the correct thread state 780 osthread->set_thread_type(thr_type); 781 782 // Initial state is ALLOCATED but not INITIALIZED 783 osthread->set_state(ALLOCATED); 784 785 thread->set_osthread(osthread); 786 787 // init thread attributes 788 pthread_attr_t attr; 789 pthread_attr_init(&attr); 790 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 791 792 // stack size 793 if (os::Linux::supports_variable_stack_size()) { 794 // calculate stack size if it's not specified by caller 795 if (stack_size == 0) { 796 stack_size = os::Linux::default_stack_size(thr_type); 797 798 switch (thr_type) { 799 case os::java_thread: 800 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss 801 if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create(); 802 break; 803 case os::compiler_thread: 804 if (CompilerThreadStackSize > 0) { 805 stack_size = (size_t)(CompilerThreadStackSize * K); 806 break; 807 } // else fall through: 808 // use VMThreadStackSize if CompilerThreadStackSize is not defined 809 case os::vm_thread: 810 case os::pgc_thread: 811 case os::cgc_thread: 812 case os::watcher_thread: 813 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K); 814 break; 815 } 816 } 817 818 stack_size = MAX2(stack_size, os::Linux::min_stack_allowed); 819 pthread_attr_setstacksize(&attr, stack_size); 820 } else { 821 // let pthread_create() pick the default value. 822 } 823 824 // glibc guard page 825 pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type)); 826 827 ThreadState state; 828 829 { 830 // Serialize thread creation if we are running with fixed stack LinuxThreads 831 bool lock = os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack(); 832 if (lock) { 833 os::Linux::createThread_lock()->lock_without_safepoint_check(); 834 } 835 836 pthread_t tid; 837 int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread); 838 839 pthread_attr_destroy(&attr); 840 841 if (ret != 0) { 842 if (PrintMiscellaneous && (Verbose || WizardMode)) { 843 perror("pthread_create()"); 844 } 845 // Need to clean up stuff we've allocated so far 846 thread->set_osthread(NULL); 847 delete osthread; 848 if (lock) os::Linux::createThread_lock()->unlock(); 849 return false; 850 } 851 852 // Store pthread info into the OSThread 853 osthread->set_pthread_id(tid); 854 855 // Wait until child thread is either initialized or aborted 856 { 857 Monitor* sync_with_child = osthread->startThread_lock(); 858 MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag); 859 while ((state = osthread->get_state()) == ALLOCATED) { 860 sync_with_child->wait(Mutex::_no_safepoint_check_flag); 861 } 862 } 863 864 if (lock) { 865 os::Linux::createThread_lock()->unlock(); 866 } 867 } 868 869 // Aborted due to thread limit being reached 870 if (state == ZOMBIE) { 871 thread->set_osthread(NULL); 872 delete osthread; 873 return false; 874 } 875 876 // The thread is returned suspended (in state INITIALIZED), 877 // and is started higher up in the call chain 878 assert(state == INITIALIZED, "race condition"); 879 return true; 880} 881 882///////////////////////////////////////////////////////////////////////////// 883// attach existing thread 884 885// bootstrap the main thread 886bool os::create_main_thread(JavaThread* thread) { 887 assert(os::Linux::_main_thread == pthread_self(), "should be called inside main thread"); 888 return create_attached_thread(thread); 889} 890 891bool os::create_attached_thread(JavaThread* thread) { 892#ifdef ASSERT 893 thread->verify_not_published(); 894#endif 895 896 // Allocate the OSThread object 897 OSThread* osthread = new OSThread(NULL, NULL); 898 899 if (osthread == NULL) { 900 return false; 901 } 902 903 // Store pthread info into the OSThread 904 osthread->set_thread_id(os::Linux::gettid()); 905 osthread->set_pthread_id(::pthread_self()); 906 907 // initialize floating point control register 908 os::Linux::init_thread_fpu_state(); 909 910 // Initial thread state is RUNNABLE 911 osthread->set_state(RUNNABLE); 912 913 thread->set_osthread(osthread); 914 915 if (UseNUMA) { 916 int lgrp_id = os::numa_get_group_id(); 917 if (lgrp_id != -1) { 918 thread->set_lgrp_id(lgrp_id); 919 } 920 } 921 922 if (os::Linux::is_initial_thread()) { 923 // If current thread is initial thread, its stack is mapped on demand, 924 // see notes about MAP_GROWSDOWN. Here we try to force kernel to map 925 // the entire stack region to avoid SEGV in stack banging. 926 // It is also useful to get around the heap-stack-gap problem on SuSE 927 // kernel (see 4821821 for details). We first expand stack to the top 928 // of yellow zone, then enable stack yellow zone (order is significant, 929 // enabling yellow zone first will crash JVM on SuSE Linux), so there 930 // is no gap between the last two virtual memory regions. 931 932 JavaThread *jt = (JavaThread *)thread; 933 address addr = jt->stack_yellow_zone_base(); 934 assert(addr != NULL, "initialization problem?"); 935 assert(jt->stack_available(addr) > 0, "stack guard should not be enabled"); 936 937 osthread->set_expanding_stack(); 938 os::Linux::manually_expand_stack(jt, addr); 939 osthread->clear_expanding_stack(); 940 } 941 942 // initialize signal mask for this thread 943 // and save the caller's signal mask 944 os::Linux::hotspot_sigmask(thread); 945 946 return true; 947} 948 949void os::pd_start_thread(Thread* thread) { 950 OSThread * osthread = thread->osthread(); 951 assert(osthread->get_state() != INITIALIZED, "just checking"); 952 Monitor* sync_with_child = osthread->startThread_lock(); 953 MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag); 954 sync_with_child->notify(); 955} 956 957// Free Linux resources related to the OSThread 958void os::free_thread(OSThread* osthread) { 959 assert(osthread != NULL, "osthread not set"); 960 961 if (Thread::current()->osthread() == osthread) { 962 // Restore caller's signal mask 963 sigset_t sigmask = osthread->caller_sigmask(); 964 pthread_sigmask(SIG_SETMASK, &sigmask, NULL); 965 } 966 967 delete osthread; 968} 969 970////////////////////////////////////////////////////////////////////////////// 971// thread local storage 972 973int os::allocate_thread_local_storage() { 974 pthread_key_t key; 975 int rslt = pthread_key_create(&key, NULL); 976 assert(rslt == 0, "cannot allocate thread local storage"); 977 return (int)key; 978} 979 980// Note: This is currently not used by VM, as we don't destroy TLS key 981// on VM exit. 982void os::free_thread_local_storage(int index) { 983 int rslt = pthread_key_delete((pthread_key_t)index); 984 assert(rslt == 0, "invalid index"); 985} 986 987void os::thread_local_storage_at_put(int index, void* value) { 988 int rslt = pthread_setspecific((pthread_key_t)index, value); 989 assert(rslt == 0, "pthread_setspecific failed"); 990} 991 992extern "C" Thread* get_thread() { 993 return ThreadLocalStorage::thread(); 994} 995 996////////////////////////////////////////////////////////////////////////////// 997// initial thread 998 999// Check if current thread is the initial thread, similar to Solaris thr_main. 1000bool os::Linux::is_initial_thread(void) { 1001 char dummy; 1002 // If called before init complete, thread stack bottom will be null. 1003 // Can be called if fatal error occurs before initialization. 1004 if (initial_thread_stack_bottom() == NULL) return false; 1005 assert(initial_thread_stack_bottom() != NULL && 1006 initial_thread_stack_size() != 0, 1007 "os::init did not locate initial thread's stack region"); 1008 if ((address)&dummy >= initial_thread_stack_bottom() && 1009 (address)&dummy < initial_thread_stack_bottom() + initial_thread_stack_size()) 1010 return true; 1011 else return false; 1012} 1013 1014// Find the virtual memory area that contains addr 1015static bool find_vma(address addr, address* vma_low, address* vma_high) { 1016 FILE *fp = fopen("/proc/self/maps", "r"); 1017 if (fp) { 1018 address low, high; 1019 while (!feof(fp)) { 1020 if (fscanf(fp, "%p-%p", &low, &high) == 2) { 1021 if (low <= addr && addr < high) { 1022 if (vma_low) *vma_low = low; 1023 if (vma_high) *vma_high = high; 1024 fclose (fp); 1025 return true; 1026 } 1027 } 1028 for (;;) { 1029 int ch = fgetc(fp); 1030 if (ch == EOF || ch == (int)'\n') break; 1031 } 1032 } 1033 fclose(fp); 1034 } 1035 return false; 1036} 1037 1038// Locate initial thread stack. This special handling of initial thread stack 1039// is needed because pthread_getattr_np() on most (all?) Linux distros returns 1040// bogus value for initial thread. 1041void os::Linux::capture_initial_stack(size_t max_size) { 1042 // stack size is the easy part, get it from RLIMIT_STACK 1043 size_t stack_size; 1044 struct rlimit rlim; 1045 getrlimit(RLIMIT_STACK, &rlim); 1046 stack_size = rlim.rlim_cur; 1047 1048 // 6308388: a bug in ld.so will relocate its own .data section to the 1049 // lower end of primordial stack; reduce ulimit -s value a little bit 1050 // so we won't install guard page on ld.so's data section. 1051 stack_size -= 2 * page_size(); 1052 1053 // 4441425: avoid crash with "unlimited" stack size on SuSE 7.1 or Redhat 1054 // 7.1, in both cases we will get 2G in return value. 1055 // 4466587: glibc 2.2.x compiled w/o "--enable-kernel=2.4.0" (RH 7.0, 1056 // SuSE 7.2, Debian) can not handle alternate signal stack correctly 1057 // for initial thread if its stack size exceeds 6M. Cap it at 2M, 1058 // in case other parts in glibc still assumes 2M max stack size. 1059 // FIXME: alt signal stack is gone, maybe we can relax this constraint? 1060#ifndef IA64 1061 if (stack_size > 2 * K * K) stack_size = 2 * K * K; 1062#else 1063 // Problem still exists RH7.2 (IA64 anyway) but 2MB is a little small 1064 if (stack_size > 4 * K * K) stack_size = 4 * K * K; 1065#endif 1066 1067 // Try to figure out where the stack base (top) is. This is harder. 1068 // 1069 // When an application is started, glibc saves the initial stack pointer in 1070 // a global variable "__libc_stack_end", which is then used by system 1071 // libraries. __libc_stack_end should be pretty close to stack top. The 1072 // variable is available since the very early days. However, because it is 1073 // a private interface, it could disappear in the future. 1074 // 1075 // Linux kernel saves start_stack information in /proc/<pid>/stat. Similar 1076 // to __libc_stack_end, it is very close to stack top, but isn't the real 1077 // stack top. Note that /proc may not exist if VM is running as a chroot 1078 // program, so reading /proc/<pid>/stat could fail. Also the contents of 1079 // /proc/<pid>/stat could change in the future (though unlikely). 1080 // 1081 // We try __libc_stack_end first. If that doesn't work, look for 1082 // /proc/<pid>/stat. If neither of them works, we use current stack pointer 1083 // as a hint, which should work well in most cases. 1084 1085 uintptr_t stack_start; 1086 1087 // try __libc_stack_end first 1088 uintptr_t *p = (uintptr_t *)dlsym(RTLD_DEFAULT, "__libc_stack_end"); 1089 if (p && *p) { 1090 stack_start = *p; 1091 } else { 1092 // see if we can get the start_stack field from /proc/self/stat 1093 FILE *fp; 1094 int pid; 1095 char state; 1096 int ppid; 1097 int pgrp; 1098 int session; 1099 int nr; 1100 int tpgrp; 1101 unsigned long flags; 1102 unsigned long minflt; 1103 unsigned long cminflt; 1104 unsigned long majflt; 1105 unsigned long cmajflt; 1106 unsigned long utime; 1107 unsigned long stime; 1108 long cutime; 1109 long cstime; 1110 long prio; 1111 long nice; 1112 long junk; 1113 long it_real; 1114 uintptr_t start; 1115 uintptr_t vsize; 1116 uintptr_t rss; 1117 unsigned long rsslim; 1118 uintptr_t scodes; 1119 uintptr_t ecode; 1120 int i; 1121 1122 // Figure what the primordial thread stack base is. Code is inspired 1123 // by email from Hans Boehm. /proc/self/stat begins with current pid, 1124 // followed by command name surrounded by parentheses, state, etc. 1125 char stat[2048]; 1126 int statlen; 1127 1128 fp = fopen("/proc/self/stat", "r"); 1129 if (fp) { 1130 statlen = fread(stat, 1, 2047, fp); 1131 stat[statlen] = '\0'; 1132 fclose(fp); 1133 1134 // Skip pid and the command string. Note that we could be dealing with 1135 // weird command names, e.g. user could decide to rename java launcher 1136 // to "java 1.4.2 :)", then the stat file would look like 1137 // 1234 (java 1.4.2 :)) R ... ... 1138 // We don't really need to know the command string, just find the last 1139 // occurrence of ")" and then start parsing from there. See bug 4726580. 1140 char * s = strrchr(stat, ')'); 1141 1142 i = 0; 1143 if (s) { 1144 // Skip blank chars 1145 do s++; while (isspace(*s)); 1146 1147 /* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 */ 1148 /* 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 */ 1149 i = sscanf(s, "%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %lu %lu %ld %lu %lu %lu %lu", 1150 &state, /* 3 %c */ 1151 &ppid, /* 4 %d */ 1152 &pgrp, /* 5 %d */ 1153 &session, /* 6 %d */ 1154 &nr, /* 7 %d */ 1155 &tpgrp, /* 8 %d */ 1156 &flags, /* 9 %lu */ 1157 &minflt, /* 10 %lu */ 1158 &cminflt, /* 11 %lu */ 1159 &majflt, /* 12 %lu */ 1160 &cmajflt, /* 13 %lu */ 1161 &utime, /* 14 %lu */ 1162 &stime, /* 15 %lu */ 1163 &cutime, /* 16 %ld */ 1164 &cstime, /* 17 %ld */ 1165 &prio, /* 18 %ld */ 1166 &nice, /* 19 %ld */ 1167 &junk, /* 20 %ld */ 1168 &it_real, /* 21 %ld */ 1169 &start, /* 22 %lu */ 1170 &vsize, /* 23 %lu */ 1171 &rss, /* 24 %ld */ 1172 &rsslim, /* 25 %lu */ 1173 &scodes, /* 26 %lu */ 1174 &ecode, /* 27 %lu */ 1175 &stack_start); /* 28 %lu */ 1176 } 1177 1178 if (i != 28 - 2) { 1179 assert(false, "Bad conversion from /proc/self/stat"); 1180 // product mode - assume we are the initial thread, good luck in the 1181 // embedded case. 1182 warning("Can't detect initial thread stack location - bad conversion"); 1183 stack_start = (uintptr_t) &rlim; 1184 } 1185 } else { 1186 // For some reason we can't open /proc/self/stat (for example, running on 1187 // FreeBSD with a Linux emulator, or inside chroot), this should work for 1188 // most cases, so don't abort: 1189 warning("Can't detect initial thread stack location - no /proc/self/stat"); 1190 stack_start = (uintptr_t) &rlim; 1191 } 1192 } 1193 1194 // Now we have a pointer (stack_start) very close to the stack top, the 1195 // next thing to do is to figure out the exact location of stack top. We 1196 // can find out the virtual memory area that contains stack_start by 1197 // reading /proc/self/maps, it should be the last vma in /proc/self/maps, 1198 // and its upper limit is the real stack top. (again, this would fail if 1199 // running inside chroot, because /proc may not exist.) 1200 1201 uintptr_t stack_top; 1202 address low, high; 1203 if (find_vma((address)stack_start, &low, &high)) { 1204 // success, "high" is the true stack top. (ignore "low", because initial 1205 // thread stack grows on demand, its real bottom is high - RLIMIT_STACK.) 1206 stack_top = (uintptr_t)high; 1207 } else { 1208 // failed, likely because /proc/self/maps does not exist 1209 warning("Can't detect initial thread stack location - find_vma failed"); 1210 // best effort: stack_start is normally within a few pages below the real 1211 // stack top, use it as stack top, and reduce stack size so we won't put 1212 // guard page outside stack. 1213 stack_top = stack_start; 1214 stack_size -= 16 * page_size(); 1215 } 1216 1217 // stack_top could be partially down the page so align it 1218 stack_top = align_size_up(stack_top, page_size()); 1219 1220 if (max_size && stack_size > max_size) { 1221 _initial_thread_stack_size = max_size; 1222 } else { 1223 _initial_thread_stack_size = stack_size; 1224 } 1225 1226 _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size()); 1227 _initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size; 1228} 1229 1230//////////////////////////////////////////////////////////////////////////////// 1231// time support 1232 1233// Time since start-up in seconds to a fine granularity. 1234// Used by VMSelfDestructTimer and the MemProfiler. 1235double os::elapsedTime() { 1236 1237 return (double)(os::elapsed_counter()) * 0.000001; 1238} 1239 1240jlong os::elapsed_counter() { 1241 timeval time; 1242 int status = gettimeofday(&time, NULL); 1243 return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count; 1244} 1245 1246jlong os::elapsed_frequency() { 1247 return (1000 * 1000); 1248} 1249 1250jlong os::timeofday() { 1251 timeval time; 1252 int status = gettimeofday(&time, NULL); 1253 assert(status != -1, "linux error"); 1254 return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000); 1255} 1256 1257// Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis 1258// _use_global_time is only set if CacheTimeMillis is true 1259jlong os::javaTimeMillis() { 1260 return (_use_global_time ? read_global_time() : timeofday()); 1261} 1262 1263#ifndef CLOCK_MONOTONIC 1264#define CLOCK_MONOTONIC (1) 1265#endif 1266 1267void os::Linux::clock_init() { 1268 // we do dlopen's in this particular order due to bug in linux 1269 // dynamical loader (see 6348968) leading to crash on exit 1270 void* handle = dlopen("librt.so.1", RTLD_LAZY); 1271 if (handle == NULL) { 1272 handle = dlopen("librt.so", RTLD_LAZY); 1273 } 1274 1275 if (handle) { 1276 int (*clock_getres_func)(clockid_t, struct timespec*) = 1277 (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_getres"); 1278 int (*clock_gettime_func)(clockid_t, struct timespec*) = 1279 (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_gettime"); 1280 if (clock_getres_func && clock_gettime_func) { 1281 // See if monotonic clock is supported by the kernel. Note that some 1282 // early implementations simply return kernel jiffies (updated every 1283 // 1/100 or 1/1000 second). It would be bad to use such a low res clock 1284 // for nano time (though the monotonic property is still nice to have). 1285 // It's fixed in newer kernels, however clock_getres() still returns 1286 // 1/HZ. We check if clock_getres() works, but will ignore its reported 1287 // resolution for now. Hopefully as people move to new kernels, this 1288 // won't be a problem. 1289 struct timespec res; 1290 struct timespec tp; 1291 if (clock_getres_func (CLOCK_MONOTONIC, &res) == 0 && 1292 clock_gettime_func(CLOCK_MONOTONIC, &tp) == 0) { 1293 // yes, monotonic clock is supported 1294 _clock_gettime = clock_gettime_func; 1295 } else { 1296 // close librt if there is no monotonic clock 1297 dlclose(handle); 1298 } 1299 } 1300 } 1301} 1302 1303#ifndef SYS_clock_getres 1304 1305#if defined(IA32) || defined(AMD64) 1306#define SYS_clock_getres IA32_ONLY(266) AMD64_ONLY(229) 1307#else 1308#error Value of SYS_clock_getres not known on this platform 1309#endif 1310 1311#endif 1312 1313#define sys_clock_getres(x,y) ::syscall(SYS_clock_getres, x, y) 1314 1315void os::Linux::fast_thread_clock_init() { 1316 if (!UseLinuxPosixThreadCPUClocks) { 1317 return; 1318 } 1319 clockid_t clockid; 1320 struct timespec tp; 1321 int (*pthread_getcpuclockid_func)(pthread_t, clockid_t *) = 1322 (int(*)(pthread_t, clockid_t *)) dlsym(RTLD_DEFAULT, "pthread_getcpuclockid"); 1323 1324 // Switch to using fast clocks for thread cpu time if 1325 // the sys_clock_getres() returns 0 error code. 1326 // Note, that some kernels may support the current thread 1327 // clock (CLOCK_THREAD_CPUTIME_ID) but not the clocks 1328 // returned by the pthread_getcpuclockid(). 1329 // If the fast Posix clocks are supported then the sys_clock_getres() 1330 // must return at least tp.tv_sec == 0 which means a resolution 1331 // better than 1 sec. This is extra check for reliability. 1332 1333 if(pthread_getcpuclockid_func && 1334 pthread_getcpuclockid_func(_main_thread, &clockid) == 0 && 1335 sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) { 1336 1337 _supports_fast_thread_cpu_time = true; 1338 _pthread_getcpuclockid = pthread_getcpuclockid_func; 1339 } 1340} 1341 1342jlong os::javaTimeNanos() { 1343 if (Linux::supports_monotonic_clock()) { 1344 struct timespec tp; 1345 int status = Linux::clock_gettime(CLOCK_MONOTONIC, &tp); 1346 assert(status == 0, "gettime error"); 1347 jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec); 1348 return result; 1349 } else { 1350 timeval time; 1351 int status = gettimeofday(&time, NULL); 1352 assert(status != -1, "linux error"); 1353 jlong usecs = jlong(time.tv_sec) * (1000 * 1000) + jlong(time.tv_usec); 1354 return 1000 * usecs; 1355 } 1356} 1357 1358void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 1359 if (Linux::supports_monotonic_clock()) { 1360 info_ptr->max_value = ALL_64_BITS; 1361 1362 // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past 1363 info_ptr->may_skip_backward = false; // not subject to resetting or drifting 1364 info_ptr->may_skip_forward = false; // not subject to resetting or drifting 1365 } else { 1366 // gettimeofday - based on time in seconds since the Epoch thus does not wrap 1367 info_ptr->max_value = ALL_64_BITS; 1368 1369 // gettimeofday is a real time clock so it skips 1370 info_ptr->may_skip_backward = true; 1371 info_ptr->may_skip_forward = true; 1372 } 1373 1374 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 1375} 1376 1377// Return the real, user, and system times in seconds from an 1378// arbitrary fixed point in the past. 1379bool os::getTimesSecs(double* process_real_time, 1380 double* process_user_time, 1381 double* process_system_time) { 1382 struct tms ticks; 1383 clock_t real_ticks = times(&ticks); 1384 1385 if (real_ticks == (clock_t) (-1)) { 1386 return false; 1387 } else { 1388 double ticks_per_second = (double) clock_tics_per_sec; 1389 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second; 1390 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second; 1391 *process_real_time = ((double) real_ticks) / ticks_per_second; 1392 1393 return true; 1394 } 1395} 1396 1397 1398char * os::local_time_string(char *buf, size_t buflen) { 1399 struct tm t; 1400 time_t long_time; 1401 time(&long_time); 1402 localtime_r(&long_time, &t); 1403 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 1404 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, 1405 t.tm_hour, t.tm_min, t.tm_sec); 1406 return buf; 1407} 1408 1409//////////////////////////////////////////////////////////////////////////////// 1410// runtime exit support 1411 1412// Note: os::shutdown() might be called very early during initialization, or 1413// called from signal handler. Before adding something to os::shutdown(), make 1414// sure it is async-safe and can handle partially initialized VM. 1415void os::shutdown() { 1416 1417 // allow PerfMemory to attempt cleanup of any persistent resources 1418 perfMemory_exit(); 1419 1420 // needs to remove object in file system 1421 AttachListener::abort(); 1422 1423 // flush buffered output, finish log files 1424 ostream_abort(); 1425 1426 // Check for abort hook 1427 abort_hook_t abort_hook = Arguments::abort_hook(); 1428 if (abort_hook != NULL) { 1429 abort_hook(); 1430 } 1431 1432} 1433 1434// Note: os::abort() might be called very early during initialization, or 1435// called from signal handler. Before adding something to os::abort(), make 1436// sure it is async-safe and can handle partially initialized VM. 1437void os::abort(bool dump_core) { 1438 os::shutdown(); 1439 if (dump_core) { 1440#ifndef PRODUCT 1441 fdStream out(defaultStream::output_fd()); 1442 out.print_raw("Current thread is "); 1443 char buf[16]; 1444 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id()); 1445 out.print_raw_cr(buf); 1446 out.print_raw_cr("Dumping core ..."); 1447#endif 1448 ::abort(); // dump core 1449 } 1450 1451 ::exit(1); 1452} 1453 1454// Die immediately, no exit hook, no abort hook, no cleanup. 1455void os::die() { 1456 // _exit() on LinuxThreads only kills current thread 1457 ::abort(); 1458} 1459 1460// unused on linux for now. 1461void os::set_error_file(const char *logfile) {} 1462 1463intx os::current_thread_id() { return (intx)pthread_self(); } 1464int os::current_process_id() { 1465 1466 // Under the old linux thread library, linux gives each thread 1467 // its own process id. Because of this each thread will return 1468 // a different pid if this method were to return the result 1469 // of getpid(2). Linux provides no api that returns the pid 1470 // of the launcher thread for the vm. This implementation 1471 // returns a unique pid, the pid of the launcher thread 1472 // that starts the vm 'process'. 1473 1474 // Under the NPTL, getpid() returns the same pid as the 1475 // launcher thread rather than a unique pid per thread. 1476 // Use gettid() if you want the old pre NPTL behaviour. 1477 1478 // if you are looking for the result of a call to getpid() that 1479 // returns a unique pid for the calling thread, then look at the 1480 // OSThread::thread_id() method in osThread_linux.hpp file 1481 1482 return (int)(_initial_pid ? _initial_pid : getpid()); 1483} 1484 1485// DLL functions 1486 1487const char* os::dll_file_extension() { return ".so"; } 1488 1489const char* os::get_temp_directory() { return "/tmp/"; } 1490 1491const char* os::get_current_directory(char *buf, int buflen) { 1492 return getcwd(buf, buflen); 1493} 1494 1495// check if addr is inside libjvm[_g].so 1496bool os::address_is_in_vm(address addr) { 1497 static address libjvm_base_addr; 1498 Dl_info dlinfo; 1499 1500 if (libjvm_base_addr == NULL) { 1501 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo); 1502 libjvm_base_addr = (address)dlinfo.dli_fbase; 1503 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm"); 1504 } 1505 1506 if (dladdr((void *)addr, &dlinfo)) { 1507 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true; 1508 } 1509 1510 return false; 1511} 1512 1513bool os::dll_address_to_function_name(address addr, char *buf, 1514 int buflen, int *offset) { 1515 Dl_info dlinfo; 1516 1517 if (dladdr((void*)addr, &dlinfo) && dlinfo.dli_sname != NULL) { 1518 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname); 1519 if (offset) *offset = addr - (address)dlinfo.dli_saddr; 1520 return true; 1521 } else { 1522 if (buf) buf[0] = '\0'; 1523 if (offset) *offset = -1; 1524 return false; 1525 } 1526} 1527 1528struct _address_to_library_name { 1529 address addr; // input : memory address 1530 size_t buflen; // size of fname 1531 char* fname; // output: library name 1532 address base; // library base addr 1533}; 1534 1535static int address_to_library_name_callback(struct dl_phdr_info *info, 1536 size_t size, void *data) { 1537 int i; 1538 bool found = false; 1539 address libbase = NULL; 1540 struct _address_to_library_name * d = (struct _address_to_library_name *)data; 1541 1542 // iterate through all loadable segments 1543 for (i = 0; i < info->dlpi_phnum; i++) { 1544 address segbase = (address)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr); 1545 if (info->dlpi_phdr[i].p_type == PT_LOAD) { 1546 // base address of a library is the lowest address of its loaded 1547 // segments. 1548 if (libbase == NULL || libbase > segbase) { 1549 libbase = segbase; 1550 } 1551 // see if 'addr' is within current segment 1552 if (segbase <= d->addr && 1553 d->addr < segbase + info->dlpi_phdr[i].p_memsz) { 1554 found = true; 1555 } 1556 } 1557 } 1558 1559 // dlpi_name is NULL or empty if the ELF file is executable, return 0 1560 // so dll_address_to_library_name() can fall through to use dladdr() which 1561 // can figure out executable name from argv[0]. 1562 if (found && info->dlpi_name && info->dlpi_name[0]) { 1563 d->base = libbase; 1564 if (d->fname) { 1565 jio_snprintf(d->fname, d->buflen, "%s", info->dlpi_name); 1566 } 1567 return 1; 1568 } 1569 return 0; 1570} 1571 1572bool os::dll_address_to_library_name(address addr, char* buf, 1573 int buflen, int* offset) { 1574 Dl_info dlinfo; 1575 struct _address_to_library_name data; 1576 1577 // There is a bug in old glibc dladdr() implementation that it could resolve 1578 // to wrong library name if the .so file has a base address != NULL. Here 1579 // we iterate through the program headers of all loaded libraries to find 1580 // out which library 'addr' really belongs to. This workaround can be 1581 // removed once the minimum requirement for glibc is moved to 2.3.x. 1582 data.addr = addr; 1583 data.fname = buf; 1584 data.buflen = buflen; 1585 data.base = NULL; 1586 int rslt = dl_iterate_phdr(address_to_library_name_callback, (void *)&data); 1587 1588 if (rslt) { 1589 // buf already contains library name 1590 if (offset) *offset = addr - data.base; 1591 return true; 1592 } else if (dladdr((void*)addr, &dlinfo)){ 1593 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname); 1594 if (offset) *offset = addr - (address)dlinfo.dli_fbase; 1595 return true; 1596 } else { 1597 if (buf) buf[0] = '\0'; 1598 if (offset) *offset = -1; 1599 return false; 1600 } 1601} 1602 1603 // Loads .dll/.so and 1604 // in case of error it checks if .dll/.so was built for the 1605 // same architecture as Hotspot is running on 1606 1607void * os::dll_load(const char *filename, char *ebuf, int ebuflen) 1608{ 1609 void * result= ::dlopen(filename, RTLD_LAZY); 1610 if (result != NULL) { 1611 // Successful loading 1612 return result; 1613 } 1614 1615 Elf32_Ehdr elf_head; 1616 1617 // Read system error message into ebuf 1618 // It may or may not be overwritten below 1619 ::strncpy(ebuf, ::dlerror(), ebuflen-1); 1620 ebuf[ebuflen-1]='\0'; 1621 int diag_msg_max_length=ebuflen-strlen(ebuf); 1622 char* diag_msg_buf=ebuf+strlen(ebuf); 1623 1624 if (diag_msg_max_length==0) { 1625 // No more space in ebuf for additional diagnostics message 1626 return NULL; 1627 } 1628 1629 1630 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK); 1631 1632 if (file_descriptor < 0) { 1633 // Can't open library, report dlerror() message 1634 return NULL; 1635 } 1636 1637 bool failed_to_read_elf_head= 1638 (sizeof(elf_head)!= 1639 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ; 1640 1641 ::close(file_descriptor); 1642 if (failed_to_read_elf_head) { 1643 // file i/o error - report dlerror() msg 1644 return NULL; 1645 } 1646 1647 typedef struct { 1648 Elf32_Half code; // Actual value as defined in elf.h 1649 Elf32_Half compat_class; // Compatibility of archs at VM's sense 1650 char elf_class; // 32 or 64 bit 1651 char endianess; // MSB or LSB 1652 char* name; // String representation 1653 } arch_t; 1654 1655 #ifndef EM_486 1656 #define EM_486 6 /* Intel 80486 */ 1657 #endif 1658 1659 static const arch_t arch_array[]={ 1660 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 1661 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 1662 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"}, 1663 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"}, 1664 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 1665 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 1666 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"}, 1667 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"}, 1668 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"} 1669 }; 1670 1671 #if (defined IA32) 1672 static Elf32_Half running_arch_code=EM_386; 1673 #elif (defined AMD64) 1674 static Elf32_Half running_arch_code=EM_X86_64; 1675 #elif (defined IA64) 1676 static Elf32_Half running_arch_code=EM_IA_64; 1677 #elif (defined __sparc) && (defined _LP64) 1678 static Elf32_Half running_arch_code=EM_SPARCV9; 1679 #elif (defined __sparc) && (!defined _LP64) 1680 static Elf32_Half running_arch_code=EM_SPARC; 1681 #elif (defined __powerpc64__) 1682 static Elf32_Half running_arch_code=EM_PPC64; 1683 #elif (defined __powerpc__) 1684 static Elf32_Half running_arch_code=EM_PPC; 1685 #else 1686 #error Method os::dll_load requires that one of following is defined:\ 1687 IA32, AMD64, IA64, __sparc, __powerpc__ 1688 #endif 1689 1690 // Identify compatability class for VM's architecture and library's architecture 1691 // Obtain string descriptions for architectures 1692 1693 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL}; 1694 int running_arch_index=-1; 1695 1696 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) { 1697 if (running_arch_code == arch_array[i].code) { 1698 running_arch_index = i; 1699 } 1700 if (lib_arch.code == arch_array[i].code) { 1701 lib_arch.compat_class = arch_array[i].compat_class; 1702 lib_arch.name = arch_array[i].name; 1703 } 1704 } 1705 1706 assert(running_arch_index != -1, 1707 "Didn't find running architecture code (running_arch_code) in arch_array"); 1708 if (running_arch_index == -1) { 1709 // Even though running architecture detection failed 1710 // we may still continue with reporting dlerror() message 1711 return NULL; 1712 } 1713 1714 if (lib_arch.endianess != arch_array[running_arch_index].endianess) { 1715 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)"); 1716 return NULL; 1717 } 1718 1719 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) { 1720 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)"); 1721 return NULL; 1722 } 1723 1724 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) { 1725 if ( lib_arch.name!=NULL ) { 1726 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 1727 " (Possible cause: can't load %s-bit .so on a %s-bit platform)", 1728 lib_arch.name, arch_array[running_arch_index].name); 1729 } else { 1730 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 1731 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)", 1732 lib_arch.code, 1733 arch_array[running_arch_index].name); 1734 } 1735 } 1736 1737 return NULL; 1738} 1739 1740 1741 1742 1743bool _print_ascii_file(const char* filename, outputStream* st) { 1744 int fd = open(filename, O_RDONLY); 1745 if (fd == -1) { 1746 return false; 1747 } 1748 1749 char buf[32]; 1750 int bytes; 1751 while ((bytes = read(fd, buf, sizeof(buf))) > 0) { 1752 st->print_raw(buf, bytes); 1753 } 1754 1755 close(fd); 1756 1757 return true; 1758} 1759 1760void os::print_dll_info(outputStream *st) { 1761 st->print_cr("Dynamic libraries:"); 1762 1763 char fname[32]; 1764 pid_t pid = os::Linux::gettid(); 1765 1766 jio_snprintf(fname, sizeof(fname), "/proc/%d/maps", pid); 1767 1768 if (!_print_ascii_file(fname, st)) { 1769 st->print("Can not get library information for pid = %d\n", pid); 1770 } 1771} 1772 1773 1774void os::print_os_info(outputStream* st) { 1775 st->print("OS:"); 1776 1777 // Try to identify popular distros. 1778 // Most Linux distributions have /etc/XXX-release file, which contains 1779 // the OS version string. Some have more than one /etc/XXX-release file 1780 // (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.), 1781 // so the order is important. 1782 if (!_print_ascii_file("/etc/mandrake-release", st) && 1783 !_print_ascii_file("/etc/sun-release", st) && 1784 !_print_ascii_file("/etc/redhat-release", st) && 1785 !_print_ascii_file("/etc/SuSE-release", st) && 1786 !_print_ascii_file("/etc/turbolinux-release", st) && 1787 !_print_ascii_file("/etc/gentoo-release", st) && 1788 !_print_ascii_file("/etc/debian_version", st)) { 1789 st->print("Linux"); 1790 } 1791 st->cr(); 1792 1793 // kernel 1794 st->print("uname:"); 1795 struct utsname name; 1796 uname(&name); 1797 st->print(name.sysname); st->print(" "); 1798 st->print(name.release); st->print(" "); 1799 st->print(name.version); st->print(" "); 1800 st->print(name.machine); 1801 st->cr(); 1802 1803 // Print warning if unsafe chroot environment detected 1804 if (unsafe_chroot_detected) { 1805 st->print("WARNING!! "); 1806 st->print_cr(unstable_chroot_error); 1807 } 1808 1809 // libc, pthread 1810 st->print("libc:"); 1811 st->print(os::Linux::glibc_version()); st->print(" "); 1812 st->print(os::Linux::libpthread_version()); st->print(" "); 1813 if (os::Linux::is_LinuxThreads()) { 1814 st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed"); 1815 } 1816 st->cr(); 1817 1818 // rlimit 1819 st->print("rlimit:"); 1820 struct rlimit rlim; 1821 1822 st->print(" STACK "); 1823 getrlimit(RLIMIT_STACK, &rlim); 1824 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1825 else st->print("%uk", rlim.rlim_cur >> 10); 1826 1827 st->print(", CORE "); 1828 getrlimit(RLIMIT_CORE, &rlim); 1829 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1830 else st->print("%uk", rlim.rlim_cur >> 10); 1831 1832 st->print(", NPROC "); 1833 getrlimit(RLIMIT_NPROC, &rlim); 1834 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1835 else st->print("%d", rlim.rlim_cur); 1836 1837 st->print(", NOFILE "); 1838 getrlimit(RLIMIT_NOFILE, &rlim); 1839 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1840 else st->print("%d", rlim.rlim_cur); 1841 1842 st->print(", AS "); 1843 getrlimit(RLIMIT_AS, &rlim); 1844 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1845 else st->print("%uk", rlim.rlim_cur >> 10); 1846 st->cr(); 1847 1848 // load average 1849 st->print("load average:"); 1850 double loadavg[3]; 1851 os::loadavg(loadavg, 3); 1852 st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); 1853 st->cr(); 1854} 1855 1856void os::print_memory_info(outputStream* st) { 1857 1858 st->print("Memory:"); 1859 st->print(" %dk page", os::vm_page_size()>>10); 1860 1861 // values in struct sysinfo are "unsigned long" 1862 struct sysinfo si; 1863 sysinfo(&si); 1864 1865 st->print(", physical " UINT64_FORMAT "k", 1866 os::physical_memory() >> 10); 1867 st->print("(" UINT64_FORMAT "k free)", 1868 os::available_memory() >> 10); 1869 st->print(", swap " UINT64_FORMAT "k", 1870 ((jlong)si.totalswap * si.mem_unit) >> 10); 1871 st->print("(" UINT64_FORMAT "k free)", 1872 ((jlong)si.freeswap * si.mem_unit) >> 10); 1873 st->cr(); 1874} 1875 1876// Taken from /usr/include/bits/siginfo.h Supposed to be architecture specific 1877// but they're the same for all the linux arch that we support 1878// and they're the same for solaris but there's no common place to put this. 1879const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR", 1880 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG", 1881 "ILL_COPROC", "ILL_BADSTK" }; 1882 1883const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV", 1884 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES", 1885 "FPE_FLTINV", "FPE_FLTSUB", "FPE_FLTDEN" }; 1886 1887const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" }; 1888 1889const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" }; 1890 1891void os::print_siginfo(outputStream* st, void* siginfo) { 1892 st->print("siginfo:"); 1893 1894 const int buflen = 100; 1895 char buf[buflen]; 1896 siginfo_t *si = (siginfo_t*)siginfo; 1897 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen)); 1898 if (si->si_errno != 0 && strerror_r(si->si_errno, buf, buflen) == 0) { 1899 st->print("si_errno=%s", buf); 1900 } else { 1901 st->print("si_errno=%d", si->si_errno); 1902 } 1903 const int c = si->si_code; 1904 assert(c > 0, "unexpected si_code"); 1905 switch (si->si_signo) { 1906 case SIGILL: 1907 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]); 1908 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 1909 break; 1910 case SIGFPE: 1911 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]); 1912 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 1913 break; 1914 case SIGSEGV: 1915 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]); 1916 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 1917 break; 1918 case SIGBUS: 1919 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]); 1920 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 1921 break; 1922 default: 1923 st->print(", si_code=%d", si->si_code); 1924 // no si_addr 1925 } 1926 1927 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) && 1928 UseSharedSpaces) { 1929 FileMapInfo* mapinfo = FileMapInfo::current_info(); 1930 if (mapinfo->is_in_shared_space(si->si_addr)) { 1931 st->print("\n\nError accessing class data sharing archive." \ 1932 " Mapped file inaccessible during execution, " \ 1933 " possible disk/network problem."); 1934 } 1935 } 1936 st->cr(); 1937} 1938 1939 1940static void print_signal_handler(outputStream* st, int sig, 1941 char* buf, size_t buflen); 1942 1943void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 1944 st->print_cr("Signal Handlers:"); 1945 print_signal_handler(st, SIGSEGV, buf, buflen); 1946 print_signal_handler(st, SIGBUS , buf, buflen); 1947 print_signal_handler(st, SIGFPE , buf, buflen); 1948 print_signal_handler(st, SIGPIPE, buf, buflen); 1949 print_signal_handler(st, SIGXFSZ, buf, buflen); 1950 print_signal_handler(st, SIGILL , buf, buflen); 1951 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen); 1952 print_signal_handler(st, SR_signum, buf, buflen); 1953 print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen); 1954 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen); 1955 print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen); 1956 print_signal_handler(st, BREAK_SIGNAL, buf, buflen); 1957} 1958 1959static char saved_jvm_path[MAXPATHLEN] = {0}; 1960 1961// Find the full path to the current module, libjvm.so or libjvm_g.so 1962void os::jvm_path(char *buf, jint len) { 1963 // Error checking. 1964 if (len < MAXPATHLEN) { 1965 assert(false, "must use a large-enough buffer"); 1966 buf[0] = '\0'; 1967 return; 1968 } 1969 // Lazy resolve the path to current module. 1970 if (saved_jvm_path[0] != 0) { 1971 strcpy(buf, saved_jvm_path); 1972 return; 1973 } 1974 1975 char dli_fname[MAXPATHLEN]; 1976 bool ret = dll_address_to_library_name( 1977 CAST_FROM_FN_PTR(address, os::jvm_path), 1978 dli_fname, sizeof(dli_fname), NULL); 1979 assert(ret != 0, "cannot locate libjvm"); 1980 realpath(dli_fname, buf); 1981 1982 if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) { 1983 // Support for the gamma launcher. Typical value for buf is 1984 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at 1985 // the right place in the string, then assume we are installed in a JDK and 1986 // we're done. Otherwise, check for a JAVA_HOME environment variable and fix 1987 // up the path so it looks like libjvm.so is installed there (append a 1988 // fake suffix hotspot/libjvm.so). 1989 const char *p = buf + strlen(buf) - 1; 1990 for (int count = 0; p > buf && count < 5; ++count) { 1991 for (--p; p > buf && *p != '/'; --p) 1992 /* empty */ ; 1993 } 1994 1995 if (strncmp(p, "/jre/lib/", 9) != 0) { 1996 // Look for JAVA_HOME in the environment. 1997 char* java_home_var = ::getenv("JAVA_HOME"); 1998 if (java_home_var != NULL && java_home_var[0] != 0) { 1999 // Check the current module name "libjvm.so" or "libjvm_g.so". 2000 p = strrchr(buf, '/'); 2001 assert(strstr(p, "/libjvm") == p, "invalid library name"); 2002 p = strstr(p, "_g") ? "_g" : ""; 2003 2004 realpath(java_home_var, buf); 2005 sprintf(buf + strlen(buf), "/jre/lib/%s", cpu_arch); 2006 if (0 == access(buf, F_OK)) { 2007 // Use current module name "libjvm[_g].so" instead of 2008 // "libjvm"debug_only("_g")".so" since for fastdebug version 2009 // we should have "libjvm.so" but debug_only("_g") adds "_g"! 2010 // It is used when we are choosing the HPI library's name 2011 // "libhpi[_g].so" in hpi::initialize_get_interface(). 2012 sprintf(buf + strlen(buf), "/hotspot/libjvm%s.so", p); 2013 } else { 2014 // Go back to path of .so 2015 realpath(dli_fname, buf); 2016 } 2017 } 2018 } 2019 } 2020 2021 strcpy(saved_jvm_path, buf); 2022} 2023 2024void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 2025 // no prefix required, not even "_" 2026} 2027 2028void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 2029 // no suffix required 2030} 2031 2032//////////////////////////////////////////////////////////////////////////////// 2033// sun.misc.Signal support 2034 2035static volatile jint sigint_count = 0; 2036 2037static void 2038UserHandler(int sig, void *siginfo, void *context) { 2039 // 4511530 - sem_post is serialized and handled by the manager thread. When 2040 // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We 2041 // don't want to flood the manager thread with sem_post requests. 2042 if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1) 2043 return; 2044 2045 // Ctrl-C is pressed during error reporting, likely because the error 2046 // handler fails to abort. Let VM die immediately. 2047 if (sig == SIGINT && is_error_reported()) { 2048 os::die(); 2049 } 2050 2051 os::signal_notify(sig); 2052} 2053 2054void* os::user_handler() { 2055 return CAST_FROM_FN_PTR(void*, UserHandler); 2056} 2057 2058extern "C" { 2059 typedef void (*sa_handler_t)(int); 2060 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); 2061} 2062 2063void* os::signal(int signal_number, void* handler) { 2064 struct sigaction sigAct, oldSigAct; 2065 2066 sigfillset(&(sigAct.sa_mask)); 2067 sigAct.sa_flags = SA_RESTART|SA_SIGINFO; 2068 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler); 2069 2070 if (sigaction(signal_number, &sigAct, &oldSigAct)) { 2071 // -1 means registration failed 2072 return (void *)-1; 2073 } 2074 2075 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler); 2076} 2077 2078void os::signal_raise(int signal_number) { 2079 ::raise(signal_number); 2080} 2081 2082/* 2083 * The following code is moved from os.cpp for making this 2084 * code platform specific, which it is by its very nature. 2085 */ 2086 2087// Will be modified when max signal is changed to be dynamic 2088int os::sigexitnum_pd() { 2089 return NSIG; 2090} 2091 2092// a counter for each possible signal value 2093static volatile jint pending_signals[NSIG+1] = { 0 }; 2094 2095// Linux(POSIX) specific hand shaking semaphore. 2096static sem_t sig_sem; 2097 2098void os::signal_init_pd() { 2099 // Initialize signal structures 2100 ::memset((void*)pending_signals, 0, sizeof(pending_signals)); 2101 2102 // Initialize signal semaphore 2103 ::sem_init(&sig_sem, 0, 0); 2104} 2105 2106void os::signal_notify(int sig) { 2107 Atomic::inc(&pending_signals[sig]); 2108 ::sem_post(&sig_sem); 2109} 2110 2111static int check_pending_signals(bool wait) { 2112 Atomic::store(0, &sigint_count); 2113 for (;;) { 2114 for (int i = 0; i < NSIG + 1; i++) { 2115 jint n = pending_signals[i]; 2116 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 2117 return i; 2118 } 2119 } 2120 if (!wait) { 2121 return -1; 2122 } 2123 JavaThread *thread = JavaThread::current(); 2124 ThreadBlockInVM tbivm(thread); 2125 2126 bool threadIsSuspended; 2127 do { 2128 thread->set_suspend_equivalent(); 2129 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 2130 ::sem_wait(&sig_sem); 2131 2132 // were we externally suspended while we were waiting? 2133 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 2134 if (threadIsSuspended) { 2135 // 2136 // The semaphore has been incremented, but while we were waiting 2137 // another thread suspended us. We don't want to continue running 2138 // while suspended because that would surprise the thread that 2139 // suspended us. 2140 // 2141 ::sem_post(&sig_sem); 2142 2143 thread->java_suspend_self(); 2144 } 2145 } while (threadIsSuspended); 2146 } 2147} 2148 2149int os::signal_lookup() { 2150 return check_pending_signals(false); 2151} 2152 2153int os::signal_wait() { 2154 return check_pending_signals(true); 2155} 2156 2157//////////////////////////////////////////////////////////////////////////////// 2158// Virtual Memory 2159 2160int os::vm_page_size() { 2161 // Seems redundant as all get out 2162 assert(os::Linux::page_size() != -1, "must call os::init"); 2163 return os::Linux::page_size(); 2164} 2165 2166// Solaris allocates memory by pages. 2167int os::vm_allocation_granularity() { 2168 assert(os::Linux::page_size() != -1, "must call os::init"); 2169 return os::Linux::page_size(); 2170} 2171 2172// Rationale behind this function: 2173// current (Mon Apr 25 20:12:18 MSD 2005) oprofile drops samples without executable 2174// mapping for address (see lookup_dcookie() in the kernel module), thus we cannot get 2175// samples for JITted code. Here we create private executable mapping over the code cache 2176// and then we can use standard (well, almost, as mapping can change) way to provide 2177// info for the reporting script by storing timestamp and location of symbol 2178void linux_wrap_code(char* base, size_t size) { 2179 static volatile jint cnt = 0; 2180 2181 if (!UseOprofile) { 2182 return; 2183 } 2184 2185 char buf[40]; 2186 int num = Atomic::add(1, &cnt); 2187 2188 sprintf(buf, "/tmp/hs-vm-%d-%d", os::current_process_id(), num); 2189 unlink(buf); 2190 2191 int fd = open(buf, O_CREAT | O_RDWR, S_IRWXU); 2192 2193 if (fd != -1) { 2194 off_t rv = lseek(fd, size-2, SEEK_SET); 2195 if (rv != (off_t)-1) { 2196 if (write(fd, "", 1) == 1) { 2197 mmap(base, size, 2198 PROT_READ|PROT_WRITE|PROT_EXEC, 2199 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, fd, 0); 2200 } 2201 } 2202 close(fd); 2203 unlink(buf); 2204 } 2205} 2206 2207// NOTE: Linux kernel does not really reserve the pages for us. 2208// All it does is to check if there are enough free pages 2209// left at the time of mmap(). This could be a potential 2210// problem. 2211bool os::commit_memory(char* addr, size_t size) { 2212 uintptr_t res = (uintptr_t) ::mmap(addr, size, 2213 PROT_READ|PROT_WRITE|PROT_EXEC, 2214 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); 2215 return res != (uintptr_t) MAP_FAILED; 2216} 2217 2218bool os::commit_memory(char* addr, size_t size, size_t alignment_hint) { 2219 return commit_memory(addr, size); 2220} 2221 2222void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } 2223void os::free_memory(char *addr, size_t bytes) { } 2224void os::numa_make_global(char *addr, size_t bytes) { } 2225void os::numa_make_local(char *addr, size_t bytes) { } 2226bool os::numa_topology_changed() { return false; } 2227size_t os::numa_get_groups_num() { return 1; } 2228int os::numa_get_group_id() { return 0; } 2229size_t os::numa_get_leaf_groups(int *ids, size_t size) { 2230 if (size > 0) { 2231 ids[0] = 0; 2232 return 1; 2233 } 2234 return 0; 2235} 2236 2237bool os::get_page_info(char *start, page_info* info) { 2238 return false; 2239} 2240 2241char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 2242 return end; 2243} 2244 2245bool os::uncommit_memory(char* addr, size_t size) { 2246 return ::mmap(addr, size, 2247 PROT_READ|PROT_WRITE|PROT_EXEC, 2248 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0) 2249 != MAP_FAILED; 2250} 2251 2252static address _highest_vm_reserved_address = NULL; 2253 2254// If 'fixed' is true, anon_mmap() will attempt to reserve anonymous memory 2255// at 'requested_addr'. If there are existing memory mappings at the same 2256// location, however, they will be overwritten. If 'fixed' is false, 2257// 'requested_addr' is only treated as a hint, the return value may or 2258// may not start from the requested address. Unlike Linux mmap(), this 2259// function returns NULL to indicate failure. 2260static char* anon_mmap(char* requested_addr, size_t bytes, bool fixed) { 2261 char * addr; 2262 int flags; 2263 2264 flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS; 2265 if (fixed) { 2266 assert((uintptr_t)requested_addr % os::Linux::page_size() == 0, "unaligned address"); 2267 flags |= MAP_FIXED; 2268 } 2269 2270 addr = (char*)::mmap(requested_addr, bytes, PROT_READ|PROT_WRITE|PROT_EXEC, 2271 flags, -1, 0); 2272 2273 if (addr != MAP_FAILED) { 2274 // anon_mmap() should only get called during VM initialization, 2275 // don't need lock (actually we can skip locking even it can be called 2276 // from multiple threads, because _highest_vm_reserved_address is just a 2277 // hint about the upper limit of non-stack memory regions.) 2278 if ((address)addr + bytes > _highest_vm_reserved_address) { 2279 _highest_vm_reserved_address = (address)addr + bytes; 2280 } 2281 } 2282 2283 return addr == MAP_FAILED ? NULL : addr; 2284} 2285 2286// Don't update _highest_vm_reserved_address, because there might be memory 2287// regions above addr + size. If so, releasing a memory region only creates 2288// a hole in the address space, it doesn't help prevent heap-stack collision. 2289// 2290static int anon_munmap(char * addr, size_t size) { 2291 return ::munmap(addr, size) == 0; 2292} 2293 2294char* os::reserve_memory(size_t bytes, char* requested_addr, 2295 size_t alignment_hint) { 2296 return anon_mmap(requested_addr, bytes, (requested_addr != NULL)); 2297} 2298 2299bool os::release_memory(char* addr, size_t size) { 2300 return anon_munmap(addr, size); 2301} 2302 2303static address highest_vm_reserved_address() { 2304 return _highest_vm_reserved_address; 2305} 2306 2307static bool linux_mprotect(char* addr, size_t size, int prot) { 2308 // Linux wants the mprotect address argument to be page aligned. 2309 char* bottom = (char*)align_size_down((intptr_t)addr, os::Linux::page_size()); 2310 2311 // According to SUSv3, mprotect() should only be used with mappings 2312 // established by mmap(), and mmap() always maps whole pages. Unaligned 2313 // 'addr' likely indicates problem in the VM (e.g. trying to change 2314 // protection of malloc'ed or statically allocated memory). Check the 2315 // caller if you hit this assert. 2316 assert(addr == bottom, "sanity check"); 2317 2318 size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Linux::page_size()); 2319 return ::mprotect(bottom, size, prot) == 0; 2320} 2321 2322bool os::protect_memory(char* addr, size_t size) { 2323 return linux_mprotect(addr, size, PROT_READ); 2324} 2325 2326bool os::guard_memory(char* addr, size_t size) { 2327 return linux_mprotect(addr, size, PROT_NONE); 2328} 2329 2330bool os::unguard_memory(char* addr, size_t size) { 2331 return linux_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC); 2332} 2333 2334// Large page support 2335 2336static size_t _large_page_size = 0; 2337 2338bool os::large_page_init() { 2339 if (!UseLargePages) return false; 2340 2341 if (LargePageSizeInBytes) { 2342 _large_page_size = LargePageSizeInBytes; 2343 } else { 2344 // large_page_size on Linux is used to round up heap size. x86 uses either 2345 // 2M or 4M page, depending on whether PAE (Physical Address Extensions) 2346 // mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. IA64 can use 2347 // page as large as 256M. 2348 // 2349 // Here we try to figure out page size by parsing /proc/meminfo and looking 2350 // for a line with the following format: 2351 // Hugepagesize: 2048 kB 2352 // 2353 // If we can't determine the value (e.g. /proc is not mounted, or the text 2354 // format has been changed), we'll use the largest page size supported by 2355 // the processor. 2356 2357 _large_page_size = IA32_ONLY(4 * M) AMD64_ONLY(2 * M) IA64_ONLY(256 * M) SPARC_ONLY(4 * M); 2358 2359 FILE *fp = fopen("/proc/meminfo", "r"); 2360 if (fp) { 2361 while (!feof(fp)) { 2362 int x = 0; 2363 char buf[16]; 2364 if (fscanf(fp, "Hugepagesize: %d", &x) == 1) { 2365 if (x && fgets(buf, sizeof(buf), fp) && strcmp(buf, " kB\n") == 0) { 2366 _large_page_size = x * K; 2367 break; 2368 } 2369 } else { 2370 // skip to next line 2371 for (;;) { 2372 int ch = fgetc(fp); 2373 if (ch == EOF || ch == (int)'\n') break; 2374 } 2375 } 2376 } 2377 fclose(fp); 2378 } 2379 } 2380 2381 const size_t default_page_size = (size_t)Linux::page_size(); 2382 if (_large_page_size > default_page_size) { 2383 _page_sizes[0] = _large_page_size; 2384 _page_sizes[1] = default_page_size; 2385 _page_sizes[2] = 0; 2386 } 2387 2388 // Large page support is available on 2.6 or newer kernel, some vendors 2389 // (e.g. Redhat) have backported it to their 2.4 based distributions. 2390 // We optimistically assume the support is available. If later it turns out 2391 // not true, VM will automatically switch to use regular page size. 2392 return true; 2393} 2394 2395#ifndef SHM_HUGETLB 2396#define SHM_HUGETLB 04000 2397#endif 2398 2399char* os::reserve_memory_special(size_t bytes) { 2400 assert(UseLargePages, "only for large pages"); 2401 2402 key_t key = IPC_PRIVATE; 2403 char *addr; 2404 2405 bool warn_on_failure = UseLargePages && 2406 (!FLAG_IS_DEFAULT(UseLargePages) || 2407 !FLAG_IS_DEFAULT(LargePageSizeInBytes) 2408 ); 2409 char msg[128]; 2410 2411 // Create a large shared memory region to attach to based on size. 2412 // Currently, size is the total size of the heap 2413 int shmid = shmget(key, bytes, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W); 2414 if (shmid == -1) { 2415 // Possible reasons for shmget failure: 2416 // 1. shmmax is too small for Java heap. 2417 // > check shmmax value: cat /proc/sys/kernel/shmmax 2418 // > increase shmmax value: echo "0xffffffff" > /proc/sys/kernel/shmmax 2419 // 2. not enough large page memory. 2420 // > check available large pages: cat /proc/meminfo 2421 // > increase amount of large pages: 2422 // echo new_value > /proc/sys/vm/nr_hugepages 2423 // Note 1: different Linux may use different name for this property, 2424 // e.g. on Redhat AS-3 it is "hugetlb_pool". 2425 // Note 2: it's possible there's enough physical memory available but 2426 // they are so fragmented after a long run that they can't 2427 // coalesce into large pages. Try to reserve large pages when 2428 // the system is still "fresh". 2429 if (warn_on_failure) { 2430 jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno); 2431 warning(msg); 2432 } 2433 return NULL; 2434 } 2435 2436 // attach to the region 2437 addr = (char*)shmat(shmid, NULL, 0); 2438 int err = errno; 2439 2440 // Remove shmid. If shmat() is successful, the actual shared memory segment 2441 // will be deleted when it's detached by shmdt() or when the process 2442 // terminates. If shmat() is not successful this will remove the shared 2443 // segment immediately. 2444 shmctl(shmid, IPC_RMID, NULL); 2445 2446 if ((intptr_t)addr == -1) { 2447 if (warn_on_failure) { 2448 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err); 2449 warning(msg); 2450 } 2451 return NULL; 2452 } 2453 2454 return addr; 2455} 2456 2457bool os::release_memory_special(char* base, size_t bytes) { 2458 // detaching the SHM segment will also delete it, see reserve_memory_special() 2459 int rslt = shmdt(base); 2460 return rslt == 0; 2461} 2462 2463size_t os::large_page_size() { 2464 return _large_page_size; 2465} 2466 2467// Linux does not support anonymous mmap with large page memory. The only way 2468// to reserve large page memory without file backing is through SysV shared 2469// memory API. The entire memory region is committed and pinned upfront. 2470// Hopefully this will change in the future... 2471bool os::can_commit_large_page_memory() { 2472 return false; 2473} 2474 2475// Reserve memory at an arbitrary address, only if that area is 2476// available (and not reserved for something else). 2477 2478char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2479 const int max_tries = 10; 2480 char* base[max_tries]; 2481 size_t size[max_tries]; 2482 const size_t gap = 0x000000; 2483 2484 // Assert only that the size is a multiple of the page size, since 2485 // that's all that mmap requires, and since that's all we really know 2486 // about at this low abstraction level. If we need higher alignment, 2487 // we can either pass an alignment to this method or verify alignment 2488 // in one of the methods further up the call chain. See bug 5044738. 2489 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block"); 2490 2491 // Repeatedly allocate blocks until the block is allocated at the 2492 // right spot. Give up after max_tries. Note that reserve_memory() will 2493 // automatically update _highest_vm_reserved_address if the call is 2494 // successful. The variable tracks the highest memory address every reserved 2495 // by JVM. It is used to detect heap-stack collision if running with 2496 // fixed-stack LinuxThreads. Because here we may attempt to reserve more 2497 // space than needed, it could confuse the collision detecting code. To 2498 // solve the problem, save current _highest_vm_reserved_address and 2499 // calculate the correct value before return. 2500 address old_highest = _highest_vm_reserved_address; 2501 2502 // Linux mmap allows caller to pass an address as hint; give it a try first, 2503 // if kernel honors the hint then we can return immediately. 2504 char * addr = anon_mmap(requested_addr, bytes, false); 2505 if (addr == requested_addr) { 2506 return requested_addr; 2507 } 2508 2509 if (addr != NULL) { 2510 // mmap() is successful but it fails to reserve at the requested address 2511 anon_munmap(addr, bytes); 2512 } 2513 2514 int i; 2515 for (i = 0; i < max_tries; ++i) { 2516 base[i] = reserve_memory(bytes); 2517 2518 if (base[i] != NULL) { 2519 // Is this the block we wanted? 2520 if (base[i] == requested_addr) { 2521 size[i] = bytes; 2522 break; 2523 } 2524 2525 // Does this overlap the block we wanted? Give back the overlapped 2526 // parts and try again. 2527 2528 size_t top_overlap = requested_addr + (bytes + gap) - base[i]; 2529 if (top_overlap >= 0 && top_overlap < bytes) { 2530 unmap_memory(base[i], top_overlap); 2531 base[i] += top_overlap; 2532 size[i] = bytes - top_overlap; 2533 } else { 2534 size_t bottom_overlap = base[i] + bytes - requested_addr; 2535 if (bottom_overlap >= 0 && bottom_overlap < bytes) { 2536 unmap_memory(requested_addr, bottom_overlap); 2537 size[i] = bytes - bottom_overlap; 2538 } else { 2539 size[i] = bytes; 2540 } 2541 } 2542 } 2543 } 2544 2545 // Give back the unused reserved pieces. 2546 2547 for (int j = 0; j < i; ++j) { 2548 if (base[j] != NULL) { 2549 unmap_memory(base[j], size[j]); 2550 } 2551 } 2552 2553 if (i < max_tries) { 2554 _highest_vm_reserved_address = MAX2(old_highest, (address)requested_addr + bytes); 2555 return requested_addr; 2556 } else { 2557 _highest_vm_reserved_address = old_highest; 2558 return NULL; 2559 } 2560} 2561 2562size_t os::read(int fd, void *buf, unsigned int nBytes) { 2563 return ::read(fd, buf, nBytes); 2564} 2565 2566// TODO-FIXME: reconcile Solaris' os::sleep with the linux variation. 2567// Solaris uses poll(), linux uses park(). 2568// Poll() is likely a better choice, assuming that Thread.interrupt() 2569// generates a SIGUSRx signal. Note that SIGUSR1 can interfere with 2570// SIGSEGV, see 4355769. 2571 2572const int NANOSECS_PER_MILLISECS = 1000000; 2573 2574int os::sleep(Thread* thread, jlong millis, bool interruptible) { 2575 assert(thread == Thread::current(), "thread consistency check"); 2576 2577 ParkEvent * const slp = thread->_SleepEvent ; 2578 slp->reset() ; 2579 OrderAccess::fence() ; 2580 2581 if (interruptible) { 2582 jlong prevtime = javaTimeNanos(); 2583 2584 for (;;) { 2585 if (os::is_interrupted(thread, true)) { 2586 return OS_INTRPT; 2587 } 2588 2589 jlong newtime = javaTimeNanos(); 2590 2591 if (newtime - prevtime < 0) { 2592 // time moving backwards, should only happen if no monotonic clock 2593 // not a guarantee() because JVM should not abort on kernel/glibc bugs 2594 assert(!Linux::supports_monotonic_clock(), "time moving backwards"); 2595 } else { 2596 millis -= (newtime - prevtime) / NANOSECS_PER_MILLISECS; 2597 } 2598 2599 if(millis <= 0) { 2600 return OS_OK; 2601 } 2602 2603 prevtime = newtime; 2604 2605 { 2606 assert(thread->is_Java_thread(), "sanity check"); 2607 JavaThread *jt = (JavaThread *) thread; 2608 ThreadBlockInVM tbivm(jt); 2609 OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */); 2610 2611 jt->set_suspend_equivalent(); 2612 // cleared by handle_special_suspend_equivalent_condition() or 2613 // java_suspend_self() via check_and_wait_while_suspended() 2614 2615 slp->park(millis); 2616 2617 // were we externally suspended while we were waiting? 2618 jt->check_and_wait_while_suspended(); 2619 } 2620 } 2621 } else { 2622 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 2623 jlong prevtime = javaTimeNanos(); 2624 2625 for (;;) { 2626 // It'd be nice to avoid the back-to-back javaTimeNanos() calls on 2627 // the 1st iteration ... 2628 jlong newtime = javaTimeNanos(); 2629 2630 if (newtime - prevtime < 0) { 2631 // time moving backwards, should only happen if no monotonic clock 2632 // not a guarantee() because JVM should not abort on kernel/glibc bugs 2633 assert(!Linux::supports_monotonic_clock(), "time moving backwards"); 2634 } else { 2635 millis -= (newtime - prevtime) / NANOSECS_PER_MILLISECS; 2636 } 2637 2638 if(millis <= 0) break ; 2639 2640 prevtime = newtime; 2641 slp->park(millis); 2642 } 2643 return OS_OK ; 2644 } 2645} 2646 2647int os::naked_sleep() { 2648 // %% make the sleep time an integer flag. for now use 1 millisec. 2649 return os::sleep(Thread::current(), 1, false); 2650} 2651 2652// Sleep forever; naked call to OS-specific sleep; use with CAUTION 2653void os::infinite_sleep() { 2654 while (true) { // sleep forever ... 2655 ::sleep(100); // ... 100 seconds at a time 2656 } 2657} 2658 2659// Used to convert frequent JVM_Yield() to nops 2660bool os::dont_yield() { 2661 return DontYieldALot; 2662} 2663 2664void os::yield() { 2665 sched_yield(); 2666} 2667 2668os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;} 2669 2670void os::yield_all(int attempts) { 2671 // Yields to all threads, including threads with lower priorities 2672 // Threads on Linux are all with same priority. The Solaris style 2673 // os::yield_all() with nanosleep(1ms) is not necessary. 2674 sched_yield(); 2675} 2676 2677// Called from the tight loops to possibly influence time-sharing heuristics 2678void os::loop_breaker(int attempts) { 2679 os::yield_all(attempts); 2680} 2681 2682//////////////////////////////////////////////////////////////////////////////// 2683// thread priority support 2684 2685// Note: Normal Linux applications are run with SCHED_OTHER policy. SCHED_OTHER 2686// only supports dynamic priority, static priority must be zero. For real-time 2687// applications, Linux supports SCHED_RR which allows static priority (1-99). 2688// However, for large multi-threaded applications, SCHED_RR is not only slower 2689// than SCHED_OTHER, but also very unstable (my volano tests hang hard 4 out 2690// of 5 runs - Sep 2005). 2691// 2692// The following code actually changes the niceness of kernel-thread/LWP. It 2693// has an assumption that setpriority() only modifies one kernel-thread/LWP, 2694// not the entire user process, and user level threads are 1:1 mapped to kernel 2695// threads. It has always been the case, but could change in the future. For 2696// this reason, the code should not be used as default (ThreadPriorityPolicy=0). 2697// It is only used when ThreadPriorityPolicy=1 and requires root privilege. 2698 2699int os::java_to_os_priority[MaxPriority + 1] = { 2700 19, // 0 Entry should never be used 2701 2702 4, // 1 MinPriority 2703 3, // 2 2704 2, // 3 2705 2706 1, // 4 2707 0, // 5 NormPriority 2708 -1, // 6 2709 2710 -2, // 7 2711 -3, // 8 2712 -4, // 9 NearMaxPriority 2713 2714 -5 // 10 MaxPriority 2715}; 2716 2717static int prio_init() { 2718 if (ThreadPriorityPolicy == 1) { 2719 // Only root can raise thread priority. Don't allow ThreadPriorityPolicy=1 2720 // if effective uid is not root. Perhaps, a more elegant way of doing 2721 // this is to test CAP_SYS_NICE capability, but that will require libcap.so 2722 if (geteuid() != 0) { 2723 if (!FLAG_IS_DEFAULT(ThreadPriorityPolicy)) { 2724 warning("-XX:ThreadPriorityPolicy requires root privilege on Linux"); 2725 } 2726 ThreadPriorityPolicy = 0; 2727 } 2728 } 2729 return 0; 2730} 2731 2732OSReturn os::set_native_priority(Thread* thread, int newpri) { 2733 if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) return OS_OK; 2734 2735 int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri); 2736 return (ret == 0) ? OS_OK : OS_ERR; 2737} 2738 2739OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) { 2740 if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) { 2741 *priority_ptr = java_to_os_priority[NormPriority]; 2742 return OS_OK; 2743 } 2744 2745 errno = 0; 2746 *priority_ptr = getpriority(PRIO_PROCESS, thread->osthread()->thread_id()); 2747 return (*priority_ptr != -1 || errno == 0 ? OS_OK : OS_ERR); 2748} 2749 2750// Hint to the underlying OS that a task switch would not be good. 2751// Void return because it's a hint and can fail. 2752void os::hint_no_preempt() {} 2753 2754//////////////////////////////////////////////////////////////////////////////// 2755// suspend/resume support 2756 2757// the low-level signal-based suspend/resume support is a remnant from the 2758// old VM-suspension that used to be for java-suspension, safepoints etc, 2759// within hotspot. Now there is a single use-case for this: 2760// - calling get_thread_pc() on the VMThread by the flat-profiler task 2761// that runs in the watcher thread. 2762// The remaining code is greatly simplified from the more general suspension 2763// code that used to be used. 2764// 2765// The protocol is quite simple: 2766// - suspend: 2767// - sends a signal to the target thread 2768// - polls the suspend state of the osthread using a yield loop 2769// - target thread signal handler (SR_handler) sets suspend state 2770// and blocks in sigsuspend until continued 2771// - resume: 2772// - sets target osthread state to continue 2773// - sends signal to end the sigsuspend loop in the SR_handler 2774// 2775// Note that the SR_lock plays no role in this suspend/resume protocol. 2776// 2777 2778static void resume_clear_context(OSThread *osthread) { 2779 osthread->set_ucontext(NULL); 2780 osthread->set_siginfo(NULL); 2781 2782 // notify the suspend action is completed, we have now resumed 2783 osthread->sr.clear_suspended(); 2784} 2785 2786static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) { 2787 osthread->set_ucontext(context); 2788 osthread->set_siginfo(siginfo); 2789} 2790 2791// 2792// Handler function invoked when a thread's execution is suspended or 2793// resumed. We have to be careful that only async-safe functions are 2794// called here (Note: most pthread functions are not async safe and 2795// should be avoided.) 2796// 2797// Note: sigwait() is a more natural fit than sigsuspend() from an 2798// interface point of view, but sigwait() prevents the signal hander 2799// from being run. libpthread would get very confused by not having 2800// its signal handlers run and prevents sigwait()'s use with the 2801// mutex granting granting signal. 2802// 2803// Currently only ever called on the VMThread 2804// 2805static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) { 2806 // Save and restore errno to avoid confusing native code with EINTR 2807 // after sigsuspend. 2808 int old_errno = errno; 2809 2810 Thread* thread = Thread::current(); 2811 OSThread* osthread = thread->osthread(); 2812 assert(thread->is_VM_thread(), "Must be VMThread"); 2813 // read current suspend action 2814 int action = osthread->sr.suspend_action(); 2815 if (action == SR_SUSPEND) { 2816 suspend_save_context(osthread, siginfo, context); 2817 2818 // Notify the suspend action is about to be completed. do_suspend() 2819 // waits until SR_SUSPENDED is set and then returns. We will wait 2820 // here for a resume signal and that completes the suspend-other 2821 // action. do_suspend/do_resume is always called as a pair from 2822 // the same thread - so there are no races 2823 2824 // notify the caller 2825 osthread->sr.set_suspended(); 2826 2827 sigset_t suspend_set; // signals for sigsuspend() 2828 2829 // get current set of blocked signals and unblock resume signal 2830 pthread_sigmask(SIG_BLOCK, NULL, &suspend_set); 2831 sigdelset(&suspend_set, SR_signum); 2832 2833 // wait here until we are resumed 2834 do { 2835 sigsuspend(&suspend_set); 2836 // ignore all returns until we get a resume signal 2837 } while (osthread->sr.suspend_action() != SR_CONTINUE); 2838 2839 resume_clear_context(osthread); 2840 2841 } else { 2842 assert(action == SR_CONTINUE, "unexpected sr action"); 2843 // nothing special to do - just leave the handler 2844 } 2845 2846 errno = old_errno; 2847} 2848 2849 2850static int SR_initialize() { 2851 struct sigaction act; 2852 char *s; 2853 /* Get signal number to use for suspend/resume */ 2854 if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) { 2855 int sig = ::strtol(s, 0, 10); 2856 if (sig > 0 || sig < _NSIG) { 2857 SR_signum = sig; 2858 } 2859 } 2860 2861 assert(SR_signum > SIGSEGV && SR_signum > SIGBUS, 2862 "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769"); 2863 2864 sigemptyset(&SR_sigset); 2865 sigaddset(&SR_sigset, SR_signum); 2866 2867 /* Set up signal handler for suspend/resume */ 2868 act.sa_flags = SA_RESTART|SA_SIGINFO; 2869 act.sa_handler = (void (*)(int)) SR_handler; 2870 2871 // SR_signum is blocked by default. 2872 // 4528190 - We also need to block pthread restart signal (32 on all 2873 // supported Linux platforms). Note that LinuxThreads need to block 2874 // this signal for all threads to work properly. So we don't have 2875 // to use hard-coded signal number when setting up the mask. 2876 pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask); 2877 2878 if (sigaction(SR_signum, &act, 0) == -1) { 2879 return -1; 2880 } 2881 2882 // Save signal flag 2883 os::Linux::set_our_sigflags(SR_signum, act.sa_flags); 2884 return 0; 2885} 2886 2887static int SR_finalize() { 2888 return 0; 2889} 2890 2891 2892// returns true on success and false on error - really an error is fatal 2893// but this seems the normal response to library errors 2894static bool do_suspend(OSThread* osthread) { 2895 // mark as suspended and send signal 2896 osthread->sr.set_suspend_action(SR_SUSPEND); 2897 int status = pthread_kill(osthread->pthread_id(), SR_signum); 2898 assert_status(status == 0, status, "pthread_kill"); 2899 2900 // check status and wait until notified of suspension 2901 if (status == 0) { 2902 for (int i = 0; !osthread->sr.is_suspended(); i++) { 2903 os::yield_all(i); 2904 } 2905 osthread->sr.set_suspend_action(SR_NONE); 2906 return true; 2907 } 2908 else { 2909 osthread->sr.set_suspend_action(SR_NONE); 2910 return false; 2911 } 2912} 2913 2914static void do_resume(OSThread* osthread) { 2915 assert(osthread->sr.is_suspended(), "thread should be suspended"); 2916 osthread->sr.set_suspend_action(SR_CONTINUE); 2917 2918 int status = pthread_kill(osthread->pthread_id(), SR_signum); 2919 assert_status(status == 0, status, "pthread_kill"); 2920 // check status and wait unit notified of resumption 2921 if (status == 0) { 2922 for (int i = 0; osthread->sr.is_suspended(); i++) { 2923 os::yield_all(i); 2924 } 2925 } 2926 osthread->sr.set_suspend_action(SR_NONE); 2927} 2928 2929//////////////////////////////////////////////////////////////////////////////// 2930// interrupt support 2931 2932void os::interrupt(Thread* thread) { 2933 assert(Thread::current() == thread || Threads_lock->owned_by_self(), 2934 "possibility of dangling Thread pointer"); 2935 2936 OSThread* osthread = thread->osthread(); 2937 2938 if (!osthread->interrupted()) { 2939 osthread->set_interrupted(true); 2940 // More than one thread can get here with the same value of osthread, 2941 // resulting in multiple notifications. We do, however, want the store 2942 // to interrupted() to be visible to other threads before we execute unpark(). 2943 OrderAccess::fence(); 2944 ParkEvent * const slp = thread->_SleepEvent ; 2945 if (slp != NULL) slp->unpark() ; 2946 } 2947 2948 // For JSR166. Unpark even if interrupt status already was set 2949 if (thread->is_Java_thread()) 2950 ((JavaThread*)thread)->parker()->unpark(); 2951 2952 ParkEvent * ev = thread->_ParkEvent ; 2953 if (ev != NULL) ev->unpark() ; 2954 2955} 2956 2957bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 2958 assert(Thread::current() == thread || Threads_lock->owned_by_self(), 2959 "possibility of dangling Thread pointer"); 2960 2961 OSThread* osthread = thread->osthread(); 2962 2963 bool interrupted = osthread->interrupted(); 2964 2965 if (interrupted && clear_interrupted) { 2966 osthread->set_interrupted(false); 2967 // consider thread->_SleepEvent->reset() ... optional optimization 2968 } 2969 2970 return interrupted; 2971} 2972 2973/////////////////////////////////////////////////////////////////////////////////// 2974// signal handling (except suspend/resume) 2975 2976// This routine may be used by user applications as a "hook" to catch signals. 2977// The user-defined signal handler must pass unrecognized signals to this 2978// routine, and if it returns true (non-zero), then the signal handler must 2979// return immediately. If the flag "abort_if_unrecognized" is true, then this 2980// routine will never retun false (zero), but instead will execute a VM panic 2981// routine kill the process. 2982// 2983// If this routine returns false, it is OK to call it again. This allows 2984// the user-defined signal handler to perform checks either before or after 2985// the VM performs its own checks. Naturally, the user code would be making 2986// a serious error if it tried to handle an exception (such as a null check 2987// or breakpoint) that the VM was generating for its own correct operation. 2988// 2989// This routine may recognize any of the following kinds of signals: 2990// SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1. 2991// It should be consulted by handlers for any of those signals. 2992// 2993// The caller of this routine must pass in the three arguments supplied 2994// to the function referred to in the "sa_sigaction" (not the "sa_handler") 2995// field of the structure passed to sigaction(). This routine assumes that 2996// the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART. 2997// 2998// Note that the VM will print warnings if it detects conflicting signal 2999// handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers". 3000// 3001extern "C" int 3002JVM_handle_linux_signal(int signo, siginfo_t* siginfo, 3003 void* ucontext, int abort_if_unrecognized); 3004 3005void signalHandler(int sig, siginfo_t* info, void* uc) { 3006 assert(info != NULL && uc != NULL, "it must be old kernel"); 3007 JVM_handle_linux_signal(sig, info, uc, true); 3008} 3009 3010 3011// This boolean allows users to forward their own non-matching signals 3012// to JVM_handle_linux_signal, harmlessly. 3013bool os::Linux::signal_handlers_are_installed = false; 3014 3015// For signal-chaining 3016struct sigaction os::Linux::sigact[MAXSIGNUM]; 3017unsigned int os::Linux::sigs = 0; 3018bool os::Linux::libjsig_is_loaded = false; 3019typedef struct sigaction *(*get_signal_t)(int); 3020get_signal_t os::Linux::get_signal_action = NULL; 3021 3022struct sigaction* os::Linux::get_chained_signal_action(int sig) { 3023 struct sigaction *actp = NULL; 3024 3025 if (libjsig_is_loaded) { 3026 // Retrieve the old signal handler from libjsig 3027 actp = (*get_signal_action)(sig); 3028 } 3029 if (actp == NULL) { 3030 // Retrieve the preinstalled signal handler from jvm 3031 actp = get_preinstalled_handler(sig); 3032 } 3033 3034 return actp; 3035} 3036 3037static bool call_chained_handler(struct sigaction *actp, int sig, 3038 siginfo_t *siginfo, void *context) { 3039 // Call the old signal handler 3040 if (actp->sa_handler == SIG_DFL) { 3041 // It's more reasonable to let jvm treat it as an unexpected exception 3042 // instead of taking the default action. 3043 return false; 3044 } else if (actp->sa_handler != SIG_IGN) { 3045 if ((actp->sa_flags & SA_NODEFER) == 0) { 3046 // automaticlly block the signal 3047 sigaddset(&(actp->sa_mask), sig); 3048 } 3049 3050 sa_handler_t hand; 3051 sa_sigaction_t sa; 3052 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0; 3053 // retrieve the chained handler 3054 if (siginfo_flag_set) { 3055 sa = actp->sa_sigaction; 3056 } else { 3057 hand = actp->sa_handler; 3058 } 3059 3060 if ((actp->sa_flags & SA_RESETHAND) != 0) { 3061 actp->sa_handler = SIG_DFL; 3062 } 3063 3064 // try to honor the signal mask 3065 sigset_t oset; 3066 pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset); 3067 3068 // call into the chained handler 3069 if (siginfo_flag_set) { 3070 (*sa)(sig, siginfo, context); 3071 } else { 3072 (*hand)(sig); 3073 } 3074 3075 // restore the signal mask 3076 pthread_sigmask(SIG_SETMASK, &oset, 0); 3077 } 3078 // Tell jvm's signal handler the signal is taken care of. 3079 return true; 3080} 3081 3082bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) { 3083 bool chained = false; 3084 // signal-chaining 3085 if (UseSignalChaining) { 3086 struct sigaction *actp = get_chained_signal_action(sig); 3087 if (actp != NULL) { 3088 chained = call_chained_handler(actp, sig, siginfo, context); 3089 } 3090 } 3091 return chained; 3092} 3093 3094struct sigaction* os::Linux::get_preinstalled_handler(int sig) { 3095 if ((( (unsigned int)1 << sig ) & sigs) != 0) { 3096 return &sigact[sig]; 3097 } 3098 return NULL; 3099} 3100 3101void os::Linux::save_preinstalled_handler(int sig, struct sigaction& oldAct) { 3102 assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range"); 3103 sigact[sig] = oldAct; 3104 sigs |= (unsigned int)1 << sig; 3105} 3106 3107// for diagnostic 3108int os::Linux::sigflags[MAXSIGNUM]; 3109 3110int os::Linux::get_our_sigflags(int sig) { 3111 assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range"); 3112 return sigflags[sig]; 3113} 3114 3115void os::Linux::set_our_sigflags(int sig, int flags) { 3116 assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range"); 3117 sigflags[sig] = flags; 3118} 3119 3120void os::Linux::set_signal_handler(int sig, bool set_installed) { 3121 // Check for overwrite. 3122 struct sigaction oldAct; 3123 sigaction(sig, (struct sigaction*)NULL, &oldAct); 3124 3125 void* oldhand = oldAct.sa_sigaction 3126 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 3127 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 3128 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) && 3129 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) && 3130 oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)signalHandler)) { 3131 if (AllowUserSignalHandlers || !set_installed) { 3132 // Do not overwrite; user takes responsibility to forward to us. 3133 return; 3134 } else if (UseSignalChaining) { 3135 // save the old handler in jvm 3136 save_preinstalled_handler(sig, oldAct); 3137 // libjsig also interposes the sigaction() call below and saves the 3138 // old sigaction on it own. 3139 } else { 3140 fatal2("Encountered unexpected pre-existing sigaction handler %#lx for signal %d.", (long)oldhand, sig); 3141 } 3142 } 3143 3144 struct sigaction sigAct; 3145 sigfillset(&(sigAct.sa_mask)); 3146 sigAct.sa_handler = SIG_DFL; 3147 if (!set_installed) { 3148 sigAct.sa_flags = SA_SIGINFO|SA_RESTART; 3149 } else { 3150 sigAct.sa_sigaction = signalHandler; 3151 sigAct.sa_flags = SA_SIGINFO|SA_RESTART; 3152 } 3153 // Save flags, which are set by ours 3154 assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range"); 3155 sigflags[sig] = sigAct.sa_flags; 3156 3157 int ret = sigaction(sig, &sigAct, &oldAct); 3158 assert(ret == 0, "check"); 3159 3160 void* oldhand2 = oldAct.sa_sigaction 3161 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 3162 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 3163 assert(oldhand2 == oldhand, "no concurrent signal handler installation"); 3164} 3165 3166// install signal handlers for signals that HotSpot needs to 3167// handle in order to support Java-level exception handling. 3168 3169void os::Linux::install_signal_handlers() { 3170 if (!signal_handlers_are_installed) { 3171 signal_handlers_are_installed = true; 3172 3173 // signal-chaining 3174 typedef void (*signal_setting_t)(); 3175 signal_setting_t begin_signal_setting = NULL; 3176 signal_setting_t end_signal_setting = NULL; 3177 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 3178 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting")); 3179 if (begin_signal_setting != NULL) { 3180 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 3181 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting")); 3182 get_signal_action = CAST_TO_FN_PTR(get_signal_t, 3183 dlsym(RTLD_DEFAULT, "JVM_get_signal_action")); 3184 libjsig_is_loaded = true; 3185 assert(UseSignalChaining, "should enable signal-chaining"); 3186 } 3187 if (libjsig_is_loaded) { 3188 // Tell libjsig jvm is setting signal handlers 3189 (*begin_signal_setting)(); 3190 } 3191 3192 set_signal_handler(SIGSEGV, true); 3193 set_signal_handler(SIGPIPE, true); 3194 set_signal_handler(SIGBUS, true); 3195 set_signal_handler(SIGILL, true); 3196 set_signal_handler(SIGFPE, true); 3197 set_signal_handler(SIGXFSZ, true); 3198 3199 if (libjsig_is_loaded) { 3200 // Tell libjsig jvm finishes setting signal handlers 3201 (*end_signal_setting)(); 3202 } 3203 3204 // We don't activate signal checker if libjsig is in place, we trust ourselves 3205 // and if UserSignalHandler is installed all bets are off 3206 if (CheckJNICalls) { 3207 if (libjsig_is_loaded) { 3208 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled"); 3209 check_signals = false; 3210 } 3211 if (AllowUserSignalHandlers) { 3212 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled"); 3213 check_signals = false; 3214 } 3215 } 3216 } 3217} 3218 3219// This is the fastest way to get thread cpu time on Linux. 3220// Returns cpu time (user+sys) for any thread, not only for current. 3221// POSIX compliant clocks are implemented in the kernels 2.6.16+. 3222// It might work on 2.6.10+ with a special kernel/glibc patch. 3223// For reference, please, see IEEE Std 1003.1-2004: 3224// http://www.unix.org/single_unix_specification 3225 3226jlong os::Linux::fast_thread_cpu_time(clockid_t clockid) { 3227 struct timespec tp; 3228 int rc = os::Linux::clock_gettime(clockid, &tp); 3229 assert(rc == 0, "clock_gettime is expected to return 0 code"); 3230 3231 return (tp.tv_sec * SEC_IN_NANOSECS) + tp.tv_nsec; 3232} 3233 3234///// 3235// glibc on Linux platform uses non-documented flag 3236// to indicate, that some special sort of signal 3237// trampoline is used. 3238// We will never set this flag, and we should 3239// ignore this flag in our diagnostic 3240#ifdef SIGNIFICANT_SIGNAL_MASK 3241#undef SIGNIFICANT_SIGNAL_MASK 3242#endif 3243#define SIGNIFICANT_SIGNAL_MASK (~0x04000000) 3244 3245static const char* get_signal_handler_name(address handler, 3246 char* buf, int buflen) { 3247 int offset; 3248 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset); 3249 if (found) { 3250 // skip directory names 3251 const char *p1, *p2; 3252 p1 = buf; 3253 size_t len = strlen(os::file_separator()); 3254 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len; 3255 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset); 3256 } else { 3257 jio_snprintf(buf, buflen, PTR_FORMAT, handler); 3258 } 3259 return buf; 3260} 3261 3262static void print_signal_handler(outputStream* st, int sig, 3263 char* buf, size_t buflen) { 3264 struct sigaction sa; 3265 3266 sigaction(sig, NULL, &sa); 3267 3268 // See comment for SIGNIFICANT_SIGNAL_MASK define 3269 sa.sa_flags &= SIGNIFICANT_SIGNAL_MASK; 3270 3271 st->print("%s: ", os::exception_name(sig, buf, buflen)); 3272 3273 address handler = (sa.sa_flags & SA_SIGINFO) 3274 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction) 3275 : CAST_FROM_FN_PTR(address, sa.sa_handler); 3276 3277 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) { 3278 st->print("SIG_DFL"); 3279 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) { 3280 st->print("SIG_IGN"); 3281 } else { 3282 st->print("[%s]", get_signal_handler_name(handler, buf, buflen)); 3283 } 3284 3285 st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask); 3286 3287 address rh = VMError::get_resetted_sighandler(sig); 3288 // May be, handler was resetted by VMError? 3289 if(rh != NULL) { 3290 handler = rh; 3291 sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK; 3292 } 3293 3294 st->print(", sa_flags=" PTR32_FORMAT, sa.sa_flags); 3295 3296 // Check: is it our handler? 3297 if(handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) || 3298 handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) { 3299 // It is our signal handler 3300 // check for flags, reset system-used one! 3301 if((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) { 3302 st->print( 3303 ", flags was changed from " PTR32_FORMAT ", consider using jsig library", 3304 os::Linux::get_our_sigflags(sig)); 3305 } 3306 } 3307 st->cr(); 3308} 3309 3310 3311#define DO_SIGNAL_CHECK(sig) \ 3312 if (!sigismember(&check_signal_done, sig)) \ 3313 os::Linux::check_signal_handler(sig) 3314 3315// This method is a periodic task to check for misbehaving JNI applications 3316// under CheckJNI, we can add any periodic checks here 3317 3318void os::run_periodic_checks() { 3319 3320 if (check_signals == false) return; 3321 3322 // SEGV and BUS if overridden could potentially prevent 3323 // generation of hs*.log in the event of a crash, debugging 3324 // such a case can be very challenging, so we absolutely 3325 // check the following for a good measure: 3326 DO_SIGNAL_CHECK(SIGSEGV); 3327 DO_SIGNAL_CHECK(SIGILL); 3328 DO_SIGNAL_CHECK(SIGFPE); 3329 DO_SIGNAL_CHECK(SIGBUS); 3330 DO_SIGNAL_CHECK(SIGPIPE); 3331 DO_SIGNAL_CHECK(SIGXFSZ); 3332 3333 3334 // ReduceSignalUsage allows the user to override these handlers 3335 // see comments at the very top and jvm_solaris.h 3336 if (!ReduceSignalUsage) { 3337 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL); 3338 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL); 3339 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL); 3340 DO_SIGNAL_CHECK(BREAK_SIGNAL); 3341 } 3342 3343 DO_SIGNAL_CHECK(SR_signum); 3344 DO_SIGNAL_CHECK(INTERRUPT_SIGNAL); 3345} 3346 3347typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *); 3348 3349static os_sigaction_t os_sigaction = NULL; 3350 3351void os::Linux::check_signal_handler(int sig) { 3352 char buf[O_BUFLEN]; 3353 address jvmHandler = NULL; 3354 3355 3356 struct sigaction act; 3357 if (os_sigaction == NULL) { 3358 // only trust the default sigaction, in case it has been interposed 3359 os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction"); 3360 if (os_sigaction == NULL) return; 3361 } 3362 3363 os_sigaction(sig, (struct sigaction*)NULL, &act); 3364 3365 3366 act.sa_flags &= SIGNIFICANT_SIGNAL_MASK; 3367 3368 address thisHandler = (act.sa_flags & SA_SIGINFO) 3369 ? CAST_FROM_FN_PTR(address, act.sa_sigaction) 3370 : CAST_FROM_FN_PTR(address, act.sa_handler) ; 3371 3372 3373 switch(sig) { 3374 case SIGSEGV: 3375 case SIGBUS: 3376 case SIGFPE: 3377 case SIGPIPE: 3378 case SIGILL: 3379 case SIGXFSZ: 3380 jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler); 3381 break; 3382 3383 case SHUTDOWN1_SIGNAL: 3384 case SHUTDOWN2_SIGNAL: 3385 case SHUTDOWN3_SIGNAL: 3386 case BREAK_SIGNAL: 3387 jvmHandler = (address)user_handler(); 3388 break; 3389 3390 case INTERRUPT_SIGNAL: 3391 jvmHandler = CAST_FROM_FN_PTR(address, SIG_DFL); 3392 break; 3393 3394 default: 3395 if (sig == SR_signum) { 3396 jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler); 3397 } else { 3398 return; 3399 } 3400 break; 3401 } 3402 3403 if (thisHandler != jvmHandler) { 3404 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN)); 3405 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN)); 3406 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN)); 3407 // No need to check this sig any longer 3408 sigaddset(&check_signal_done, sig); 3409 } else if(os::Linux::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Linux::get_our_sigflags(sig)) { 3410 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN)); 3411 tty->print("expected:" PTR32_FORMAT, os::Linux::get_our_sigflags(sig)); 3412 tty->print_cr(" found:" PTR32_FORMAT, act.sa_flags); 3413 // No need to check this sig any longer 3414 sigaddset(&check_signal_done, sig); 3415 } 3416 3417 // Dump all the signal 3418 if (sigismember(&check_signal_done, sig)) { 3419 print_signal_handlers(tty, buf, O_BUFLEN); 3420 } 3421} 3422 3423extern void report_error(char* file_name, int line_no, char* title, char* format, ...); 3424 3425extern bool signal_name(int signo, char* buf, size_t len); 3426 3427const char* os::exception_name(int exception_code, char* buf, size_t size) { 3428 if (0 < exception_code && exception_code <= SIGRTMAX) { 3429 // signal 3430 if (!signal_name(exception_code, buf, size)) { 3431 jio_snprintf(buf, size, "SIG%d", exception_code); 3432 } 3433 return buf; 3434 } else { 3435 return NULL; 3436 } 3437} 3438 3439// this is called _before_ the most of global arguments have been parsed 3440void os::init(void) { 3441 char dummy; /* used to get a guess on initial stack address */ 3442// first_hrtime = gethrtime(); 3443 3444 // With LinuxThreads the JavaMain thread pid (primordial thread) 3445 // is different than the pid of the java launcher thread. 3446 // So, on Linux, the launcher thread pid is passed to the VM 3447 // via the sun.java.launcher.pid property. 3448 // Use this property instead of getpid() if it was correctly passed. 3449 // See bug 6351349. 3450 pid_t java_launcher_pid = (pid_t) Arguments::sun_java_launcher_pid(); 3451 3452 _initial_pid = (java_launcher_pid > 0) ? java_launcher_pid : getpid(); 3453 3454 clock_tics_per_sec = sysconf(_SC_CLK_TCK); 3455 3456 init_random(1234567); 3457 3458 ThreadCritical::initialize(); 3459 3460 Linux::set_page_size(sysconf(_SC_PAGESIZE)); 3461 if (Linux::page_size() == -1) { 3462 fatal1("os_linux.cpp: os::init: sysconf failed (%s)", strerror(errno)); 3463 } 3464 init_page_sizes((size_t) Linux::page_size()); 3465 3466 Linux::initialize_system_info(); 3467 3468 // main_thread points to the aboriginal thread 3469 Linux::_main_thread = pthread_self(); 3470 3471 Linux::clock_init(); 3472 initial_time_count = os::elapsed_counter(); 3473} 3474 3475// To install functions for atexit system call 3476extern "C" { 3477 static void perfMemory_exit_helper() { 3478 perfMemory_exit(); 3479 } 3480} 3481 3482// this is called _after_ the global arguments have been parsed 3483jint os::init_2(void) 3484{ 3485 Linux::fast_thread_clock_init(); 3486 3487 // Allocate a single page and mark it as readable for safepoint polling 3488 address polling_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); 3489 guarantee( polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page" ); 3490 3491 os::set_polling_page( polling_page ); 3492 3493#ifndef PRODUCT 3494 if(Verbose && PrintMiscellaneous) 3495 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 3496#endif 3497 3498 if (!UseMembar) { 3499 address mem_serialize_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); 3500 guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page"); 3501 os::set_memory_serialize_page( mem_serialize_page ); 3502 3503#ifndef PRODUCT 3504 if(Verbose && PrintMiscellaneous) 3505 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 3506#endif 3507 } 3508 3509 FLAG_SET_DEFAULT(UseLargePages, os::large_page_init()); 3510 3511 // initialize suspend/resume support - must do this before signal_sets_init() 3512 if (SR_initialize() != 0) { 3513 perror("SR_initialize failed"); 3514 return JNI_ERR; 3515 } 3516 3517 Linux::signal_sets_init(); 3518 Linux::install_signal_handlers(); 3519 3520 size_t threadStackSizeInBytes = ThreadStackSize * K; 3521 if (threadStackSizeInBytes != 0 && 3522 threadStackSizeInBytes < Linux::min_stack_allowed) { 3523 tty->print_cr("\nThe stack size specified is too small, " 3524 "Specify at least %dk", 3525 Linux::min_stack_allowed / K); 3526 return JNI_ERR; 3527 } 3528 3529 // Make the stack size a multiple of the page size so that 3530 // the yellow/red zones can be guarded. 3531 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, 3532 vm_page_size())); 3533 3534 Linux::capture_initial_stack(JavaThread::stack_size_at_create()); 3535 3536 Linux::libpthread_init(); 3537 if (PrintMiscellaneous && (Verbose || WizardMode)) { 3538 tty->print_cr("[HotSpot is running with %s, %s(%s)]\n", 3539 Linux::glibc_version(), Linux::libpthread_version(), 3540 Linux::is_floating_stack() ? "floating stack" : "fixed stack"); 3541 } 3542 3543 if (MaxFDLimit) { 3544 // set the number of file descriptors to max. print out error 3545 // if getrlimit/setrlimit fails but continue regardless. 3546 struct rlimit nbr_files; 3547 int status = getrlimit(RLIMIT_NOFILE, &nbr_files); 3548 if (status != 0) { 3549 if (PrintMiscellaneous && (Verbose || WizardMode)) 3550 perror("os::init_2 getrlimit failed"); 3551 } else { 3552 nbr_files.rlim_cur = nbr_files.rlim_max; 3553 status = setrlimit(RLIMIT_NOFILE, &nbr_files); 3554 if (status != 0) { 3555 if (PrintMiscellaneous && (Verbose || WizardMode)) 3556 perror("os::init_2 setrlimit failed"); 3557 } 3558 } 3559 } 3560 3561 // Initialize lock used to serialize thread creation (see os::create_thread) 3562 Linux::set_createThread_lock(new Mutex(Mutex::leaf, "createThread_lock", false)); 3563 3564 // Initialize HPI. 3565 jint hpi_result = hpi::initialize(); 3566 if (hpi_result != JNI_OK) { 3567 tty->print_cr("There was an error trying to initialize the HPI library."); 3568 return hpi_result; 3569 } 3570 3571 // at-exit methods are called in the reverse order of their registration. 3572 // atexit functions are called on return from main or as a result of a 3573 // call to exit(3C). There can be only 32 of these functions registered 3574 // and atexit() does not set errno. 3575 3576 if (PerfAllowAtExitRegistration) { 3577 // only register atexit functions if PerfAllowAtExitRegistration is set. 3578 // atexit functions can be delayed until process exit time, which 3579 // can be problematic for embedded VM situations. Embedded VMs should 3580 // call DestroyJavaVM() to assure that VM resources are released. 3581 3582 // note: perfMemory_exit_helper atexit function may be removed in 3583 // the future if the appropriate cleanup code can be added to the 3584 // VM_Exit VMOperation's doit method. 3585 if (atexit(perfMemory_exit_helper) != 0) { 3586 warning("os::init2 atexit(perfMemory_exit_helper) failed"); 3587 } 3588 } 3589 3590 // initialize thread priority policy 3591 prio_init(); 3592 3593 return JNI_OK; 3594} 3595 3596// Mark the polling page as unreadable 3597void os::make_polling_page_unreadable(void) { 3598 if( !guard_memory((char*)_polling_page, Linux::page_size()) ) 3599 fatal("Could not disable polling page"); 3600}; 3601 3602// Mark the polling page as readable 3603void os::make_polling_page_readable(void) { 3604 if( !protect_memory((char *)_polling_page, Linux::page_size()) ) 3605 fatal("Could not enable polling page"); 3606}; 3607 3608int os::active_processor_count() { 3609 // Linux doesn't yet have a (official) notion of processor sets, 3610 // so just return the number of online processors. 3611 int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN); 3612 assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check"); 3613 return online_cpus; 3614} 3615 3616bool os::distribute_processes(uint length, uint* distribution) { 3617 // Not yet implemented. 3618 return false; 3619} 3620 3621bool os::bind_to_processor(uint processor_id) { 3622 // Not yet implemented. 3623 return false; 3624} 3625 3626/// 3627 3628// Suspends the target using the signal mechanism and then grabs the PC before 3629// resuming the target. Used by the flat-profiler only 3630ExtendedPC os::get_thread_pc(Thread* thread) { 3631 // Make sure that it is called by the watcher for the VMThread 3632 assert(Thread::current()->is_Watcher_thread(), "Must be watcher"); 3633 assert(thread->is_VM_thread(), "Can only be called for VMThread"); 3634 3635 ExtendedPC epc; 3636 3637 OSThread* osthread = thread->osthread(); 3638 if (do_suspend(osthread)) { 3639 if (osthread->ucontext() != NULL) { 3640 epc = os::Linux::ucontext_get_pc(osthread->ucontext()); 3641 } else { 3642 // NULL context is unexpected, double-check this is the VMThread 3643 guarantee(thread->is_VM_thread(), "can only be called for VMThread"); 3644 } 3645 do_resume(osthread); 3646 } 3647 // failure means pthread_kill failed for some reason - arguably this is 3648 // a fatal problem, but such problems are ignored elsewhere 3649 3650 return epc; 3651} 3652 3653int os::Linux::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime) 3654{ 3655 if (is_NPTL()) { 3656 return pthread_cond_timedwait(_cond, _mutex, _abstime); 3657 } else { 3658#ifndef IA64 3659 // 6292965: LinuxThreads pthread_cond_timedwait() resets FPU control 3660 // word back to default 64bit precision if condvar is signaled. Java 3661 // wants 53bit precision. Save and restore current value. 3662 int fpu = get_fpu_control_word(); 3663#endif // IA64 3664 int status = pthread_cond_timedwait(_cond, _mutex, _abstime); 3665#ifndef IA64 3666 set_fpu_control_word(fpu); 3667#endif // IA64 3668 return status; 3669 } 3670} 3671 3672//////////////////////////////////////////////////////////////////////////////// 3673// debug support 3674 3675#ifndef PRODUCT 3676static address same_page(address x, address y) { 3677 int page_bits = -os::vm_page_size(); 3678 if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits)) 3679 return x; 3680 else if (x > y) 3681 return (address)(intptr_t(y) | ~page_bits) + 1; 3682 else 3683 return (address)(intptr_t(y) & page_bits); 3684} 3685 3686bool os::find(address addr) { 3687 Dl_info dlinfo; 3688 memset(&dlinfo, 0, sizeof(dlinfo)); 3689 if (dladdr(addr, &dlinfo)) { 3690 tty->print(PTR_FORMAT ": ", addr); 3691 if (dlinfo.dli_sname != NULL) { 3692 tty->print("%s+%#x", dlinfo.dli_sname, 3693 addr - (intptr_t)dlinfo.dli_saddr); 3694 } else if (dlinfo.dli_fname) { 3695 tty->print("<offset %#x>", addr - (intptr_t)dlinfo.dli_fbase); 3696 } else { 3697 tty->print("<absolute address>"); 3698 } 3699 if (dlinfo.dli_fname) { 3700 tty->print(" in %s", dlinfo.dli_fname); 3701 } 3702 if (dlinfo.dli_fbase) { 3703 tty->print(" at " PTR_FORMAT, dlinfo.dli_fbase); 3704 } 3705 tty->cr(); 3706 3707 if (Verbose) { 3708 // decode some bytes around the PC 3709 address begin = same_page(addr-40, addr); 3710 address end = same_page(addr+40, addr); 3711 address lowest = (address) dlinfo.dli_sname; 3712 if (!lowest) lowest = (address) dlinfo.dli_fbase; 3713 if (begin < lowest) begin = lowest; 3714 Dl_info dlinfo2; 3715 if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr 3716 && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) 3717 end = (address) dlinfo2.dli_saddr; 3718 Disassembler::decode(begin, end); 3719 } 3720 return true; 3721 } 3722 return false; 3723} 3724 3725#endif 3726 3727//////////////////////////////////////////////////////////////////////////////// 3728// misc 3729 3730// This does not do anything on Linux. This is basically a hook for being 3731// able to use structured exception handling (thread-local exception filters) 3732// on, e.g., Win32. 3733void 3734os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, 3735 JavaCallArguments* args, Thread* thread) { 3736 f(value, method, args, thread); 3737} 3738 3739void os::print_statistics() { 3740} 3741 3742int os::message_box(const char* title, const char* message) { 3743 int i; 3744 fdStream err(defaultStream::error_fd()); 3745 for (i = 0; i < 78; i++) err.print_raw("="); 3746 err.cr(); 3747 err.print_raw_cr(title); 3748 for (i = 0; i < 78; i++) err.print_raw("-"); 3749 err.cr(); 3750 err.print_raw_cr(message); 3751 for (i = 0; i < 78; i++) err.print_raw("="); 3752 err.cr(); 3753 3754 char buf[16]; 3755 // Prevent process from exiting upon "read error" without consuming all CPU 3756 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); } 3757 3758 return buf[0] == 'y' || buf[0] == 'Y'; 3759} 3760 3761int os::stat(const char *path, struct stat *sbuf) { 3762 char pathbuf[MAX_PATH]; 3763 if (strlen(path) > MAX_PATH - 1) { 3764 errno = ENAMETOOLONG; 3765 return -1; 3766 } 3767 hpi::native_path(strcpy(pathbuf, path)); 3768 return ::stat(pathbuf, sbuf); 3769} 3770 3771bool os::check_heap(bool force) { 3772 return true; 3773} 3774 3775int local_vsnprintf(char* buf, size_t count, const char* format, va_list args) { 3776 return ::vsnprintf(buf, count, format, args); 3777} 3778 3779// Is a (classpath) directory empty? 3780bool os::dir_is_empty(const char* path) { 3781 DIR *dir = NULL; 3782 struct dirent *ptr; 3783 3784 dir = opendir(path); 3785 if (dir == NULL) return true; 3786 3787 /* Scan the directory */ 3788 bool result = true; 3789 char buf[sizeof(struct dirent) + MAX_PATH]; 3790 while (result && (ptr = ::readdir(dir)) != NULL) { 3791 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) { 3792 result = false; 3793 } 3794 } 3795 closedir(dir); 3796 return result; 3797} 3798 3799// create binary file, rewriting existing file if required 3800int os::create_binary_file(const char* path, bool rewrite_existing) { 3801 int oflags = O_WRONLY | O_CREAT; 3802 if (!rewrite_existing) { 3803 oflags |= O_EXCL; 3804 } 3805 return ::open64(path, oflags, S_IREAD | S_IWRITE); 3806} 3807 3808// return current position of file pointer 3809jlong os::current_file_offset(int fd) { 3810 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR); 3811} 3812 3813// move file pointer to the specified offset 3814jlong os::seek_to_file_offset(int fd, jlong offset) { 3815 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); 3816} 3817 3818// Map a block of memory. 3819char* os::map_memory(int fd, const char* file_name, size_t file_offset, 3820 char *addr, size_t bytes, bool read_only, 3821 bool allow_exec) { 3822 int prot; 3823 int flags; 3824 3825 if (read_only) { 3826 prot = PROT_READ; 3827 flags = MAP_SHARED; 3828 } else { 3829 prot = PROT_READ | PROT_WRITE; 3830 flags = MAP_PRIVATE; 3831 } 3832 3833 if (allow_exec) { 3834 prot |= PROT_EXEC; 3835 } 3836 3837 if (addr != NULL) { 3838 flags |= MAP_FIXED; 3839 } 3840 3841 char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags, 3842 fd, file_offset); 3843 if (mapped_address == MAP_FAILED) { 3844 return NULL; 3845 } 3846 return mapped_address; 3847} 3848 3849 3850// Remap a block of memory. 3851char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 3852 char *addr, size_t bytes, bool read_only, 3853 bool allow_exec) { 3854 // same as map_memory() on this OS 3855 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 3856 allow_exec); 3857} 3858 3859 3860// Unmap a block of memory. 3861bool os::unmap_memory(char* addr, size_t bytes) { 3862 return munmap(addr, bytes) == 0; 3863} 3864 3865static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time); 3866 3867static clockid_t thread_cpu_clockid(Thread* thread) { 3868 pthread_t tid = thread->osthread()->pthread_id(); 3869 clockid_t clockid; 3870 3871 // Get thread clockid 3872 int rc = os::Linux::pthread_getcpuclockid(tid, &clockid); 3873 assert(rc == 0, "pthread_getcpuclockid is expected to return 0 code"); 3874 return clockid; 3875} 3876 3877// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 3878// are used by JVM M&M and JVMTI to get user+sys or user CPU time 3879// of a thread. 3880// 3881// current_thread_cpu_time() and thread_cpu_time(Thread*) returns 3882// the fast estimate available on the platform. 3883 3884jlong os::current_thread_cpu_time() { 3885 if (os::Linux::supports_fast_thread_cpu_time()) { 3886 return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID); 3887 } else { 3888 // return user + sys since the cost is the same 3889 return slow_thread_cpu_time(Thread::current(), true /* user + sys */); 3890 } 3891} 3892 3893jlong os::thread_cpu_time(Thread* thread) { 3894 // consistent with what current_thread_cpu_time() returns 3895 if (os::Linux::supports_fast_thread_cpu_time()) { 3896 return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread)); 3897 } else { 3898 return slow_thread_cpu_time(thread, true /* user + sys */); 3899 } 3900} 3901 3902jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 3903 if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) { 3904 return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID); 3905 } else { 3906 return slow_thread_cpu_time(Thread::current(), user_sys_cpu_time); 3907 } 3908} 3909 3910jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { 3911 if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) { 3912 return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread)); 3913 } else { 3914 return slow_thread_cpu_time(thread, user_sys_cpu_time); 3915 } 3916} 3917 3918// 3919// -1 on error. 3920// 3921 3922static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { 3923 static bool proc_pid_cpu_avail = true; 3924 static bool proc_task_unchecked = true; 3925 static const char *proc_stat_path = "/proc/%d/stat"; 3926 pid_t tid = thread->osthread()->thread_id(); 3927 int i; 3928 char *s; 3929 char stat[2048]; 3930 int statlen; 3931 char proc_name[64]; 3932 int count; 3933 long sys_time, user_time; 3934 char string[64]; 3935 int idummy; 3936 long ldummy; 3937 FILE *fp; 3938 3939 // We first try accessing /proc/<pid>/cpu since this is faster to 3940 // process. If this file is not present (linux kernels 2.5 and above) 3941 // then we open /proc/<pid>/stat. 3942 if ( proc_pid_cpu_avail ) { 3943 sprintf(proc_name, "/proc/%d/cpu", tid); 3944 fp = fopen(proc_name, "r"); 3945 if ( fp != NULL ) { 3946 count = fscanf( fp, "%s %lu %lu\n", string, &user_time, &sys_time); 3947 fclose(fp); 3948 if ( count != 3 ) return -1; 3949 3950 if (user_sys_cpu_time) { 3951 return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec); 3952 } else { 3953 return (jlong)user_time * (1000000000 / clock_tics_per_sec); 3954 } 3955 } 3956 else proc_pid_cpu_avail = false; 3957 } 3958 3959 // The /proc/<tid>/stat aggregates per-process usage on 3960 // new Linux kernels 2.6+ where NPTL is supported. 3961 // The /proc/self/task/<tid>/stat still has the per-thread usage. 3962 // See bug 6328462. 3963 // There can be no directory /proc/self/task on kernels 2.4 with NPTL 3964 // and possibly in some other cases, so we check its availability. 3965 if (proc_task_unchecked && os::Linux::is_NPTL()) { 3966 // This is executed only once 3967 proc_task_unchecked = false; 3968 fp = fopen("/proc/self/task", "r"); 3969 if (fp != NULL) { 3970 proc_stat_path = "/proc/self/task/%d/stat"; 3971 fclose(fp); 3972 } 3973 } 3974 3975 sprintf(proc_name, proc_stat_path, tid); 3976 fp = fopen(proc_name, "r"); 3977 if ( fp == NULL ) return -1; 3978 statlen = fread(stat, 1, 2047, fp); 3979 stat[statlen] = '\0'; 3980 fclose(fp); 3981 3982 // Skip pid and the command string. Note that we could be dealing with 3983 // weird command names, e.g. user could decide to rename java launcher 3984 // to "java 1.4.2 :)", then the stat file would look like 3985 // 1234 (java 1.4.2 :)) R ... ... 3986 // We don't really need to know the command string, just find the last 3987 // occurrence of ")" and then start parsing from there. See bug 4726580. 3988 s = strrchr(stat, ')'); 3989 i = 0; 3990 if (s == NULL ) return -1; 3991 3992 // Skip blank chars 3993 do s++; while (isspace(*s)); 3994 3995 count = sscanf(s,"%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu", 3996 &idummy, &idummy, &idummy, &idummy, &idummy, &idummy, 3997 &ldummy, &ldummy, &ldummy, &ldummy, &ldummy, 3998 &user_time, &sys_time); 3999 if ( count != 13 ) return -1; 4000 if (user_sys_cpu_time) { 4001 return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec); 4002 } else { 4003 return (jlong)user_time * (1000000000 / clock_tics_per_sec); 4004 } 4005} 4006 4007void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4008 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 4009 info_ptr->may_skip_backward = false; // elapsed time not wall time 4010 info_ptr->may_skip_forward = false; // elapsed time not wall time 4011 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4012} 4013 4014void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4015 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 4016 info_ptr->may_skip_backward = false; // elapsed time not wall time 4017 info_ptr->may_skip_forward = false; // elapsed time not wall time 4018 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4019} 4020 4021bool os::is_thread_cpu_time_supported() { 4022 return true; 4023} 4024 4025// System loadavg support. Returns -1 if load average cannot be obtained. 4026// Linux doesn't yet have a (official) notion of processor sets, 4027// so just return the system wide load average. 4028int os::loadavg(double loadavg[], int nelem) { 4029 return ::getloadavg(loadavg, nelem); 4030} 4031 4032void os::pause() { 4033 char filename[MAX_PATH]; 4034 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 4035 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 4036 } else { 4037 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 4038 } 4039 4040 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 4041 if (fd != -1) { 4042 struct stat buf; 4043 close(fd); 4044 while (::stat(filename, &buf) == 0) { 4045 (void)::poll(NULL, 0, 100); 4046 } 4047 } else { 4048 jio_fprintf(stderr, 4049 "Could not open pause file '%s', continuing immediately.\n", filename); 4050 } 4051} 4052 4053extern "C" { 4054 4055/** 4056 * NOTE: the following code is to keep the green threads code 4057 * in the libjava.so happy. Once the green threads is removed, 4058 * these code will no longer be needed. 4059 */ 4060int 4061jdk_waitpid(pid_t pid, int* status, int options) { 4062 return waitpid(pid, status, options); 4063} 4064 4065int 4066fork1() { 4067 return fork(); 4068} 4069 4070int 4071jdk_sem_init(sem_t *sem, int pshared, unsigned int value) { 4072 return sem_init(sem, pshared, value); 4073} 4074 4075int 4076jdk_sem_post(sem_t *sem) { 4077 return sem_post(sem); 4078} 4079 4080int 4081jdk_sem_wait(sem_t *sem) { 4082 return sem_wait(sem); 4083} 4084 4085int 4086jdk_pthread_sigmask(int how , const sigset_t* newmask, sigset_t* oldmask) { 4087 return pthread_sigmask(how , newmask, oldmask); 4088} 4089 4090} 4091 4092// Refer to the comments in os_solaris.cpp park-unpark. 4093// 4094// Beware -- Some versions of NPTL embody a flaw where pthread_cond_timedwait() can 4095// hang indefinitely. For instance NPTL 0.60 on 2.4.21-4ELsmp is vulnerable. 4096// For specifics regarding the bug see GLIBC BUGID 261237 : 4097// http://www.mail-archive.com/debian-glibc@lists.debian.org/msg10837.html. 4098// Briefly, pthread_cond_timedwait() calls with an expiry time that's not in the future 4099// will either hang or corrupt the condvar, resulting in subsequent hangs if the condvar 4100// is used. (The simple C test-case provided in the GLIBC bug report manifests the 4101// hang). The JVM is vulernable via sleep(), Object.wait(timo), LockSupport.parkNanos() 4102// and monitorenter when we're using 1-0 locking. All those operations may result in 4103// calls to pthread_cond_timedwait(). Using LD_ASSUME_KERNEL to use an older version 4104// of libpthread avoids the problem, but isn't practical. 4105// 4106// Possible remedies: 4107// 4108// 1. Establish a minimum relative wait time. 50 to 100 msecs seems to work. 4109// This is palliative and probabilistic, however. If the thread is preempted 4110// between the call to compute_abstime() and pthread_cond_timedwait(), more 4111// than the minimum period may have passed, and the abstime may be stale (in the 4112// past) resultin in a hang. Using this technique reduces the odds of a hang 4113// but the JVM is still vulnerable, particularly on heavily loaded systems. 4114// 4115// 2. Modify park-unpark to use per-thread (per ParkEvent) pipe-pairs instead 4116// of the usual flag-condvar-mutex idiom. The write side of the pipe is set 4117// NDELAY. unpark() reduces to write(), park() reduces to read() and park(timo) 4118// reduces to poll()+read(). This works well, but consumes 2 FDs per extant 4119// thread. 4120// 4121// 3. Embargo pthread_cond_timedwait() and implement a native "chron" thread 4122// that manages timeouts. We'd emulate pthread_cond_timedwait() by enqueuing 4123// a timeout request to the chron thread and then blocking via pthread_cond_wait(). 4124// This also works well. In fact it avoids kernel-level scalability impediments 4125// on certain platforms that don't handle lots of active pthread_cond_timedwait() 4126// timers in a graceful fashion. 4127// 4128// 4. When the abstime value is in the past it appears that control returns 4129// correctly from pthread_cond_timedwait(), but the condvar is left corrupt. 4130// Subsequent timedwait/wait calls may hang indefinitely. Given that, we 4131// can avoid the problem by reinitializing the condvar -- by cond_destroy() 4132// followed by cond_init() -- after all calls to pthread_cond_timedwait(). 4133// It may be possible to avoid reinitialization by checking the return 4134// value from pthread_cond_timedwait(). In addition to reinitializing the 4135// condvar we must establish the invariant that cond_signal() is only called 4136// within critical sections protected by the adjunct mutex. This prevents 4137// cond_signal() from "seeing" a condvar that's in the midst of being 4138// reinitialized or that is corrupt. Sadly, this invariant obviates the 4139// desirable signal-after-unlock optimization that avoids futile context switching. 4140// 4141// I'm also concerned that some versions of NTPL might allocate an auxilliary 4142// structure when a condvar is used or initialized. cond_destroy() would 4143// release the helper structure. Our reinitialize-after-timedwait fix 4144// put excessive stress on malloc/free and locks protecting the c-heap. 4145// 4146// We currently use (4). See the WorkAroundNTPLTimedWaitHang flag. 4147// It may be possible to refine (4) by checking the kernel and NTPL verisons 4148// and only enabling the work-around for vulnerable environments. 4149 4150// utility to compute the abstime argument to timedwait: 4151// millis is the relative timeout time 4152// abstime will be the absolute timeout time 4153// TODO: replace compute_abstime() with unpackTime() 4154 4155static struct timespec* compute_abstime(timespec* abstime, jlong millis) { 4156 if (millis < 0) millis = 0; 4157 struct timeval now; 4158 int status = gettimeofday(&now, NULL); 4159 assert(status == 0, "gettimeofday"); 4160 jlong seconds = millis / 1000; 4161 millis %= 1000; 4162 if (seconds > 50000000) { // see man cond_timedwait(3T) 4163 seconds = 50000000; 4164 } 4165 abstime->tv_sec = now.tv_sec + seconds; 4166 long usec = now.tv_usec + millis * 1000; 4167 if (usec >= 1000000) { 4168 abstime->tv_sec += 1; 4169 usec -= 1000000; 4170 } 4171 abstime->tv_nsec = usec * 1000; 4172 return abstime; 4173} 4174 4175 4176// Test-and-clear _Event, always leaves _Event set to 0, returns immediately. 4177// Conceptually TryPark() should be equivalent to park(0). 4178 4179int os::PlatformEvent::TryPark() { 4180 for (;;) { 4181 const int v = _Event ; 4182 guarantee ((v == 0) || (v == 1), "invariant") ; 4183 if (Atomic::cmpxchg (0, &_Event, v) == v) return v ; 4184 } 4185} 4186 4187void os::PlatformEvent::park() { // AKA "down()" 4188 // Invariant: Only the thread associated with the Event/PlatformEvent 4189 // may call park(). 4190 // TODO: assert that _Assoc != NULL or _Assoc == Self 4191 int v ; 4192 for (;;) { 4193 v = _Event ; 4194 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4195 } 4196 guarantee (v >= 0, "invariant") ; 4197 if (v == 0) { 4198 // Do this the hard way by blocking ... 4199 int status = pthread_mutex_lock(_mutex); 4200 assert_status(status == 0, status, "mutex_lock"); 4201 guarantee (_nParked == 0, "invariant") ; 4202 ++ _nParked ; 4203 while (_Event < 0) { 4204 status = pthread_cond_wait(_cond, _mutex); 4205 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ... 4206 // Treat this the same as if the wait was interrupted 4207 if (status == ETIME) { status = EINTR; } 4208 assert_status(status == 0 || status == EINTR, status, "cond_wait"); 4209 } 4210 -- _nParked ; 4211 4212 // In theory we could move the ST of 0 into _Event past the unlock(), 4213 // but then we'd need a MEMBAR after the ST. 4214 _Event = 0 ; 4215 status = pthread_mutex_unlock(_mutex); 4216 assert_status(status == 0, status, "mutex_unlock"); 4217 } 4218 guarantee (_Event >= 0, "invariant") ; 4219} 4220 4221int os::PlatformEvent::park(jlong millis) { 4222 guarantee (_nParked == 0, "invariant") ; 4223 4224 int v ; 4225 for (;;) { 4226 v = _Event ; 4227 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4228 } 4229 guarantee (v >= 0, "invariant") ; 4230 if (v != 0) return OS_OK ; 4231 4232 // We do this the hard way, by blocking the thread. 4233 // Consider enforcing a minimum timeout value. 4234 struct timespec abst; 4235 compute_abstime(&abst, millis); 4236 4237 int ret = OS_TIMEOUT; 4238 int status = pthread_mutex_lock(_mutex); 4239 assert_status(status == 0, status, "mutex_lock"); 4240 guarantee (_nParked == 0, "invariant") ; 4241 ++_nParked ; 4242 4243 // Object.wait(timo) will return because of 4244 // (a) notification 4245 // (b) timeout 4246 // (c) thread.interrupt 4247 // 4248 // Thread.interrupt and object.notify{All} both call Event::set. 4249 // That is, we treat thread.interrupt as a special case of notification. 4250 // The underlying Solaris implementation, cond_timedwait, admits 4251 // spurious/premature wakeups, but the JLS/JVM spec prevents the 4252 // JVM from making those visible to Java code. As such, we must 4253 // filter out spurious wakeups. We assume all ETIME returns are valid. 4254 // 4255 // TODO: properly differentiate simultaneous notify+interrupt. 4256 // In that case, we should propagate the notify to another waiter. 4257 4258 while (_Event < 0) { 4259 status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst); 4260 if (status != 0 && WorkAroundNPTLTimedWaitHang) { 4261 pthread_cond_destroy (_cond); 4262 pthread_cond_init (_cond, NULL) ; 4263 } 4264 assert_status(status == 0 || status == EINTR || 4265 status == ETIME || status == ETIMEDOUT, 4266 status, "cond_timedwait"); 4267 if (!FilterSpuriousWakeups) break ; // previous semantics 4268 if (status == ETIME || status == ETIMEDOUT) break ; 4269 // We consume and ignore EINTR and spurious wakeups. 4270 } 4271 --_nParked ; 4272 if (_Event >= 0) { 4273 ret = OS_OK; 4274 } 4275 _Event = 0 ; 4276 status = pthread_mutex_unlock(_mutex); 4277 assert_status(status == 0, status, "mutex_unlock"); 4278 assert (_nParked == 0, "invariant") ; 4279 return ret; 4280} 4281 4282void os::PlatformEvent::unpark() { 4283 int v, AnyWaiters ; 4284 for (;;) { 4285 v = _Event ; 4286 if (v > 0) { 4287 // The LD of _Event could have reordered or be satisfied 4288 // by a read-aside from this processor's write buffer. 4289 // To avoid problems execute a barrier and then 4290 // ratify the value. 4291 OrderAccess::fence() ; 4292 if (_Event == v) return ; 4293 continue ; 4294 } 4295 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 4296 } 4297 if (v < 0) { 4298 // Wait for the thread associated with the event to vacate 4299 int status = pthread_mutex_lock(_mutex); 4300 assert_status(status == 0, status, "mutex_lock"); 4301 AnyWaiters = _nParked ; 4302 assert (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ; 4303 if (AnyWaiters != 0 && WorkAroundNPTLTimedWaitHang) { 4304 AnyWaiters = 0 ; 4305 pthread_cond_signal (_cond); 4306 } 4307 status = pthread_mutex_unlock(_mutex); 4308 assert_status(status == 0, status, "mutex_unlock"); 4309 if (AnyWaiters != 0) { 4310 status = pthread_cond_signal(_cond); 4311 assert_status(status == 0, status, "cond_signal"); 4312 } 4313 } 4314 4315 // Note that we signal() _after dropping the lock for "immortal" Events. 4316 // This is safe and avoids a common class of futile wakeups. In rare 4317 // circumstances this can cause a thread to return prematurely from 4318 // cond_{timed}wait() but the spurious wakeup is benign and the victim will 4319 // simply re-test the condition and re-park itself. 4320} 4321 4322 4323// JSR166 4324// ------------------------------------------------------- 4325 4326/* 4327 * The solaris and linux implementations of park/unpark are fairly 4328 * conservative for now, but can be improved. They currently use a 4329 * mutex/condvar pair, plus a a count. 4330 * Park decrements count if > 0, else does a condvar wait. Unpark 4331 * sets count to 1 and signals condvar. Only one thread ever waits 4332 * on the condvar. Contention seen when trying to park implies that someone 4333 * is unparking you, so don't wait. And spurious returns are fine, so there 4334 * is no need to track notifications. 4335 */ 4336 4337 4338#define NANOSECS_PER_SEC 1000000000 4339#define NANOSECS_PER_MILLISEC 1000000 4340#define MAX_SECS 100000000 4341/* 4342 * This code is common to linux and solaris and will be moved to a 4343 * common place in dolphin. 4344 * 4345 * The passed in time value is either a relative time in nanoseconds 4346 * or an absolute time in milliseconds. Either way it has to be unpacked 4347 * into suitable seconds and nanoseconds components and stored in the 4348 * given timespec structure. 4349 * Given time is a 64-bit value and the time_t used in the timespec is only 4350 * a signed-32-bit value (except on 64-bit Linux) we have to watch for 4351 * overflow if times way in the future are given. Further on Solaris versions 4352 * prior to 10 there is a restriction (see cond_timedwait) that the specified 4353 * number of seconds, in abstime, is less than current_time + 100,000,000. 4354 * As it will be 28 years before "now + 100000000" will overflow we can 4355 * ignore overflow and just impose a hard-limit on seconds using the value 4356 * of "now + 100,000,000". This places a limit on the timeout of about 3.17 4357 * years from "now". 4358 */ 4359 4360static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) { 4361 assert (time > 0, "convertTime"); 4362 4363 struct timeval now; 4364 int status = gettimeofday(&now, NULL); 4365 assert(status == 0, "gettimeofday"); 4366 4367 time_t max_secs = now.tv_sec + MAX_SECS; 4368 4369 if (isAbsolute) { 4370 jlong secs = time / 1000; 4371 if (secs > max_secs) { 4372 absTime->tv_sec = max_secs; 4373 } 4374 else { 4375 absTime->tv_sec = secs; 4376 } 4377 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC; 4378 } 4379 else { 4380 jlong secs = time / NANOSECS_PER_SEC; 4381 if (secs >= MAX_SECS) { 4382 absTime->tv_sec = max_secs; 4383 absTime->tv_nsec = 0; 4384 } 4385 else { 4386 absTime->tv_sec = now.tv_sec + secs; 4387 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000; 4388 if (absTime->tv_nsec >= NANOSECS_PER_SEC) { 4389 absTime->tv_nsec -= NANOSECS_PER_SEC; 4390 ++absTime->tv_sec; // note: this must be <= max_secs 4391 } 4392 } 4393 } 4394 assert(absTime->tv_sec >= 0, "tv_sec < 0"); 4395 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs"); 4396 assert(absTime->tv_nsec >= 0, "tv_nsec < 0"); 4397 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec"); 4398} 4399 4400void Parker::park(bool isAbsolute, jlong time) { 4401 // Optional fast-path check: 4402 // Return immediately if a permit is available. 4403 if (_counter > 0) { 4404 _counter = 0 ; 4405 return ; 4406 } 4407 4408 Thread* thread = Thread::current(); 4409 assert(thread->is_Java_thread(), "Must be JavaThread"); 4410 JavaThread *jt = (JavaThread *)thread; 4411 4412 // Optional optimization -- avoid state transitions if there's an interrupt pending. 4413 // Check interrupt before trying to wait 4414 if (Thread::is_interrupted(thread, false)) { 4415 return; 4416 } 4417 4418 // Next, demultiplex/decode time arguments 4419 timespec absTime; 4420 if (time < 0) { // don't wait at all 4421 return; 4422 } 4423 if (time > 0) { 4424 unpackTime(&absTime, isAbsolute, time); 4425 } 4426 4427 4428 // Enter safepoint region 4429 // Beware of deadlocks such as 6317397. 4430 // The per-thread Parker:: mutex is a classic leaf-lock. 4431 // In particular a thread must never block on the Threads_lock while 4432 // holding the Parker:: mutex. If safepoints are pending both the 4433 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock. 4434 ThreadBlockInVM tbivm(jt); 4435 4436 // Don't wait if cannot get lock since interference arises from 4437 // unblocking. Also. check interrupt before trying wait 4438 if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) { 4439 return; 4440 } 4441 4442 int status ; 4443 if (_counter > 0) { // no wait needed 4444 _counter = 0; 4445 status = pthread_mutex_unlock(_mutex); 4446 assert (status == 0, "invariant") ; 4447 return; 4448 } 4449 4450#ifdef ASSERT 4451 // Don't catch signals while blocked; let the running threads have the signals. 4452 // (This allows a debugger to break into the running thread.) 4453 sigset_t oldsigs; 4454 sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals(); 4455 pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs); 4456#endif 4457 4458 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 4459 jt->set_suspend_equivalent(); 4460 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 4461 4462 if (time == 0) { 4463 status = pthread_cond_wait (_cond, _mutex) ; 4464 } else { 4465 status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ; 4466 if (status != 0 && WorkAroundNPTLTimedWaitHang) { 4467 pthread_cond_destroy (_cond) ; 4468 pthread_cond_init (_cond, NULL); 4469 } 4470 } 4471 assert_status(status == 0 || status == EINTR || 4472 status == ETIME || status == ETIMEDOUT, 4473 status, "cond_timedwait"); 4474 4475#ifdef ASSERT 4476 pthread_sigmask(SIG_SETMASK, &oldsigs, NULL); 4477#endif 4478 4479 _counter = 0 ; 4480 status = pthread_mutex_unlock(_mutex) ; 4481 assert_status(status == 0, status, "invariant") ; 4482 // If externally suspended while waiting, re-suspend 4483 if (jt->handle_special_suspend_equivalent_condition()) { 4484 jt->java_suspend_self(); 4485 } 4486 4487} 4488 4489void Parker::unpark() { 4490 int s, status ; 4491 status = pthread_mutex_lock(_mutex); 4492 assert (status == 0, "invariant") ; 4493 s = _counter; 4494 _counter = 1; 4495 if (s < 1) { 4496 if (WorkAroundNPTLTimedWaitHang) { 4497 status = pthread_cond_signal (_cond) ; 4498 assert (status == 0, "invariant") ; 4499 status = pthread_mutex_unlock(_mutex); 4500 assert (status == 0, "invariant") ; 4501 } else { 4502 status = pthread_mutex_unlock(_mutex); 4503 assert (status == 0, "invariant") ; 4504 status = pthread_cond_signal (_cond) ; 4505 assert (status == 0, "invariant") ; 4506 } 4507 } else { 4508 pthread_mutex_unlock(_mutex); 4509 assert (status == 0, "invariant") ; 4510 } 4511} 4512 4513 4514extern char** environ; 4515 4516#ifndef __NR_fork 4517#define __NR_fork IA32_ONLY(2) IA64_ONLY(not defined) AMD64_ONLY(57) 4518#endif 4519 4520#ifndef __NR_execve 4521#define __NR_execve IA32_ONLY(11) IA64_ONLY(1033) AMD64_ONLY(59) 4522#endif 4523 4524// Run the specified command in a separate process. Return its exit value, 4525// or -1 on failure (e.g. can't fork a new process). 4526// Unlike system(), this function can be called from signal handler. It 4527// doesn't block SIGINT et al. 4528int os::fork_and_exec(char* cmd) { 4529 char * argv[4]; 4530 argv[0] = "sh"; 4531 argv[1] = "-c"; 4532 argv[2] = cmd; 4533 argv[3] = NULL; 4534 4535 // fork() in LinuxThreads/NPTL is not async-safe. It needs to run 4536 // pthread_atfork handlers and reset pthread library. All we need is a 4537 // separate process to execve. Make a direct syscall to fork process. 4538 // On IA64 there's no fork syscall, we have to use fork() and hope for 4539 // the best... 4540 pid_t pid = NOT_IA64(syscall(__NR_fork);) 4541 IA64_ONLY(fork();) 4542 4543 if (pid < 0) { 4544 // fork failed 4545 return -1; 4546 4547 } else if (pid == 0) { 4548 // child process 4549 4550 // execve() in LinuxThreads will call pthread_kill_other_threads_np() 4551 // first to kill every thread on the thread list. Because this list is 4552 // not reset by fork() (see notes above), execve() will instead kill 4553 // every thread in the parent process. We know this is the only thread 4554 // in the new process, so make a system call directly. 4555 // IA64 should use normal execve() from glibc to match the glibc fork() 4556 // above. 4557 NOT_IA64(syscall(__NR_execve, "/bin/sh", argv, environ);) 4558 IA64_ONLY(execve("/bin/sh", argv, environ);) 4559 4560 // execve failed 4561 _exit(-1); 4562 4563 } else { 4564 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't 4565 // care about the actual exit code, for now. 4566 4567 int status; 4568 4569 // Wait for the child process to exit. This returns immediately if 4570 // the child has already exited. */ 4571 while (waitpid(pid, &status, 0) < 0) { 4572 switch (errno) { 4573 case ECHILD: return 0; 4574 case EINTR: break; 4575 default: return -1; 4576 } 4577 } 4578 4579 if (WIFEXITED(status)) { 4580 // The child exited normally; get its exit code. 4581 return WEXITSTATUS(status); 4582 } else if (WIFSIGNALED(status)) { 4583 // The child exited because of a signal 4584 // The best value to return is 0x80 + signal number, 4585 // because that is what all Unix shells do, and because 4586 // it allows callers to distinguish between process exit and 4587 // process death by signal. 4588 return 0x80 + WTERMSIG(status); 4589 } else { 4590 // Unknown exit code; pass it through 4591 return status; 4592 } 4593 } 4594} 4595