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