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