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