annotate src/os/bsd/vm/os_bsd.cpp @ 5982:124fc080dc67

7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM Summary: Ergonomics now also takes available virtual memory into account when deciding for a heap size. The helper method to determine the maximum allocatable memory block now uses the appropriate OS specific calls to retrieve available virtual memory for the java process. In 32 bit environments this method now also searches for the maximum actually reservable amount of memory. Merge previously separate implementations for Linux/BSD/Solaris into a single method. Reviewed-by: jmasa, tamao
author tschatzl
date Tue, 18 Apr 2017 04:54:54 +0100
parents ccb68f77d07a
children b86041bd7b99
rev   line source
never@3009 1 /*
hseigel@5260 2 * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
never@3009 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
never@3009 4 *
never@3009 5 * This code is free software; you can redistribute it and/or modify it
never@3009 6 * under the terms of the GNU General Public License version 2 only, as
never@3009 7 * published by the Free Software Foundation.
never@3009 8 *
never@3009 9 * This code is distributed in the hope that it will be useful, but WITHOUT
never@3009 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
never@3009 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
never@3009 12 * version 2 for more details (a copy is included in the LICENSE file that
never@3009 13 * accompanied this code).
never@3009 14 *
never@3009 15 * You should have received a copy of the GNU General Public License version
never@3009 16 * 2 along with this work; if not, write to the Free Software Foundation,
never@3009 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
never@3009 18 *
never@3009 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
never@3009 20 * or visit www.oracle.com if you need additional information or have any
never@3009 21 * questions.
never@3009 22 *
never@3009 23 */
never@3009 24
never@3009 25 // no precompiled headers
never@3009 26 #include "classfile/classLoader.hpp"
never@3009 27 #include "classfile/systemDictionary.hpp"
never@3009 28 #include "classfile/vmSymbols.hpp"
never@3009 29 #include "code/icBuffer.hpp"
never@3009 30 #include "code/vtableStubs.hpp"
never@3009 31 #include "compiler/compileBroker.hpp"
never@3009 32 #include "interpreter/interpreter.hpp"
never@3009 33 #include "jvm_bsd.h"
never@3009 34 #include "memory/allocation.inline.hpp"
never@3009 35 #include "memory/filemap.hpp"
never@3009 36 #include "mutex_bsd.inline.hpp"
never@3009 37 #include "oops/oop.inline.hpp"
never@3009 38 #include "os_share_bsd.hpp"
never@3009 39 #include "prims/jniFastGetField.hpp"
never@3009 40 #include "prims/jvm.h"
never@3009 41 #include "prims/jvm_misc.hpp"
never@3009 42 #include "runtime/arguments.hpp"
never@3009 43 #include "runtime/extendedPC.hpp"
never@3009 44 #include "runtime/globals.hpp"
never@3009 45 #include "runtime/interfaceSupport.hpp"
never@3009 46 #include "runtime/java.hpp"
never@3009 47 #include "runtime/javaCalls.hpp"
never@3009 48 #include "runtime/mutexLocker.hpp"
never@3009 49 #include "runtime/objectMonitor.hpp"
never@3009 50 #include "runtime/osThread.hpp"
never@3009 51 #include "runtime/perfMemory.hpp"
never@3009 52 #include "runtime/sharedRuntime.hpp"
never@3009 53 #include "runtime/statSampler.hpp"
never@3009 54 #include "runtime/stubRoutines.hpp"
never@3009 55 #include "runtime/threadCritical.hpp"
never@3009 56 #include "runtime/timer.hpp"
never@3009 57 #include "services/attachListener.hpp"
zgu@4529 58 #include "services/memTracker.hpp"
never@3009 59 #include "services/runtimeService.hpp"
never@3009 60 #include "thread_bsd.inline.hpp"
never@3009 61 #include "utilities/decoder.hpp"
never@3009 62 #include "utilities/defaultStream.hpp"
never@3009 63 #include "utilities/events.hpp"
never@3009 64 #include "utilities/growableArray.hpp"
never@3009 65 #include "utilities/vmError.hpp"
never@3009 66 #ifdef TARGET_ARCH_x86
never@3009 67 # include "assembler_x86.inline.hpp"
never@3009 68 # include "nativeInst_x86.hpp"
never@3009 69 #endif
never@3009 70 #ifdef TARGET_ARCH_sparc
never@3009 71 # include "assembler_sparc.inline.hpp"
never@3009 72 # include "nativeInst_sparc.hpp"
never@3009 73 #endif
never@3009 74 #ifdef TARGET_ARCH_zero
never@3009 75 # include "assembler_zero.inline.hpp"
never@3009 76 # include "nativeInst_zero.hpp"
never@3009 77 #endif
never@3009 78 #ifdef TARGET_ARCH_arm
never@3009 79 # include "assembler_arm.inline.hpp"
never@3009 80 # include "nativeInst_arm.hpp"
never@3009 81 #endif
never@3009 82 #ifdef TARGET_ARCH_ppc
never@3009 83 # include "assembler_ppc.inline.hpp"
never@3009 84 # include "nativeInst_ppc.hpp"
never@3009 85 #endif
never@3009 86
never@3009 87 // put OS-includes here
never@3009 88 # include <sys/types.h>
never@3009 89 # include <sys/mman.h>
never@3009 90 # include <sys/stat.h>
never@3009 91 # include <sys/select.h>
never@3009 92 # include <pthread.h>
never@3009 93 # include <signal.h>
never@3009 94 # include <errno.h>
never@3009 95 # include <dlfcn.h>
never@3009 96 # include <stdio.h>
never@3009 97 # include <unistd.h>
never@3009 98 # include <sys/resource.h>
never@3009 99 # include <pthread.h>
never@3009 100 # include <sys/stat.h>
never@3009 101 # include <sys/time.h>
never@3009 102 # include <sys/times.h>
never@3009 103 # include <sys/utsname.h>
never@3009 104 # include <sys/socket.h>
never@3009 105 # include <sys/wait.h>
never@3009 106 # include <time.h>
never@3009 107 # include <pwd.h>
never@3009 108 # include <poll.h>
never@3009 109 # include <semaphore.h>
never@3009 110 # include <fcntl.h>
never@3009 111 # include <string.h>
never@3009 112 #ifdef _ALLBSD_SOURCE
never@3009 113 # include <sys/param.h>
never@3009 114 # include <sys/sysctl.h>
never@3009 115 #else
never@3009 116 # include <syscall.h>
never@3009 117 # include <sys/sysinfo.h>
never@3009 118 # include <gnu/libc-version.h>
never@3009 119 #endif
never@3009 120 # include <sys/ipc.h>
never@3009 121 # include <sys/shm.h>
never@3009 122 #ifndef __APPLE__
never@3009 123 # include <link.h>
never@3009 124 #endif
never@3009 125 # include <stdint.h>
never@3009 126 # include <inttypes.h>
never@3009 127 # include <sys/ioctl.h>
never@3009 128
never@3009 129 #if defined(__FreeBSD__) || defined(__NetBSD__)
never@3009 130 # include <elf.h>
never@3009 131 #endif
never@3009 132
never@3009 133 #ifdef __APPLE__
dcubed@3055 134 # include <mach/mach.h> // semaphore_* API
dcubed@3055 135 # include <mach-o/dyld.h>
dcubed@3055 136 # include <sys/proc_info.h>
dcubed@3055 137 # include <objc/objc-auto.h>
never@3009 138 #endif
never@3009 139
never@3009 140 #ifndef MAP_ANONYMOUS
never@3009 141 #define MAP_ANONYMOUS MAP_ANON
never@3009 142 #endif
never@3009 143
never@3009 144 #define MAX_PATH (2 * K)
never@3009 145
never@3009 146 // for timer info max values which include all bits
never@3009 147 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
never@3009 148
never@3009 149 #define LARGEPAGES_BIT (1 << 6)
never@3009 150 ////////////////////////////////////////////////////////////////////////////////
never@3009 151 // global variables
never@3009 152 julong os::Bsd::_physical_memory = 0;
never@3009 153
never@3009 154 #ifndef _ALLBSD_SOURCE
never@3009 155 address os::Bsd::_initial_thread_stack_bottom = NULL;
never@3009 156 uintptr_t os::Bsd::_initial_thread_stack_size = 0;
never@3009 157 #endif
never@3009 158
never@3009 159 int (*os::Bsd::_clock_gettime)(clockid_t, struct timespec *) = NULL;
never@3009 160 #ifndef _ALLBSD_SOURCE
never@3009 161 int (*os::Bsd::_pthread_getcpuclockid)(pthread_t, clockid_t *) = NULL;
never@3009 162 Mutex* os::Bsd::_createThread_lock = NULL;
never@3009 163 #endif
never@3009 164 pthread_t os::Bsd::_main_thread;
never@3009 165 int os::Bsd::_page_size = -1;
never@3009 166 #ifndef _ALLBSD_SOURCE
never@3009 167 bool os::Bsd::_is_floating_stack = false;
never@3009 168 bool os::Bsd::_is_NPTL = false;
never@3009 169 bool os::Bsd::_supports_fast_thread_cpu_time = false;
never@3009 170 const char * os::Bsd::_glibc_version = NULL;
never@3009 171 const char * os::Bsd::_libpthread_version = NULL;
never@3009 172 #endif
never@3009 173
never@3009 174 static jlong initial_time_count=0;
never@3009 175
never@3009 176 static int clock_tics_per_sec = 100;
never@3009 177
never@3009 178 // For diagnostics to print a message once. see run_periodic_checks
never@3009 179 static sigset_t check_signal_done;
never@3009 180 static bool check_signals = true;;
never@3009 181
never@3009 182 static pid_t _initial_pid = 0;
never@3009 183
never@3009 184 /* Signal number used to suspend/resume a thread */
never@3009 185
never@3009 186 /* do not use any signal number less than SIGSEGV, see 4355769 */
never@3009 187 static int SR_signum = SIGUSR2;
never@3009 188 sigset_t SR_sigset;
never@3009 189
never@3009 190
never@3009 191 ////////////////////////////////////////////////////////////////////////////////
never@3009 192 // utility functions
never@3009 193
never@3009 194 static int SR_initialize();
never@3009 195 static int SR_finalize();
never@3009 196
never@3009 197 julong os::available_memory() {
never@3009 198 return Bsd::available_memory();
never@3009 199 }
never@3009 200
never@3009 201 julong os::Bsd::available_memory() {
never@3009 202 #ifdef _ALLBSD_SOURCE
never@3009 203 // XXXBSD: this is just a stopgap implementation
never@3009 204 return physical_memory() >> 2;
never@3009 205 #else
never@3009 206 // values in struct sysinfo are "unsigned long"
never@3009 207 struct sysinfo si;
never@3009 208 sysinfo(&si);
never@3009 209
never@3009 210 return (julong)si.freeram * si.mem_unit;
never@3009 211 #endif
never@3009 212 }
never@3009 213
never@3009 214 julong os::physical_memory() {
never@3009 215 return Bsd::physical_memory();
never@3009 216 }
never@3009 217
never@3009 218 ////////////////////////////////////////////////////////////////////////////////
never@3009 219 // environment support
never@3009 220
never@3009 221 bool os::getenv(const char* name, char* buf, int len) {
never@3009 222 const char* val = ::getenv(name);
never@3009 223 if (val != NULL && strlen(val) < (size_t)len) {
never@3009 224 strcpy(buf, val);
never@3009 225 return true;
never@3009 226 }
never@3009 227 if (len > 0) buf[0] = 0; // return a null string
never@3009 228 return false;
never@3009 229 }
never@3009 230
never@3009 231
never@3009 232 // Return true if user is running as root.
never@3009 233
never@3009 234 bool os::have_special_privileges() {
never@3009 235 static bool init = false;
never@3009 236 static bool privileges = false;
never@3009 237 if (!init) {
never@3009 238 privileges = (getuid() != geteuid()) || (getgid() != getegid());
never@3009 239 init = true;
never@3009 240 }
never@3009 241 return privileges;
never@3009 242 }
never@3009 243
never@3009 244
never@3009 245 #ifndef _ALLBSD_SOURCE
never@3009 246 #ifndef SYS_gettid
never@3009 247 // i386: 224, ia64: 1105, amd64: 186, sparc 143
never@3009 248 #ifdef __ia64__
never@3009 249 #define SYS_gettid 1105
never@3009 250 #elif __i386__
never@3009 251 #define SYS_gettid 224
never@3009 252 #elif __amd64__
never@3009 253 #define SYS_gettid 186
never@3009 254 #elif __sparc__
never@3009 255 #define SYS_gettid 143
never@3009 256 #else
never@3009 257 #error define gettid for the arch
never@3009 258 #endif
never@3009 259 #endif
never@3009 260 #endif
never@3009 261
never@3009 262 // Cpu architecture string
never@3009 263 #if defined(ZERO)
never@3009 264 static char cpu_arch[] = ZERO_LIBARCH;
never@3009 265 #elif defined(IA64)
never@3009 266 static char cpu_arch[] = "ia64";
never@3009 267 #elif defined(IA32)
never@3009 268 static char cpu_arch[] = "i386";
never@3009 269 #elif defined(AMD64)
never@3009 270 static char cpu_arch[] = "amd64";
never@3009 271 #elif defined(ARM)
never@3009 272 static char cpu_arch[] = "arm";
goetz@5936 273 #elif defined(PPC32)
never@3009 274 static char cpu_arch[] = "ppc";
never@3009 275 #elif defined(SPARC)
never@3009 276 # ifdef _LP64
never@3009 277 static char cpu_arch[] = "sparcv9";
never@3009 278 # else
never@3009 279 static char cpu_arch[] = "sparc";
never@3009 280 # endif
never@3009 281 #else
never@3009 282 #error Add appropriate cpu_arch setting
never@3009 283 #endif
never@3009 284
phh@3342 285 // Compiler variant
phh@3342 286 #ifdef COMPILER2
phh@3342 287 #define COMPILER_VARIANT "server"
phh@3342 288 #else
phh@3342 289 #define COMPILER_VARIANT "client"
phh@3342 290 #endif
never@3009 291
never@3009 292 #ifndef _ALLBSD_SOURCE
never@3009 293 // pid_t gettid()
never@3009 294 //
never@3009 295 // Returns the kernel thread id of the currently running thread. Kernel
never@3009 296 // thread id is used to access /proc.
never@3009 297 //
never@3009 298 // (Note that getpid() on BsdThreads returns kernel thread id too; but
never@3009 299 // on NPTL, it returns the same pid for all threads, as required by POSIX.)
never@3009 300 //
never@3009 301 pid_t os::Bsd::gettid() {
never@3009 302 int rslt = syscall(SYS_gettid);
never@3009 303 if (rslt == -1) {
never@3009 304 // old kernel, no NPTL support
never@3009 305 return getpid();
never@3009 306 } else {
never@3009 307 return (pid_t)rslt;
never@3009 308 }
never@3009 309 }
never@3009 310
never@3009 311 // Most versions of bsd have a bug where the number of processors are
never@3009 312 // determined by looking at the /proc file system. In a chroot environment,
never@3009 313 // the system call returns 1. This causes the VM to act as if it is
never@3009 314 // a single processor and elide locking (see is_MP() call).
never@3009 315 static bool unsafe_chroot_detected = false;
never@3009 316 static const char *unstable_chroot_error = "/proc file system not found.\n"
never@3009 317 "Java may be unstable running multithreaded in a chroot "
never@3009 318 "environment on Bsd when /proc filesystem is not mounted.";
never@3009 319 #endif
never@3009 320
never@3009 321 #ifdef _ALLBSD_SOURCE
never@3009 322 void os::Bsd::initialize_system_info() {
never@3009 323 int mib[2];
never@3009 324 size_t len;
never@3009 325 int cpu_val;
brutisso@4413 326 julong mem_val;
never@3009 327
never@3009 328 /* get processors count via hw.ncpus sysctl */
never@3009 329 mib[0] = CTL_HW;
never@3009 330 mib[1] = HW_NCPU;
never@3009 331 len = sizeof(cpu_val);
never@3009 332 if (sysctl(mib, 2, &cpu_val, &len, NULL, 0) != -1 && cpu_val >= 1) {
brutisso@4413 333 assert(len == sizeof(cpu_val), "unexpected data size");
never@3009 334 set_processor_count(cpu_val);
never@3009 335 }
never@3009 336 else {
never@3009 337 set_processor_count(1); // fallback
never@3009 338 }
never@3009 339
brutisso@4413 340 /* get physical memory via hw.memsize sysctl (hw.memsize is used
brutisso@4413 341 * since it returns a 64 bit value)
never@3009 342 */
never@3009 343 mib[0] = CTL_HW;
brutisso@4413 344 mib[1] = HW_MEMSIZE;
never@3009 345 len = sizeof(mem_val);
brutisso@4413 346 if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {
brutisso@4413 347 assert(len == sizeof(mem_val), "unexpected data size");
never@3009 348 _physical_memory = mem_val;
brutisso@4413 349 } else {
never@3009 350 _physical_memory = 256*1024*1024; // fallback (XXXBSD?)
brutisso@4413 351 }
never@3009 352
never@3009 353 #ifdef __OpenBSD__
never@3009 354 {
never@3009 355 // limit _physical_memory memory view on OpenBSD since
never@3009 356 // datasize rlimit restricts us anyway.
never@3009 357 struct rlimit limits;
never@3009 358 getrlimit(RLIMIT_DATA, &limits);
never@3009 359 _physical_memory = MIN2(_physical_memory, (julong)limits.rlim_cur);
never@3009 360 }
never@3009 361 #endif
never@3009 362 }
never@3009 363 #else
never@3009 364 void os::Bsd::initialize_system_info() {
never@3009 365 set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
never@3009 366 if (processor_count() == 1) {
never@3009 367 pid_t pid = os::Bsd::gettid();
never@3009 368 char fname[32];
never@3009 369 jio_snprintf(fname, sizeof(fname), "/proc/%d", pid);
never@3009 370 FILE *fp = fopen(fname, "r");
never@3009 371 if (fp == NULL) {
never@3009 372 unsafe_chroot_detected = true;
never@3009 373 } else {
never@3009 374 fclose(fp);
never@3009 375 }
never@3009 376 }
never@3009 377 _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
never@3009 378 assert(processor_count() > 0, "bsd error");
never@3009 379 }
never@3009 380 #endif
never@3009 381
dcubed@3055 382 #ifdef __APPLE__
dcubed@3055 383 static const char *get_home() {
dcubed@3055 384 const char *home_dir = ::getenv("HOME");
dcubed@3055 385 if ((home_dir == NULL) || (*home_dir == '\0')) {
dcubed@3055 386 struct passwd *passwd_info = getpwuid(geteuid());
dcubed@3055 387 if (passwd_info != NULL) {
dcubed@3055 388 home_dir = passwd_info->pw_dir;
dcubed@3055 389 }
dcubed@3055 390 }
dcubed@3055 391
dcubed@3055 392 return home_dir;
dcubed@3055 393 }
dcubed@3055 394 #endif
dcubed@3055 395
never@3009 396 void os::init_system_properties_values() {
never@3009 397 // char arch[12];
never@3009 398 // sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));
never@3009 399
never@3009 400 // The next steps are taken in the product version:
never@3009 401 //
never@3009 402 // Obtain the JAVA_HOME value from the location of libjvm[_g].so.
never@3009 403 // This library should be located at:
never@3009 404 // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so.
never@3009 405 //
never@3009 406 // If "/jre/lib/" appears at the right place in the path, then we
never@3009 407 // assume libjvm[_g].so is installed in a JDK and we use this path.
never@3009 408 //
never@3009 409 // Otherwise exit with message: "Could not create the Java virtual machine."
never@3009 410 //
never@3009 411 // The following extra steps are taken in the debugging version:
never@3009 412 //
never@3009 413 // If "/jre/lib/" does NOT appear at the right place in the path
never@3009 414 // instead of exit check for $JAVA_HOME environment variable.
never@3009 415 //
never@3009 416 // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,
never@3009 417 // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so
never@3009 418 // it looks like libjvm[_g].so is installed there
never@3009 419 // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.
never@3009 420 //
never@3009 421 // Otherwise exit.
never@3009 422 //
never@3009 423 // Important note: if the location of libjvm.so changes this
never@3009 424 // code needs to be changed accordingly.
never@3009 425
never@3009 426 // The next few definitions allow the code to be verbatim:
zgu@4135 427 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal)
never@3009 428 #define getenv(n) ::getenv(n)
never@3009 429
never@3009 430 /*
never@3009 431 * See ld(1):
never@3009 432 * The linker uses the following search paths to locate required
never@3009 433 * shared libraries:
never@3009 434 * 1: ...
never@3009 435 * ...
never@3009 436 * 7: The default directories, normally /lib and /usr/lib.
never@3009 437 */
never@3009 438 #ifndef DEFAULT_LIBPATH
never@3009 439 #define DEFAULT_LIBPATH "/lib:/usr/lib"
never@3009 440 #endif
never@3009 441
never@3009 442 #define EXTENSIONS_DIR "/lib/ext"
never@3009 443 #define ENDORSED_DIR "/lib/endorsed"
never@3009 444 #define REG_DIR "/usr/java/packages"
never@3009 445
dcubed@3055 446 #ifdef __APPLE__
dcubed@3055 447 #define SYS_EXTENSIONS_DIR "/Library/Java/Extensions"
dcubed@3055 448 #define SYS_EXTENSIONS_DIRS SYS_EXTENSIONS_DIR ":/Network" SYS_EXTENSIONS_DIR ":/System" SYS_EXTENSIONS_DIR ":/usr/lib/java"
dcubed@3055 449 const char *user_home_dir = get_home();
dcubed@3055 450 // the null in SYS_EXTENSIONS_DIRS counts for the size of the colon after user_home_dir
dcubed@3055 451 int system_ext_size = strlen(user_home_dir) + sizeof(SYS_EXTENSIONS_DIR) +
dcubed@3055 452 sizeof(SYS_EXTENSIONS_DIRS);
dcubed@3055 453 #endif
dcubed@3055 454
never@3009 455 {
never@3009 456 /* sysclasspath, java_home, dll_dir */
never@3009 457 {
never@3009 458 char *home_path;
never@3009 459 char *dll_path;
never@3009 460 char *pslash;
never@3009 461 char buf[MAXPATHLEN];
never@3009 462 os::jvm_path(buf, sizeof(buf));
never@3009 463
never@3009 464 // Found the full path to libjvm.so.
never@3009 465 // Now cut the path to <java_home>/jre if we can.
never@3009 466 *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */
never@3009 467 pslash = strrchr(buf, '/');
never@3009 468 if (pslash != NULL)
never@3009 469 *pslash = '\0'; /* get rid of /{client|server|hotspot} */
never@3009 470 dll_path = malloc(strlen(buf) + 1);
never@3009 471 if (dll_path == NULL)
never@3009 472 return;
never@3009 473 strcpy(dll_path, buf);
never@3009 474 Arguments::set_dll_dir(dll_path);
never@3009 475
never@3009 476 if (pslash != NULL) {
never@3009 477 pslash = strrchr(buf, '/');
never@3009 478 if (pslash != NULL) {
dcubed@3055 479 *pslash = '\0'; /* get rid of /<arch> (/lib on macosx) */
dcubed@3055 480 #ifndef __APPLE__
never@3009 481 pslash = strrchr(buf, '/');
never@3009 482 if (pslash != NULL)
never@3009 483 *pslash = '\0'; /* get rid of /lib */
dcubed@3055 484 #endif
never@3009 485 }
never@3009 486 }
never@3009 487
never@3009 488 home_path = malloc(strlen(buf) + 1);
never@3009 489 if (home_path == NULL)
never@3009 490 return;
never@3009 491 strcpy(home_path, buf);
never@3009 492 Arguments::set_java_home(home_path);
never@3009 493
never@3009 494 if (!set_boot_path('/', ':'))
never@3009 495 return;
never@3009 496 }
never@3009 497
never@3009 498 /*
never@3009 499 * Where to look for native libraries
never@3009 500 *
never@3009 501 * Note: Due to a legacy implementation, most of the library path
never@3009 502 * is set in the launcher. This was to accomodate linking restrictions
never@3009 503 * on legacy Bsd implementations (which are no longer supported).
never@3009 504 * Eventually, all the library path setting will be done here.
never@3009 505 *
never@3009 506 * However, to prevent the proliferation of improperly built native
never@3009 507 * libraries, the new path component /usr/java/packages is added here.
never@3009 508 * Eventually, all the library path setting will be done here.
never@3009 509 */
never@3009 510 {
never@3009 511 char *ld_library_path;
never@3009 512
never@3009 513 /*
never@3009 514 * Construct the invariant part of ld_library_path. Note that the
never@3009 515 * space for the colon and the trailing null are provided by the
never@3009 516 * nulls included by the sizeof operator (so actually we allocate
never@3009 517 * a byte more than necessary).
never@3009 518 */
dcubed@3055 519 #ifdef __APPLE__
dcubed@3055 520 ld_library_path = (char *) malloc(system_ext_size);
dcubed@3055 521 sprintf(ld_library_path, "%s" SYS_EXTENSIONS_DIR ":" SYS_EXTENSIONS_DIRS, user_home_dir);
dcubed@3055 522 #else
never@3009 523 ld_library_path = (char *) malloc(sizeof(REG_DIR) + sizeof("/lib/") +
never@3009 524 strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH));
never@3009 525 sprintf(ld_library_path, REG_DIR "/lib/%s:" DEFAULT_LIBPATH, cpu_arch);
dcubed@3055 526 #endif
never@3009 527
never@3009 528 /*
never@3009 529 * Get the user setting of LD_LIBRARY_PATH, and prepended it. It
never@3009 530 * should always exist (until the legacy problem cited above is
never@3009 531 * addressed).
never@3009 532 */
never@3009 533 #ifdef __APPLE__
dcubed@3055 534 // Prepend the default path with the JAVA_LIBRARY_PATH so that the app launcher code can specify a directory inside an app wrapper
dcubed@3055 535 char *l = getenv("JAVA_LIBRARY_PATH");
dcubed@3055 536 if (l != NULL) {
dcubed@3055 537 char *t = ld_library_path;
dcubed@3055 538 /* That's +1 for the colon and +1 for the trailing '\0' */
dcubed@3055 539 ld_library_path = (char *) malloc(strlen(l) + 1 + strlen(t) + 1);
dcubed@3055 540 sprintf(ld_library_path, "%s:%s", l, t);
dcubed@3055 541 free(t);
dcubed@3055 542 }
dcubed@3055 543
never@3009 544 char *v = getenv("DYLD_LIBRARY_PATH");
never@3009 545 #else
never@3009 546 char *v = getenv("LD_LIBRARY_PATH");
never@3009 547 #endif
never@3009 548 if (v != NULL) {
never@3009 549 char *t = ld_library_path;
never@3009 550 /* That's +1 for the colon and +1 for the trailing '\0' */
never@3009 551 ld_library_path = (char *) malloc(strlen(v) + 1 + strlen(t) + 1);
never@3009 552 sprintf(ld_library_path, "%s:%s", v, t);
dcubed@3055 553 free(t);
never@3009 554 }
dcubed@3506 555
dcubed@3506 556 #ifdef __APPLE__
dcubed@3506 557 // Apple's Java6 has "." at the beginning of java.library.path.
dcubed@3506 558 // OpenJDK on Windows has "." at the end of java.library.path.
dcubed@3506 559 // OpenJDK on Linux and Solaris don't have "." in java.library.path
dcubed@3506 560 // at all. To ease the transition from Apple's Java6 to OpenJDK7,
dcubed@3506 561 // "." is appended to the end of java.library.path. Yes, this
dcubed@3506 562 // could cause a change in behavior, but Apple's Java6 behavior
dcubed@3506 563 // can be achieved by putting "." at the beginning of the
dcubed@3506 564 // JAVA_LIBRARY_PATH environment variable.
dcubed@3506 565 {
dcubed@3506 566 char *t = ld_library_path;
dcubed@3506 567 // that's +3 for appending ":." and the trailing '\0'
dcubed@3506 568 ld_library_path = (char *) malloc(strlen(t) + 3);
dcubed@3506 569 sprintf(ld_library_path, "%s:%s", t, ".");
dcubed@3506 570 free(t);
dcubed@3506 571 }
dcubed@3506 572 #endif
dcubed@3506 573
never@3009 574 Arguments::set_library_path(ld_library_path);
never@3009 575 }
never@3009 576
never@3009 577 /*
never@3009 578 * Extensions directories.
never@3009 579 *
never@3009 580 * Note that the space for the colon and the trailing null are provided
never@3009 581 * by the nulls included by the sizeof operator (so actually one byte more
never@3009 582 * than necessary is allocated).
never@3009 583 */
never@3009 584 {
dcubed@3055 585 #ifdef __APPLE__
dcubed@3055 586 char *buf = malloc(strlen(Arguments::get_java_home()) +
dcubed@3055 587 sizeof(EXTENSIONS_DIR) + system_ext_size);
dcubed@3055 588 sprintf(buf, "%s" SYS_EXTENSIONS_DIR ":%s" EXTENSIONS_DIR ":"
dcubed@3055 589 SYS_EXTENSIONS_DIRS, user_home_dir, Arguments::get_java_home());
dcubed@3055 590 #else
never@3009 591 char *buf = malloc(strlen(Arguments::get_java_home()) +
never@3009 592 sizeof(EXTENSIONS_DIR) + sizeof(REG_DIR) + sizeof(EXTENSIONS_DIR));
never@3009 593 sprintf(buf, "%s" EXTENSIONS_DIR ":" REG_DIR EXTENSIONS_DIR,
never@3009 594 Arguments::get_java_home());
dcubed@3055 595 #endif
dcubed@3055 596
never@3009 597 Arguments::set_ext_dirs(buf);
never@3009 598 }
never@3009 599
never@3009 600 /* Endorsed standards default directory. */
never@3009 601 {
never@3009 602 char * buf;
never@3009 603 buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));
never@3009 604 sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());
never@3009 605 Arguments::set_endorsed_dirs(buf);
never@3009 606 }
never@3009 607 }
never@3009 608
dcubed@3055 609 #ifdef __APPLE__
dcubed@3055 610 #undef SYS_EXTENSIONS_DIR
dcubed@3055 611 #endif
never@3009 612 #undef malloc
never@3009 613 #undef getenv
never@3009 614 #undef EXTENSIONS_DIR
never@3009 615 #undef ENDORSED_DIR
never@3009 616
never@3009 617 // Done
never@3009 618 return;
never@3009 619 }
never@3009 620
never@3009 621 ////////////////////////////////////////////////////////////////////////////////
never@3009 622 // breakpoint support
never@3009 623
never@3009 624 void os::breakpoint() {
never@3009 625 BREAKPOINT;
never@3009 626 }
never@3009 627
never@3009 628 extern "C" void breakpoint() {
never@3009 629 // use debugger to set breakpoint here
never@3009 630 }
never@3009 631
never@3009 632 ////////////////////////////////////////////////////////////////////////////////
never@3009 633 // signal support
never@3009 634
never@3009 635 debug_only(static bool signal_sets_initialized = false);
never@3009 636 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
never@3009 637
never@3009 638 bool os::Bsd::is_sig_ignored(int sig) {
never@3009 639 struct sigaction oact;
never@3009 640 sigaction(sig, (struct sigaction*)NULL, &oact);
never@3009 641 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
never@3009 642 : CAST_FROM_FN_PTR(void*, oact.sa_handler);
never@3009 643 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
never@3009 644 return true;
never@3009 645 else
never@3009 646 return false;
never@3009 647 }
never@3009 648
never@3009 649 void os::Bsd::signal_sets_init() {
never@3009 650 // Should also have an assertion stating we are still single-threaded.
never@3009 651 assert(!signal_sets_initialized, "Already initialized");
never@3009 652 // Fill in signals that are necessarily unblocked for all threads in
never@3009 653 // the VM. Currently, we unblock the following signals:
never@3009 654 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
never@3009 655 // by -Xrs (=ReduceSignalUsage));
never@3009 656 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
never@3009 657 // other threads. The "ReduceSignalUsage" boolean tells us not to alter
never@3009 658 // the dispositions or masks wrt these signals.
never@3009 659 // Programs embedding the VM that want to use the above signals for their
never@3009 660 // own purposes must, at this time, use the "-Xrs" option to prevent
never@3009 661 // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
never@3009 662 // (See bug 4345157, and other related bugs).
never@3009 663 // In reality, though, unblocking these signals is really a nop, since
never@3009 664 // these signals are not blocked by default.
never@3009 665 sigemptyset(&unblocked_sigs);
never@3009 666 sigemptyset(&allowdebug_blocked_sigs);
never@3009 667 sigaddset(&unblocked_sigs, SIGILL);
never@3009 668 sigaddset(&unblocked_sigs, SIGSEGV);
never@3009 669 sigaddset(&unblocked_sigs, SIGBUS);
never@3009 670 sigaddset(&unblocked_sigs, SIGFPE);
never@3009 671 sigaddset(&unblocked_sigs, SR_signum);
never@3009 672
never@3009 673 if (!ReduceSignalUsage) {
never@3009 674 if (!os::Bsd::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
never@3009 675 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
never@3009 676 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
never@3009 677 }
never@3009 678 if (!os::Bsd::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
never@3009 679 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
never@3009 680 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
never@3009 681 }
never@3009 682 if (!os::Bsd::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
never@3009 683 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
never@3009 684 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
never@3009 685 }
never@3009 686 }
never@3009 687 // Fill in signals that are blocked by all but the VM thread.
never@3009 688 sigemptyset(&vm_sigs);
never@3009 689 if (!ReduceSignalUsage)
never@3009 690 sigaddset(&vm_sigs, BREAK_SIGNAL);
never@3009 691 debug_only(signal_sets_initialized = true);
never@3009 692
never@3009 693 }
never@3009 694
never@3009 695 // These are signals that are unblocked while a thread is running Java.
never@3009 696 // (For some reason, they get blocked by default.)
never@3009 697 sigset_t* os::Bsd::unblocked_signals() {
never@3009 698 assert(signal_sets_initialized, "Not initialized");
never@3009 699 return &unblocked_sigs;
never@3009 700 }
never@3009 701
never@3009 702 // These are the signals that are blocked while a (non-VM) thread is
never@3009 703 // running Java. Only the VM thread handles these signals.
never@3009 704 sigset_t* os::Bsd::vm_signals() {
never@3009 705 assert(signal_sets_initialized, "Not initialized");
never@3009 706 return &vm_sigs;
never@3009 707 }
never@3009 708
never@3009 709 // These are signals that are blocked during cond_wait to allow debugger in
never@3009 710 sigset_t* os::Bsd::allowdebug_blocked_signals() {
never@3009 711 assert(signal_sets_initialized, "Not initialized");
never@3009 712 return &allowdebug_blocked_sigs;
never@3009 713 }
never@3009 714
never@3009 715 void os::Bsd::hotspot_sigmask(Thread* thread) {
never@3009 716
never@3009 717 //Save caller's signal mask before setting VM signal mask
never@3009 718 sigset_t caller_sigmask;
never@3009 719 pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);
never@3009 720
never@3009 721 OSThread* osthread = thread->osthread();
never@3009 722 osthread->set_caller_sigmask(caller_sigmask);
never@3009 723
never@3009 724 pthread_sigmask(SIG_UNBLOCK, os::Bsd::unblocked_signals(), NULL);
never@3009 725
never@3009 726 if (!ReduceSignalUsage) {
never@3009 727 if (thread->is_VM_thread()) {
never@3009 728 // Only the VM thread handles BREAK_SIGNAL ...
never@3009 729 pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);
never@3009 730 } else {
never@3009 731 // ... all other threads block BREAK_SIGNAL
never@3009 732 pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);
never@3009 733 }
never@3009 734 }
never@3009 735 }
never@3009 736
never@3009 737 #ifndef _ALLBSD_SOURCE
never@3009 738 //////////////////////////////////////////////////////////////////////////////
never@3009 739 // detecting pthread library
never@3009 740
never@3009 741 void os::Bsd::libpthread_init() {
never@3009 742 // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION
never@3009 743 // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a
never@3009 744 // generic name for earlier versions.
never@3009 745 // Define macros here so we can build HotSpot on old systems.
never@3009 746 # ifndef _CS_GNU_LIBC_VERSION
never@3009 747 # define _CS_GNU_LIBC_VERSION 2
never@3009 748 # endif
never@3009 749 # ifndef _CS_GNU_LIBPTHREAD_VERSION
never@3009 750 # define _CS_GNU_LIBPTHREAD_VERSION 3
never@3009 751 # endif
never@3009 752
never@3009 753 size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);
never@3009 754 if (n > 0) {
never@3009 755 char *str = (char *)malloc(n);
never@3009 756 confstr(_CS_GNU_LIBC_VERSION, str, n);
never@3009 757 os::Bsd::set_glibc_version(str);
never@3009 758 } else {
never@3009 759 // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
never@3009 760 static char _gnu_libc_version[32];
never@3009 761 jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),
never@3009 762 "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());
never@3009 763 os::Bsd::set_glibc_version(_gnu_libc_version);
never@3009 764 }
never@3009 765
never@3009 766 n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
never@3009 767 if (n > 0) {
never@3009 768 char *str = (char *)malloc(n);
never@3009 769 confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);
never@3009 770 // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells
never@3009 771 // us "NPTL-0.29" even we are running with BsdThreads. Check if this
never@3009 772 // is the case. BsdThreads has a hard limit on max number of threads.
never@3009 773 // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
never@3009 774 // On the other hand, NPTL does not have such a limit, sysconf()
never@3009 775 // will return -1 and errno is not changed. Check if it is really NPTL.
never@3009 776 if (strcmp(os::Bsd::glibc_version(), "glibc 2.3.2") == 0 &&
never@3009 777 strstr(str, "NPTL") &&
never@3009 778 sysconf(_SC_THREAD_THREADS_MAX) > 0) {
never@3009 779 free(str);
never@3009 780 os::Bsd::set_libpthread_version("bsdthreads");
never@3009 781 } else {
never@3009 782 os::Bsd::set_libpthread_version(str);
never@3009 783 }
never@3009 784 } else {
never@3009 785 // glibc before 2.3.2 only has BsdThreads.
never@3009 786 os::Bsd::set_libpthread_version("bsdthreads");
never@3009 787 }
never@3009 788
never@3009 789 if (strstr(libpthread_version(), "NPTL")) {
never@3009 790 os::Bsd::set_is_NPTL();
never@3009 791 } else {
never@3009 792 os::Bsd::set_is_BsdThreads();
never@3009 793 }
never@3009 794
never@3009 795 // BsdThreads have two flavors: floating-stack mode, which allows variable
never@3009 796 // stack size; and fixed-stack mode. NPTL is always floating-stack.
never@3009 797 if (os::Bsd::is_NPTL() || os::Bsd::supports_variable_stack_size()) {
never@3009 798 os::Bsd::set_is_floating_stack();
never@3009 799 }
never@3009 800 }
never@3009 801
never@3009 802 /////////////////////////////////////////////////////////////////////////////
never@3009 803 // thread stack
never@3009 804
never@3009 805 // Force Bsd kernel to expand current thread stack. If "bottom" is close
never@3009 806 // to the stack guard, caller should block all signals.
never@3009 807 //
never@3009 808 // MAP_GROWSDOWN:
never@3009 809 // A special mmap() flag that is used to implement thread stacks. It tells
never@3009 810 // kernel that the memory region should extend downwards when needed. This
never@3009 811 // allows early versions of BsdThreads to only mmap the first few pages
never@3009 812 // when creating a new thread. Bsd kernel will automatically expand thread
never@3009 813 // stack as needed (on page faults).
never@3009 814 //
never@3009 815 // However, because the memory region of a MAP_GROWSDOWN stack can grow on
never@3009 816 // demand, if a page fault happens outside an already mapped MAP_GROWSDOWN
never@3009 817 // region, it's hard to tell if the fault is due to a legitimate stack
never@3009 818 // access or because of reading/writing non-exist memory (e.g. buffer
never@3009 819 // overrun). As a rule, if the fault happens below current stack pointer,
never@3009 820 // Bsd kernel does not expand stack, instead a SIGSEGV is sent to the
never@3009 821 // application (see Bsd kernel fault.c).
never@3009 822 //
never@3009 823 // This Bsd feature can cause SIGSEGV when VM bangs thread stack for
never@3009 824 // stack overflow detection.
never@3009 825 //
never@3009 826 // Newer version of BsdThreads (since glibc-2.2, or, RH-7.x) and NPTL do
never@3009 827 // not use this flag. However, the stack of initial thread is not created
never@3009 828 // by pthread, it is still MAP_GROWSDOWN. Also it's possible (though
never@3009 829 // unlikely) that user code can create a thread with MAP_GROWSDOWN stack
never@3009 830 // and then attach the thread to JVM.
never@3009 831 //
never@3009 832 // To get around the problem and allow stack banging on Bsd, we need to
never@3009 833 // manually expand thread stack after receiving the SIGSEGV.
never@3009 834 //
never@3009 835 // There are two ways to expand thread stack to address "bottom", we used
never@3009 836 // both of them in JVM before 1.5:
never@3009 837 // 1. adjust stack pointer first so that it is below "bottom", and then
never@3009 838 // touch "bottom"
never@3009 839 // 2. mmap() the page in question
never@3009 840 //
never@3009 841 // Now alternate signal stack is gone, it's harder to use 2. For instance,
never@3009 842 // if current sp is already near the lower end of page 101, and we need to
never@3009 843 // call mmap() to map page 100, it is possible that part of the mmap() frame
never@3009 844 // will be placed in page 100. When page 100 is mapped, it is zero-filled.
never@3009 845 // That will destroy the mmap() frame and cause VM to crash.
never@3009 846 //
never@3009 847 // The following code works by adjusting sp first, then accessing the "bottom"
never@3009 848 // page to force a page fault. Bsd kernel will then automatically expand the
never@3009 849 // stack mapping.
never@3009 850 //
never@3009 851 // _expand_stack_to() assumes its frame size is less than page size, which
never@3009 852 // should always be true if the function is not inlined.
never@3009 853
never@3009 854 #if __GNUC__ < 3 // gcc 2.x does not support noinline attribute
never@3009 855 #define NOINLINE
never@3009 856 #else
never@3009 857 #define NOINLINE __attribute__ ((noinline))
never@3009 858 #endif
never@3009 859
never@3009 860 static void _expand_stack_to(address bottom) NOINLINE;
never@3009 861
never@3009 862 static void _expand_stack_to(address bottom) {
never@3009 863 address sp;
never@3009 864 size_t size;
never@3009 865 volatile char *p;
never@3009 866
never@3009 867 // Adjust bottom to point to the largest address within the same page, it
never@3009 868 // gives us a one-page buffer if alloca() allocates slightly more memory.
never@3009 869 bottom = (address)align_size_down((uintptr_t)bottom, os::Bsd::page_size());
never@3009 870 bottom += os::Bsd::page_size() - 1;
never@3009 871
never@3009 872 // sp might be slightly above current stack pointer; if that's the case, we
never@3009 873 // will alloca() a little more space than necessary, which is OK. Don't use
never@3009 874 // os::current_stack_pointer(), as its result can be slightly below current
never@3009 875 // stack pointer, causing us to not alloca enough to reach "bottom".
never@3009 876 sp = (address)&sp;
never@3009 877
never@3009 878 if (sp > bottom) {
never@3009 879 size = sp - bottom;
never@3009 880 p = (volatile char *)alloca(size);
never@3009 881 assert(p != NULL && p <= (volatile char *)bottom, "alloca problem?");
never@3009 882 p[0] = '\0';
never@3009 883 }
never@3009 884 }
never@3009 885
never@3009 886 bool os::Bsd::manually_expand_stack(JavaThread * t, address addr) {
never@3009 887 assert(t!=NULL, "just checking");
never@3009 888 assert(t->osthread()->expanding_stack(), "expand should be set");
never@3009 889 assert(t->stack_base() != NULL, "stack_base was not initialized");
never@3009 890
never@3009 891 if (addr < t->stack_base() && addr >= t->stack_yellow_zone_base()) {
never@3009 892 sigset_t mask_all, old_sigset;
never@3009 893 sigfillset(&mask_all);
never@3009 894 pthread_sigmask(SIG_SETMASK, &mask_all, &old_sigset);
never@3009 895 _expand_stack_to(addr);
never@3009 896 pthread_sigmask(SIG_SETMASK, &old_sigset, NULL);
never@3009 897 return true;
never@3009 898 }
never@3009 899 return false;
never@3009 900 }
never@3009 901 #endif
never@3009 902
never@3009 903 //////////////////////////////////////////////////////////////////////////////
never@3009 904 // create new thread
never@3009 905
never@3009 906 static address highest_vm_reserved_address();
never@3009 907
never@3009 908 // check if it's safe to start a new thread
never@3009 909 static bool _thread_safety_check(Thread* thread) {
never@3009 910 #ifdef _ALLBSD_SOURCE
never@3009 911 return true;
never@3009 912 #else
never@3009 913 if (os::Bsd::is_BsdThreads() && !os::Bsd::is_floating_stack()) {
never@3009 914 // Fixed stack BsdThreads (SuSE Bsd/x86, and some versions of Redhat)
never@3009 915 // Heap is mmap'ed at lower end of memory space. Thread stacks are
never@3009 916 // allocated (MAP_FIXED) from high address space. Every thread stack
never@3009 917 // occupies a fixed size slot (usually 2Mbytes, but user can change
never@3009 918 // it to other values if they rebuild BsdThreads).
never@3009 919 //
never@3009 920 // Problem with MAP_FIXED is that mmap() can still succeed even part of
never@3009 921 // the memory region has already been mmap'ed. That means if we have too
never@3009 922 // many threads and/or very large heap, eventually thread stack will
never@3009 923 // collide with heap.
never@3009 924 //
never@3009 925 // Here we try to prevent heap/stack collision by comparing current
never@3009 926 // stack bottom with the highest address that has been mmap'ed by JVM
never@3009 927 // plus a safety margin for memory maps created by native code.
never@3009 928 //
never@3009 929 // This feature can be disabled by setting ThreadSafetyMargin to 0
never@3009 930 //
never@3009 931 if (ThreadSafetyMargin > 0) {
never@3009 932 address stack_bottom = os::current_stack_base() - os::current_stack_size();
never@3009 933
never@3009 934 // not safe if our stack extends below the safety margin
never@3009 935 return stack_bottom - ThreadSafetyMargin >= highest_vm_reserved_address();
never@3009 936 } else {
never@3009 937 return true;
never@3009 938 }
never@3009 939 } else {
never@3009 940 // Floating stack BsdThreads or NPTL:
never@3009 941 // Unlike fixed stack BsdThreads, thread stacks are not MAP_FIXED. When
never@3009 942 // there's not enough space left, pthread_create() will fail. If we come
never@3009 943 // here, that means enough space has been reserved for stack.
never@3009 944 return true;
never@3009 945 }
never@3009 946 #endif
never@3009 947 }
never@3009 948
dcubed@3055 949 #ifdef __APPLE__
dcubed@3055 950 // library handle for calling objc_registerThreadWithCollector()
dcubed@3055 951 // without static linking to the libobjc library
dcubed@3055 952 #define OBJC_LIB "/usr/lib/libobjc.dylib"
dcubed@3055 953 #define OBJC_GCREGISTER "objc_registerThreadWithCollector"
dcubed@3055 954 typedef void (*objc_registerThreadWithCollector_t)();
dcubed@3055 955 extern "C" objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction;
dcubed@3055 956 objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction = NULL;
dcubed@3055 957 #endif
dcubed@3055 958
sla@4611 959 #ifdef __APPLE__
sla@4962 960 static uint64_t locate_unique_thread_id(mach_port_t mach_thread_port) {
sla@4611 961 // Additional thread_id used to correlate threads in SA
sla@4611 962 thread_identifier_info_data_t m_ident_info;
sla@4611 963 mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
sla@4611 964
sla@4962 965 thread_info(mach_thread_port, THREAD_IDENTIFIER_INFO,
sla@4611 966 (thread_info_t) &m_ident_info, &count);
sla@4962 967
sla@4611 968 return m_ident_info.thread_id;
sla@4611 969 }
sla@4611 970 #endif
sla@4611 971
never@3009 972 // Thread start routine for all newly created threads
never@3009 973 static void *java_start(Thread *thread) {
never@3009 974 // Try to randomize the cache line index of hot stack frames.
never@3009 975 // This helps when threads of the same stack traces evict each other's
never@3009 976 // cache lines. The threads can be either from the same JVM instance, or
never@3009 977 // from different JVM instances. The benefit is especially true for
never@3009 978 // processors with hyperthreading technology.
never@3009 979 static int counter = 0;
never@3009 980 int pid = os::current_process_id();
never@3009 981 alloca(((pid ^ counter++) & 7) * 128);
never@3009 982
never@3009 983 ThreadLocalStorage::set_thread(thread);
never@3009 984
never@3009 985 OSThread* osthread = thread->osthread();
never@3009 986 Monitor* sync = osthread->startThread_lock();
never@3009 987
never@3009 988 // non floating stack BsdThreads needs extra check, see above
never@3009 989 if (!_thread_safety_check(thread)) {
never@3009 990 // notify parent thread
never@3009 991 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);
never@3009 992 osthread->set_state(ZOMBIE);
never@3009 993 sync->notify_all();
never@3009 994 return NULL;
never@3009 995 }
never@3009 996
never@3009 997 #ifdef _ALLBSD_SOURCE
sla@3544 998 #ifdef __APPLE__
sla@4962 999 // thread_id is mach thread on macos, which pthreads graciously caches and provides for us
sla@4962 1000 mach_port_t thread_id = ::pthread_mach_thread_np(::pthread_self());
sla@4962 1001 guarantee(thread_id != 0, "thread id missing from pthreads");
sla@4962 1002 osthread->set_thread_id(thread_id);
sla@4962 1003
sla@4962 1004 uint64_t unique_thread_id = locate_unique_thread_id(thread_id);
sla@4962 1005 guarantee(unique_thread_id != 0, "unique thread id was not found");
sla@4962 1006 osthread->set_unique_thread_id(unique_thread_id);
sla@3544 1007 #else
never@3009 1008 // thread_id is pthread_id on BSD
never@3009 1009 osthread->set_thread_id(::pthread_self());
sla@3544 1010 #endif
never@3009 1011 #else
never@3009 1012 // thread_id is kernel thread id (similar to Solaris LWP id)
never@3009 1013 osthread->set_thread_id(os::Bsd::gettid());
never@3009 1014
never@3009 1015 if (UseNUMA) {
never@3009 1016 int lgrp_id = os::numa_get_group_id();
never@3009 1017 if (lgrp_id != -1) {
never@3009 1018 thread->set_lgrp_id(lgrp_id);
never@3009 1019 }
never@3009 1020 }
never@3009 1021 #endif
never@3009 1022 // initialize signal mask for this thread
never@3009 1023 os::Bsd::hotspot_sigmask(thread);
never@3009 1024
never@3009 1025 // initialize floating point control register
never@3009 1026 os::Bsd::init_thread_fpu_state();
never@3009 1027
dcubed@3055 1028 #ifdef __APPLE__
dcubed@3055 1029 // register thread with objc gc
dcubed@3055 1030 if (objc_registerThreadWithCollectorFunction != NULL) {
dcubed@3055 1031 objc_registerThreadWithCollectorFunction();
dcubed@3055 1032 }
dcubed@3055 1033 #endif
dcubed@3055 1034
never@3009 1035 // handshaking with parent thread
never@3009 1036 {
never@3009 1037 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);
never@3009 1038
never@3009 1039 // notify parent thread
never@3009 1040 osthread->set_state(INITIALIZED);
never@3009 1041 sync->notify_all();
never@3009 1042
never@3009 1043 // wait until os::start_thread()
never@3009 1044 while (osthread->get_state() == INITIALIZED) {
never@3009 1045 sync->wait(Mutex::_no_safepoint_check_flag);
never@3009 1046 }
never@3009 1047 }
never@3009 1048
never@3009 1049 // call one more level start routine
never@3009 1050 thread->run();
never@3009 1051
never@3009 1052 return 0;
never@3009 1053 }
never@3009 1054
never@3009 1055 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
never@3009 1056 assert(thread->osthread() == NULL, "caller responsible");
never@3009 1057
never@3009 1058 // Allocate the OSThread object
never@3009 1059 OSThread* osthread = new OSThread(NULL, NULL);
never@3009 1060 if (osthread == NULL) {
never@3009 1061 return false;
never@3009 1062 }
never@3009 1063
never@3009 1064 // set the correct thread state
never@3009 1065 osthread->set_thread_type(thr_type);
never@3009 1066
never@3009 1067 // Initial state is ALLOCATED but not INITIALIZED
never@3009 1068 osthread->set_state(ALLOCATED);
never@3009 1069
never@3009 1070 thread->set_osthread(osthread);
never@3009 1071
never@3009 1072 // init thread attributes
never@3009 1073 pthread_attr_t attr;
never@3009 1074 pthread_attr_init(&attr);
never@3009 1075 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
never@3009 1076
never@3009 1077 // stack size
never@3009 1078 if (os::Bsd::supports_variable_stack_size()) {
never@3009 1079 // calculate stack size if it's not specified by caller
never@3009 1080 if (stack_size == 0) {
never@3009 1081 stack_size = os::Bsd::default_stack_size(thr_type);
never@3009 1082
never@3009 1083 switch (thr_type) {
never@3009 1084 case os::java_thread:
never@3009 1085 // Java threads use ThreadStackSize which default value can be
never@3009 1086 // changed with the flag -Xss
never@3009 1087 assert (JavaThread::stack_size_at_create() > 0, "this should be set");
never@3009 1088 stack_size = JavaThread::stack_size_at_create();
never@3009 1089 break;
never@3009 1090 case os::compiler_thread:
never@3009 1091 if (CompilerThreadStackSize > 0) {
never@3009 1092 stack_size = (size_t)(CompilerThreadStackSize * K);
never@3009 1093 break;
never@3009 1094 } // else fall through:
never@3009 1095 // use VMThreadStackSize if CompilerThreadStackSize is not defined
never@3009 1096 case os::vm_thread:
never@3009 1097 case os::pgc_thread:
never@3009 1098 case os::cgc_thread:
never@3009 1099 case os::watcher_thread:
never@3009 1100 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
never@3009 1101 break;
never@3009 1102 }
never@3009 1103 }
never@3009 1104
never@3009 1105 stack_size = MAX2(stack_size, os::Bsd::min_stack_allowed);
never@3009 1106 pthread_attr_setstacksize(&attr, stack_size);
never@3009 1107 } else {
never@3009 1108 // let pthread_create() pick the default value.
never@3009 1109 }
never@3009 1110
never@3009 1111 #ifndef _ALLBSD_SOURCE
never@3009 1112 // glibc guard page
never@3009 1113 pthread_attr_setguardsize(&attr, os::Bsd::default_guard_size(thr_type));
never@3009 1114 #endif
never@3009 1115
never@3009 1116 ThreadState state;
never@3009 1117
never@3009 1118 {
never@3009 1119
never@3009 1120 #ifndef _ALLBSD_SOURCE
never@3009 1121 // Serialize thread creation if we are running with fixed stack BsdThreads
never@3009 1122 bool lock = os::Bsd::is_BsdThreads() && !os::Bsd::is_floating_stack();
never@3009 1123 if (lock) {
never@3009 1124 os::Bsd::createThread_lock()->lock_without_safepoint_check();
never@3009 1125 }
never@3009 1126 #endif
never@3009 1127
never@3009 1128 pthread_t tid;
never@3009 1129 int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
never@3009 1130
never@3009 1131 pthread_attr_destroy(&attr);
never@3009 1132
never@3009 1133 if (ret != 0) {
never@3009 1134 if (PrintMiscellaneous && (Verbose || WizardMode)) {
never@3009 1135 perror("pthread_create()");
never@3009 1136 }
never@3009 1137 // Need to clean up stuff we've allocated so far
never@3009 1138 thread->set_osthread(NULL);
never@3009 1139 delete osthread;
never@3009 1140 #ifndef _ALLBSD_SOURCE
never@3009 1141 if (lock) os::Bsd::createThread_lock()->unlock();
never@3009 1142 #endif
never@3009 1143 return false;
never@3009 1144 }
never@3009 1145
never@3009 1146 // Store pthread info into the OSThread
never@3009 1147 osthread->set_pthread_id(tid);
never@3009 1148
never@3009 1149 // Wait until child thread is either initialized or aborted
never@3009 1150 {
never@3009 1151 Monitor* sync_with_child = osthread->startThread_lock();
never@3009 1152 MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
never@3009 1153 while ((state = osthread->get_state()) == ALLOCATED) {
never@3009 1154 sync_with_child->wait(Mutex::_no_safepoint_check_flag);
never@3009 1155 }
never@3009 1156 }
never@3009 1157
never@3009 1158 #ifndef _ALLBSD_SOURCE
never@3009 1159 if (lock) {
never@3009 1160 os::Bsd::createThread_lock()->unlock();
never@3009 1161 }
never@3009 1162 #endif
never@3009 1163 }
never@3009 1164
never@3009 1165 // Aborted due to thread limit being reached
never@3009 1166 if (state == ZOMBIE) {
never@3009 1167 thread->set_osthread(NULL);
never@3009 1168 delete osthread;
never@3009 1169 return false;
never@3009 1170 }
never@3009 1171
never@3009 1172 // The thread is returned suspended (in state INITIALIZED),
never@3009 1173 // and is started higher up in the call chain
never@3009 1174 assert(state == INITIALIZED, "race condition");
never@3009 1175 return true;
never@3009 1176 }
never@3009 1177
never@3009 1178 /////////////////////////////////////////////////////////////////////////////
never@3009 1179 // attach existing thread
never@3009 1180
never@3009 1181 // bootstrap the main thread
never@3009 1182 bool os::create_main_thread(JavaThread* thread) {
never@3009 1183 assert(os::Bsd::_main_thread == pthread_self(), "should be called inside main thread");
never@3009 1184 return create_attached_thread(thread);
never@3009 1185 }
never@3009 1186
never@3009 1187 bool os::create_attached_thread(JavaThread* thread) {
never@3009 1188 #ifdef ASSERT
never@3009 1189 thread->verify_not_published();
never@3009 1190 #endif
never@3009 1191
never@3009 1192 // Allocate the OSThread object
never@3009 1193 OSThread* osthread = new OSThread(NULL, NULL);
never@3009 1194
never@3009 1195 if (osthread == NULL) {
never@3009 1196 return false;
never@3009 1197 }
never@3009 1198
never@3009 1199 // Store pthread info into the OSThread
never@3009 1200 #ifdef _ALLBSD_SOURCE
sla@3544 1201 #ifdef __APPLE__
sla@4962 1202 // thread_id is mach thread on macos, which pthreads graciously caches and provides for us
sla@4962 1203 mach_port_t thread_id = ::pthread_mach_thread_np(::pthread_self());
sla@4962 1204 guarantee(thread_id != 0, "just checking");
sla@4962 1205 osthread->set_thread_id(thread_id);
sla@4962 1206
sla@4962 1207 uint64_t unique_thread_id = locate_unique_thread_id(thread_id);
sla@4962 1208 guarantee(unique_thread_id != 0, "just checking");
sla@4962 1209 osthread->set_unique_thread_id(unique_thread_id);
sla@3544 1210 #else
never@3009 1211 osthread->set_thread_id(::pthread_self());
sla@3544 1212 #endif
never@3009 1213 #else
never@3009 1214 osthread->set_thread_id(os::Bsd::gettid());
never@3009 1215 #endif
never@3009 1216 osthread->set_pthread_id(::pthread_self());
never@3009 1217
never@3009 1218 // initialize floating point control register
never@3009 1219 os::Bsd::init_thread_fpu_state();
never@3009 1220
never@3009 1221 // Initial thread state is RUNNABLE
never@3009 1222 osthread->set_state(RUNNABLE);
never@3009 1223
never@3009 1224 thread->set_osthread(osthread);
never@3009 1225
never@3009 1226 #ifndef _ALLBSD_SOURCE
never@3009 1227 if (UseNUMA) {
never@3009 1228 int lgrp_id = os::numa_get_group_id();
never@3009 1229 if (lgrp_id != -1) {
never@3009 1230 thread->set_lgrp_id(lgrp_id);
never@3009 1231 }
never@3009 1232 }
never@3009 1233
never@3009 1234 if (os::Bsd::is_initial_thread()) {
never@3009 1235 // If current thread is initial thread, its stack is mapped on demand,
never@3009 1236 // see notes about MAP_GROWSDOWN. Here we try to force kernel to map
never@3009 1237 // the entire stack region to avoid SEGV in stack banging.
never@3009 1238 // It is also useful to get around the heap-stack-gap problem on SuSE
never@3009 1239 // kernel (see 4821821 for details). We first expand stack to the top
never@3009 1240 // of yellow zone, then enable stack yellow zone (order is significant,
never@3009 1241 // enabling yellow zone first will crash JVM on SuSE Bsd), so there
never@3009 1242 // is no gap between the last two virtual memory regions.
never@3009 1243
never@3009 1244 JavaThread *jt = (JavaThread *)thread;
never@3009 1245 address addr = jt->stack_yellow_zone_base();
never@3009 1246 assert(addr != NULL, "initialization problem?");
never@3009 1247 assert(jt->stack_available(addr) > 0, "stack guard should not be enabled");
never@3009 1248
never@3009 1249 osthread->set_expanding_stack();
never@3009 1250 os::Bsd::manually_expand_stack(jt, addr);
never@3009 1251 osthread->clear_expanding_stack();
never@3009 1252 }
never@3009 1253 #endif
never@3009 1254
never@3009 1255 // initialize signal mask for this thread
never@3009 1256 // and save the caller's signal mask
never@3009 1257 os::Bsd::hotspot_sigmask(thread);
never@3009 1258
never@3009 1259 return true;
never@3009 1260 }
never@3009 1261
never@3009 1262 void os::pd_start_thread(Thread* thread) {
never@3009 1263 OSThread * osthread = thread->osthread();
never@3009 1264 assert(osthread->get_state() != INITIALIZED, "just checking");
never@3009 1265 Monitor* sync_with_child = osthread->startThread_lock();
never@3009 1266 MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
never@3009 1267 sync_with_child->notify();
never@3009 1268 }
never@3009 1269
never@3009 1270 // Free Bsd resources related to the OSThread
never@3009 1271 void os::free_thread(OSThread* osthread) {
never@3009 1272 assert(osthread != NULL, "osthread not set");
never@3009 1273
never@3009 1274 if (Thread::current()->osthread() == osthread) {
never@3009 1275 // Restore caller's signal mask
never@3009 1276 sigset_t sigmask = osthread->caller_sigmask();
never@3009 1277 pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
never@3009 1278 }
never@3009 1279
never@3009 1280 delete osthread;
never@3009 1281 }
never@3009 1282
never@3009 1283 //////////////////////////////////////////////////////////////////////////////
never@3009 1284 // thread local storage
never@3009 1285
kevinw@5618 1286 // Restore the thread pointer if the destructor is called. This is in case
kevinw@5618 1287 // someone from JNI code sets up a destructor with pthread_key_create to run
kevinw@5618 1288 // detachCurrentThread on thread death. Unless we restore the thread pointer we
kevinw@5618 1289 // will hang or crash. When detachCurrentThread is called the key will be set
kevinw@5618 1290 // to null and we will not be called again. If detachCurrentThread is never
kevinw@5618 1291 // called we could loop forever depending on the pthread implementation.
kevinw@5618 1292 static void restore_thread_pointer(void* p) {
kevinw@5618 1293 Thread* thread = (Thread*) p;
kevinw@5618 1294 os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);
kevinw@5618 1295 }
kevinw@5618 1296
never@3009 1297 int os::allocate_thread_local_storage() {
never@3009 1298 pthread_key_t key;
kevinw@5618 1299 int rslt = pthread_key_create(&key, restore_thread_pointer);
never@3009 1300 assert(rslt == 0, "cannot allocate thread local storage");
never@3009 1301 return (int)key;
never@3009 1302 }
never@3009 1303
never@3009 1304 // Note: This is currently not used by VM, as we don't destroy TLS key
never@3009 1305 // on VM exit.
never@3009 1306 void os::free_thread_local_storage(int index) {
never@3009 1307 int rslt = pthread_key_delete((pthread_key_t)index);
never@3009 1308 assert(rslt == 0, "invalid index");
never@3009 1309 }
never@3009 1310
never@3009 1311 void os::thread_local_storage_at_put(int index, void* value) {
never@3009 1312 int rslt = pthread_setspecific((pthread_key_t)index, value);
never@3009 1313 assert(rslt == 0, "pthread_setspecific failed");
never@3009 1314 }
never@3009 1315
never@3009 1316 extern "C" Thread* get_thread() {
never@3009 1317 return ThreadLocalStorage::thread();
never@3009 1318 }
never@3009 1319
never@3009 1320 //////////////////////////////////////////////////////////////////////////////
never@3009 1321 // initial thread
never@3009 1322
never@3009 1323 #ifndef _ALLBSD_SOURCE
never@3009 1324 // Check if current thread is the initial thread, similar to Solaris thr_main.
never@3009 1325 bool os::Bsd::is_initial_thread(void) {
never@3009 1326 char dummy;
never@3009 1327 // If called before init complete, thread stack bottom will be null.
never@3009 1328 // Can be called if fatal error occurs before initialization.
never@3009 1329 if (initial_thread_stack_bottom() == NULL) return false;
never@3009 1330 assert(initial_thread_stack_bottom() != NULL &&
never@3009 1331 initial_thread_stack_size() != 0,
never@3009 1332 "os::init did not locate initial thread's stack region");
never@3009 1333 if ((address)&dummy >= initial_thread_stack_bottom() &&
never@3009 1334 (address)&dummy < initial_thread_stack_bottom() + initial_thread_stack_size())
never@3009 1335 return true;
never@3009 1336 else return false;
never@3009 1337 }
never@3009 1338
never@3009 1339 // Find the virtual memory area that contains addr
never@3009 1340 static bool find_vma(address addr, address* vma_low, address* vma_high) {
never@3009 1341 FILE *fp = fopen("/proc/self/maps", "r");
never@3009 1342 if (fp) {
never@3009 1343 address low, high;
never@3009 1344 while (!feof(fp)) {
never@3009 1345 if (fscanf(fp, "%p-%p", &low, &high) == 2) {
never@3009 1346 if (low <= addr && addr < high) {
never@3009 1347 if (vma_low) *vma_low = low;
never@3009 1348 if (vma_high) *vma_high = high;
never@3009 1349 fclose (fp);
never@3009 1350 return true;
never@3009 1351 }
never@3009 1352 }
never@3009 1353 for (;;) {
never@3009 1354 int ch = fgetc(fp);
never@3009 1355 if (ch == EOF || ch == (int)'\n') break;
never@3009 1356 }
never@3009 1357 }
never@3009 1358 fclose(fp);
never@3009 1359 }
never@3009 1360 return false;
never@3009 1361 }
never@3009 1362
never@3009 1363 // Locate initial thread stack. This special handling of initial thread stack
never@3009 1364 // is needed because pthread_getattr_np() on most (all?) Bsd distros returns
never@3009 1365 // bogus value for initial thread.
never@3009 1366 void os::Bsd::capture_initial_stack(size_t max_size) {
never@3009 1367 // stack size is the easy part, get it from RLIMIT_STACK
never@3009 1368 size_t stack_size;
never@3009 1369 struct rlimit rlim;
never@3009 1370 getrlimit(RLIMIT_STACK, &rlim);
never@3009 1371 stack_size = rlim.rlim_cur;
never@3009 1372
never@3009 1373 // 6308388: a bug in ld.so will relocate its own .data section to the
never@3009 1374 // lower end of primordial stack; reduce ulimit -s value a little bit
never@3009 1375 // so we won't install guard page on ld.so's data section.
never@3009 1376 stack_size -= 2 * page_size();
never@3009 1377
never@3009 1378 // 4441425: avoid crash with "unlimited" stack size on SuSE 7.1 or Redhat
never@3009 1379 // 7.1, in both cases we will get 2G in return value.
never@3009 1380 // 4466587: glibc 2.2.x compiled w/o "--enable-kernel=2.4.0" (RH 7.0,
never@3009 1381 // SuSE 7.2, Debian) can not handle alternate signal stack correctly
never@3009 1382 // for initial thread if its stack size exceeds 6M. Cap it at 2M,
never@3009 1383 // in case other parts in glibc still assumes 2M max stack size.
never@3009 1384 // FIXME: alt signal stack is gone, maybe we can relax this constraint?
never@3009 1385 #ifndef IA64
never@3009 1386 if (stack_size > 2 * K * K) stack_size = 2 * K * K;
never@3009 1387 #else
never@3009 1388 // Problem still exists RH7.2 (IA64 anyway) but 2MB is a little small
never@3009 1389 if (stack_size > 4 * K * K) stack_size = 4 * K * K;
never@3009 1390 #endif
never@3009 1391
never@3009 1392 // Try to figure out where the stack base (top) is. This is harder.
never@3009 1393 //
never@3009 1394 // When an application is started, glibc saves the initial stack pointer in
never@3009 1395 // a global variable "__libc_stack_end", which is then used by system
never@3009 1396 // libraries. __libc_stack_end should be pretty close to stack top. The
never@3009 1397 // variable is available since the very early days. However, because it is
never@3009 1398 // a private interface, it could disappear in the future.
never@3009 1399 //
never@3009 1400 // Bsd kernel saves start_stack information in /proc/<pid>/stat. Similar
never@3009 1401 // to __libc_stack_end, it is very close to stack top, but isn't the real
never@3009 1402 // stack top. Note that /proc may not exist if VM is running as a chroot
never@3009 1403 // program, so reading /proc/<pid>/stat could fail. Also the contents of
never@3009 1404 // /proc/<pid>/stat could change in the future (though unlikely).
never@3009 1405 //
never@3009 1406 // We try __libc_stack_end first. If that doesn't work, look for
never@3009 1407 // /proc/<pid>/stat. If neither of them works, we use current stack pointer
never@3009 1408 // as a hint, which should work well in most cases.
never@3009 1409
never@3009 1410 uintptr_t stack_start;
never@3009 1411
never@3009 1412 // try __libc_stack_end first
never@3009 1413 uintptr_t *p = (uintptr_t *)dlsym(RTLD_DEFAULT, "__libc_stack_end");
never@3009 1414 if (p && *p) {
never@3009 1415 stack_start = *p;
never@3009 1416 } else {
never@3009 1417 // see if we can get the start_stack field from /proc/self/stat
never@3009 1418 FILE *fp;
never@3009 1419 int pid;
never@3009 1420 char state;
never@3009 1421 int ppid;
never@3009 1422 int pgrp;
never@3009 1423 int session;
never@3009 1424 int nr;
never@3009 1425 int tpgrp;
never@3009 1426 unsigned long flags;
never@3009 1427 unsigned long minflt;
never@3009 1428 unsigned long cminflt;
never@3009 1429 unsigned long majflt;
never@3009 1430 unsigned long cmajflt;
never@3009 1431 unsigned long utime;
never@3009 1432 unsigned long stime;
never@3009 1433 long cutime;
never@3009 1434 long cstime;
never@3009 1435 long prio;
never@3009 1436 long nice;
never@3009 1437 long junk;
never@3009 1438 long it_real;
never@3009 1439 uintptr_t start;
never@3009 1440 uintptr_t vsize;
never@3009 1441 intptr_t rss;
never@3009 1442 uintptr_t rsslim;
never@3009 1443 uintptr_t scodes;
never@3009 1444 uintptr_t ecode;
never@3009 1445 int i;
never@3009 1446
never@3009 1447 // Figure what the primordial thread stack base is. Code is inspired
never@3009 1448 // by email from Hans Boehm. /proc/self/stat begins with current pid,
never@3009 1449 // followed by command name surrounded by parentheses, state, etc.
never@3009 1450 char stat[2048];
never@3009 1451 int statlen;
never@3009 1452
never@3009 1453 fp = fopen("/proc/self/stat", "r");
never@3009 1454 if (fp) {
never@3009 1455 statlen = fread(stat, 1, 2047, fp);
never@3009 1456 stat[statlen] = '\0';
never@3009 1457 fclose(fp);
never@3009 1458
never@3009 1459 // Skip pid and the command string. Note that we could be dealing with
never@3009 1460 // weird command names, e.g. user could decide to rename java launcher
never@3009 1461 // to "java 1.4.2 :)", then the stat file would look like
never@3009 1462 // 1234 (java 1.4.2 :)) R ... ...
never@3009 1463 // We don't really need to know the command string, just find the last
never@3009 1464 // occurrence of ")" and then start parsing from there. See bug 4726580.
never@3009 1465 char * s = strrchr(stat, ')');
never@3009 1466
never@3009 1467 i = 0;
never@3009 1468 if (s) {
never@3009 1469 // Skip blank chars
never@3009 1470 do s++; while (isspace(*s));
never@3009 1471
never@3009 1472 #define _UFM UINTX_FORMAT
never@3009 1473 #define _DFM INTX_FORMAT
never@3009 1474
never@3009 1475 /* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 */
never@3009 1476 /* 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 */
never@3009 1477 i = sscanf(s, "%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld " _UFM _UFM _DFM _UFM _UFM _UFM _UFM,
never@3009 1478 &state, /* 3 %c */
never@3009 1479 &ppid, /* 4 %d */
never@3009 1480 &pgrp, /* 5 %d */
never@3009 1481 &session, /* 6 %d */
never@3009 1482 &nr, /* 7 %d */
never@3009 1483 &tpgrp, /* 8 %d */
never@3009 1484 &flags, /* 9 %lu */
never@3009 1485 &minflt, /* 10 %lu */
never@3009 1486 &cminflt, /* 11 %lu */
never@3009 1487 &majflt, /* 12 %lu */
never@3009 1488 &cmajflt, /* 13 %lu */
never@3009 1489 &utime, /* 14 %lu */
never@3009 1490 &stime, /* 15 %lu */
never@3009 1491 &cutime, /* 16 %ld */
never@3009 1492 &cstime, /* 17 %ld */
never@3009 1493 &prio, /* 18 %ld */
never@3009 1494 &nice, /* 19 %ld */
never@3009 1495 &junk, /* 20 %ld */
never@3009 1496 &it_real, /* 21 %ld */
never@3009 1497 &start, /* 22 UINTX_FORMAT */
never@3009 1498 &vsize, /* 23 UINTX_FORMAT */
never@3009 1499 &rss, /* 24 INTX_FORMAT */
never@3009 1500 &rsslim, /* 25 UINTX_FORMAT */
never@3009 1501 &scodes, /* 26 UINTX_FORMAT */
never@3009 1502 &ecode, /* 27 UINTX_FORMAT */
never@3009 1503 &stack_start); /* 28 UINTX_FORMAT */
never@3009 1504 }
never@3009 1505
never@3009 1506 #undef _UFM
never@3009 1507 #undef _DFM
never@3009 1508
never@3009 1509 if (i != 28 - 2) {
never@3009 1510 assert(false, "Bad conversion from /proc/self/stat");
never@3009 1511 // product mode - assume we are the initial thread, good luck in the
never@3009 1512 // embedded case.
never@3009 1513 warning("Can't detect initial thread stack location - bad conversion");
never@3009 1514 stack_start = (uintptr_t) &rlim;
never@3009 1515 }
never@3009 1516 } else {
never@3009 1517 // For some reason we can't open /proc/self/stat (for example, running on
never@3009 1518 // FreeBSD with a Bsd emulator, or inside chroot), this should work for
never@3009 1519 // most cases, so don't abort:
never@3009 1520 warning("Can't detect initial thread stack location - no /proc/self/stat");
never@3009 1521 stack_start = (uintptr_t) &rlim;
never@3009 1522 }
never@3009 1523 }
never@3009 1524
never@3009 1525 // Now we have a pointer (stack_start) very close to the stack top, the
never@3009 1526 // next thing to do is to figure out the exact location of stack top. We
never@3009 1527 // can find out the virtual memory area that contains stack_start by
never@3009 1528 // reading /proc/self/maps, it should be the last vma in /proc/self/maps,
never@3009 1529 // and its upper limit is the real stack top. (again, this would fail if
never@3009 1530 // running inside chroot, because /proc may not exist.)
never@3009 1531
never@3009 1532 uintptr_t stack_top;
never@3009 1533 address low, high;
never@3009 1534 if (find_vma((address)stack_start, &low, &high)) {
never@3009 1535 // success, "high" is the true stack top. (ignore "low", because initial
never@3009 1536 // thread stack grows on demand, its real bottom is high - RLIMIT_STACK.)
never@3009 1537 stack_top = (uintptr_t)high;
never@3009 1538 } else {
never@3009 1539 // failed, likely because /proc/self/maps does not exist
never@3009 1540 warning("Can't detect initial thread stack location - find_vma failed");
never@3009 1541 // best effort: stack_start is normally within a few pages below the real
never@3009 1542 // stack top, use it as stack top, and reduce stack size so we won't put
never@3009 1543 // guard page outside stack.
never@3009 1544 stack_top = stack_start;
never@3009 1545 stack_size -= 16 * page_size();
never@3009 1546 }
never@3009 1547
never@3009 1548 // stack_top could be partially down the page so align it
never@3009 1549 stack_top = align_size_up(stack_top, page_size());
never@3009 1550
never@3009 1551 if (max_size && stack_size > max_size) {
never@3009 1552 _initial_thread_stack_size = max_size;
never@3009 1553 } else {
never@3009 1554 _initial_thread_stack_size = stack_size;
never@3009 1555 }
never@3009 1556
never@3009 1557 _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size());
never@3009 1558 _initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size;
never@3009 1559 }
never@3009 1560 #endif
never@3009 1561
never@3009 1562 ////////////////////////////////////////////////////////////////////////////////
never@3009 1563 // time support
never@3009 1564
never@3009 1565 // Time since start-up in seconds to a fine granularity.
never@3009 1566 // Used by VMSelfDestructTimer and the MemProfiler.
never@3009 1567 double os::elapsedTime() {
never@3009 1568
never@3009 1569 return (double)(os::elapsed_counter()) * 0.000001;
never@3009 1570 }
never@3009 1571
never@3009 1572 jlong os::elapsed_counter() {
never@3009 1573 timeval time;
never@3009 1574 int status = gettimeofday(&time, NULL);
never@3009 1575 return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
never@3009 1576 }
never@3009 1577
never@3009 1578 jlong os::elapsed_frequency() {
never@3009 1579 return (1000 * 1000);
never@3009 1580 }
never@3009 1581
tschatzl@5167 1582 bool os::supports_vtime() { return true; }
never@3009 1583 bool os::enable_vtime() { return false; }
never@3009 1584 bool os::vtime_enabled() { return false; }
tschatzl@5167 1585
never@3009 1586 double os::elapsedVTime() {
never@3009 1587 // better than nothing, but not much
never@3009 1588 return elapsedTime();
never@3009 1589 }
never@3009 1590
never@3009 1591 jlong os::javaTimeMillis() {
never@3009 1592 timeval time;
never@3009 1593 int status = gettimeofday(&time, NULL);
never@3009 1594 assert(status != -1, "bsd error");
never@3009 1595 return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);
never@3009 1596 }
never@3009 1597
never@3009 1598 #ifndef CLOCK_MONOTONIC
never@3009 1599 #define CLOCK_MONOTONIC (1)
never@3009 1600 #endif
never@3009 1601
never@3009 1602 #ifdef __APPLE__
never@3009 1603 void os::Bsd::clock_init() {
never@3009 1604 // XXXDARWIN: Investigate replacement monotonic clock
never@3009 1605 }
never@3009 1606 #elif defined(_ALLBSD_SOURCE)
never@3009 1607 void os::Bsd::clock_init() {
never@3009 1608 struct timespec res;
never@3009 1609 struct timespec tp;
never@3009 1610 if (::clock_getres(CLOCK_MONOTONIC, &res) == 0 &&
never@3009 1611 ::clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
never@3009 1612 // yes, monotonic clock is supported
never@3009 1613 _clock_gettime = ::clock_gettime;
never@3009 1614 }
never@3009 1615 }
never@3009 1616 #else
never@3009 1617 void os::Bsd::clock_init() {
never@3009 1618 // we do dlopen's in this particular order due to bug in bsd
never@3009 1619 // dynamical loader (see 6348968) leading to crash on exit
never@3009 1620 void* handle = dlopen("librt.so.1", RTLD_LAZY);
never@3009 1621 if (handle == NULL) {
never@3009 1622 handle = dlopen("librt.so", RTLD_LAZY);
never@3009 1623 }
never@3009 1624
never@3009 1625 if (handle) {
never@3009 1626 int (*clock_getres_func)(clockid_t, struct timespec*) =
never@3009 1627 (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_getres");
never@3009 1628 int (*clock_gettime_func)(clockid_t, struct timespec*) =
never@3009 1629 (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_gettime");
never@3009 1630 if (clock_getres_func && clock_gettime_func) {
never@3009 1631 // See if monotonic clock is supported by the kernel. Note that some
never@3009 1632 // early implementations simply return kernel jiffies (updated every
never@3009 1633 // 1/100 or 1/1000 second). It would be bad to use such a low res clock
never@3009 1634 // for nano time (though the monotonic property is still nice to have).
never@3009 1635 // It's fixed in newer kernels, however clock_getres() still returns
never@3009 1636 // 1/HZ. We check if clock_getres() works, but will ignore its reported
never@3009 1637 // resolution for now. Hopefully as people move to new kernels, this
never@3009 1638 // won't be a problem.
never@3009 1639 struct timespec res;
never@3009 1640 struct timespec tp;
never@3009 1641 if (clock_getres_func (CLOCK_MONOTONIC, &res) == 0 &&
never@3009 1642 clock_gettime_func(CLOCK_MONOTONIC, &tp) == 0) {
never@3009 1643 // yes, monotonic clock is supported
never@3009 1644 _clock_gettime = clock_gettime_func;
never@3009 1645 } else {
never@3009 1646 // close librt if there is no monotonic clock
never@3009 1647 dlclose(handle);
never@3009 1648 }
never@3009 1649 }
never@3009 1650 }
never@3009 1651 }
never@3009 1652 #endif
never@3009 1653
never@3009 1654 #ifndef _ALLBSD_SOURCE
never@3009 1655 #ifndef SYS_clock_getres
never@3009 1656
never@3009 1657 #if defined(IA32) || defined(AMD64)
never@3009 1658 #define SYS_clock_getres IA32_ONLY(266) AMD64_ONLY(229)
never@3009 1659 #define sys_clock_getres(x,y) ::syscall(SYS_clock_getres, x, y)
never@3009 1660 #else
never@3009 1661 #warning "SYS_clock_getres not defined for this platform, disabling fast_thread_cpu_time"
never@3009 1662 #define sys_clock_getres(x,y) -1
never@3009 1663 #endif
never@3009 1664
never@3009 1665 #else
never@3009 1666 #define sys_clock_getres(x,y) ::syscall(SYS_clock_getres, x, y)
never@3009 1667 #endif
never@3009 1668
never@3009 1669 void os::Bsd::fast_thread_clock_init() {
never@3009 1670 if (!UseBsdPosixThreadCPUClocks) {
never@3009 1671 return;
never@3009 1672 }
never@3009 1673 clockid_t clockid;
never@3009 1674 struct timespec tp;
never@3009 1675 int (*pthread_getcpuclockid_func)(pthread_t, clockid_t *) =
never@3009 1676 (int(*)(pthread_t, clockid_t *)) dlsym(RTLD_DEFAULT, "pthread_getcpuclockid");
never@3009 1677
never@3009 1678 // Switch to using fast clocks for thread cpu time if
never@3009 1679 // the sys_clock_getres() returns 0 error code.
never@3009 1680 // Note, that some kernels may support the current thread
never@3009 1681 // clock (CLOCK_THREAD_CPUTIME_ID) but not the clocks
never@3009 1682 // returned by the pthread_getcpuclockid().
never@3009 1683 // If the fast Posix clocks are supported then the sys_clock_getres()
never@3009 1684 // must return at least tp.tv_sec == 0 which means a resolution
never@3009 1685 // better than 1 sec. This is extra check for reliability.
never@3009 1686
never@3009 1687 if(pthread_getcpuclockid_func &&
never@3009 1688 pthread_getcpuclockid_func(_main_thread, &clockid) == 0 &&
never@3009 1689 sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) {
never@3009 1690
never@3009 1691 _supports_fast_thread_cpu_time = true;
never@3009 1692 _pthread_getcpuclockid = pthread_getcpuclockid_func;
never@3009 1693 }
never@3009 1694 }
never@3009 1695 #endif
never@3009 1696
never@3009 1697 jlong os::javaTimeNanos() {
never@3009 1698 if (Bsd::supports_monotonic_clock()) {
never@3009 1699 struct timespec tp;
never@3009 1700 int status = Bsd::clock_gettime(CLOCK_MONOTONIC, &tp);
never@3009 1701 assert(status == 0, "gettime error");
never@3009 1702 jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec);
never@3009 1703 return result;
never@3009 1704 } else {
never@3009 1705 timeval time;
never@3009 1706 int status = gettimeofday(&time, NULL);
never@3009 1707 assert(status != -1, "bsd error");
never@3009 1708 jlong usecs = jlong(time.tv_sec) * (1000 * 1000) + jlong(time.tv_usec);
never@3009 1709 return 1000 * usecs;
never@3009 1710 }
never@3009 1711 }
never@3009 1712
never@3009 1713 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
never@3009 1714 if (Bsd::supports_monotonic_clock()) {
never@3009 1715 info_ptr->max_value = ALL_64_BITS;
never@3009 1716
never@3009 1717 // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past
never@3009 1718 info_ptr->may_skip_backward = false; // not subject to resetting or drifting
never@3009 1719 info_ptr->may_skip_forward = false; // not subject to resetting or drifting
never@3009 1720 } else {
never@3009 1721 // gettimeofday - based on time in seconds since the Epoch thus does not wrap
never@3009 1722 info_ptr->max_value = ALL_64_BITS;
never@3009 1723
never@3009 1724 // gettimeofday is a real time clock so it skips
never@3009 1725 info_ptr->may_skip_backward = true;
never@3009 1726 info_ptr->may_skip_forward = true;
never@3009 1727 }
never@3009 1728
never@3009 1729 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time
never@3009 1730 }
never@3009 1731
never@3009 1732 // Return the real, user, and system times in seconds from an
never@3009 1733 // arbitrary fixed point in the past.
never@3009 1734 bool os::getTimesSecs(double* process_real_time,
never@3009 1735 double* process_user_time,
never@3009 1736 double* process_system_time) {
never@3009 1737 struct tms ticks;
never@3009 1738 clock_t real_ticks = times(&ticks);
never@3009 1739
never@3009 1740 if (real_ticks == (clock_t) (-1)) {
never@3009 1741 return false;
never@3009 1742 } else {
never@3009 1743 double ticks_per_second = (double) clock_tics_per_sec;
never@3009 1744 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
never@3009 1745 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
never@3009 1746 *process_real_time = ((double) real_ticks) / ticks_per_second;
never@3009 1747
never@3009 1748 return true;
never@3009 1749 }
never@3009 1750 }
never@3009 1751
never@3009 1752
never@3009 1753 char * os::local_time_string(char *buf, size_t buflen) {
never@3009 1754 struct tm t;
never@3009 1755 time_t long_time;
never@3009 1756 time(&long_time);
never@3009 1757 localtime_r(&long_time, &t);
never@3009 1758 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
never@3009 1759 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
never@3009 1760 t.tm_hour, t.tm_min, t.tm_sec);
never@3009 1761 return buf;
never@3009 1762 }
never@3009 1763
never@3009 1764 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
never@3009 1765 return localtime_r(clock, res);
never@3009 1766 }
never@3009 1767
never@3009 1768 ////////////////////////////////////////////////////////////////////////////////
never@3009 1769 // runtime exit support
never@3009 1770
never@3009 1771 // Note: os::shutdown() might be called very early during initialization, or
never@3009 1772 // called from signal handler. Before adding something to os::shutdown(), make
never@3009 1773 // sure it is async-safe and can handle partially initialized VM.
never@3009 1774 void os::shutdown() {
never@3009 1775
never@3009 1776 // allow PerfMemory to attempt cleanup of any persistent resources
never@3009 1777 perfMemory_exit();
never@3009 1778
never@3009 1779 // needs to remove object in file system
never@3009 1780 AttachListener::abort();
never@3009 1781
never@3009 1782 // flush buffered output, finish log files
never@3009 1783 ostream_abort();
never@3009 1784
never@3009 1785 // Check for abort hook
never@3009 1786 abort_hook_t abort_hook = Arguments::abort_hook();
never@3009 1787 if (abort_hook != NULL) {
never@3009 1788 abort_hook();
never@3009 1789 }
never@3009 1790
never@3009 1791 }
never@3009 1792
never@3009 1793 // Note: os::abort() might be called very early during initialization, or
never@3009 1794 // called from signal handler. Before adding something to os::abort(), make
never@3009 1795 // sure it is async-safe and can handle partially initialized VM.
never@3009 1796 void os::abort(bool dump_core) {
never@3009 1797 os::shutdown();
never@3009 1798 if (dump_core) {
never@3009 1799 #ifndef PRODUCT
never@3009 1800 fdStream out(defaultStream::output_fd());
never@3009 1801 out.print_raw("Current thread is ");
never@3009 1802 char buf[16];
never@3009 1803 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
never@3009 1804 out.print_raw_cr(buf);
never@3009 1805 out.print_raw_cr("Dumping core ...");
never@3009 1806 #endif
never@3009 1807 ::abort(); // dump core
never@3009 1808 }
never@3009 1809
never@3009 1810 ::exit(1);
never@3009 1811 }
never@3009 1812
never@3009 1813 // Die immediately, no exit hook, no abort hook, no cleanup.
never@3009 1814 void os::die() {
never@3009 1815 // _exit() on BsdThreads only kills current thread
never@3009 1816 ::abort();
never@3009 1817 }
never@3009 1818
never@3009 1819
never@3009 1820 // This method is a copy of JDK's sysGetLastErrorString
never@3009 1821 // from src/solaris/hpi/src/system_md.c
never@3009 1822
never@3009 1823 size_t os::lasterror(char *buf, size_t len) {
never@3009 1824
never@3009 1825 if (errno == 0) return 0;
never@3009 1826
never@3009 1827 const char *s = ::strerror(errno);
never@3009 1828 size_t n = ::strlen(s);
never@3009 1829 if (n >= len) {
never@3009 1830 n = len - 1;
never@3009 1831 }
never@3009 1832 ::strncpy(buf, s, n);
never@3009 1833 buf[n] = '\0';
never@3009 1834 return n;
never@3009 1835 }
never@3009 1836
sla@3544 1837 intx os::current_thread_id() {
sla@3544 1838 #ifdef __APPLE__
sla@4962 1839 return (intx)::pthread_mach_thread_np(::pthread_self());
sla@3544 1840 #else
sla@3544 1841 return (intx)::pthread_self();
sla@3544 1842 #endif
sla@3544 1843 }
never@3009 1844 int os::current_process_id() {
never@3009 1845
never@3009 1846 // Under the old bsd thread library, bsd gives each thread
never@3009 1847 // its own process id. Because of this each thread will return
never@3009 1848 // a different pid if this method were to return the result
never@3009 1849 // of getpid(2). Bsd provides no api that returns the pid
never@3009 1850 // of the launcher thread for the vm. This implementation
never@3009 1851 // returns a unique pid, the pid of the launcher thread
never@3009 1852 // that starts the vm 'process'.
never@3009 1853
never@3009 1854 // Under the NPTL, getpid() returns the same pid as the
never@3009 1855 // launcher thread rather than a unique pid per thread.
never@3009 1856 // Use gettid() if you want the old pre NPTL behaviour.
never@3009 1857
never@3009 1858 // if you are looking for the result of a call to getpid() that
never@3009 1859 // returns a unique pid for the calling thread, then look at the
never@3009 1860 // OSThread::thread_id() method in osThread_bsd.hpp file
never@3009 1861
never@3009 1862 return (int)(_initial_pid ? _initial_pid : getpid());
never@3009 1863 }
never@3009 1864
never@3009 1865 // DLL functions
never@3009 1866
never@3009 1867 #define JNI_LIB_PREFIX "lib"
never@3009 1868 #ifdef __APPLE__
never@3009 1869 #define JNI_LIB_SUFFIX ".dylib"
never@3009 1870 #else
never@3009 1871 #define JNI_LIB_SUFFIX ".so"
never@3009 1872 #endif
never@3009 1873
never@3009 1874 const char* os::dll_file_extension() { return JNI_LIB_SUFFIX; }
never@3009 1875
never@3009 1876 // This must be hard coded because it's the system's temporary
never@3009 1877 // directory not the java application's temp directory, ala java.io.tmpdir.
dcubed@3055 1878 #ifdef __APPLE__
dcubed@3055 1879 // macosx has a secure per-user temporary directory
dcubed@3055 1880 char temp_path_storage[PATH_MAX];
dcubed@3055 1881 const char* os::get_temp_directory() {
dcubed@3055 1882 static char *temp_path = NULL;
dcubed@3055 1883 if (temp_path == NULL) {
dcubed@3055 1884 int pathSize = confstr(_CS_DARWIN_USER_TEMP_DIR, temp_path_storage, PATH_MAX);
dcubed@3055 1885 if (pathSize == 0 || pathSize > PATH_MAX) {
dcubed@3055 1886 strlcpy(temp_path_storage, "/tmp/", sizeof(temp_path_storage));
dcubed@3055 1887 }
dcubed@3055 1888 temp_path = temp_path_storage;
dcubed@3055 1889 }
dcubed@3055 1890 return temp_path;
dcubed@3055 1891 }
dcubed@3055 1892 #else /* __APPLE__ */
never@3009 1893 const char* os::get_temp_directory() { return "/tmp"; }
dcubed@3055 1894 #endif /* __APPLE__ */
never@3009 1895
never@3009 1896 static bool file_exists(const char* filename) {
never@3009 1897 struct stat statbuf;
never@3009 1898 if (filename == NULL || strlen(filename) == 0) {
never@3009 1899 return false;
never@3009 1900 }
never@3009 1901 return os::stat(filename, &statbuf) == 0;
never@3009 1902 }
never@3009 1903
never@3009 1904 void os::dll_build_name(char* buffer, size_t buflen,
never@3009 1905 const char* pname, const char* fname) {
never@3009 1906 // Copied from libhpi
never@3009 1907 const size_t pnamelen = pname ? strlen(pname) : 0;
never@3009 1908
never@3009 1909 // Quietly truncate on buffer overflow. Should be an error.
never@3009 1910 if (pnamelen + strlen(fname) + strlen(JNI_LIB_PREFIX) + strlen(JNI_LIB_SUFFIX) + 2 > buflen) {
never@3009 1911 *buffer = '\0';
never@3009 1912 return;
never@3009 1913 }
never@3009 1914
never@3009 1915 if (pnamelen == 0) {
never@3009 1916 snprintf(buffer, buflen, JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX, fname);
never@3009 1917 } else if (strchr(pname, *os::path_separator()) != NULL) {
never@3009 1918 int n;
never@3009 1919 char** pelements = split_path(pname, &n);
never@3009 1920 for (int i = 0 ; i < n ; i++) {
never@3009 1921 // Really shouldn't be NULL, but check can't hurt
never@3009 1922 if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
never@3009 1923 continue; // skip the empty path values
never@3009 1924 }
never@3009 1925 snprintf(buffer, buflen, "%s/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX,
never@3009 1926 pelements[i], fname);
never@3009 1927 if (file_exists(buffer)) {
never@3009 1928 break;
never@3009 1929 }
never@3009 1930 }
never@3009 1931 // release the storage
never@3009 1932 for (int i = 0 ; i < n ; i++) {
never@3009 1933 if (pelements[i] != NULL) {
zgu@4135 1934 FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
never@3009 1935 }
never@3009 1936 }
never@3009 1937 if (pelements != NULL) {
zgu@4135 1938 FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
never@3009 1939 }
never@3009 1940 } else {
never@3009 1941 snprintf(buffer, buflen, "%s/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX, pname, fname);
never@3009 1942 }
never@3009 1943 }
never@3009 1944
never@3009 1945 const char* os::get_current_directory(char *buf, int buflen) {
never@3009 1946 return getcwd(buf, buflen);
never@3009 1947 }
never@3009 1948
never@3009 1949 // check if addr is inside libjvm[_g].so
never@3009 1950 bool os::address_is_in_vm(address addr) {
never@3009 1951 static address libjvm_base_addr;
never@3009 1952 Dl_info dlinfo;
never@3009 1953
never@3009 1954 if (libjvm_base_addr == NULL) {
dcubed@4824 1955 if (dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo) != 0) {
dcubed@4824 1956 libjvm_base_addr = (address)dlinfo.dli_fbase;
dcubed@4824 1957 }
never@3009 1958 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
never@3009 1959 }
never@3009 1960
dcubed@4824 1961 if (dladdr((void *)addr, &dlinfo) != 0) {
never@3009 1962 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
never@3009 1963 }
never@3009 1964
never@3009 1965 return false;
never@3009 1966 }
never@3009 1967
zgu@4196 1968
zgu@4196 1969 #define MACH_MAXSYMLEN 256
zgu@4196 1970
never@3009 1971 bool os::dll_address_to_function_name(address addr, char *buf,
never@3009 1972 int buflen, int *offset) {
dcubed@4824 1973 // buf is not optional, but offset is optional
dcubed@4824 1974 assert(buf != NULL, "sanity check");
dcubed@4824 1975
never@3009 1976 Dl_info dlinfo;
zgu@4196 1977 char localbuf[MACH_MAXSYMLEN];
zgu@4196 1978
dcubed@4824 1979 if (dladdr((void*)addr, &dlinfo) != 0) {
dcubed@4824 1980 // see if we have a matching symbol
dcubed@4824 1981 if (dlinfo.dli_saddr != NULL && dlinfo.dli_sname != NULL) {
dcubed@4824 1982 if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen)) {
never@3009 1983 jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
never@3009 1984 }
dcubed@4824 1985 if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
dcubed@4824 1986 return true;
never@3009 1987 }
dcubed@4824 1988 // no matching symbol so try for just file info
dcubed@4824 1989 if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != NULL) {
dcubed@4824 1990 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
dcubed@4824 1991 buf, buflen, offset, dlinfo.dli_fname)) {
dcubed@4824 1992 return true;
dcubed@4824 1993 }
never@3009 1994 }
dcubed@4824 1995
dcubed@4824 1996 // Handle non-dynamic manually:
dcubed@4824 1997 if (dlinfo.dli_fbase != NULL &&
dcubed@4824 1998 Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset,
dcubed@4824 1999 dlinfo.dli_fbase)) {
dcubed@4824 2000 if (!Decoder::demangle(localbuf, buf, buflen)) {
dcubed@4824 2001 jio_snprintf(buf, buflen, "%s", localbuf);
dcubed@4824 2002 }
dcubed@4824 2003 return true;
zgu@4196 2004 }
dcubed@4824 2005 }
dcubed@4824 2006 buf[0] = '\0';
never@3009 2007 if (offset != NULL) *offset = -1;
never@3009 2008 return false;
never@3009 2009 }
never@3009 2010
never@3009 2011 #ifdef _ALLBSD_SOURCE
never@3009 2012 // ported from solaris version
never@3009 2013 bool os::dll_address_to_library_name(address addr, char* buf,
never@3009 2014 int buflen, int* offset) {
dcubed@4824 2015 // buf is not optional, but offset is optional
dcubed@4824 2016 assert(buf != NULL, "sanity check");
dcubed@4824 2017
never@3009 2018 Dl_info dlinfo;
never@3009 2019
dcubed@4824 2020 if (dladdr((void*)addr, &dlinfo) != 0) {
dcubed@4824 2021 if (dlinfo.dli_fname != NULL) {
dcubed@4824 2022 jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
dcubed@4824 2023 }
dcubed@4824 2024 if (dlinfo.dli_fbase != NULL && offset != NULL) {
dcubed@4824 2025 *offset = addr - (address)dlinfo.dli_fbase;
dcubed@4824 2026 }
dcubed@4824 2027 return true;
dcubed@4824 2028 }
dcubed@4824 2029
dcubed@4824 2030 buf[0] = '\0';
dcubed@4824 2031 if (offset) *offset = -1;
dcubed@4824 2032 return false;
never@3009 2033 }
never@3009 2034 #else
never@3009 2035 struct _address_to_library_name {
never@3009 2036 address addr; // input : memory address
never@3009 2037 size_t buflen; // size of fname
never@3009 2038 char* fname; // output: library name
never@3009 2039 address base; // library base addr
never@3009 2040 };
never@3009 2041
never@3009 2042 static int address_to_library_name_callback(struct dl_phdr_info *info,
never@3009 2043 size_t size, void *data) {
never@3009 2044 int i;
never@3009 2045 bool found = false;
never@3009 2046 address libbase = NULL;
never@3009 2047 struct _address_to_library_name * d = (struct _address_to_library_name *)data;
never@3009 2048
never@3009 2049 // iterate through all loadable segments
never@3009 2050 for (i = 0; i < info->dlpi_phnum; i++) {
never@3009 2051 address segbase = (address)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);
never@3009 2052 if (info->dlpi_phdr[i].p_type == PT_LOAD) {
never@3009 2053 // base address of a library is the lowest address of its loaded
never@3009 2054 // segments.
never@3009 2055 if (libbase == NULL || libbase > segbase) {
never@3009 2056 libbase = segbase;
never@3009 2057 }
never@3009 2058 // see if 'addr' is within current segment
never@3009 2059 if (segbase <= d->addr &&
never@3009 2060 d->addr < segbase + info->dlpi_phdr[i].p_memsz) {
never@3009 2061 found = true;
never@3009 2062 }
never@3009 2063 }
never@3009 2064 }
never@3009 2065
never@3009 2066 // dlpi_name is NULL or empty if the ELF file is executable, return 0
never@3009 2067 // so dll_address_to_library_name() can fall through to use dladdr() which
never@3009 2068 // can figure out executable name from argv[0].
never@3009 2069 if (found && info->dlpi_name && info->dlpi_name[0]) {
never@3009 2070 d->base = libbase;
never@3009 2071 if (d->fname) {
never@3009 2072 jio_snprintf(d->fname, d->buflen, "%s", info->dlpi_name);
never@3009 2073 }
never@3009 2074 return 1;
never@3009 2075 }
never@3009 2076 return 0;
never@3009 2077 }
never@3009 2078
never@3009 2079 bool os::dll_address_to_library_name(address addr, char* buf,
never@3009 2080 int buflen, int* offset) {
never@3009 2081 Dl_info dlinfo;
never@3009 2082 struct _address_to_library_name data;
never@3009 2083
never@3009 2084 // There is a bug in old glibc dladdr() implementation that it could resolve
never@3009 2085 // to wrong library name if the .so file has a base address != NULL. Here
never@3009 2086 // we iterate through the program headers of all loaded libraries to find
never@3009 2087 // out which library 'addr' really belongs to. This workaround can be
never@3009 2088 // removed once the minimum requirement for glibc is moved to 2.3.x.
never@3009 2089 data.addr = addr;
never@3009 2090 data.fname = buf;
never@3009 2091 data.buflen = buflen;
never@3009 2092 data.base = NULL;
never@3009 2093 int rslt = dl_iterate_phdr(address_to_library_name_callback, (void *)&data);
never@3009 2094
never@3009 2095 if (rslt) {
never@3009 2096 // buf already contains library name
never@3009 2097 if (offset) *offset = addr - data.base;
never@3009 2098 return true;
never@3009 2099 } else if (dladdr((void*)addr, &dlinfo)){
never@3009 2100 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
never@3009 2101 if (offset) *offset = addr - (address)dlinfo.dli_fbase;
never@3009 2102 return true;
never@3009 2103 } else {
never@3009 2104 if (buf) buf[0] = '\0';
never@3009 2105 if (offset) *offset = -1;
never@3009 2106 return false;
never@3009 2107 }
never@3009 2108 }
never@3009 2109 #endif
never@3009 2110
never@3009 2111 // Loads .dll/.so and
never@3009 2112 // in case of error it checks if .dll/.so was built for the
never@3009 2113 // same architecture as Hotspot is running on
never@3009 2114
never@3009 2115 #ifdef __APPLE__
never@3009 2116 void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
never@3009 2117 void * result= ::dlopen(filename, RTLD_LAZY);
never@3009 2118 if (result != NULL) {
never@3009 2119 // Successful loading
never@3009 2120 return result;
never@3009 2121 }
never@3009 2122
never@3009 2123 // Read system error message into ebuf
never@3009 2124 ::strncpy(ebuf, ::dlerror(), ebuflen-1);
never@3009 2125 ebuf[ebuflen-1]='\0';
never@3009 2126
never@3009 2127 return NULL;
never@3009 2128 }
never@3009 2129 #else
never@3009 2130 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
never@3009 2131 {
never@3009 2132 void * result= ::dlopen(filename, RTLD_LAZY);
never@3009 2133 if (result != NULL) {
never@3009 2134 // Successful loading
never@3009 2135 return result;
never@3009 2136 }
never@3009 2137
never@3009 2138 Elf32_Ehdr elf_head;
never@3009 2139
never@3009 2140 // Read system error message into ebuf
never@3009 2141 // It may or may not be overwritten below
never@3009 2142 ::strncpy(ebuf, ::dlerror(), ebuflen-1);
never@3009 2143 ebuf[ebuflen-1]='\0';
never@3009 2144 int diag_msg_max_length=ebuflen-strlen(ebuf);
never@3009 2145 char* diag_msg_buf=ebuf+strlen(ebuf);
never@3009 2146
never@3009 2147 if (diag_msg_max_length==0) {
never@3009 2148 // No more space in ebuf for additional diagnostics message
never@3009 2149 return NULL;
never@3009 2150 }
never@3009 2151
never@3009 2152
never@3009 2153 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
never@3009 2154
never@3009 2155 if (file_descriptor < 0) {
never@3009 2156 // Can't open library, report dlerror() message
never@3009 2157 return NULL;
never@3009 2158 }
never@3009 2159
never@3009 2160 bool failed_to_read_elf_head=
never@3009 2161 (sizeof(elf_head)!=
never@3009 2162 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
never@3009 2163
never@3009 2164 ::close(file_descriptor);
never@3009 2165 if (failed_to_read_elf_head) {
never@3009 2166 // file i/o error - report dlerror() msg
never@3009 2167 return NULL;
never@3009 2168 }
never@3009 2169
never@3009 2170 typedef struct {
never@3009 2171 Elf32_Half code; // Actual value as defined in elf.h
never@3009 2172 Elf32_Half compat_class; // Compatibility of archs at VM's sense
never@3009 2173 char elf_class; // 32 or 64 bit
never@3009 2174 char endianess; // MSB or LSB
never@3009 2175 char* name; // String representation
never@3009 2176 } arch_t;
never@3009 2177
never@3009 2178 #ifndef EM_486
never@3009 2179 #define EM_486 6 /* Intel 80486 */
never@3009 2180 #endif
never@3009 2181
never@3009 2182 #ifndef EM_MIPS_RS3_LE
never@3009 2183 #define EM_MIPS_RS3_LE 10 /* MIPS */
never@3009 2184 #endif
never@3009 2185
never@3009 2186 #ifndef EM_PPC64
never@3009 2187 #define EM_PPC64 21 /* PowerPC64 */
never@3009 2188 #endif
never@3009 2189
never@3009 2190 #ifndef EM_S390
never@3009 2191 #define EM_S390 22 /* IBM System/390 */
never@3009 2192 #endif
never@3009 2193
never@3009 2194 #ifndef EM_IA_64
never@3009 2195 #define EM_IA_64 50 /* HP/Intel IA-64 */
never@3009 2196 #endif
never@3009 2197
never@3009 2198 #ifndef EM_X86_64
never@3009 2199 #define EM_X86_64 62 /* AMD x86-64 */
never@3009 2200 #endif
never@3009 2201
never@3009 2202 static const arch_t arch_array[]={
never@3009 2203 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
never@3009 2204 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
never@3009 2205 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
never@3009 2206 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
never@3009 2207 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
never@3009 2208 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
never@3009 2209 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
never@3009 2210 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
never@3009 2211 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
never@3009 2212 {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM"},
never@3009 2213 {EM_S390, EM_S390, ELFCLASSNONE, ELFDATA2MSB, (char*)"IBM System/390"},
never@3009 2214 {EM_ALPHA, EM_ALPHA, ELFCLASS64, ELFDATA2LSB, (char*)"Alpha"},
never@3009 2215 {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"},
never@3009 2216 {EM_MIPS, EM_MIPS, ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"},
never@3009 2217 {EM_PARISC, EM_PARISC, ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},
never@3009 2218 {EM_68K, EM_68K, ELFCLASS32, ELFDATA2MSB, (char*)"M68k"}
never@3009 2219 };
never@3009 2220
never@3009 2221 #if (defined IA32)
never@3009 2222 static Elf32_Half running_arch_code=EM_386;
never@3009 2223 #elif (defined AMD64)
never@3009 2224 static Elf32_Half running_arch_code=EM_X86_64;
never@3009 2225 #elif (defined IA64)
never@3009 2226 static Elf32_Half running_arch_code=EM_IA_64;
never@3009 2227 #elif (defined __sparc) && (defined _LP64)
never@3009 2228 static Elf32_Half running_arch_code=EM_SPARCV9;
never@3009 2229 #elif (defined __sparc) && (!defined _LP64)
never@3009 2230 static Elf32_Half running_arch_code=EM_SPARC;
never@3009 2231 #elif (defined __powerpc64__)
never@3009 2232 static Elf32_Half running_arch_code=EM_PPC64;
never@3009 2233 #elif (defined __powerpc__)
never@3009 2234 static Elf32_Half running_arch_code=EM_PPC;
never@3009 2235 #elif (defined ARM)
never@3009 2236 static Elf32_Half running_arch_code=EM_ARM;
never@3009 2237 #elif (defined S390)
never@3009 2238 static Elf32_Half running_arch_code=EM_S390;
never@3009 2239 #elif (defined ALPHA)
never@3009 2240 static Elf32_Half running_arch_code=EM_ALPHA;
never@3009 2241 #elif (defined MIPSEL)
never@3009 2242 static Elf32_Half running_arch_code=EM_MIPS_RS3_LE;
never@3009 2243 #elif (defined PARISC)
never@3009 2244 static Elf32_Half running_arch_code=EM_PARISC;
never@3009 2245 #elif (defined MIPS)
never@3009 2246 static Elf32_Half running_arch_code=EM_MIPS;
never@3009 2247 #elif (defined M68K)
never@3009 2248 static Elf32_Half running_arch_code=EM_68K;
never@3009 2249 #else
never@3009 2250 #error Method os::dll_load requires that one of following is defined:\
never@3009 2251 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, S390, ALPHA, MIPS, MIPSEL, PARISC, M68K
never@3009 2252 #endif
never@3009 2253
never@3009 2254 // Identify compatability class for VM's architecture and library's architecture
never@3009 2255 // Obtain string descriptions for architectures
never@3009 2256
never@3009 2257 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
never@3009 2258 int running_arch_index=-1;
never@3009 2259
never@3009 2260 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
never@3009 2261 if (running_arch_code == arch_array[i].code) {
never@3009 2262 running_arch_index = i;
never@3009 2263 }
never@3009 2264 if (lib_arch.code == arch_array[i].code) {
never@3009 2265 lib_arch.compat_class = arch_array[i].compat_class;
never@3009 2266 lib_arch.name = arch_array[i].name;
never@3009 2267 }
never@3009 2268 }
never@3009 2269
never@3009 2270 assert(running_arch_index != -1,
never@3009 2271 "Didn't find running architecture code (running_arch_code) in arch_array");
never@3009 2272 if (running_arch_index == -1) {
never@3009 2273 // Even though running architecture detection failed
never@3009 2274 // we may still continue with reporting dlerror() message
never@3009 2275 return NULL;
never@3009 2276 }
never@3009 2277
never@3009 2278 if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
never@3009 2279 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
never@3009 2280 return NULL;
never@3009 2281 }
never@3009 2282
never@3009 2283 #ifndef S390
never@3009 2284 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
never@3009 2285 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
never@3009 2286 return NULL;
never@3009 2287 }
never@3009 2288 #endif // !S390
never@3009 2289
never@3009 2290 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
never@3009 2291 if ( lib_arch.name!=NULL ) {
never@3009 2292 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
never@3009 2293 " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
never@3009 2294 lib_arch.name, arch_array[running_arch_index].name);
never@3009 2295 } else {
never@3009 2296 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
never@3009 2297 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
never@3009 2298 lib_arch.code,
never@3009 2299 arch_array[running_arch_index].name);
never@3009 2300 }
never@3009 2301 }
never@3009 2302
never@3009 2303 return NULL;
never@3009 2304 }
never@3009 2305 #endif /* !__APPLE__ */
never@3009 2306
never@3009 2307 // XXX: Do we need a lock around this as per Linux?
never@3009 2308 void* os::dll_lookup(void* handle, const char* name) {
never@3009 2309 return dlsym(handle, name);
never@3009 2310 }
never@3009 2311
never@3009 2312
never@3009 2313 static bool _print_ascii_file(const char* filename, outputStream* st) {
never@3009 2314 int fd = ::open(filename, O_RDONLY);
never@3009 2315 if (fd == -1) {
never@3009 2316 return false;
never@3009 2317 }
never@3009 2318
never@3009 2319 char buf[32];
never@3009 2320 int bytes;
never@3009 2321 while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) {
never@3009 2322 st->print_raw(buf, bytes);
never@3009 2323 }
never@3009 2324
never@3009 2325 ::close(fd);
never@3009 2326
never@3009 2327 return true;
never@3009 2328 }
never@3009 2329
never@3009 2330 void os::print_dll_info(outputStream *st) {
dcubed@4824 2331 st->print_cr("Dynamic libraries:");
never@3009 2332 #ifdef _ALLBSD_SOURCE
never@3009 2333 #ifdef RTLD_DI_LINKMAP
dcubed@4824 2334 Dl_info dli;
dcubed@4824 2335 void *handle;
dcubed@4824 2336 Link_map *map;
dcubed@4824 2337 Link_map *p;
dcubed@4824 2338
dcubed@4824 2339 if (dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli) == 0 ||
dcubed@4824 2340 dli.dli_fname == NULL) {
dcubed@4824 2341 st->print_cr("Error: Cannot print dynamic libraries.");
dcubed@4824 2342 return;
dcubed@4824 2343 }
dcubed@4824 2344 handle = dlopen(dli.dli_fname, RTLD_LAZY);
dcubed@4824 2345 if (handle == NULL) {
dcubed@4824 2346 st->print_cr("Error: Cannot print dynamic libraries.");
dcubed@4824 2347 return;
dcubed@4824 2348 }
dcubed@4824 2349 dlinfo(handle, RTLD_DI_LINKMAP, &map);
dcubed@4824 2350 if (map == NULL) {
dcubed@4824 2351 st->print_cr("Error: Cannot print dynamic libraries.");
dcubed@4824 2352 return;
dcubed@4824 2353 }
dcubed@4824 2354
dcubed@4824 2355 while (map->l_prev != NULL)
dcubed@4824 2356 map = map->l_prev;
dcubed@4824 2357
dcubed@4824 2358 while (map != NULL) {
dcubed@4824 2359 st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
dcubed@4824 2360 map = map->l_next;
dcubed@4824 2361 }
dcubed@4824 2362
dcubed@4824 2363 dlclose(handle);
never@3009 2364 #elif defined(__APPLE__)
dcubed@4824 2365 uint32_t count;
dcubed@4824 2366 uint32_t i;
dcubed@4824 2367
dcubed@4824 2368 count = _dyld_image_count();
dcubed@4824 2369 for (i = 1; i < count; i++) {
dcubed@4824 2370 const char *name = _dyld_get_image_name(i);
dcubed@4824 2371 intptr_t slide = _dyld_get_image_vmaddr_slide(i);
dcubed@4824 2372 st->print_cr(PTR_FORMAT " \t%s", slide, name);
dcubed@4824 2373 }
never@3009 2374 #else
dcubed@4824 2375 st->print_cr("Error: Cannot print dynamic libraries.");
never@3009 2376 #endif
never@3009 2377 #else
dcubed@4824 2378 char fname[32];
dcubed@4824 2379 pid_t pid = os::Bsd::gettid();
dcubed@4824 2380
dcubed@4824 2381 jio_snprintf(fname, sizeof(fname), "/proc/%d/maps", pid);
dcubed@4824 2382
dcubed@4824 2383 if (!_print_ascii_file(fname, st)) {
dcubed@4824 2384 st->print("Can not get library information for pid = %d\n", pid);
dcubed@4824 2385 }
never@3009 2386 #endif
never@3009 2387 }
never@3009 2388
nloodin@4020 2389 void os::print_os_info_brief(outputStream* st) {
nloodin@4020 2390 st->print("Bsd");
nloodin@4020 2391
nloodin@4020 2392 os::Posix::print_uname_info(st);
nloodin@4020 2393 }
never@3009 2394
never@3009 2395 void os::print_os_info(outputStream* st) {
never@3009 2396 st->print("OS:");
nloodin@4020 2397 st->print("Bsd");
nloodin@4020 2398
nloodin@4020 2399 os::Posix::print_uname_info(st);
nloodin@4020 2400
nloodin@4020 2401 os::Posix::print_rlimit_info(st);
nloodin@4020 2402
nloodin@4020 2403 os::Posix::print_load_average(st);
never@3009 2404 }
never@3009 2405
never@3009 2406 void os::pd_print_cpu_info(outputStream* st) {
never@3009 2407 // Nothing to do for now.
never@3009 2408 }
never@3009 2409
never@3009 2410 void os::print_memory_info(outputStream* st) {
never@3009 2411
never@3009 2412 st->print("Memory:");
never@3009 2413 st->print(" %dk page", os::vm_page_size()>>10);
never@3009 2414
never@3009 2415 #ifndef _ALLBSD_SOURCE
never@3009 2416 // values in struct sysinfo are "unsigned long"
never@3009 2417 struct sysinfo si;
never@3009 2418 sysinfo(&si);
never@3009 2419 #endif
never@3009 2420
never@3009 2421 st->print(", physical " UINT64_FORMAT "k",
never@3009 2422 os::physical_memory() >> 10);
never@3009 2423 st->print("(" UINT64_FORMAT "k free)",
never@3009 2424 os::available_memory() >> 10);
never@3009 2425 #ifndef _ALLBSD_SOURCE
never@3009 2426 st->print(", swap " UINT64_FORMAT "k",
never@3009 2427 ((jlong)si.totalswap * si.mem_unit) >> 10);
never@3009 2428 st->print("(" UINT64_FORMAT "k free)",
never@3009 2429 ((jlong)si.freeswap * si.mem_unit) >> 10);
never@3009 2430 #endif
never@3009 2431 st->cr();
never@3009 2432
never@3009 2433 // meminfo
never@3009 2434 st->print("\n/proc/meminfo:\n");
never@3009 2435 _print_ascii_file("/proc/meminfo", st);
never@3009 2436 st->cr();
never@3009 2437 }
never@3009 2438
never@3009 2439 // Taken from /usr/include/bits/siginfo.h Supposed to be architecture specific
never@3009 2440 // but they're the same for all the bsd arch that we support
never@3009 2441 // and they're the same for solaris but there's no common place to put this.
never@3009 2442 const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
never@3009 2443 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
never@3009 2444 "ILL_COPROC", "ILL_BADSTK" };
never@3009 2445
never@3009 2446 const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
never@3009 2447 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
never@3009 2448 "FPE_FLTINV", "FPE_FLTSUB", "FPE_FLTDEN" };
never@3009 2449
never@3009 2450 const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
never@3009 2451
never@3009 2452 const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
never@3009 2453
never@3009 2454 void os::print_siginfo(outputStream* st, void* siginfo) {
never@3009 2455 st->print("siginfo:");
never@3009 2456
never@3009 2457 const int buflen = 100;
never@3009 2458 char buf[buflen];
never@3009 2459 siginfo_t *si = (siginfo_t*)siginfo;
never@3009 2460 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
never@3009 2461 if (si->si_errno != 0 && strerror_r(si->si_errno, buf, buflen) == 0) {
never@3009 2462 st->print("si_errno=%s", buf);
never@3009 2463 } else {
never@3009 2464 st->print("si_errno=%d", si->si_errno);
never@3009 2465 }
never@3009 2466 const int c = si->si_code;
never@3009 2467 assert(c > 0, "unexpected si_code");
never@3009 2468 switch (si->si_signo) {
never@3009 2469 case SIGILL:
never@3009 2470 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
never@3009 2471 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
never@3009 2472 break;
never@3009 2473 case SIGFPE:
never@3009 2474 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
never@3009 2475 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
never@3009 2476 break;
never@3009 2477 case SIGSEGV:
never@3009 2478 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
never@3009 2479 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
never@3009 2480 break;
never@3009 2481 case SIGBUS:
never@3009 2482 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
never@3009 2483 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
never@3009 2484 break;
never@3009 2485 default:
never@3009 2486 st->print(", si_code=%d", si->si_code);
never@3009 2487 // no si_addr
never@3009 2488 }
never@3009 2489
never@3009 2490 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
never@3009 2491 UseSharedSpaces) {
never@3009 2492 FileMapInfo* mapinfo = FileMapInfo::current_info();
never@3009 2493 if (mapinfo->is_in_shared_space(si->si_addr)) {
never@3009 2494 st->print("\n\nError accessing class data sharing archive." \
never@3009 2495 " Mapped file inaccessible during execution, " \
never@3009 2496 " possible disk/network problem.");
never@3009 2497 }
never@3009 2498 }
never@3009 2499 st->cr();
never@3009 2500 }
never@3009 2501
never@3009 2502
never@3009 2503 static void print_signal_handler(outputStream* st, int sig,
never@3009 2504 char* buf, size_t buflen);
never@3009 2505
never@3009 2506 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
never@3009 2507 st->print_cr("Signal Handlers:");
never@3009 2508 print_signal_handler(st, SIGSEGV, buf, buflen);
never@3009 2509 print_signal_handler(st, SIGBUS , buf, buflen);
never@3009 2510 print_signal_handler(st, SIGFPE , buf, buflen);
never@3009 2511 print_signal_handler(st, SIGPIPE, buf, buflen);
never@3009 2512 print_signal_handler(st, SIGXFSZ, buf, buflen);
never@3009 2513 print_signal_handler(st, SIGILL , buf, buflen);
never@3009 2514 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
never@3009 2515 print_signal_handler(st, SR_signum, buf, buflen);
never@3009 2516 print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
never@3009 2517 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
never@3009 2518 print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
never@3009 2519 print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
never@3009 2520 }
never@3009 2521
never@3009 2522 static char saved_jvm_path[MAXPATHLEN] = {0};
never@3009 2523
phh@3342 2524 // Find the full path to the current module, libjvm or libjvm_g
never@3009 2525 void os::jvm_path(char *buf, jint buflen) {
never@3009 2526 // Error checking.
never@3009 2527 if (buflen < MAXPATHLEN) {
never@3009 2528 assert(false, "must use a large-enough buffer");
never@3009 2529 buf[0] = '\0';
never@3009 2530 return;
never@3009 2531 }
never@3009 2532 // Lazy resolve the path to current module.
never@3009 2533 if (saved_jvm_path[0] != 0) {
never@3009 2534 strcpy(buf, saved_jvm_path);
never@3009 2535 return;
never@3009 2536 }
never@3009 2537
never@3009 2538 char dli_fname[MAXPATHLEN];
never@3009 2539 bool ret = dll_address_to_library_name(
never@3009 2540 CAST_FROM_FN_PTR(address, os::jvm_path),
never@3009 2541 dli_fname, sizeof(dli_fname), NULL);
dcubed@4824 2542 assert(ret, "cannot locate libjvm");
dcubed@4824 2543 char *rp = NULL;
dcubed@4824 2544 if (ret && dli_fname[0] != '\0') {
dcubed@4824 2545 rp = realpath(dli_fname, buf);
dcubed@4824 2546 }
never@3009 2547 if (rp == NULL)
never@3009 2548 return;
never@3009 2549
never@3009 2550 if (Arguments::created_by_gamma_launcher()) {
never@3009 2551 // Support for the gamma launcher. Typical value for buf is
phh@3342 2552 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm". If "/jre/lib/" appears at
never@3009 2553 // the right place in the string, then assume we are installed in a JDK and
phh@3342 2554 // we're done. Otherwise, check for a JAVA_HOME environment variable and
phh@3342 2555 // construct a path to the JVM being overridden.
phh@3342 2556
never@3009 2557 const char *p = buf + strlen(buf) - 1;
never@3009 2558 for (int count = 0; p > buf && count < 5; ++count) {
never@3009 2559 for (--p; p > buf && *p != '/'; --p)
never@3009 2560 /* empty */ ;
never@3009 2561 }
never@3009 2562
never@3009 2563 if (strncmp(p, "/jre/lib/", 9) != 0) {
never@3009 2564 // Look for JAVA_HOME in the environment.
never@3009 2565 char* java_home_var = ::getenv("JAVA_HOME");
never@3009 2566 if (java_home_var != NULL && java_home_var[0] != 0) {
never@3009 2567 char* jrelib_p;
never@3009 2568 int len;
never@3009 2569
phh@3342 2570 // Check the current module name "libjvm" or "libjvm_g".
never@3009 2571 p = strrchr(buf, '/');
never@3009 2572 assert(strstr(p, "/libjvm") == p, "invalid library name");
never@3009 2573 p = strstr(p, "_g") ? "_g" : "";
never@3009 2574
never@3009 2575 rp = realpath(java_home_var, buf);
never@3009 2576 if (rp == NULL)
never@3009 2577 return;
never@3009 2578
never@3009 2579 // determine if this is a legacy image or modules image
never@3009 2580 // modules image doesn't have "jre" subdirectory
never@3009 2581 len = strlen(buf);
hseigel@5260 2582 assert(len < buflen, "Ran out of buffer space");
never@3009 2583 jrelib_p = buf + len;
phh@3342 2584
phh@3342 2585 // Add the appropriate library subdir
phh@3342 2586 snprintf(jrelib_p, buflen-len, "/jre/lib");
never@3009 2587 if (0 != access(buf, F_OK)) {
phh@3342 2588 snprintf(jrelib_p, buflen-len, "/lib");
never@3009 2589 }
never@3009 2590
phh@3342 2591 // Add the appropriate client or server subdir
phh@3342 2592 len = strlen(buf);
phh@3342 2593 jrelib_p = buf + len;
phh@3342 2594 snprintf(jrelib_p, buflen-len, "/%s", COMPILER_VARIANT);
phh@3342 2595 if (0 != access(buf, F_OK)) {
phh@3342 2596 snprintf(jrelib_p, buflen-len, "");
phh@3342 2597 }
phh@3342 2598
phh@3342 2599 // If the path exists within JAVA_HOME, add the JVM library name
phh@3342 2600 // to complete the path to JVM being overridden. Otherwise fallback
phh@3342 2601 // to the path to the current library.
never@3009 2602 if (0 == access(buf, F_OK)) {
phh@3342 2603 // Use current module name "libjvm[_g]" instead of
phh@3342 2604 // "libjvm"debug_only("_g")"" since for fastdebug version
phh@3342 2605 // we should have "libjvm" but debug_only("_g") adds "_g"!
never@3009 2606 len = strlen(buf);
phh@3342 2607 snprintf(buf + len, buflen-len, "/libjvm%s%s", p, JNI_LIB_SUFFIX);
never@3009 2608 } else {
phh@3342 2609 // Fall back to path of current library
never@3009 2610 rp = realpath(dli_fname, buf);
never@3009 2611 if (rp == NULL)
never@3009 2612 return;
never@3009 2613 }
never@3009 2614 }
never@3009 2615 }
never@3009 2616 }
never@3009 2617
hseigel@5260 2618 strncpy(saved_jvm_path, buf, MAXPATHLEN);
never@3009 2619 }
never@3009 2620
never@3009 2621 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
never@3009 2622 // no prefix required, not even "_"
never@3009 2623 }
never@3009 2624
never@3009 2625 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
never@3009 2626 // no suffix required
never@3009 2627 }
never@3009 2628
never@3009 2629 ////////////////////////////////////////////////////////////////////////////////
never@3009 2630 // sun.misc.Signal support
never@3009 2631
never@3009 2632 static volatile jint sigint_count = 0;
never@3009 2633
never@3009 2634 static void
never@3009 2635 UserHandler(int sig, void *siginfo, void *context) {
never@3009 2636 // 4511530 - sem_post is serialized and handled by the manager thread. When
never@3009 2637 // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
never@3009 2638 // don't want to flood the manager thread with sem_post requests.
never@3009 2639 if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
never@3009 2640 return;
never@3009 2641
never@3009 2642 // Ctrl-C is pressed during error reporting, likely because the error
never@3009 2643 // handler fails to abort. Let VM die immediately.
never@3009 2644 if (sig == SIGINT && is_error_reported()) {
never@3009 2645 os::die();
never@3009 2646 }
never@3009 2647
never@3009 2648 os::signal_notify(sig);
never@3009 2649 }
never@3009 2650
never@3009 2651 void* os::user_handler() {
never@3009 2652 return CAST_FROM_FN_PTR(void*, UserHandler);
never@3009 2653 }
never@3009 2654
never@3009 2655 extern "C" {
never@3009 2656 typedef void (*sa_handler_t)(int);
never@3009 2657 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
never@3009 2658 }
never@3009 2659
never@3009 2660 void* os::signal(int signal_number, void* handler) {
never@3009 2661 struct sigaction sigAct, oldSigAct;
never@3009 2662
never@3009 2663 sigfillset(&(sigAct.sa_mask));
never@3009 2664 sigAct.sa_flags = SA_RESTART|SA_SIGINFO;
never@3009 2665 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
never@3009 2666
never@3009 2667 if (sigaction(signal_number, &sigAct, &oldSigAct)) {
never@3009 2668 // -1 means registration failed
never@3009 2669 return (void *)-1;
never@3009 2670 }
never@3009 2671
never@3009 2672 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
never@3009 2673 }
never@3009 2674
never@3009 2675 void os::signal_raise(int signal_number) {
never@3009 2676 ::raise(signal_number);
never@3009 2677 }
never@3009 2678
never@3009 2679 /*
never@3009 2680 * The following code is moved from os.cpp for making this
never@3009 2681 * code platform specific, which it is by its very nature.
never@3009 2682 */
never@3009 2683
never@3009 2684 // Will be modified when max signal is changed to be dynamic
never@3009 2685 int os::sigexitnum_pd() {
never@3009 2686 return NSIG;
never@3009 2687 }
never@3009 2688
never@3009 2689 // a counter for each possible signal value
never@3009 2690 static volatile jint pending_signals[NSIG+1] = { 0 };
never@3009 2691
never@3009 2692 // Bsd(POSIX) specific hand shaking semaphore.
never@3009 2693 #ifdef __APPLE__
rbackman@4627 2694 typedef semaphore_t os_semaphore_t;
never@3009 2695 #define SEM_INIT(sem, value) semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)
rbackman@4627 2696 #define SEM_WAIT(sem) semaphore_wait(sem)
rbackman@4627 2697 #define SEM_POST(sem) semaphore_signal(sem)
rbackman@4627 2698 #define SEM_DESTROY(sem) semaphore_destroy(mach_task_self(), sem)
never@3009 2699 #else
rbackman@4627 2700 typedef sem_t os_semaphore_t;
never@3009 2701 #define SEM_INIT(sem, value) sem_init(&sem, 0, value)
rbackman@4627 2702 #define SEM_WAIT(sem) sem_wait(&sem)
rbackman@4627 2703 #define SEM_POST(sem) sem_post(&sem)
rbackman@4627 2704 #define SEM_DESTROY(sem) sem_destroy(&sem)
never@3009 2705 #endif
never@3009 2706
rbackman@4627 2707 class Semaphore : public StackObj {
rbackman@4627 2708 public:
rbackman@4627 2709 Semaphore();
rbackman@4627 2710 ~Semaphore();
rbackman@4627 2711 void signal();
rbackman@4627 2712 void wait();
rbackman@4627 2713 bool trywait();
rbackman@4627 2714 bool timedwait(unsigned int sec, int nsec);
rbackman@4627 2715 private:
rbackman@4627 2716 jlong currenttime() const;
rbackman@4627 2717 semaphore_t _semaphore;
rbackman@4627 2718 };
rbackman@4627 2719
rbackman@4627 2720 Semaphore::Semaphore() : _semaphore(0) {
rbackman@4627 2721 SEM_INIT(_semaphore, 0);
rbackman@4627 2722 }
rbackman@4627 2723
rbackman@4627 2724 Semaphore::~Semaphore() {
rbackman@4627 2725 SEM_DESTROY(_semaphore);
rbackman@4627 2726 }
rbackman@4627 2727
rbackman@4627 2728 void Semaphore::signal() {
rbackman@4627 2729 SEM_POST(_semaphore);
rbackman@4627 2730 }
rbackman@4627 2731
rbackman@4627 2732 void Semaphore::wait() {
rbackman@4627 2733 SEM_WAIT(_semaphore);
rbackman@4627 2734 }
rbackman@4627 2735
rbackman@4627 2736 jlong Semaphore::currenttime() const {
rbackman@4627 2737 struct timeval tv;
rbackman@4627 2738 gettimeofday(&tv, NULL);
rbackman@4627 2739 return (tv.tv_sec * NANOSECS_PER_SEC) + (tv.tv_usec * 1000);
rbackman@4627 2740 }
rbackman@4627 2741
rbackman@4627 2742 #ifdef __APPLE__
rbackman@4627 2743 bool Semaphore::trywait() {
rbackman@4627 2744 return timedwait(0, 0);
rbackman@4627 2745 }
rbackman@4627 2746
rbackman@4627 2747 bool Semaphore::timedwait(unsigned int sec, int nsec) {
rbackman@4627 2748 kern_return_t kr = KERN_ABORTED;
rbackman@4627 2749 mach_timespec_t waitspec;
rbackman@4627 2750 waitspec.tv_sec = sec;
rbackman@4627 2751 waitspec.tv_nsec = nsec;
rbackman@4627 2752
rbackman@4627 2753 jlong starttime = currenttime();
rbackman@4627 2754
rbackman@4627 2755 kr = semaphore_timedwait(_semaphore, waitspec);
rbackman@4627 2756 while (kr == KERN_ABORTED) {
rbackman@4627 2757 jlong totalwait = (sec * NANOSECS_PER_SEC) + nsec;
rbackman@4627 2758
rbackman@4627 2759 jlong current = currenttime();
rbackman@4627 2760 jlong passedtime = current - starttime;
rbackman@4627 2761
rbackman@4627 2762 if (passedtime >= totalwait) {
rbackman@4627 2763 waitspec.tv_sec = 0;
rbackman@4627 2764 waitspec.tv_nsec = 0;
rbackman@4627 2765 } else {
rbackman@4627 2766 jlong waittime = totalwait - (current - starttime);
rbackman@4627 2767 waitspec.tv_sec = waittime / NANOSECS_PER_SEC;
rbackman@4627 2768 waitspec.tv_nsec = waittime % NANOSECS_PER_SEC;
rbackman@4627 2769 }
rbackman@4627 2770
rbackman@4627 2771 kr = semaphore_timedwait(_semaphore, waitspec);
rbackman@4627 2772 }
rbackman@4627 2773
rbackman@4627 2774 return kr == KERN_SUCCESS;
rbackman@4627 2775 }
rbackman@4627 2776
rbackman@4627 2777 #else
rbackman@4627 2778
rbackman@4627 2779 bool Semaphore::trywait() {
rbackman@4627 2780 return sem_trywait(&_semaphore) == 0;
rbackman@4627 2781 }
rbackman@4627 2782
rbackman@4627 2783 bool Semaphore::timedwait(unsigned int sec, int nsec) {
rbackman@4627 2784 struct timespec ts;
rbackman@4627 2785 jlong endtime = unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
rbackman@4627 2786
rbackman@4627 2787 while (1) {
rbackman@4627 2788 int result = sem_timedwait(&_semaphore, &ts);
rbackman@4627 2789 if (result == 0) {
rbackman@4627 2790 return true;
rbackman@4627 2791 } else if (errno == EINTR) {
rbackman@4627 2792 continue;
rbackman@4627 2793 } else if (errno == ETIMEDOUT) {
rbackman@4627 2794 return false;
rbackman@4627 2795 } else {
rbackman@4627 2796 return false;
rbackman@4627 2797 }
rbackman@4627 2798 }
rbackman@4627 2799 }
rbackman@4627 2800
rbackman@4627 2801 #endif // __APPLE__
rbackman@4627 2802
rbackman@4627 2803 static os_semaphore_t sig_sem;
rbackman@4627 2804 static Semaphore sr_semaphore;
rbackman@4627 2805
never@3009 2806 void os::signal_init_pd() {
never@3009 2807 // Initialize signal structures
never@3009 2808 ::memset((void*)pending_signals, 0, sizeof(pending_signals));
never@3009 2809
never@3009 2810 // Initialize signal semaphore
never@3009 2811 ::SEM_INIT(sig_sem, 0);
never@3009 2812 }
never@3009 2813
never@3009 2814 void os::signal_notify(int sig) {
never@3009 2815 Atomic::inc(&pending_signals[sig]);
never@3009 2816 ::SEM_POST(sig_sem);
never@3009 2817 }
never@3009 2818
never@3009 2819 static int check_pending_signals(bool wait) {
never@3009 2820 Atomic::store(0, &sigint_count);
never@3009 2821 for (;;) {
never@3009 2822 for (int i = 0; i < NSIG + 1; i++) {
never@3009 2823 jint n = pending_signals[i];
never@3009 2824 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
never@3009 2825 return i;
never@3009 2826 }
never@3009 2827 }
never@3009 2828 if (!wait) {
never@3009 2829 return -1;
never@3009 2830 }
never@3009 2831 JavaThread *thread = JavaThread::current();
never@3009 2832 ThreadBlockInVM tbivm(thread);
never@3009 2833
never@3009 2834 bool threadIsSuspended;
never@3009 2835 do {
never@3009 2836 thread->set_suspend_equivalent();
never@3009 2837 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
never@3009 2838 ::SEM_WAIT(sig_sem);
never@3009 2839
never@3009 2840 // were we externally suspended while we were waiting?
never@3009 2841 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
never@3009 2842 if (threadIsSuspended) {
never@3009 2843 //
never@3009 2844 // The semaphore has been incremented, but while we were waiting
never@3009 2845 // another thread suspended us. We don't want to continue running
never@3009 2846 // while suspended because that would surprise the thread that
never@3009 2847 // suspended us.
never@3009 2848 //
never@3009 2849 ::SEM_POST(sig_sem);
never@3009 2850
never@3009 2851 thread->java_suspend_self();
never@3009 2852 }
never@3009 2853 } while (threadIsSuspended);
never@3009 2854 }
never@3009 2855 }
never@3009 2856
never@3009 2857 int os::signal_lookup() {
never@3009 2858 return check_pending_signals(false);
never@3009 2859 }
never@3009 2860
never@3009 2861 int os::signal_wait() {
never@3009 2862 return check_pending_signals(true);
never@3009 2863 }
never@3009 2864
never@3009 2865 ////////////////////////////////////////////////////////////////////////////////
never@3009 2866 // Virtual Memory
never@3009 2867
never@3009 2868 int os::vm_page_size() {
never@3009 2869 // Seems redundant as all get out
never@3009 2870 assert(os::Bsd::page_size() != -1, "must call os::init");
never@3009 2871 return os::Bsd::page_size();
never@3009 2872 }
never@3009 2873
never@3009 2874 // Solaris allocates memory by pages.
never@3009 2875 int os::vm_allocation_granularity() {
never@3009 2876 assert(os::Bsd::page_size() != -1, "must call os::init");
never@3009 2877 return os::Bsd::page_size();
never@3009 2878 }
never@3009 2879
never@3009 2880 // Rationale behind this function:
never@3009 2881 // current (Mon Apr 25 20:12:18 MSD 2005) oprofile drops samples without executable
never@3009 2882 // mapping for address (see lookup_dcookie() in the kernel module), thus we cannot get
never@3009 2883 // samples for JITted code. Here we create private executable mapping over the code cache
never@3009 2884 // and then we can use standard (well, almost, as mapping can change) way to provide
never@3009 2885 // info for the reporting script by storing timestamp and location of symbol
never@3009 2886 void bsd_wrap_code(char* base, size_t size) {
never@3009 2887 static volatile jint cnt = 0;
never@3009 2888
never@3009 2889 if (!UseOprofile) {
never@3009 2890 return;
never@3009 2891 }
never@3009 2892
never@3009 2893 char buf[PATH_MAX + 1];
never@3009 2894 int num = Atomic::add(1, &cnt);
never@3009 2895
never@3009 2896 snprintf(buf, PATH_MAX + 1, "%s/hs-vm-%d-%d",
never@3009 2897 os::get_temp_directory(), os::current_process_id(), num);
never@3009 2898 unlink(buf);
never@3009 2899
never@3009 2900 int fd = ::open(buf, O_CREAT | O_RDWR, S_IRWXU);
never@3009 2901
never@3009 2902 if (fd != -1) {
never@3009 2903 off_t rv = ::lseek(fd, size-2, SEEK_SET);
never@3009 2904 if (rv != (off_t)-1) {
never@3009 2905 if (::write(fd, "", 1) == 1) {
never@3009 2906 mmap(base, size,
never@3009 2907 PROT_READ|PROT_WRITE|PROT_EXEC,
never@3009 2908 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, fd, 0);
never@3009 2909 }
never@3009 2910 }
never@3009 2911 ::close(fd);
never@3009 2912 unlink(buf);
never@3009 2913 }
never@3009 2914 }
never@3009 2915
dcubed@4744 2916 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
dcubed@4744 2917 int err) {
dcubed@4744 2918 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
dcubed@4744 2919 ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
dcubed@4744 2920 strerror(err), err);
dcubed@4744 2921 }
dcubed@4744 2922
never@3009 2923 // NOTE: Bsd kernel does not really reserve the pages for us.
never@3009 2924 // All it does is to check if there are enough free pages
never@3009 2925 // left at the time of mmap(). This could be a potential
never@3009 2926 // problem.
zgu@4135 2927 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
never@3009 2928 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
never@3009 2929 #ifdef __OpenBSD__
never@3009 2930 // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD
dcubed@4744 2931 if (::mprotect(addr, size, prot) == 0) {
dcubed@4744 2932 return true;
dcubed@4744 2933 }
never@3009 2934 #else
never@3009 2935 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
never@3009 2936 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
dcubed@4744 2937 if (res != (uintptr_t) MAP_FAILED) {
dcubed@4744 2938 return true;
dcubed@4744 2939 }
never@3009 2940 #endif
dcubed@4744 2941
dcubed@4744 2942 // Warn about any commit errors we see in non-product builds just
dcubed@4744 2943 // in case mmap() doesn't work as described on the man page.
dcubed@4744 2944 NOT_PRODUCT(warn_fail_commit_memory(addr, size, exec, errno);)
dcubed@4744 2945
dcubed@4744 2946 return false;
never@3009 2947 }
never@3009 2948
never@3009 2949 #ifndef _ALLBSD_SOURCE
never@3009 2950 // Define MAP_HUGETLB here so we can build HotSpot on old systems.
never@3009 2951 #ifndef MAP_HUGETLB
never@3009 2952 #define MAP_HUGETLB 0x40000
never@3009 2953 #endif
never@3009 2954
never@3009 2955 // Define MADV_HUGEPAGE here so we can build HotSpot on old systems.
never@3009 2956 #ifndef MADV_HUGEPAGE
never@3009 2957 #define MADV_HUGEPAGE 14
never@3009 2958 #endif
never@3009 2959 #endif
never@3009 2960
zgu@4135 2961 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
never@3009 2962 bool exec) {
never@3009 2963 #ifndef _ALLBSD_SOURCE
never@3009 2964 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
never@3009 2965 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
never@3009 2966 uintptr_t res =
never@3009 2967 (uintptr_t) ::mmap(addr, size, prot,
never@3009 2968 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS|MAP_HUGETLB,
never@3009 2969 -1, 0);
never@3009 2970 return res != (uintptr_t) MAP_FAILED;
never@3009 2971 }
never@3009 2972 #endif
never@3009 2973
dcubed@4744 2974 // alignment_hint is ignored on this OS
dcubed@4744 2975 return pd_commit_memory(addr, size, exec);
dcubed@4744 2976 }
dcubed@4744 2977
dcubed@4744 2978 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
dcubed@4744 2979 const char* mesg) {
dcubed@4744 2980 assert(mesg != NULL, "mesg must be specified");
dcubed@4744 2981 if (!pd_commit_memory(addr, size, exec)) {
dcubed@4744 2982 // add extra info in product mode for vm_exit_out_of_memory():
dcubed@4744 2983 PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
dcubed@4744 2984 vm_exit_out_of_memory(size, mesg);
dcubed@4744 2985 }
dcubed@4744 2986 }
dcubed@4744 2987
dcubed@4744 2988 void os::pd_commit_memory_or_exit(char* addr, size_t size,
dcubed@4744 2989 size_t alignment_hint, bool exec,
dcubed@4744 2990 const char* mesg) {
dcubed@4744 2991 // alignment_hint is ignored on this OS
dcubed@4744 2992 pd_commit_memory_or_exit(addr, size, exec, mesg);
never@3009 2993 }
never@3009 2994
zgu@4135 2995 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
never@3009 2996 #ifndef _ALLBSD_SOURCE
never@3009 2997 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
never@3009 2998 // We don't check the return value: madvise(MADV_HUGEPAGE) may not
never@3009 2999 // be supported or the memory may already be backed by huge pages.
never@3009 3000 ::madvise(addr, bytes, MADV_HUGEPAGE);
never@3009 3001 }
never@3009 3002 #endif
never@3009 3003 }
never@3009 3004
zgu@4135 3005 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
never@3009 3006 ::madvise(addr, bytes, MADV_DONTNEED);
never@3009 3007 }
never@3009 3008
never@3009 3009 void os::numa_make_global(char *addr, size_t bytes) {
never@3009 3010 }
never@3009 3011
never@3009 3012 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
never@3009 3013 }
never@3009 3014
never@3009 3015 bool os::numa_topology_changed() { return false; }
never@3009 3016
never@3009 3017 size_t os::numa_get_groups_num() {
never@3009 3018 return 1;
never@3009 3019 }
never@3009 3020
never@3009 3021 int os::numa_get_group_id() {
never@3009 3022 return 0;
never@3009 3023 }
never@3009 3024
never@3009 3025 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
never@3009 3026 if (size > 0) {
never@3009 3027 ids[0] = 0;
never@3009 3028 return 1;
never@3009 3029 }
never@3009 3030 return 0;
never@3009 3031 }
never@3009 3032
never@3009 3033 bool os::get_page_info(char *start, page_info* info) {
never@3009 3034 return false;
never@3009 3035 }
never@3009 3036
never@3009 3037 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
never@3009 3038 return end;
never@3009 3039 }
never@3009 3040
never@3009 3041 #ifndef _ALLBSD_SOURCE
never@3009 3042 // Something to do with the numa-aware allocator needs these symbols
never@3009 3043 extern "C" JNIEXPORT void numa_warn(int number, char *where, ...) { }
never@3009 3044 extern "C" JNIEXPORT void numa_error(char *where) { }
never@3009 3045 extern "C" JNIEXPORT int fork1() { return fork(); }
never@3009 3046
never@3009 3047
never@3009 3048 // If we are running with libnuma version > 2, then we should
never@3009 3049 // be trying to use symbols with versions 1.1
never@3009 3050 // If we are running with earlier version, which did not have symbol versions,
never@3009 3051 // we should use the base version.
never@3009 3052 void* os::Bsd::libnuma_dlsym(void* handle, const char *name) {
never@3009 3053 void *f = dlvsym(handle, name, "libnuma_1.1");
never@3009 3054 if (f == NULL) {
never@3009 3055 f = dlsym(handle, name);
never@3009 3056 }
never@3009 3057 return f;
never@3009 3058 }
never@3009 3059
never@3009 3060 bool os::Bsd::libnuma_init() {
never@3009 3061 // sched_getcpu() should be in libc.
never@3009 3062 set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,
never@3009 3063 dlsym(RTLD_DEFAULT, "sched_getcpu")));
never@3009 3064
never@3009 3065 if (sched_getcpu() != -1) { // Does it work?
never@3009 3066 void *handle = dlopen("libnuma.so.1", RTLD_LAZY);
never@3009 3067 if (handle != NULL) {
never@3009 3068 set_numa_node_to_cpus(CAST_TO_FN_PTR(numa_node_to_cpus_func_t,
never@3009 3069 libnuma_dlsym(handle, "numa_node_to_cpus")));
never@3009 3070 set_numa_max_node(CAST_TO_FN_PTR(numa_max_node_func_t,
never@3009 3071 libnuma_dlsym(handle, "numa_max_node")));
never@3009 3072 set_numa_available(CAST_TO_FN_PTR(numa_available_func_t,
never@3009 3073 libnuma_dlsym(handle, "numa_available")));
never@3009 3074 set_numa_tonode_memory(CAST_TO_FN_PTR(numa_tonode_memory_func_t,
never@3009 3075 libnuma_dlsym(handle, "numa_tonode_memory")));
never@3009 3076 set_numa_interleave_memory(CAST_TO_FN_PTR(numa_interleave_memory_func_t,
never@3009 3077 libnuma_dlsym(handle, "numa_interleave_memory")));
never@3009 3078
never@3009 3079
never@3009 3080 if (numa_available() != -1) {
never@3009 3081 set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));
never@3009 3082 // Create a cpu -> node mapping
never@3009 3083 _cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray<int>(0, true);
never@3009 3084 rebuild_cpu_to_node_map();
never@3009 3085 return true;
never@3009 3086 }
never@3009 3087 }
never@3009 3088 }
never@3009 3089 return false;
never@3009 3090 }
never@3009 3091
never@3009 3092 // rebuild_cpu_to_node_map() constructs a table mapping cpud id to node id.
never@3009 3093 // The table is later used in get_node_by_cpu().
never@3009 3094 void os::Bsd::rebuild_cpu_to_node_map() {
never@3009 3095 const size_t NCPUS = 32768; // Since the buffer size computation is very obscure
never@3009 3096 // in libnuma (possible values are starting from 16,
never@3009 3097 // and continuing up with every other power of 2, but less
never@3009 3098 // than the maximum number of CPUs supported by kernel), and
never@3009 3099 // is a subject to change (in libnuma version 2 the requirements
never@3009 3100 // are more reasonable) we'll just hardcode the number they use
never@3009 3101 // in the library.
never@3009 3102 const size_t BitsPerCLong = sizeof(long) * CHAR_BIT;
never@3009 3103
never@3009 3104 size_t cpu_num = os::active_processor_count();
never@3009 3105 size_t cpu_map_size = NCPUS / BitsPerCLong;
never@3009 3106 size_t cpu_map_valid_size =
never@3009 3107 MIN2((cpu_num + BitsPerCLong - 1) / BitsPerCLong, cpu_map_size);
never@3009 3108
never@3009 3109 cpu_to_node()->clear();
never@3009 3110 cpu_to_node()->at_grow(cpu_num - 1);
never@3009 3111 size_t node_num = numa_get_groups_num();
never@3009 3112
never@3009 3113 unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size);
never@3009 3114 for (size_t i = 0; i < node_num; i++) {
never@3009 3115 if (numa_node_to_cpus(i, cpu_map, cpu_map_size * sizeof(unsigned long)) != -1) {
never@3009 3116 for (size_t j = 0; j < cpu_map_valid_size; j++) {
never@3009 3117 if (cpu_map[j] != 0) {
never@3009 3118 for (size_t k = 0; k < BitsPerCLong; k++) {
never@3009 3119 if (cpu_map[j] & (1UL << k)) {
never@3009 3120 cpu_to_node()->at_put(j * BitsPerCLong + k, i);
never@3009 3121 }
never@3009 3122 }
never@3009 3123 }
never@3009 3124 }
never@3009 3125 }
never@3009 3126 }
never@3009 3127 FREE_C_HEAP_ARRAY(unsigned long, cpu_map);
never@3009 3128 }
never@3009 3129
never@3009 3130 int os::Bsd::get_node_by_cpu(int cpu_id) {
never@3009 3131 if (cpu_to_node() != NULL && cpu_id >= 0 && cpu_id < cpu_to_node()->length()) {
never@3009 3132 return cpu_to_node()->at(cpu_id);
never@3009 3133 }
never@3009 3134 return -1;
never@3009 3135 }
never@3009 3136
never@3009 3137 GrowableArray<int>* os::Bsd::_cpu_to_node;
never@3009 3138 os::Bsd::sched_getcpu_func_t os::Bsd::_sched_getcpu;
never@3009 3139 os::Bsd::numa_node_to_cpus_func_t os::Bsd::_numa_node_to_cpus;
never@3009 3140 os::Bsd::numa_max_node_func_t os::Bsd::_numa_max_node;
never@3009 3141 os::Bsd::numa_available_func_t os::Bsd::_numa_available;
never@3009 3142 os::Bsd::numa_tonode_memory_func_t os::Bsd::_numa_tonode_memory;
never@3009 3143 os::Bsd::numa_interleave_memory_func_t os::Bsd::_numa_interleave_memory;
never@3009 3144 unsigned long* os::Bsd::_numa_all_nodes;
never@3009 3145 #endif
never@3009 3146
zgu@4135 3147 bool os::pd_uncommit_memory(char* addr, size_t size) {
never@3009 3148 #ifdef __OpenBSD__
never@3009 3149 // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD
never@3009 3150 return ::mprotect(addr, size, PROT_NONE) == 0;
never@3009 3151 #else
never@3009 3152 uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,
never@3009 3153 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);
never@3009 3154 return res != (uintptr_t) MAP_FAILED;
never@3009 3155 #endif
never@3009 3156 }
never@3009 3157
zgu@4135 3158 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
dcubed@4744 3159 return os::commit_memory(addr, size, !ExecMem);
never@3009 3160 }
never@3009 3161
never@3009 3162 // If this is a growable mapping, remove the guard pages entirely by
never@3009 3163 // munmap()ping them. If not, just call uncommit_memory().
never@3009 3164 bool os::remove_stack_guard_pages(char* addr, size_t size) {
never@3009 3165 return os::uncommit_memory(addr, size);
never@3009 3166 }
never@3009 3167
never@3009 3168 static address _highest_vm_reserved_address = NULL;
never@3009 3169
never@3009 3170 // If 'fixed' is true, anon_mmap() will attempt to reserve anonymous memory
never@3009 3171 // at 'requested_addr'. If there are existing memory mappings at the same
never@3009 3172 // location, however, they will be overwritten. If 'fixed' is false,
never@3009 3173 // 'requested_addr' is only treated as a hint, the return value may or
never@3009 3174 // may not start from the requested address. Unlike Bsd mmap(), this
never@3009 3175 // function returns NULL to indicate failure.
never@3009 3176 static char* anon_mmap(char* requested_addr, size_t bytes, bool fixed) {
never@3009 3177 char * addr;
never@3009 3178 int flags;
never@3009 3179
never@3009 3180 flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS;
never@3009 3181 if (fixed) {
never@3009 3182 assert((uintptr_t)requested_addr % os::Bsd::page_size() == 0, "unaligned address");
never@3009 3183 flags |= MAP_FIXED;
never@3009 3184 }
never@3009 3185
never@3009 3186 // Map uncommitted pages PROT_READ and PROT_WRITE, change access
never@3009 3187 // to PROT_EXEC if executable when we commit the page.
never@3009 3188 addr = (char*)::mmap(requested_addr, bytes, PROT_READ|PROT_WRITE,
never@3009 3189 flags, -1, 0);
never@3009 3190
never@3009 3191 if (addr != MAP_FAILED) {
never@3009 3192 // anon_mmap() should only get called during VM initialization,
never@3009 3193 // don't need lock (actually we can skip locking even it can be called
never@3009 3194 // from multiple threads, because _highest_vm_reserved_address is just a
never@3009 3195 // hint about the upper limit of non-stack memory regions.)
never@3009 3196 if ((address)addr + bytes > _highest_vm_reserved_address) {
never@3009 3197 _highest_vm_reserved_address = (address)addr + bytes;
never@3009 3198 }
never@3009 3199 }
never@3009 3200
never@3009 3201 return addr == MAP_FAILED ? NULL : addr;
never@3009 3202 }
never@3009 3203
never@3009 3204 // Don't update _highest_vm_reserved_address, because there might be memory
never@3009 3205 // regions above addr + size. If so, releasing a memory region only creates
never@3009 3206 // a hole in the address space, it doesn't help prevent heap-stack collision.
never@3009 3207 //
never@3009 3208 static int anon_munmap(char * addr, size_t size) {
never@3009 3209 return ::munmap(addr, size) == 0;
never@3009 3210 }
never@3009 3211
zgu@4135 3212 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
never@3009 3213 size_t alignment_hint) {
never@3009 3214 return anon_mmap(requested_addr, bytes, (requested_addr != NULL));
never@3009 3215 }
never@3009 3216
zgu@4135 3217 bool os::pd_release_memory(char* addr, size_t size) {
never@3009 3218 return anon_munmap(addr, size);
never@3009 3219 }
never@3009 3220
never@3009 3221 static address highest_vm_reserved_address() {
never@3009 3222 return _highest_vm_reserved_address;
never@3009 3223 }
never@3009 3224
never@3009 3225 static bool bsd_mprotect(char* addr, size_t size, int prot) {
never@3009 3226 // Bsd wants the mprotect address argument to be page aligned.
never@3009 3227 char* bottom = (char*)align_size_down((intptr_t)addr, os::Bsd::page_size());
never@3009 3228
never@3009 3229 // According to SUSv3, mprotect() should only be used with mappings
never@3009 3230 // established by mmap(), and mmap() always maps whole pages. Unaligned
never@3009 3231 // 'addr' likely indicates problem in the VM (e.g. trying to change
never@3009 3232 // protection of malloc'ed or statically allocated memory). Check the
never@3009 3233 // caller if you hit this assert.
never@3009 3234 assert(addr == bottom, "sanity check");
never@3009 3235
never@3009 3236 size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Bsd::page_size());
never@3009 3237 return ::mprotect(bottom, size, prot) == 0;
never@3009 3238 }
never@3009 3239
never@3009 3240 // Set protections specified
never@3009 3241 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
never@3009 3242 bool is_committed) {
never@3009 3243 unsigned int p = 0;
never@3009 3244 switch (prot) {
never@3009 3245 case MEM_PROT_NONE: p = PROT_NONE; break;
never@3009 3246 case MEM_PROT_READ: p = PROT_READ; break;
never@3009 3247 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break;
never@3009 3248 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
never@3009 3249 default:
never@3009 3250 ShouldNotReachHere();
never@3009 3251 }
never@3009 3252 // is_committed is unused.
never@3009 3253 return bsd_mprotect(addr, bytes, p);
never@3009 3254 }
never@3009 3255
never@3009 3256 bool os::guard_memory(char* addr, size_t size) {
never@3009 3257 return bsd_mprotect(addr, size, PROT_NONE);
never@3009 3258 }
never@3009 3259
never@3009 3260 bool os::unguard_memory(char* addr, size_t size) {
never@3009 3261 return bsd_mprotect(addr, size, PROT_READ|PROT_WRITE);
never@3009 3262 }
never@3009 3263
never@3009 3264 bool os::Bsd::hugetlbfs_sanity_check(bool warn, size_t page_size) {
never@3009 3265 bool result = false;
never@3009 3266 #ifndef _ALLBSD_SOURCE
never@3009 3267 void *p = mmap (NULL, page_size, PROT_READ|PROT_WRITE,
never@3009 3268 MAP_ANONYMOUS|MAP_PRIVATE|MAP_HUGETLB,
never@3009 3269 -1, 0);
never@3009 3270
never@3009 3271 if (p != (void *) -1) {
never@3009 3272 // We don't know if this really is a huge page or not.
never@3009 3273 FILE *fp = fopen("/proc/self/maps", "r");
never@3009 3274 if (fp) {
never@3009 3275 while (!feof(fp)) {
never@3009 3276 char chars[257];
never@3009 3277 long x = 0;
never@3009 3278 if (fgets(chars, sizeof(chars), fp)) {
never@3009 3279 if (sscanf(chars, "%lx-%*x", &x) == 1
never@3009 3280 && x == (long)p) {
never@3009 3281 if (strstr (chars, "hugepage")) {
never@3009 3282 result = true;
never@3009 3283 break;
never@3009 3284 }
never@3009 3285 }
never@3009 3286 }
never@3009 3287 }
never@3009 3288 fclose(fp);
never@3009 3289 }
never@3009 3290 munmap (p, page_size);
never@3009 3291 if (result)
never@3009 3292 return true;
never@3009 3293 }
never@3009 3294
never@3009 3295 if (warn) {
never@3009 3296 warning("HugeTLBFS is not supported by the operating system.");
never@3009 3297 }
never@3009 3298 #endif
never@3009 3299
never@3009 3300 return result;
never@3009 3301 }
never@3009 3302
never@3009 3303 /*
never@3009 3304 * Set the coredump_filter bits to include largepages in core dump (bit 6)
never@3009 3305 *
never@3009 3306 * From the coredump_filter documentation:
never@3009 3307 *
never@3009 3308 * - (bit 0) anonymous private memory
never@3009 3309 * - (bit 1) anonymous shared memory
never@3009 3310 * - (bit 2) file-backed private memory
never@3009 3311 * - (bit 3) file-backed shared memory
never@3009 3312 * - (bit 4) ELF header pages in file-backed private memory areas (it is
never@3009 3313 * effective only if the bit 2 is cleared)
never@3009 3314 * - (bit 5) hugetlb private memory
never@3009 3315 * - (bit 6) hugetlb shared memory
never@3009 3316 */
never@3009 3317 static void set_coredump_filter(void) {
never@3009 3318 FILE *f;
never@3009 3319 long cdm;
never@3009 3320
never@3009 3321 if ((f = fopen("/proc/self/coredump_filter", "r+")) == NULL) {
never@3009 3322 return;
never@3009 3323 }
never@3009 3324
never@3009 3325 if (fscanf(f, "%lx", &cdm) != 1) {
never@3009 3326 fclose(f);
never@3009 3327 return;
never@3009 3328 }
never@3009 3329
never@3009 3330 rewind(f);
never@3009 3331
never@3009 3332 if ((cdm & LARGEPAGES_BIT) == 0) {
never@3009 3333 cdm |= LARGEPAGES_BIT;
never@3009 3334 fprintf(f, "%#lx", cdm);
never@3009 3335 }
never@3009 3336
never@3009 3337 fclose(f);
never@3009 3338 }
never@3009 3339
never@3009 3340 // Large page support
never@3009 3341
never@3009 3342 static size_t _large_page_size = 0;
never@3009 3343
never@3009 3344 void os::large_page_init() {
never@3009 3345 #ifndef _ALLBSD_SOURCE
never@3009 3346 if (!UseLargePages) {
never@3009 3347 UseHugeTLBFS = false;
never@3009 3348 UseSHM = false;
never@3009 3349 return;
never@3009 3350 }
never@3009 3351
never@3009 3352 if (FLAG_IS_DEFAULT(UseHugeTLBFS) && FLAG_IS_DEFAULT(UseSHM)) {
never@3009 3353 // If UseLargePages is specified on the command line try both methods,
never@3009 3354 // if it's default, then try only HugeTLBFS.
never@3009 3355 if (FLAG_IS_DEFAULT(UseLargePages)) {
never@3009 3356 UseHugeTLBFS = true;
never@3009 3357 } else {
never@3009 3358 UseHugeTLBFS = UseSHM = true;
never@3009 3359 }
never@3009 3360 }
never@3009 3361
never@3009 3362 if (LargePageSizeInBytes) {
never@3009 3363 _large_page_size = LargePageSizeInBytes;
never@3009 3364 } else {
never@3009 3365 // large_page_size on Bsd is used to round up heap size. x86 uses either
never@3009 3366 // 2M or 4M page, depending on whether PAE (Physical Address Extensions)
never@3009 3367 // mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. IA64 can use
never@3009 3368 // page as large as 256M.
never@3009 3369 //
never@3009 3370 // Here we try to figure out page size by parsing /proc/meminfo and looking
never@3009 3371 // for a line with the following format:
never@3009 3372 // Hugepagesize: 2048 kB
never@3009 3373 //
never@3009 3374 // If we can't determine the value (e.g. /proc is not mounted, or the text
never@3009 3375 // format has been changed), we'll use the largest page size supported by
never@3009 3376 // the processor.
never@3009 3377
never@3009 3378 #ifndef ZERO
never@3009 3379 _large_page_size = IA32_ONLY(4 * M) AMD64_ONLY(2 * M) IA64_ONLY(256 * M) SPARC_ONLY(4 * M)
never@3009 3380 ARM_ONLY(2 * M) PPC_ONLY(4 * M);
never@3009 3381 #endif // ZERO
never@3009 3382
never@3009 3383 FILE *fp = fopen("/proc/meminfo", "r");
never@3009 3384 if (fp) {
never@3009 3385 while (!feof(fp)) {
never@3009 3386 int x = 0;
never@3009 3387 char buf[16];
never@3009 3388 if (fscanf(fp, "Hugepagesize: %d", &x) == 1) {
never@3009 3389 if (x && fgets(buf, sizeof(buf), fp) && strcmp(buf, " kB\n") == 0) {
never@3009 3390 _large_page_size = x * K;
never@3009 3391 break;
never@3009 3392 }
never@3009 3393 } else {
never@3009 3394 // skip to next line
never@3009 3395 for (;;) {
never@3009 3396 int ch = fgetc(fp);
never@3009 3397 if (ch == EOF || ch == (int)'\n') break;
never@3009 3398 }
never@3009 3399 }
never@3009 3400 }
never@3009 3401 fclose(fp);
never@3009 3402 }
never@3009 3403 }
never@3009 3404
never@3009 3405 // print a warning if any large page related flag is specified on command line
never@3009 3406 bool warn_on_failure = !FLAG_IS_DEFAULT(UseHugeTLBFS);
never@3009 3407
never@3009 3408 const size_t default_page_size = (size_t)Bsd::page_size();
never@3009 3409 if (_large_page_size > default_page_size) {
never@3009 3410 _page_sizes[0] = _large_page_size;
never@3009 3411 _page_sizes[1] = default_page_size;
never@3009 3412 _page_sizes[2] = 0;
never@3009 3413 }
never@3009 3414 UseHugeTLBFS = UseHugeTLBFS &&
never@3009 3415 Bsd::hugetlbfs_sanity_check(warn_on_failure, _large_page_size);
never@3009 3416
never@3009 3417 if (UseHugeTLBFS)
never@3009 3418 UseSHM = false;
never@3009 3419
never@3009 3420 UseLargePages = UseHugeTLBFS || UseSHM;
never@3009 3421
never@3009 3422 set_coredump_filter();
never@3009 3423 #endif
never@3009 3424 }
never@3009 3425
never@3009 3426 #ifndef _ALLBSD_SOURCE
never@3009 3427 #ifndef SHM_HUGETLB
never@3009 3428 #define SHM_HUGETLB 04000
never@3009 3429 #endif
never@3009 3430 #endif
never@3009 3431
stefank@5112 3432 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
stefank@5112 3433 fatal("This code is not used or maintained.");
stefank@5112 3434
never@3009 3435 // "exec" is passed in but not used. Creating the shared image for
never@3009 3436 // the code cache doesn't have an SHM_X executable permission to check.
never@3009 3437 assert(UseLargePages && UseSHM, "only for SHM large pages");
never@3009 3438
never@3009 3439 key_t key = IPC_PRIVATE;
never@3009 3440 char *addr;
never@3009 3441
never@3009 3442 bool warn_on_failure = UseLargePages &&
never@3009 3443 (!FLAG_IS_DEFAULT(UseLargePages) ||
never@3009 3444 !FLAG_IS_DEFAULT(LargePageSizeInBytes)
never@3009 3445 );